Elasticsearch-Abfrage, um alle Datensätze zurückzugeben

http://127.0.0.1:9200/foo/_search/?size=1000&pretty=1
                                   ^

Beachten Sie die Größe param, wodurch die angezeigten Treffer von der Standardeinstellung (10) auf 1000 pro Shard erhöht werden.

http://www.elasticsearch.org/guide/de/elasticsearch/reference/current/search-request-from-size.html

elasticsearch (ES) unterstützt sowohl eine GET- als auch eine POST -Anforderung zum Abrufen der Daten aus dem ES-Clusterindex. 

Wenn wir ein GET machen:

http://localhost:9200/[your index name]/_search?size=[no of records you want]&q=*:*

Wenn wir eine POST machen:

http://localhost:9200/[your_index_name]/_search
{
  "size": [your value] //default 10
  "from": [your start index] //default 0
  "query":
   {
    "match_all": {}
   }
}   

Ich würde vorschlagen, ein UI-Plugin mit Elasticsearch http://mobz.github.io/elasticsearch-head/ .__ zu verwenden, um ein besseres Gefühl für die von Ihnen erstellten Indizes zu erhalten und Ihre Indizes zu testen. 

Die folgende Abfrage würde das NO_OF_RESULTS zurückgeben, das Sie zurückgeben möchten.

curl -XGET 'localhost:9200/foo/_search?size=NO_OF_RESULTS' -d '
{
"query" : {
    "match_all" : {}
  }
}'

Nun ist die Frage, dass Sie all die Datensätze zurückgeben möchten. Bevor Sie eine Abfrage schreiben, kennen Sie den Wert von NO_OF_RESULTS natürlich nicht. 

Woher wissen wir, wie viele Datensätze in Ihrem Dokument vorhanden sind? Geben Sie einfach die folgende Abfrage ein

curl -XGET 'localhost:9200/foo/_search' -d '

