Consulta Elasticsearch para retornar todos os registros

Eu tenho um pequeno database no Elasticsearch e, para fins de teste, gostaria de recuperar todos os registros. Eu estou tentando usar um URL do formulário …

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

Alguém pode me dar o URL que você usaria para realizar isso, por favor?

Eu acho que a syntax do lucene é suportada assim:

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

o tamanho padrão é 10, então você também pode precisar de &size=BIGNUMBER para obter mais de 10 itens. (onde BIGNUMBER é igual a um número que você acredita ser maior que seu dataset)

MAS, a documentação do elasticsearch sugere grandes conjuntos de resultados, usando o tipo de pesquisa de varredura.

POR EXEMPLO:

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

e, em seguida, continue solicitando de acordo com o link da documentação acima sugere.

EDIT: scan Deprecated em 2.1.0.

scan não fornece nenhum benefício sobre uma solicitação de scroll normal classificada por _doc . link para docs elástico (manchado por @ christophe-roussy)

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

Observe o tamanho param , que aumenta os resultados exibidos do padrão (10) para 1000 por fragment.

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

elasticsearch (ES) suporta uma solicitação GET ou POST para obter os dados do índice de cluster ES.

Quando fazemos um GET:

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

Quando fazemos um POST:

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

Eu sugeriria usar um plugin de interface do usuário com o elasticsearch http://mobz.github.io/elasticsearch-head/ Isso ajudará você a ter uma melhor noção dos índices criados e também testará seus índices.

A consulta abaixo retornaria o NO_OF_RESULTS que você gostaria de ser retornado.

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

Agora, a questão aqui é que você quer que todos os registros sejam retornados. Então, naturalmente, antes de escrever uma consulta, você não saberá o valor de NO_OF_RESULTS .

Como sabemos quantos registros existem em seu documento? Basta digitar a consulta abaixo

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

Isso lhe daria um resultado parecido com o abaixo

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

O total do resultado informa quantos registros estão disponíveis em seu documento. Essa é uma boa maneira de saber o valor de NO_OF RESULTS

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

Pesquisar todos os tipos em todos os índices

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

Pesquisar todos os tipos no índice foo

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

Pesquise todos os tipos nos índices foo1 e foo2

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

Pesquisar todos os tipos em qualquer índice que comece com f

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

Tipos de pesquisa usuário e tweet em todos os índices

Esta é a melhor solução que encontrei usando o cliente 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

Usando o cliente 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

use server:9200/_stats também para obter statistics sobre todos os seus aliases .. como tamanho e número de elementos por alias, isso é muito útil e fornece informações úteis

Simples! Você pode usar size e from parâmetro!

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

então você altera gradualmente a from até obter todos os dados.

A melhor maneira de ajustar o tamanho é usar size = number na frente do URL

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

Nota: o valor máximo que pode ser definido neste tamanho é 10000. Para qualquer valor acima de dez mil, espera-se que você use a function de rolagem, o que minimizaria quaisquer chances de impactos no desempenho.

http: // localhost: 9200 / foo / _search / ? tamanho = 1000 e bonito = 1

você precisará especificar o tamanho do parâmetro de consulta, pois o padrão é 10

Você pode usar a API _count para obter o valor do parâmetro size :

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

Retorna {count:X, ...} . Extraia o valor ‘X’ e faça a consulta real:

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

O Elasticsearch será significativamente mais lento se você adicionar apenas um número grande como tamanho, um método a ser usado para fazer com que todos os documentos usem códigos de verificação e de rolagem.

Então sua binding seria:

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

Isso retornará um _scroll_id, que você pode usar agora para obter o primeiro lote de documentos.

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

Alguns deles deram a resposta certa de usar scan e scroll, aparentemente, eu não consegui uma resposta completa que magicamente funcionasse. Quando alguém quer puxar registros, é preciso executar o seguinte comando curl.

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

Mas nós não terminamos aqui. A saída do comando curl acima seria algo como isto

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

é importante ter o _scroll_id à mão, pois na próxima você deve executar o seguinte comando

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

No entanto, eu não acho que é fácil de executar isso manualmente. Sua melhor aposta é escrever um código java para fazer o mesmo.

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

Agora LOOP no último comando usa SearchResponse para extrair os dados.

Para o Elasticsearch 6.x

Pedido: GET /foo/_search?pretty=true

Resposta: em Hits-> total, forneça a contagem dos documentos

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

tamanho param aumenta os resultados exibidos a partir do padrão (10) para 500.

  http: // localhost: 9200 / [indexName] / _search? pretty = verdadeiro & tamanho = 500 & q = *: * 

Altere o passo a passo para obter todos os dados.

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

Para retornar todos os registros de todos os índices que você pode fazer:

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

Saída:

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

O resultado máximo que retornará por elasticSearch é 10000 fornecendo o tamanho

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

Depois disso, você tem que usar a API de rolagem para obter o resultado e obter o valor de _scroll_id e colocar esse valor em scroll_id

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

Nenhum, exceto @Akira Sendoh respondeu como obter TODOS os documentos. Mas mesmo essa solução trava meu serviço ES 6.3 sem logs. A única coisa que funcionou para mim usando a biblioteca de baixo nível elasticsearch-py foi através do helper scan que usa 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 

No entanto, a maneira mais limpa hoje em dia parece ser através elasticsearch-dsl biblioteca elasticsearch-dsl , que oferece chamadas mais abstratas e mais limpas, por exemplo: http://elasticsearch-dsl.readthedocs.io/en/latest/search_dsl.html#hits

Se alguém ainda estiver procurando por todos os dados a serem recuperados do Elasticsearch como eu para alguns casos, aqui está o que eu fiz. Além disso, todos os dados significam todos os índices e todos os tipos de documentos. Estou usando o Elasticsearch 6.3

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

Referência Elasticsearch

Você pode usar tamanho = 0 isso irá retornar todos os documentos exemplo

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