Query Elasticsearch per restituire tutti i record

Ho un piccolo database in Elasticsearch e per scopi di test vorrei recuperare tutti i record. Sto tentando di utilizzare un URL del modulo …

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

Qualcuno può darmi l’URL che useresti per realizzare questo, per favore?

Penso che la syntax di lucene sia supportata così:

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

la dimensione predefinita è 10, quindi potrebbe essere necessario &size=BIGNUMBER per ottenere più di 10 articoli. (dove BIGNUMBER è uguale a un numero che credi sia più grande del set di dati)

MA, la documentazione di elasticsearch suggerisce grandi set di risultati, utilizzando il tipo di ricerca di scansione.

PER ESEMPIO:

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

e quindi continuare a richiedere come da collegamento alla documentazione sopra suggerisce.

EDIT: scan deprecato in 2.1.0.

scan non fornisce alcun vantaggio rispetto a una normale richiesta di scroll ordinata da _doc . link a documenti elastici (individuati da @ christophe-roussy)

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

Notare la dimensione param , che aumenta i colpi visualizzati dal valore predefinito (10) a 1000 per frammento.

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

elasticsearch (ES) supporta sia una richiesta GET sia una richiesta POST per ottenere i dati dall’indice cluster ES.

Quando facciamo un GET:

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

Quando facciamo un post:

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

Ti suggerisco di utilizzare un plug-in UI con elasticsearch http://mobz.github.io/elasticsearch-head/ Questo ti aiuterà a ottenere una migliore sensazione degli indici che crei e anche a testare i tuoi indici.

La query seguente restituirà NO_OF_RESULTS che vorresti essere restituito ..

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

Ora, la domanda qui è che vuoi che vengano restituiti tutti i record. Quindi, naturalmente, prima di scrivere una query, non si conosce il valore di NO_OF_RESULTS .

Come sappiamo quanti documenti esistono nel tuo documento? Digita semplicemente la query qui sotto

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

Questo ti darebbe un risultato simile a quello qui sotto

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

Il risultato totale indica quanti record sono disponibili nel documento. Quindi, questo è un buon modo per conoscere il valore di NO_OF RISULTATI

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

Cerca tutti i tipi in tutti gli indici

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

Cerca tutti i tipi nell’indice foo

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

Cerca tutti i tipi negli indici foo1 e foo2

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

Cerca tutti i tipi in qualsiasi indice che inizia con f

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

Cerca tipi utente e tweet in tutti gli indici

Questa è la soluzione migliore che ho trovato usando il client python

  # 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

Utilizzo del client java

 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

usa il server:9200/_stats anche per ottenere statistiche su tutti i tuoi alias … come le dimensioni e il numero di elementi per alias, è molto utile e fornisce informazioni utili

Semplice! Puoi usare la size e from parametri!

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

quindi si cambia from gradualmente fino ad ottenere tutti i dati.

Il modo migliore per regolare le dimensioni è usare size = number davanti all’URL

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

Nota: il valore massimo che può essere definito in questa dimensione è 10000. Per qualsiasi valore superiore a diecimila si prevede di utilizzare la funzione di scorrimento che ridurrebbe al minimo le probabilità di impatti sulle prestazioni.

http: // localhost: 9200 / foo / _search / ? taglia = 1000 & carina = 1

sarà necessario specificare il parametro di ricerca della dimensione poiché il valore predefinito è 10

Puoi utilizzare l’API _count per ottenere il valore per il parametro size :

 http://localhost:9200/foo/_count?q= 

Restituisce {count:X, ...} . Estrai il valore ‘X’ e poi fai la query effettiva:

 http://localhost:9200/foo/_search?q=&size=X 

Elasticsearch diventerà molto più lento se si aggiunge solo un numero elevato come dimensione, un metodo da utilizzare per ottenere che tutti i documenti utilizzino gli ID di scansione e scorrimento.

Quindi la tua chiamata sarebbe:

 GET /foo/_search?search_type=scan&scroll=1m { "query": { "match_all": {}}, "size": 1000 } 

Ciò restituirà un _scroll_id, che ora puoi utilizzare per ottenere il primo batch di documenti.

https://www.elastic.co/guide/en/elasticsearch/guide/current/scan-scroll.html

Alcuni di loro hanno dato la risposta giusta usando scan e scroll, apparentemente, non ho potuto ottenere una risposta completa che funzionerebbe magicamente. Quando qualcuno vuole estrarre i record, è necessario eseguire il seguente comando di ricciolo.

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

Ma non abbiamo finito qui. L’output del comando di arricciatura precedente sarebbe qualcosa di simile

 {"_scroll_id":"c2Nhbjs1OzUyNjE6NU4tU3BrWi1UWkNIWVNBZW43bXV3Zzs1Mzc3OkhUQ0g3VGllU2FhemJVNlM5d2t0alE7NTI2Mjo1Ti1TcGtaLVRaQ0hZU0FlbjdtdXdnOzUzNzg6SFRDSDdUaWVTYWF6YlU2Uzl3a3RqUTs1MjYzOjVOLVNwa1otVFpDSFlTQWVuN211d2c7MTt0b3RhbF9oaXRzOjIyNjAxMzU3Ow==","took":109,"timed_out":false,"_shards":{"total":5,"successful":5,"failed":0},"hits":{"total":22601357,"max_score":0.0,"hits":[]}} 

è importante avere _scroll_id a portata di mano come il prossimo che esegui il seguente comando

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

Tuttavia, non penso che sia facile farlo manualmente. La soluzione migliore è scrivere un codice java per fare lo stesso.

  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(); 

Ora LOOP sull’ultimo comando usa SearchResponse per estrarre i dati.

Per Elasticsearch 6.x

Richiesta: GET /foo/_search?pretty=true

Risposta: in Hits-> total, dai il conteggio dei documenti

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

il parametro size aumenta gli hit visualizzati dal valore predefinito (10) a 500.

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

Modificare il da fase per fase per ottenere tutti i dati.

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

Per restituire tutti i record da tutti gli indici puoi fare:

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

Produzione:

  "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": {} }}' 
 curl -X GET 'localhost:9200/foo/_search?q=*&pretty' 

Il risultato massimo che verrà restituito da elasticSearch è 10000 fornendo la dimensione

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

Dopodiché, devi utilizzare l’API di scorrimento per ottenere il risultato e ottenere il valore _scroll_id e inserire questo valore in scroll_id

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

Nessuno eccetto @Akira Sendoh ha risposto a come ottenere effettivamente TUTTI i documenti. Ma anche quella soluzione si blocca il mio servizio ES 6.3 senza registri. L’unica cosa che ha funzionato per me usando la libreria elasticsearch-py basso livello era attraverso l’ assistente di scansione che utilizza scroll() api:

 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 

Tuttavia, al giorno d’oggi il modo più pulito sembra essere attraverso la libreria elasticsearch-dsl , che offre chiamate più astratte e più pulite, ad esempio: http://elasticsearch-dsl.readthedocs.io/en/latest/search_dsl.html#hits

Se ancora qualcuno sta cercando tutti i dati da recuperare da Elasticsearch come me per alcuni casi, ecco cosa ho fatto. Inoltre, tutti i mezzi di dati, tutti gli indici e tutti i tipi di documenti. Sto usando Elasticsearch 6.3

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

Riferimento Elasticsearch

Puoi usare size = 0 questo ti restituirà tutti i documenti di esempio

 curl -XGET 'localhost:9200/index/type/_search' -d ' { size:0, "query" : { "match_all" : {} } }'