Dies würde zu einem Ergebnis führen, das wie das unten stehende aussieht 

 {
hits" : {
  "total" :       2357,
  "hits" : [
    {
      ..................

Das Ergebnis total gibt an, wie viele Datensätze in Ihrem Dokument verfügbar sind. Das ist also eine schöne Art, den Wert von NO_OF RESULTS zu kennen.

curl -XGET 'localhost:9200/_search' -d ' 

Suche nach allen Typen in allen Indizes

curl -XGET 'localhost:9200/foo/_search' -d '

Suche alle Typen im FOO-Index

curl -XGET 'localhost:9200/foo1,foo2/_search' -d '

Durchsuchen Sie alle Typen in den Indizes foo1 und foo2

curl -XGET 'localhost:9200/f*/_search

Suche nach allen Typen in beliebigen Indizes, die mit f beginnen

curl -XGET 'localhost:9200/_all/type1,type2/_search' -d '

Suchtypen user und Tweet in allen Indizes

Dies ist die beste Lösung, die ich mit Python-Client gefunden habe

  # Initialize the scroll
  page = es.search(
  index = 'yourIndex',
  doc_type = 'yourType',
  scroll = '2m',
  search_type = 'scan',
  size = 1000,
  body = {
    # Your query's body
    })
  sid = page['_scroll_id']
  scroll_size = page['hits']['total']

  # Start scrolling
  while (scroll_size > 0):
    print "Scrolling..."
    page = es.scroll(scroll_id = sid, scroll = '2m')
    # Update the scroll ID
    sid = page['_scroll_id']
    # Get the number of results that we returned in the last scroll
    scroll_size = len(page['hits']['hits'])
    print "scroll size: " + str(scroll_size)
    # Do something with the obtained page

https://Gist.github.com/drorata/146ce50807d16fd4a6aa

Java-Client verwenden 

import static org.elasticsearch.index.query.QueryBuilders.*;

QueryBuilder qb = termQuery("multi", "test");

SearchResponse scrollResp = client.prepareSearch(test)
        .addSort(FieldSortBuilder.DOC_FIELD_NAME, SortOrder.ASC)
        .setScroll(new TimeValue(60000))
        .setQuery(qb)
        .setSize(100).execute().actionGet(); //100 hits per shard will be returned for each scroll
//Scroll until no hits are returned
do {
    for (SearchHit hit : scrollResp.getHits().getHits()) {
        //Handle the hit...
    }

    scrollResp = client.prepareSearchScroll(scrollResp.getScrollId()).setScroll(new TimeValue(60000)).execute().actionGet();
} while(scrollResp.getHits().getHits().length != 0); // Zero hits mark the end of the scroll and the while loop.

https://www.elastic.co/guide/de/elasticsearch/client/Java-api/current/Java-search-scrolling.html

verwenden Sie server:9200/_stats auch, um Statistiken über Ihre Aliase zu erhalten. Wie Größe und Anzahl der Elemente pro Alias, das ist sehr nützlich und bietet hilfreiche Informationen

Wenn Sie Tausende von Datensätzen abrufen möchten, geben einige Leute die richtige Antwort mit 'scroll' (Hinweis: Einige Leute schlugen auch die Verwendung von "search_type = scan" vor. Dies wurde nicht mehr unterstützt und in Version 5.0 entfernt. Du brauchst es nicht)

Beginnen Sie mit einer Suchabfrage, geben Sie jedoch einen Scroll-Parameter an (hier verwende ich ein Timeout von 1 Minute):

curl -XGET 'http://ip1:9200/myindex/_search?scroll=1m' -d '
{
    "query": {
            "match_all" : {}
    }
}
'

Dazu gehören Ihre ersten Treffer. Aber wir sind hier nicht fertig. Die Ausgabe des obigen curl-Befehls würde etwa so aussehen:

    curl -XGET  'localhost:9200/_search/scroll'  -d'
    {
        "scroll" : "1m", 
        "scroll_id" : "c2Nhbjs2OzM0NDg1ODpzRlBLc0FXNlNyNm5JWUc1" 
    }
    '

Das Weitergeben der scroll_id ist jedoch nicht dazu gedacht, manuell ausgeführt zu werden. Am besten schreiben Sie Code, um dies zu tun. z.B. in Java: 

    private TransportClient client = null;
    private Settings settings = ImmutableSettings.settingsBuilder()
                  .put(CLUSTER_NAME,"cluster-test").build();
    private SearchResponse scrollResp  = null;

    this.client = new TransportClient(settings);
    this.client.addTransportAddress(new InetSocketTransportAddress("ip", port));

    QueryBuilder queryBuilder = QueryBuilders.matchAllQuery();
    scrollResp = client.prepareSearch(index).setSearchType(SearchType.SCAN)
                 .setScroll(new TimeValue(60000))                            
                 .setQuery(queryBuilder)
                 .setSize(100).execute().actionGet();

    scrollResp = client.prepareSearchScroll(scrollResp.getScrollId())
                .setScroll(new TimeValue(timeVal))
                .execute()
                .actionGet();

Jetzt verwenden Sie LOOP für den letzten Befehl, um die Daten mithilfe von SearchResponse zu extrahieren.

Einfach! Sie können den Parameter size und from verwenden!

http://localhost:9200/[your index name]/_search?size=1000&from=0

dann ändern Sie from allmählich, bis Sie alle Daten erhalten.

Elasticsearch wird signifikante langsamer, wenn Sie nur eine große Zahl als Größe hinzufügen. Eine Methode, mit der alle Dokumente abgerufen werden können, ist die Verwendung von IDs zum Scannen und Blättern.

https://www.elastic.co/guide/de/elasticsearch/reference/current/search-request-scroll.html

http: // localhost: 9200/foo/_search/ ? size = 1000 & pretty = 1

sie müssen einen Parameter für die Größenabfrage angeben, da der Standardwert 10 ist

Der beste Weg, um die Größe anzupassen, ist size = number vor der URL 

Curl -XGET "http://localhost:9200/logstash-*/_search?size=50&pretty"

Hinweis: Der maximale Wert, der in dieser Größe definiert werden kann, ist 10000. Bei einem Wert über 10.000 wird erwartet, dass Sie die Scroll-Funktion verwenden, um die Auswirkungen auf die Leistung zu minimieren.

Sie können die API _count verwenden, um den Wert für den Parameter size abzurufen:

http://localhost:9200/foo/_count?q=<your query>

Gibt {count:X, ...} zurück. Extrahieren Sie den Wert 'X' und führen Sie dann die eigentliche Abfrage aus:

http://localhost:9200/foo/_search?q=<your query>&size=X

size param erhöht die angezeigten Treffer von der Standardeinstellung (10) auf 500.

http: // localhost: 9200/[indexName]/_search? pretty = true & size = 500 & q = *: *

Ändern Sie das von Schritt für Schritt, um alle Daten zu erhalten.

http: // localhost: 9200/[indexName]/_search? size = 500 & from = 0

Für Elasticsearch 6.x

Anfrage: GET /foo/_search?pretty=true

Antwort: Geben Sie unter Treffer-> Gesamt die Anzahl der Dokumente an

    {
      "took": 1,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
      },
      "hits": {
        "total": 1001,
        "max_score": 1,
        "hits": [
          {

Die offizielle Dokumentation liefert die Antwort auf diese Frage! Sie finden es hier . 

{
  "query": { "match_all": {} },
  "size": 1
}

Sie ersetzen einfach die Größe (1) durch die Anzahl der Ergebnisse, die Sie sehen möchten!

Von Kibana DevTools sein:

GET my_index_name/_search
{
  "query": {
    "match_all": {}
  }
}

curl -X GET 'localhost:9200/foo/_search?q=*&pretty' 

Standardmäßig gibt Elasticsearch 10 Datensätze zurück, daher sollte die Größe explizit angegeben werden.

Addiere Größe mit Anfrage, um die gewünschte Anzahl von Datensätzen zu erhalten. 

http: // {host}: 9200/{index_name}/_search? pretty = true & size = (Anzahl der Datensätze)

Hinweis : Die maximale Seitengröße darf nicht größer sein als die Indexeinstellung "index.max_result_window", deren Standardeinstellung 10.000 ist.

Wenn immer noch jemand nach Daten sucht, die von Elasticsearch wie mir für einige Anwendungsfälle abgerufen werden sollen, habe ich Folgendes getan. Darüber hinaus bedeuten alle Daten, alle Indizes und alle Dokumenttypen. Ich verwende Elasticsearch 6.3

curl -X GET "localhost:9200/_search?pretty=true" -H 'Content-Type: application/json' -d'
{
    "query": {
        "match_all": {}
    }
}
'

Elasticsearch Referenz

curl -XGET '{{IP/localhost}}:9200/{{Index name}}/{{type}}/_search?scroll=10m&pretty' -d '{
"query": {
"filtered": {
"query": {
"match_all": {}
}}'

dies ist die Abfrage, um das zu erreichen, was Sie möchten. (Ich empfehle die Verwendung von Kibana, da dies zum besseren Verständnis von Abfragen beiträgt.)

GET my_index_name/my_type_name/_search
{
   "query":{
      "match_all":{}
   },
   size : 20,
   from : 3
}

um alle Datensätze zu erhalten, müssen Sie die Abfrage "match_all" verwenden.

größe ist die Anzahl der Datensätze, die Sie abrufen möchten (Art des Limits). Standardmäßig gibt ES nur 10 Datensätze zurück

from ist wie skip, überspringe die ersten 3 Datensätze.

Wenn Sie genau alle Datensätze abrufen möchten, verwenden Sie einfach den Wert aus dem Feld "Gesamt" aus dem Ergebnis, sobald Sie diese Abfrage von Kibana getroffen haben, und verwenden Sie ihn mit "Größe".

Um alle Datensätze aus allen Indizes zurückzugeben, können Sie Folgendes tun:

curl -XGET http://35.195.120.21:9200/_all/_search?size=50&pretty

Ausgabe:

  "took" : 866,
  "timed_out" : false,
  "_shards" : {
    "total" : 25,
    "successful" : 25,
    "failed" : 0
  },
  "hits" : {
    "total" : 512034694,
    "max_score" : 1.0,
    "hits" : [ {
      "_index" : "grafana-dash",
      "_type" : "dashboard",
      "_id" : "test",
      "_score" : 1.0,
       ...

Keine außer @Akira Sendoh hat geantwortet, wie man eigentlich ALLE Dokumente erhält. Aber auch diese Lösung stürzt meinen ES 6.3 - Dienst ohne Protokolle ab. Das Einzige, was für mich mit der Low-Level-Bibliothek elasticsearch-py funktionierte, war durch Scan-Helfer , das scroll() api verwendet:

from elasticsearch.helpers import scan

doc_generator = scan(
    es_obj,
    query={"query": {"match_all": {}}},
    index="my-index",
)

# use the generator to iterate, dont try to make a list or you will get out of RAM
for doc in doc_generator:
    # use it somehow

Heutzutage scheint der sauberere Weg jedoch die elasticsearch-dsl-Bibliothek zu sein, die abstraktere, sauberere Aufrufe bietet, z. B .: http://elasticsearch-dsl.readthedocs.io/de/latest/search_dsl.html#hits

Eine einfache Lösung mit dem Python-Paket elasticsearch-dsl :

from elasticsearch_dsl import Search
from elasticsearch_dsl import connections

connections.create_connection(hosts=['localhost'])

s = Search(index="foo")
response = s.scan()

count = 0
for hit in response:
    # print(hit.to_dict())  # be careful, it will printout every hit in your index
    count += 1

print(count)

Siehe auch https://elasticsearch-dsl.readthedocs.io/de/latest/api.html#elasticsearch_dsl.Search.scan .

Das maximale Ergebnis, das von elasticSearch zurückgegeben wird, ist 10000, wenn die Größe angegeben wird 

curl -XGET 'localhost:9200/index/type/_search?scroll=1m' -d '
{
   "size":10000,
   "query" : {
   "match_all" : {}
    }
}'

Danach müssen Sie die Scroll-API verwenden, um das Ergebnis abzurufen, den _scroll_id-Wert abrufen und diesen Wert in scroll_id eingeben

curl -XGET  'localhost:9200/_search/scroll'  -d'
{
   "scroll" : "1m", 
   "scroll_id" : "" 
}'