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

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?

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)

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

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.

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

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

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>" 
}

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

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.

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.

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.

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

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

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

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

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

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 ...

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.

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.

Von Kibana DevTools ist es:

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

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/en/latest/api.html#elasticsearch_dsl.Search.scan .

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" : "" 
}'

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!

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,
       ...

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

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

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

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".

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

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":{ }
    }   
 }

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" : {}
    }
}'