Consulta Elasticsearch para retornar todos os registros


490

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?


1
... onde "foo" é o nome do índice para o qual você deseja mostrar todos os registros.
precisa saber é

Respostas:


744

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)


6
Obrigado. Este foi o I final veio com que retorna o que eu preciso para agora ... localhost: 9200 / foo / _search size = 50 & consideravelmente = true & q =? *: *
John Livermore

2
Adicionando à resposta de @ Steve, você pode encontrar uma lista de parâmetros que a elasticsearch entende neste link elasticsearch.org/guide/reference/api/search/uri-request
Karthick

1
Obrigado @Steve pela sua resposta. Não achei que fosse significativo o suficiente para uma nova pergunta. Não foi declarado explicitamente em nenhum lugar, então imaginei que pediria aqui apenas para verificar.
Churro 11/09/13

8
Você realmente deve usar as solicitações de digitalização + rolagem. Se você usar size = BIGNUMBER, observe que o Lucene aloca memória para pontuações para esse número, portanto, não a torne excessivamente grande. :)
Alex Brasetvik

4
A varredura foi descontinuada e descontinuada no 2.1.0: elastic.co/guide/en/elasticsearch/reference/current/…
Christophe Roussy

137
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


10
Porém, lembre-se de uma coisa (dos documentos da Elasticsearch): Observe que o tamanho + não pode ser maior que a configuração de índice index.max_result_window, cujo padrão é 10.000.
user3078523

2
Isso irá retornar 1000, não todos, user3078523 é certo, este método tem um limite demax_result_window
stelios

1
Ele tem um máximo, e também (se você tiver muitos milhares de registros para obter) é uma abordagem bastante pesada para subir até esse máximo. Em vez disso, você deve usar uma consulta "rolagem".
Harry Wood

37

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.


3
Como outro utilizador mencionado: from+ sizenão pode ser mais do que a index.max_result_windowconfiguração de índice que o padrão é 10000
stelios

Essa abordagem tem um máximo, e também (se você tiver muitos milhares de registros para obter), é uma abordagem bastante pesada para subir nesse nível. Em vez disso você deve usar uma consulta de "rolagem"
Harry Madeira

Curiosamente, os documentos oficiais mostram curl -XGET ... -d '{...}'qual é um unestilo misto de solicitação oficial. Obrigado por mostrar os formatos GET e POST corretos.
Jesse Chisholm

28

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


9
Por padrão, o ES retornará 10 resultados, a menos que um parâmetro de tamanho seja incluído na consulta base.
precisa saber é o seguinte

A resposta anterior tinha três anos. Atualizei para o atual.
vjpandian

19

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


Obrigado Mark, era exatamente o que eu estava procurando! No meu caso (ELK 6.2.1, python 3), o argumento SEARCH_TYPE não era válido eo document_type não é necessário mais uma vez ELK 6.0
Christoph Schranz

Solução perfeita! Obrigado. Eu estava usando elasticsearch_dsl==5.4.0e funciona sem search_type = 'scan',.
Usman Maqbool

ES 6.3. Este exemplo faz com que meu serviço Elasticsearch falhe, tentando rolar 110k documentos com size=10000algo entre as 5ª e 7ª iterações. com status=127, main ERROR Null object returned for RollingFile in Appenders, main ERROR Unable to locate appender "rolling" for logger config "root"Não faz login/var/log/elasticsearch/elasticsearch.log
stelios

