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 sintassi lucene sia supportata così:

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

la dimensione predefinita è 10, quindi potrebbe essere necessario &size=BIGNUMBERottenere più di 10 articoli. (dove BIGNUMBER è uguale a un numero che ritieni sia maggiore del tuo set di dati)

MA, la documentazione di elasticsearch suggerisce insiemi di risultati di grandi dimensioni, usando il tipo di ricerca per 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 suggerisce il collegamento sopra riportato.

EDIT: scanobsoleto in 2.1.0.

scannon offre alcun vantaggio rispetto a una normale scrollrichiesta ordinata per _doc. collegamento a documenti elastici (individuato da @ christophe-roussy)

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

Nota il parametro size , 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 una richiesta GET o POST per ottenere i dati dall'indice cluster ES.

Quando facciamo un OTTENERE:

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

Suggerirei di utilizzare un plug-in dell'interfaccia utente con elasticsearch http://mobz.github.io/elasticsearch-head/ Questo ti aiuterà a sentire meglio gli indici che crei e anche a testare i tuoi indici.

Nota: la risposta si riferisce a una versione precedente di Elasticsearch 0.90. Le versioni rilasciate da allora hanno una sintassi aggiornata. Fare riferimento ad altre risposte che potrebbero fornire una risposta più accurata all'ultima risposta che si sta cercando.

La query seguente restituirà NO_OF_RESULTS che desideri venga restituito.

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

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

Come facciamo a sapere quanti record esistono nel tuo documento? Digita semplicemente la query di seguito

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

Questo ti darebbe un risultato simile a quello qui sotto

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

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

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 tutti gli indici che iniziano con f

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

Cerca tipi utente e tweet in tutti gli indici

Questa è la migliore soluzione 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

Elasticsearch diventerà significativamente più lenta se aggiungi solo un numero grande come dimensione, un metodo da usare per ottenere tutti i documenti è usare gli ID di scansione e scorrimento.

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

In Elasticsearch v7.2, lo fai in questo modo:

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

I risultati di questo conterrebbero un _scroll_id che devi interrogare per ottenere i successivi 100 pezzi.

POST /_search/scroll 
{
    "scroll" : "1m", 
    "scroll_id" : "<YOUR SCROLL ID>" 
}

utilizzare server:9200/_statsanche per ottenere statistiche su tutti i tuoi alias .. come dimensione e numero di elementi per alias, è molto utile e fornisce informazioni utili

Se vuoi estrarre molte migliaia di record, allora ... alcune persone hanno dato la risposta giusta usando 'scroll' (Nota: alcune persone hanno anche suggerito di usare "search_type = scan". Questo è stato deprecato e rimosso nella v5.0. Non ne hai bisogno)

Inizia con una query 'cerca', ma specificando un parametro 'scroll' (qui sto usando un timeout di 1 minuto):

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

Ciò include il tuo primo "batch" di hit. Ma non abbiamo finito qui. L'output del comando curl sopra sarebbe simile a questo:

{ "_Scroll_id": "c2Nhbjs1OzUyNjE6NU4tU3BrWi1UWkNIWVNBZW43bXV3Zzs1Mzc3OkhUQ0g3VGllU2FhemJVNlM5d2t0alE7NTI2Mjo1Ti1TcGtaLVRaQ0hZU0FlbjdtdXdnOzUzNzg6SFRDSDdUaWVTYWF6YlU2Uzl3a3RqUTs1MjYzOjVOLVNwa1otVFpDSFlTQWVuN211d2c7MTt0b3RhbF9oaXRzOjIyNjAxMzU3Ow ==", "ha preso": 109, "timed_out": false, "_ cocci": { "totale": 5, "successo": 5, "fallito": 0}, "hits" : { "totale": 22601357, "max_score": 0.0, "colpi": []}}

È importante avere _scroll_id a portata di mano come dopo dovresti eseguire il seguente comando:

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

Tuttavia, passare il scroll_id in giro non è qualcosa progettato per essere fatto manualmente. La tua scommessa migliore è scrivere codice per farlo. ad esempio 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();

Adesso LOOP sull'ultimo comando usa SearchResponse per estrarre i dati.

Semplice! È possibile utilizzare sizee fromparametro!

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

quindi si modifica fromgradualmente fino a quando non si ottengono tutti i dati.

Il modo migliore per regolare la dimensione è 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 qualsiasi possibilità di impatto sulle prestazioni.

È possibile utilizzare l' _countAPI per ottenere il valore per il sizeparametro:

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

Ritorni {count:X, ...}. Estrarre il valore 'X' e quindi eseguire la query effettiva:

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

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

dovrai specificare il parametro della query di dimensioni poiché il valore predefinito è 10

size param aumenta i risultati visualizzati dal valore predefinito (10) a 500.

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

Modificare il da passo dopo passo per ottenere tutti i dati.

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

Per Elasticsearch 6.x

Richiesta: GET /foo/_search?pretty=true

