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

490

Ich habe eine kleine Datenbank in Elasticsearch und möchte zu Testzwecken alle Datensätze zurückziehen. Ich versuche eine URL des Formulars zu verwenden ...

http://localhost:9200/foo/_search?pretty=true&q={'matchAll':{''}}

Kann mir bitte jemand die URL geben, mit der Sie dies erreichen würden?

John Livermore
quelle
1
... wobei "foo" der Name des Index ist, für den Sie alle Datensätze anzeigen möchten.
Jonatan

Antworten:

744

Ich denke, Lucene-Syntax wird unterstützt, also:

http://localhost:9200/foo/_search?pretty=true&q=*:*

Die Standardgröße ist 10, daher müssen Sie möglicherweise auch &size=BIGNUMBERmehr als 10 Artikel erhalten. (wobei BIGNUMBER einer Zahl entspricht, von der Sie glauben, dass sie größer als Ihr Datensatz ist)

ABER die elasticsearch-Dokumentation schlägt für große Ergebnismengen die Verwendung des Scan-Suchtyps vor.

Z.B:

curl -XGET 'localhost:9200/foo/_search?search_type=scan&scroll=10m&size=50' -d '
{
    "query" : {
        "match_all" : {}
    }
}'

und fordern Sie dann weiter an, wie es der obige Dokumentationslink vorschlägt.

EDIT: scanVeraltet in 2.1.0.

scanbietet keine Vorteile gegenüber einer regulären scrollAnfrage, sortiert nach _doc. Link zu elastischen Dokumenten (entdeckt von @ christophe-roussy)

Steve Casey
quelle
6
Vielen Dank. Dies war das Finale, das ich mir ausgedacht habe und das zurückgibt, was ich jetzt brauche ... localhost: 9200 / foo / _search? Size = 50 & hübsch = wahr & q = *: *
John Livermore
2
Das Hinzufügen @ Steve Antwort, können Sie eine Liste der Parameter finden , dass Elasticsearch in diesem Link versteht elasticsearch.org/guide/reference/api/search/uri-request
Karthick
1
Danke @Steve für deine Antwort. Ich fand es nicht wichtig genug für eine neue Frage. Es wurde nirgendwo explizit angegeben, also dachte ich mir, ich würde hier nur zur Überprüfung fragen.
Churro
8
Sie sollten wirklich die Scan + Scroll-Anfragen verwenden. Wenn Sie size = BIGNUMBER verwenden, beachten Sie, dass Lucene Speicher für Punktzahlen für diese Zahl reserviert. Machen Sie sie also nicht zu groß. :)
Alex Brasetvik
4
Scan war veraltet in veraltet in 2.1.0: elastic.co/guide/en/elasticsearch/reference/current/…
Christophe Roussy
137
http://127.0.0.1:9200/foo/_search/?size=1000&pretty=1
                                   ^

Beachten Sie den Größenparameter , der die angezeigten Treffer von Standard (10) auf 1000 pro Shard erhöht.

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

lfender6445
quelle
10
Beachten Sie jedoch Folgendes (aus Elasticsearch-Dokumenten): Beachten Sie, dass ab + Größe nicht mehr als die Indexeinstellung index.max_result_window sein darf, die standardmäßig 10.000 ist.
user3078523
2
Dies wird 1000 zurückgeben, nicht alle, user3078523 ist richtig, diese Methode hat ein Limit vonmax_result_window
stelios
1
Es hat ein Maximum und auch (wenn Sie viele tausend Datensätze zu bekommen haben) ist es ein ziemlich kniffliger Ansatz, auf dieses Maximum zuzugehen. Stattdessen sollten Sie eine "Bildlauf" -Abfrage verwenden.
Harry Wood
37

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 einen 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. Dies hilft Ihnen dabei, ein besseres Gefühl für die von Ihnen erstellten Indizes zu bekommen und auch Ihre Indizes zu testen.

