it-swarm.com.de

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, die Sie dazu verwenden würden?

399
John Livermore

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

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

die Standardgröße ist 10, daher benötigen Sie möglicherweise auch &size=BIGNUMBER, um mehr als 10 Elemente zu erhalten. (wobei BIGNUMBER einer Zahl entspricht, von der Sie glauben, dass sie größer ist als Ihr Datensatz)

ABER, Elasticsearch-Dokumentation schlägt vor für große Ergebnismengen unter Verwendung des Suchtyps "Scan".

Z.B:

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

und fordern Sie dann weiter auf, wie in dem Dokumentationslink oben vorgeschlagen.

BEARBEITEN: scan Veraltet in 2.1.0.

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

615
Steve Casey
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

116
lfender6445

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. 

27
Prerak Diwan

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

19
vjpan8564

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

16
Akira Sendoh

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

10
TheEnglishMe

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.

7
Somum

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.

7
Aminah Nuraini

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

6
WoodyDRN

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

5
Edwin Ikechukwu

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.

5
akshay misra

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
5
Daniel

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
3
Prasanna Jathan

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

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!

2
christouandr7

Von Kibana DevTools sein:

GET my_index_name/_search
{
  "query": {
    "match_all": {}
  }
}
1
belostoky
curl -X GET 'localhost:9200/foo/_search?q=*&pretty' 
1
Dhruv Sharma

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.

1

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

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

0

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

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

0
chefarov

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 .

0
asmaier

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