Consulta Elasticsearch para retornar todos os registros

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

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

Alguém pode me fornecer a URL que você usaria para fazer isso, por favor?

Acho lucene sintaxe é suportada por isso:

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

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

MAS, a documentação da elasticsearch sugere para 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 continue solicitando conforme o link da documentação acima sugere.

EDIT: scandescontinuado no 2.1.0.

scannão fornece nenhum benefício em relação a uma scrollsolicitação regular classificada por _doc. link para documentos elásticos (descoberto por @ christophe-roussy)

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

Observe o parâmetro de tamanho , que aumenta as ocorrências exibidas do padrão (10) para 1000 por fragmento.

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

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

Nota: A resposta está relacionada a uma versão mais antiga do Elasticsearch 0.90. As versões lançadas desde então têm uma sintaxe atualizada. Consulte outras respostas que possam fornecer uma resposta mais precisa para a resposta mais recente que você está procurando.

A consulta abaixo retornaria o NO_OF_RESULTS que você gostaria que fosse devolvido.

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

Agora, a questão aqui é que você deseja 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 no seu documento? Basta digitar a consulta abaixo

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

Isso forneceria um resultado parecido com o abaixo

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

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

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

Pesquise todos os tipos em todos os índices

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

Pesquise 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

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

O Elasticsearch ficará significativo mais lento se você adicionar um número grande como tamanho, um método a ser usado para obter todos os documentos é usar os códigos de digitalização e rolagem.

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

No Elasticsearch v7.2, você faz assim:

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

Os resultados disso conteriam um _scroll_id que você deve consultar para obter os próximos 100 blocos.

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

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

Se você deseja extrair muitos milhares de registros, então ... algumas pessoas deram a resposta correta ao usar 'scroll' (Nota: Algumas pessoas também sugeriram o uso de "search_type = scan". Isso foi preterido e foi removido na v5.0. Você não precisa disso)

Comece com uma consulta 'search', mas especificando um parâmetro 'scroll' (aqui estou usando um tempo limite de 1 minuto):

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

Isso inclui seu primeiro 'lote' de hits. Mas não terminamos aqui. A saída do comando curl acima seria algo como isto:

{ "_Scroll_id": "c2Nhbjs1OzUyNjE6NU4tU3BrWi1UWkNIWVNBZW43bXV3Zzs1Mzc3OkhUQ0g3VGllU2FhemJVNlM5d2t0alE7NTI2Mjo1Ti1TcGtaLVRaQ0hZU0FlbjdtdXdnOzUzNzg6SFRDSDdUaWVTYWF6YlU2Uzl3a3RqUTs1MjYzOjVOLVNwa1otVFpDSFlTQWVuN211d2c7MTt0b3RhbF9oaXRzOjIyNjAxMzU3Ow ==", "tomou": 109, "timed_out": false, "_ cacos": { "total": 5, "bem sucedido": 5, "falhou": 0}, "hits" : {"total": 22601357, "max_score": 0,0, "hits": []}}

É importante ter _scroll_id à mão, pois em seguida você deve executar o seguinte comando:

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

No entanto, passar o scroll_id não é algo projetado para ser feito manualmente. Sua melhor aposta é escrever código para fazê-lo. por exemplo, em 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();

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

Simples! Você pode usar sizee fromparâmetro!

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

então você muda fromgradualmente 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 nesse tamanho é 10000. Para qualquer valor acima de dez mil, espera-se que você use a função de rolagem, o que minimizaria as chances de impactos no desempenho.

Você pode usar a _countAPI para obter o valor do sizeparâmetro:

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

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

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

http: // localhost: 9200 / foo / _search / ? size = 1000 e bonita = 1

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

Tamanho param aumenta os hits exibidos do padrão (10) para 500.

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

Mude de passo a passo para obter todos os dados.

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

Para Elasticsearch 6.x

Solicitação: GET /foo/_search?pretty=true

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

Se for um pequeno conjunto de dados (por exemplo, 1K registros) , você pode simplesmente especificar size:

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