Prerak Diwan
quelle
3
Wie ein anderer Benutzer erwähnte: from+ sizekann nicht mehr als die index.max_result_window
Indexeinstellung sein
Dieser Ansatz hat ein Maximum, und auch (wenn Sie viele tausend Datensätze zu erhalten haben) ist es ein ziemlich kniffliger Ansatz, auf dieses Maximum zuzugehen. Stattdessen sollten Sie eine "Bildlauf" -Abfrage verwenden
Harry Wood
Seltsamerweise zeigen curl -XGET ... -d '{...}'die offiziellen Dokumente, was ein unoffizieller gemischter Anforderungsstil ist. Vielen Dank, dass Sie die richtigen GET- und POST-Formate angezeigt haben.
Jesse Chisholm
28

Hinweis: Die Antwort bezieht sich auf eine ältere Version von Elasticsearch 0.90. Seitdem veröffentlichte Versionen haben eine aktualisierte Syntax. Bitte beziehen Sie sich auf andere Antworten, die möglicherweise eine genauere Antwort auf die neueste Antwort liefern, nach der Sie suchen.

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

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

Die Frage hier ist nun, dass Sie möchten, dass alle Datensätze zurückgegeben werden. 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 Ihnen ein Ergebnis liefern, das wie das folgende aussieht

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

Das Ergebnis insgesamt sagen Ihnen , wie viele Datensätze in Ihrem Dokument verfügbar sind. Das ist also eine gute Möglichkeit, den Wert von NO_OF RESULTS zu ermitteln

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

Suchen Sie alle Typen in allen Indizes

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

Suchen Sie alle Typen im foo-Index

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

Suchen Sie alle Typen in den Indizes foo1 und foo2

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

Suchen Sie alle Typen in beliebigen Indizes, die mit f beginnen

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

Suchtypen Benutzer und Tweet in allen Indizes

vjpandian
quelle
9
Standardmäßig gibt ES 10 Ergebnisse zurück, es sei denn, die Basisabfrage enthält einen Größenparameter.
lfender6445
Die vorherige Antwort war drei Jahre alt. Es wurde auf ein aktuelles aktualisiert.
vjpandian
19

Dies ist die beste Lösung, die ich mit dem 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/en/elasticsearch/client/java-api/current/java-search-scrolling.html