Risposta: in Hit-> totale, indica 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": [
          {

Se si tratta di un piccolo set di dati (ad es. Record 1K) , puoi semplicemente specificare size:

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

Non è necessaria la corrispondenza di tutte le query , poiché è implicita.

Se si dispone di un set di dati di medie dimensioni, come i record 1M , potrebbe non essere disponibile memoria sufficiente per caricarlo, quindi è necessario uno scorrimento .

Una pergamena è come un cursore in un DB. In Elasticsearch, ricorda da dove eri rimasto e mantiene la stessa vista dell'indice (cioè impedisce al ricercatore di andare via con un aggiornamento , impedisce ai segmenti di fondersi ).

Per quanto riguarda l'API, devi aggiungere un parametro scroll alla prima richiesta:

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

Si torna alla prima pagina e un ID di scorrimento:

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

Ricorda che sia l'ID di scorrimento che ottieni che il timeout sono validi per la pagina successiva . Un errore comune qui è quello di specificare un timeout molto grande (valore di scroll), che coprirebbe per l'elaborazione dell'intero set di dati (ad esempio record 1M) anziché di una pagina (ad esempio 100 record).

Per ottenere la pagina successiva, inserisci l'ultimo ID di scorrimento e un timeout che dovrebbe durare fino al recupero della pagina seguente:

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

Se hai molto da esportare (ad es. Documenti 1B) , ti consigliamo di parallelizzare. Questo può essere fatto tramite scorrimento a fette . Supponi di voler esportare su 10 thread. Il primo thread emetterebbe una richiesta come questa:

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

Si ottiene la prima pagina e un ID di scorrimento, esattamente come una normale richiesta di scorrimento. Lo consumeresti esattamente come una normale pergamena, tranne per il fatto che ottieni 1/10 dei dati.

Altri thread farebbero lo stesso, tranne che idsarebbe 1, 2, 3 ...

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

Per impostazione predefinita, Elasticsearch restituisce 10 record, pertanto le dimensioni devono essere fornite in modo esplicito.

Aggiungi dimensione con richiesta per ottenere il numero desiderato di record.

http: // {host}: 9200 / {nome_indice} / _search? pretty = true & size = (numero di record)

Nota: la dimensione massima della pagina non può essere superiore all'impostazione dell'indice index.max_result_window che per impostazione predefinita è 10.000.

Da Kibana DevTools è:

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

Una soluzione semplice che utilizza il pacchetto python 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)

Vedi anche https://elasticsearch-dsl.readthedocs.io/en/latest/api.html#elasticsearch_dsl.Search.scan .

Il risultato massimo che restituirà elasticSearch è 10000 fornendo la dimensione

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

Successivamente, è necessario utilizzare l'API Scroll per ottenere il risultato, ottenere il valore _scroll_id e inserire questo valore in scroll_id

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

La documentazione ufficiale fornisce la risposta a questa domanda! puoi trovarlo qui .

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

Sostituisci semplicemente la dimensione (1) con il numero di risultati che vuoi vedere!

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

Nessuno tranne @Akira Sendoh ha risposto a come ottenere TUTTI i documenti. Ma anche quella soluzione blocca il mio servizio ES 6.3 senza registri. L'unica cosa che ha funzionato per me utilizzando la elasticsearch-pylibreria di basso livello è stata tramite l' helper 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, il modo più pulito al giorno d'oggi sembra essere attraverso la elasticsearch-dslbiblioteca, che offre chiamate più astratte e più pulite, ad esempio: http://elasticsearch-dsl.readthedocs.io/en/latest/search_dsl.html#hits

Se qualcuno sta ancora cercando tutti i dati da recuperare da Elasticsearch come me per alcuni casi d'uso, ecco cosa ho fatto. Inoltre, tutti i dati indicano, 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": {}
    }
}
'

Riferimenti su Elasticsearch

questa è la domanda per realizzare ciò che vuoi, (sto suggerendo di usare Kibana, poiché aiuta a capire meglio le domande)

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

per ottenere tutti i record devi usare la query "match_all".

dimensione è il numero di record che si desidera recuperare (tipo di limite). per impostazione predefinita, ES restituirà solo 10 record

da è come saltare, saltare i primi 3 record.

Se vuoi recuperare esattamente tutti i record, usa il valore dal campo "totale" dal risultato una volta che hai colpito questa query da Kibana e usalo con "dimensione".

Utilizzo di Elasticsearch 7.5.1

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

nel caso in cui puoi anche specificare la dimensione del tuo array con & size = $ {numero}

nel caso in cui non si conosca l'indice

http://${HOST}:9200/_cat/indices?v

Utilizzando la console di kibana e my_index come indice per cercare è possibile contribuire. Chiedere all'indice di restituire solo 4 campi dell'indice, è inoltre possibile aggiungere dimensioni per indicare quanti documenti si desidera vengano restituiti dall'indice. A partire da ES 7.6 dovresti usare _source invece di filtrare per rispondere più velocemente.

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

Puoi usare size = 0 questo ti restituirà tutti gli esempi di documenti

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