A correspondência de todas as consultas não é necessária, pois está implícita.

Se você possui um conjunto de dados de tamanho médio, como registros de 1 milhão , talvez não tenha memória suficiente para carregá-lo, portanto, é necessário um scroll .

Um pergaminho é como um cursor em um banco de dados. No Elasticsearch, ele lembra de onde você parou e mantém a mesma visualização do índice (ou seja, impede que o pesquisador desapareça com uma atualização , impede a mesclagem de segmentos ).

Em termos de API, você deve adicionar um parâmetro de rolagem à primeira solicitação:

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

Você recebe a primeira página e um ID de rolagem:

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

Lembre-se de que o ID da rolagem que você recebe e o tempo limite são válidos para a próxima página . Um erro comum aqui é especificar um tempo limite muito grande (valor descroll ), que cobriria o processamento de todo o conjunto de dados (por exemplo, 1 milhão de registros) em vez de uma página (por exemplo, 100 registros).

Para obter a próxima página, preencha o último ID de rolagem e um tempo limite que deve durar até buscar a seguinte página:

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

Se você tiver muito o que exportar (por exemplo, documentos 1B) , precisará paralelizar. Isso pode ser feito via rolagem fatiada . Digamos que você queira exportar em 10 threads. O primeiro thread emitia uma solicitação como esta:

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

Você recebe de volta a primeira página e um ID de rolagem, exatamente como uma solicitação de rolagem normal. Você o consumiria exatamente como uma rolagem normal, exceto pelo fato de obter 1/10 dos dados.

Outros threads fariam o mesmo, exceto que idseriam 1, 2, 3 ...

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

Por padrão, o Elasticsearch retorna 10 registros, portanto o tamanho deve ser fornecido explicitamente.

Adicione tamanho com solicitação para obter o número desejado de registros.

http: // {host}: 9200 / {index_name} / _search? pretty = true & size = (número de registros)

Nota: O tamanho máximo da página não pode ser superior à configuração de índice index.max_result_window, cujo padrão é 10.000.

Do Kibana DevTools, seu:

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

Uma solução simples usando o pacote 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)

Consulte também https://elasticsearch-dsl.readthedocs.io/en/latest/api.html#elasticsearch_dsl.Search.scan .

O resultado máximo retornado pelo elasticSearch é 10000, fornecendo o tamanho

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

Depois disso, você deve usar a API Scroll para obter o resultado e obter o valor _scroll_id e colocar esse valor em scroll_id

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

A documentação oficial fornece a resposta para esta pergunta! você pode encontrá-lo aqui .

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

Você simplesmente substitui o tamanho (1) pelo número de resultados que deseja ver!

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

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

Resultado:

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

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 elasticsearch-pybiblioteca de baixo nível foi através do auxiliar de verificação 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 da elasticsearch-dslbiblioteca, 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 está procurando todos os dados a serem recuperados do Elasticsearch como eu para alguns casos de uso, 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 do Elasticsearch

esta é a consulta para realizar o que você deseja (sugiro usar o Kibana, pois ajuda a entender melhor as consultas)

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

para obter todos os registros, você precisa usar a consulta "match_all".

size é o número de registros que você deseja buscar (tipo de limite). por padrão, o ES retornará apenas 10 registros

de é como pular, pular os 3 primeiros registros.

Se você deseja buscar exatamente todos os registros, use o valor do campo "total" do resultado depois de acessar essa consulta do Kibana e use-o com "tamanho".

Usando o Elasticsearch 7.5.1

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

caso você também possa especificar o tamanho da sua matriz com & size = $ {number}

caso você não saiba que você indexa

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

O uso do console kibana e my_index como índice para pesquisar o seguinte pode ser contribuído. Solicitando que o índice retorne apenas 4 campos do índice, você também pode adicionar tamanho para indicar quantos documentos você deseja retornar pelo índice. No ES 7.6, você deve usar _source, em vez de filtrar, ele responderá mais rapidamente.

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

Você pode usar size = 0, isso retornará todos os exemplos de documentos

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