HungUnicorn
quelle
Danke Mark, genau das habe ich gesucht! In meinem Fall (ELK 6.2.1, Python 3) war das Argument search_type ungültig und der document_type wird seit ELK 6.0
Christoph Schranz am
Perfekte Lösung! Vielen Dank. Ich habe verwendet elasticsearch_dsl==5.4.0und es funktioniert ohne search_type = 'scan',.
Usman Maqbool
ES 6.3. In diesem Beispiel stürzt mein Elasticsearch-Dienst ab und versucht, 110.000 Dokumente mit einem Bildlauf size=10000zwischen der 5. und 7. Iteration zu scrollen . mit status=127, main ERROR Null object returned for RollingFile in Appenders, main ERROR Unable to locate appender "rolling" for logger config "root"meldet Nein in/var/log/elasticsearch/elasticsearch.log
stelios
Für die Aufzeichnung implementieren die Python-Clients einen scanHelfer, der den Bildlauf unter der Haube ausführt (seit Version 5.xx
mindestens
search_type = 'scan'ist veraltet. Ähnlicher Code wird ohne das funktionieren, obwohl es einige interessante Unterschiede gibt, die in der alten Dokumentation gut vergraben sind. elastic.co/guide/en/elasticsearch/reference/1.4/… Insbesondere bei der Migration, bei der search_type = scan nicht verwendet wird, wird diese erste Suchabfrage mit dem ersten zu verarbeitenden Ergebnisstapel geliefert.
Harry Wood
12

Elasticsearch wird erheblich langsamer, wenn Sie nur eine große Zahl als Größe hinzufügen. Eine Methode zum Abrufen aller Dokumente ist die Verwendung von Scan- und Bildlauf-IDs.

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

In Elasticsearch v7.2 gehen Sie folgendermaßen vor:

POST /foo/_search?scroll=1m
{
    "size": 100,
    "query": {
        "match_all": {}
    }
}

Die Ergebnisse daraus würden eine _scroll_id enthalten, die Sie abfragen müssen, um die nächsten 100 Blöcke zu erhalten.

POST /_search/scroll 
{
    "scroll" : "1m", 
    "scroll_id" : "<YOUR SCROLL ID>" 
}
WoodyDRN
quelle
1
Diese Antwort benötigt weitere Updates. search_type=scanist jetzt veraltet. Sie sollten das also entfernen, aber dann hat sich das Verhalten ein wenig geändert. Der erste Datenstapel stammt aus dem ersten Suchaufruf. Der von Ihnen angegebene Link zeigt die richtige Vorgehensweise.
Harry Wood
1
Mein Kommentar war wirklich zu beachten, dass man nicht einfach eine beliebige Zahl als Größe hinzufügen kann, da dies viel langsamer wäre. Also habe ich das Codebeispiel entfernt und die Leute können dem Link folgen, um den richtigen Code zu erhalten.
WoodyDRN
1
@WoodyDRN Es ist besser, den Code in Ihrer Antwort zu haben (auch wenn er alt wird), damit er auch dann verfügbar ist, wenn der Link stirbt.
Trisped
11

Verwenden server:9200/_statsSie diese Option auch, um Statistiken über alle Ihre Aliase abzurufen. Wie Größe und Anzahl der Elemente pro Alias ​​ist dies sehr nützlich und bietet hilfreiche Informationen

Oussama L.
quelle
2
Soweit ich mich erinnere, erlaubt ES jedoch nur das Abrufen von 16000 Daten pro Anfrage. Wenn die Daten also über 16000 liegen, reicht diese Lösung nicht aus.
Aminah Nuraini
10

Wenn Sie viele tausend Datensätze abrufen möchten, dann ... gaben einige Leute die richtige Antwort für die Verwendung von 'scroll' (Hinweis: Einige Leute schlugen auch die Verwendung von "search_type = scan" vor. Dies war veraltet und wurde in Version 5.0 entfernt. Du brauchst es nicht)

Beginnen Sie mit einer Suchabfrage, geben Sie jedoch einen 'Bildlauf'-Parameter an (hier verwende ich eine Zeitüberschreitung von 1 Minute):

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

Dazu gehört auch Ihre erste Treffermenge. Aber wir sind hier noch nicht fertig. Die Ausgabe des obigen Befehls curl wäre ungefähr so:

{ "_Scroll_id": "c2Nhbjs1OzUyNjE6NU4tU3BrWi1UWkNIWVNBZW43bXV3Zzs1Mzc3OkhUQ0g3VGllU2FhemJVNlM5d2t0alE7NTI2Mjo1Ti1TcGtaLVRaQ0hZU0FlbjdtdXdnOzUzNzg6SFRDSDdUaWVTYWF6YlU2Uzl3a3RqUTs1MjYzOjVOLVNwa1otVFpDSFlTQWVuN211d2c7MTt0b3RhbF9oaXRzOjIyNjAxMzU3Ow ==", "nimmt": 109, "timed_out": false, "_ Scherben": { "total": 5, "erfolgreich": 5, "nicht bestanden": 0}, "Hits" : {"total": 22601357, "max_score": 0.0, "Hits": []}}

Es ist wichtig, _scroll_id zur Hand zu haben, da Sie als nächstes den folgenden Befehl ausführen sollten:

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

Das Weitergeben der scroll_id ist jedoch nicht für die manuelle Ausführung vorgesehen. Am besten schreiben Sie dazu Code. zB 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();

Verwenden Sie jetzt LOOP für den letzten Befehl SearchResponse, um die Daten zu extrahieren.

Somum
quelle
6

Einfach! Sie können sizeund fromParameter verwenden!

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

Dann ändern Sie die fromschrittweise, bis Sie alle Daten erhalten.

Aminah Nuraini
quelle
4
Verwenden Sie diese Methode niemals, wenn die Daten viele Dokumente enthalten ... Jedes Mal, wenn Sie zur "nächsten Seite" gehen, wird Elastic immer langsamer! Verwenden Sie stattdessen SearchAfter
Joshlo
3
Diese Lösung funktioniert auch nicht, wenn die Gesamtdatengröße über 10 000 liegt. Die Option size = 1000 & from = 10001 würde fehlschlagen.
Iclman
2
In der Tat scheitert. Parameter from+ sizekönnen nicht mehr als die Indexeinstellung index.max_result_window sein, die standardmäßig 10.000 ist
stelios
1
Wenn die Daten viele tausend Dokumente enthalten, ist die richtige Antwort die Verwendung einer 'Bildlauf'-Abfrage.
Harry Wood
Mit dem fromund size-Ansatz stoßen Sie auf das Problem der tiefen Paginierung. Verwenden Sie die Bildlauf-API, um einen Speicherauszug aller Dokumente zu erstellen.
Daniel Schneiter
5

Der beste Weg, um die Größe anzupassen, ist die Verwendung von 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, beträgt 10000. Für jeden Wert über zehntausend wird erwartet, dass Sie eine Bildlauffunktion verwenden, die das Risiko von Auswirkungen auf die Leistung minimiert.

Akshay Misra
quelle
Seit welcher Version tritt die maximale Größe auf?
WoodyDRN
Das mag der "beste" Weg bis zu einem gewissen Punkt sein, aber wirklich ein bisschen nicken. Wenn Sie viele tausend Datensätze haben, ist der beste Weg eine "Bildlauf" -Abfrage.
Harry Wood
Mit dem From- und Size-Ansatz stoßen Sie auf das Deep Pagination-Problem. Verwenden Sie die Bildlauf-API, um einen Speicherauszug aller Dokumente zu erstellen.
Daniel Schneiter
5

Sie können die _countAPI verwenden, um den Wert für den sizeParameter abzurufen:

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

Rückgabe {count:X, ...}. Extrahieren Sie den Wert 'X' und führen Sie dann die eigentliche Abfrage durch:

http://localhost:9200/foo/_search?q=<your query>&size=X
Daniel
quelle
1
Wenn Sie die Größe wie folgt auf X einstellen, kann dies zu einem überraschenden Fehler bei der Parallelität führen: Überlegen Sie, was passiert, wenn zwischen dem Zählen und dem Festlegen der Größe bei Ihrer nächsten Abfrage ein Datensatz hinzugefügt wird ... aber auch, wenn Sie viele tausend Datensätze abrufen müssen , dann ist es der falsche Ansatz. Stattdessen sollten Sie eine "Bildlauf" -Abfrage verwenden.
Harry Wood
4

http: // localhost: 9200 / foo / _search / ? Größe = 1000 & hübsch = 1

Sie müssen den Größenabfrageparameter angeben, da der Standardwert 10 ist

Edwin Ikechukwu Okonkwo
quelle
Mit dem From- und Size-Ansatz stoßen Sie auf das Deep Pagination-Problem. Verwenden Sie die Bildlauf-API, um einen Speicherauszug aller Dokumente zu erstellen.
Daniel Schneiter
4

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

http: // localhost: 9200 / [indexName] / _search? hübsch = wahr & Größe = 500 & q = *: *

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

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

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": [
          {
Anurag
quelle
3

Wenn es sich um einen kleinen Datensatz handelt (z. B. 1K-Datensätze) , können Sie einfach Folgendes angeben size:

curl localhost:9200/foo_index/_search?size=1000

Die Abfrage "Alle übereinstimmen" wird nicht benötigt, da sie implizit ist.

Wenn Sie über ein mittelgroßes Dataset wie 1M-Datensätze verfügen, verfügen Sie möglicherweise nicht über genügend Speicher, um es zu laden. Daher benötigen Sie einen Bildlauf .

Ein Bildlauf ist wie ein Cursor in einer Datenbank. In Elasticsearch merkt es sich, wo Sie aufgehört haben, und behält die gleiche Ansicht des Index bei (dh verhindert, dass der Sucher eine Aktualisierung durchführt , und verhindert, dass Segmente zusammengeführt werden ).

In Bezug auf die API müssen Sie der ersten Anforderung einen Bildlaufparameter hinzufügen:

curl 'localhost:9200/foo_index/_search?size=100&scroll=1m&pretty'

Sie erhalten die erste Seite und eine Bildlauf-ID zurück:

{
  "_scroll_id" : "DXF1ZXJ5QW5kRmV0Y2gBAAAAAAAAADEWbmJlSmxjb2hSU0tMZk12aEx2c0EzUQ==",
  "took" : 0,
...

Denken Sie daran, dass sowohl die Bildlauf-ID, die Sie zurückerhalten, als auch das Zeitlimit für die nächste Seite gültig sind . Ein häufiger Fehler besteht darin, ein sehr großes Zeitlimit (Wert von scroll) anzugeben , das die Verarbeitung des gesamten Datensatzes (z. B. 1 Million Datensätze) anstelle einer Seite (z. B. 100 Datensätze) abdeckt.

Um die nächste Seite zu erhalten, geben Sie die letzte Bildlauf-ID und eine Zeitüberschreitung ein, die bis zum Abrufen der folgenden Seite dauern soll:

curl -XPOST -H 'Content-Type: application/json' 'localhost:9200/_search/scroll' -d '{
  "scroll": "1m",
  "scroll_id": "DXF1ZXJ5QW5kRmV0Y2gBAAAAAAAAADAWbmJlSmxjb2hSU0tMZk12aEx2c0EzUQ=="
}'

Wenn Sie viel exportieren müssen (z. B. 1B-Dokumente) , möchten Sie parallelisieren. Dies kann über eine in Scheiben geschnittene Schriftrolle erfolgen . Angenommen, Sie möchten 10 Threads exportieren. Der erste Thread würde eine Anfrage wie folgt ausgeben:

curl -XPOST -H 'Content-Type: application/json' 'localhost:9200/test/_search?scroll=1m&size=100' -d '{
  "slice": {
    "id": 0, 
    "max": 10 
  }
}'

Sie erhalten die erste Seite und eine Bildlauf-ID zurück, genau wie bei einer normalen Bildlaufanforderung. Sie würden es genau wie eine normale Schriftrolle verbrauchen, außer dass Sie 1/10 der Daten erhalten.

Andere Threads würden dasselbe tun, außer dass iddies 1, 2, 3 ...

Radu Gheorghe
quelle
2
curl -X GET 'localhost:9200/foo/_search?q=*&pretty' 
Dhruv Sharma
quelle
2

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

Fügen Sie die Größe mit der Anfrage hinzu, 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 mehr als die Indexeinstellung index.max_result_window betragen, die standardmäßig 10.000 beträgt.

Satyendra Sharma
quelle
2

Von Kibana DevTools ist es:

GET my_index_name/_search
{
  "query": {
    "match_all": {}
  }
}
belostoky
quelle
1

Das maximale Ergebnis, das von elasticSearch zurückgegeben wird, beträgt 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 Wert _scroll_id abzurufen und diesen Wert in scroll_id einzufügen

curl -XGET  'localhost:9200/_search/scroll'  -d'
{
   "scroll" : "1m", 
   "scroll_id" : "" 
}'
RAHUL JAIN
quelle
Die Scroll-API sollte von Anfang an bei der ersten Anforderung verwendet werden.
Daniel Schneiter
1

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

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

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

christouandr7
quelle
Der Autor der Frage fragte nach "allen" Ergebnissen, nicht nach einer vordefinierten Anzahl von Ergebnissen. Während es hilfreich ist, einen Link zu den Dokumenten zu veröffentlichen, beschreiben die Dokumente weder, wie dies erreicht werden kann, noch Ihre Antwort.
Maarten00
Mit dem From- und Size-Ansatz stoßen Sie auf das Deep Pagination-Problem. Verwenden Sie die Bildlauf-API, um einen Speicherauszug aller Dokumente zu erstellen.
Daniel Schneiter
0

So geben Sie alle Datensätze aus allen Indizes zurück:

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,
       ...
exceltior
quelle
0
curl -XGET '{{IP/localhost}}:9200/{{Index name}}/{{type}}/_search?scroll=10m&pretty' -d '{
"query": {
"filtered": {
"query": {
"match_all": {}
}}'
aditya
quelle
Während dieses Code-Snippet die Frage lösen kann, hilft eine Erklärung wirklich, die Qualität Ihres Beitrags zu verbessern. Denken Sie daran, dass Sie die Frage für Leser in Zukunft beantworten und diese Personen möglicherweise die Gründe für Ihren Codevorschlag nicht kennen.
Stamos
0

Keiner außer @Akira Sendoh hat geantwortet, wie man tatsächlich ALLE Dokumente erhält. Aber selbst diese Lösung stürzt meinen ES 6.3- Dienst ohne Protokolle ab. Das einzige, was bei der Verwendung der Low-Level- elasticsearch-pyBibliothek für mich funktioniert hat, war der Scan-Helfer , der die 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

Der sauberere Weg scheint heutzutage jedoch die elasticsearch-dslBibliothek zu sein, die abstraktere, sauberere Aufrufe bietet, z. B.: Http://elasticsearch-dsl.readthedocs.io/en/latest/search_dsl.html#hits

Stelen
quelle
0

Wenn immer noch jemand nach allen Daten sucht, die von Elasticsearch abgerufen werden sollen, wie ich, 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

Santosh Kumar Arjunan
quelle
0

Dies ist die Abfrage, um das zu erreichen, was Sie wollen (ich schlage vor, Kibana zu verwenden, da dies hilft, Abfragen besser zu verstehen).

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 der Begrenzung). Standardmäßig gibt ES nur 10 Datensätze zurück

von ist wie überspringen, überspringe die ersten 3 Datensätze.

Wenn Sie genau alle Datensätze abrufen möchten, verwenden Sie einfach den Wert aus dem Feld "total" aus dem Ergebnis, sobald Sie diese Abfrage von Kibana getroffen haben, und verwenden Sie sie mit "size".

Niranjan Harpale
quelle
Die Einschränkung dieser Abfrage besteht darin, dass Größe + von kleiner oder gleich "index.max_result_window" sein muss. Für eine große Anzahl von Dokumenten (standardmäßig 10000+) gilt diese Abfrage nicht.
KarelHusa
0

Verwenden von Elasticsearch 7.5.1

http://${HOST}:9200/${INDEX}/_search?pretty=true&q=*:*&scroll=10m&size=5000

Falls Sie die Größe Ihres Arrays auch mit & size = $ {number} angeben können

falls Sie nicht wissen, dass Sie indexieren

http://${HOST}:9200/_cat/indices?v
Tiago Medici
quelle
0

Die Verwendung der Kibana-Konsole und von my_index als Index für die Suche nach Folgendem kann dazu beitragen. Wenn Sie den Index bitten, nur 4 Felder des Index zurückzugeben, können Sie auch die Größe hinzufügen, um anzugeben, wie viele Dokumente vom Index zurückgegeben werden sollen. Ab ES 7.6 sollten Sie _source verwenden, anstatt zu filtern, da dies schneller reagiert.

GET /address/_search
 {
   "_source": ["streetaddress","city","state","postcode"],
   "size": 100,
   "query":{
   "match_all":{ }
    }   
 }
Gregory Neely
quelle
-5

Sie können size = 0 verwenden. Dadurch erhalten Sie alle Beispiele für Dokumente

curl -XGET 'localhost:9200/index/type/_search' -d '
{
   size:0,
   "query" : {
   "match_all" : {}
    }
}'
Premkumar
quelle
1
Dies wird eine akkumulierte Information zurückgeben, aber nicht die Treffer selbst
user732456