Para o registro, os clientes python implementa um scanhelpers` que faz o rolo sob o capô (desde a versão 5.xx no menos)
MCMZL

search_type = 'scan'está obsoleto. Código semelhante funcionará sem isso, embora haja algumas diferenças interessantes que estão bem escondidas na documentação antiga. elastic.co/guide/en/elasticsearch/reference/1.4/… Em particular, ao migrar para não usar search_type = scan, a primeira consulta de 'pesquisa' virá com o primeiro lote de resultados a processar.
Harry Wood

12

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

1
Esta resposta precisa de mais atualizações. search_type=scanagora está obsoleto. Portanto, você deve remover isso, mas o comportamento mudou um pouco. O primeiro lote de dados volta da chamada de pesquisa inicial. O link que você fornece mostra a maneira correta de fazer isso.
Harry Wood

1
Meu comentário foi realmente para observar que você não pode simplesmente adicionar qualquer número como tamanho, pois seria bem mais lento. Então eu removi o exemplo de código e as pessoas podem seguir o link para obter o código correto.
WoodyDRN

1
@WoodyDRN É melhor ter o código na sua resposta (mesmo que envelheça) para que ele ainda esteja disponível quando o link acabar.
Trisped

11

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


2
Mas, pelo que me lembro, o ES só permite obter 16000 dados por solicitação. Portanto, se os dados estiverem acima de 16000, esta solução não será suficiente.
Aminah Nuraini

10

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.


6

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.


4
nunca use esse método se os dados contiverem muitos documentos ... Cada vez que você for para a "página seguinte", o Elastic será cada vez mais lento! Use SearchAfter em vez disso
Joshlo 20/07

3
Além disso, esta solução não funcionará se o tamanho total dos dados estiver acima de 10 000. O tamanho da opção = 1000 & from = 10001 falharia.
iclman

2
De fato falha. Parâmetros from+ sizenão pode ter mais do que o ajuste índice index.max_result_window cujo padrão é 10.000
stelios

1
Se os dados contiverem muitos milhares de documentos, a resposta correta é usar uma consulta de 'rolagem'.
Harry Wood

Com a abordagem frome, sizevocê encontrará o problema de Paginação Profunda. Use a API de rolagem para fazer um despejo de todos os documentos.
Daniel Schneiter

5

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.


Desde qual versão o tamanho máximo ocorre?
WoodyDRN

Esse pode ser o "melhor" caminho até certo ponto, mas um pouco confuso mesmo. Se você possui muitos milhares de registros, a melhor maneira é uma consulta "rolagem".
Harry Wood

Com a abordagem from e size, você encontrará o problema de paginação profunda. Use a API de rolagem para fazer um despejo de todos os documentos.
Daniel Schneiter

5

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

1
Definir o tamanho como X dessa maneira pode causar uma falha surpreendente de simultaneidade: considere o que acontece se um registro for adicionado entre fazer a contagem e definir o tamanho na sua próxima consulta ... mas também se você tiver muitos milhares de registros para obter , então é a abordagem errada. Em vez disso, você deve usar uma consulta "rolagem".
Harry Wood


4

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

3

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

3

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



2

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.


2

Do Kibana DevTools, seu:

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

2

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 .


1

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 API de rolagem deve ser usada desde o início com a primeira solicitação.
Daniel Schneiter

1

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!


O autor da pergunta estava solicitando resultados "todos", não uma quantidade predefinida de resultados. Embora seja útil postar um link para os documentos, eles não descrevem como conseguir isso, nem sua resposta.
Maarten00

Com a abordagem from e size, você encontrará o problema de paginação profunda. Use a API de rolagem para fazer um despejo de todos os documentos.
Daniel Schneiter

0

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

0
curl -XGET '{{IP/localhost}}:9200/{{Index name}}/{{type}}/_search?scroll=10m&pretty' -d '{
"query": {
"filtered": {
"query": {
"match_all": {}
}}'

Embora esse trecho de código possa resolver a questão, incluir uma explicação realmente ajuda a melhorar a qualidade da sua postagem. Lembre-se de que você está respondendo à pergunta dos leitores no futuro e essas pessoas podem não saber os motivos da sua sugestão de código.
Stamos 27/03

0

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


0

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


0

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


A limitação desta consulta é que o tamanho + de deve ser menor ou igual a "index.max_result_window". Para um grande número de documentos (por padrão, 10000+), esta consulta não é aplicável.
KarelHusa #

0

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

0

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

-5

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

1
Isso retornará uma informação acumulada, mas não os acertos em si #
user732456 30/03
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.