Consulta Elasticsearch para devolver todos los registros


490

Tengo una pequeña base de datos en Elasticsearch y para fines de prueba me gustaría retirar todos los registros. Estoy intentando usar una URL del formulario ...

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

¿Puede alguien darme la URL que usaría para lograr esto, por favor?


1
... donde "foo" es el nombre del índice para el que desea mostrar todos los registros.
jonatan

Respuestas:


744

Creo que la sintaxis de lucene es compatible, así que:

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

el tamaño predeterminado es 10, por lo que es posible que también necesite &size=BIGNUMBERobtener más de 10 artículos. (donde BIGNUMBER es igual a un número que cree que es más grande que su conjunto de datos)

PERO, la documentación de elasticsearch sugiere conjuntos de resultados grandes, utilizando el tipo de búsqueda de escaneo.

P.EJ:

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

y luego siga solicitando según el enlace de documentación anterior sugiere.

EDITAR: scanen desuso en 2.1.0.

scanno proporciona ningún beneficio sobre una scrollsolicitud regular ordenada por _doc. enlace a documentos elásticos (visto por @ christophe-roussy)


66
Gracias. Esta fue la última que se me ocurrió que devuelve lo que necesito por ahora ... localhost: 9200 / foo / _search? Size = 50 & pretty = true & q = *: *
John Livermore

2
Agregando a @ respuesta de Steve, usted puede encontrar una lista de parámetros que elasticsearch entiende en este enlace elasticsearch.org/guide/reference/api/search/uri-request
Karthick

1
Gracias @ Steve por tu respuesta. No pensé que fuera lo suficientemente significativo para una nueva pregunta. No se mencionó explícitamente en ninguna parte, así que pensé en preguntar aquí solo para verificar.
Churro

8
Realmente deberías usar el escaneo + solicitudes de desplazamiento. Si utiliza size = BIGNUMBER, tenga en cuenta que Lucene asigna memoria para las puntuaciones de ese número, por lo que no debe hacerlo demasiado grande. :)
Alex Brasetvik

44
La exploración quedó en desuso en 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
                                   ^

Tenga en cuenta el tamaño de parámetro , que aumenta los golpes que se muestran desde el valor predeterminado (10) a 1000 por fragmento.

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


10
Sin embargo, una cosa a tener en cuenta (de los documentos de Elasticsearch): tenga en cuenta que from + size no puede ser mayor que la configuración del índice index.max_result_window, que por defecto es 10,000.
user3078523

2
Esto devolverá 1000, no todos, user3078523 es correcto, este método tiene un límite demax_result_window
stelios

1
Tiene un máximo, y también (si tiene muchos miles de registros para obtener) es un enfoque bastante asqueroso ir hacia ese máximo. En su lugar, debe utilizar una consulta de "desplazamiento".
Harry Wood

37

elasticsearch (ES) admite una solicitud GET o POST para obtener los datos del índice del clúster ES.

Cuando hacemos un GET:

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

Cuando hacemos una POST:

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

Sugeriría usar un complemento de interfaz de usuario con elasticsearch http://mobz.github.io/elasticsearch-head/ Esto lo ayudará a tener una mejor idea de los índices que crea y también probar sus índices.


3
Como otro usuario mencionó: from+ sizeno puede ser más que la index.max_result_windowconfiguración del índice que se establece por defecto en 10,000
stelios

Este enfoque tiene un máximo, y también (si tiene muchos miles de registros para obtener) es un enfoque bastante pesado para ir hacia ese máximo. En su lugar, debe utilizar una consulta de "desplazamiento"
Harry Wood

Por extraño que parezca, los documentos oficiales muestran curl -XGET ... -d '{...}'cuál es un unestilo mixto oficial de solicitud. Gracias por mostrar los formatos GET y POST correctos.
Jesse Chisholm

28

Nota: La respuesta se relaciona con una versión anterior de Elasticsearch 0.90. Las versiones lanzadas desde entonces tienen una sintaxis actualizada. Consulte otras respuestas que pueden proporcionar una respuesta más precisa a la última respuesta que está buscando.

La consulta a continuación devolverá los NO_OF_RESULTS que desea que se devuelvan.

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

Ahora, la pregunta aquí es que desea que se devuelvan todos los registros. Entonces, naturalmente, antes de escribir una consulta, no conocerá el valor de NO_OF_RESULTS .

¿Cómo sabemos cuántos registros existen en su documento? Simplemente escriba la consulta a continuación

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

Esto le daría un resultado similar al siguiente.

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

El resultado total le indica cuántos registros hay disponibles en su documento. Entonces, esa es una buena manera de conocer el valor de NO_OF RESULTADOS

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

Buscar todos los tipos en todos los índices

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

Buscar todos los tipos en el índice foo

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

Buscar todos los tipos en los índices foo1 y foo2

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

Buscar todos los tipos en cualquier índice que comience con f

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

Tipos de búsqueda usuario y tweet en todos los índices


99
De forma predeterminada, ES devolverá 10 resultados a menos que se incluya un parámetro de tamaño en la consulta base.
lfender6445

La respuesta anterior tenía tres años. Lo actualicé a uno actual.
vjpandian

19

Esta es la mejor solución que encontré usando el 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

Usar 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


Gracias Mark, ¡eso era exactamente lo que estaba buscando! En mi caso (ELK 6.2.1, python 3), el argumento search_type no era válido y el document_type ya no es necesario desde ELK 6.0
Christoph Schranz el

¡Solución perfecta! Gracias. Estaba usando elasticsearch_dsl==5.4.0y funciona sin search_type = 'scan',.
Usman Maqbool

ES 6.3. Este ejemplo hace que mi servicio Elasticsearch se bloquee, tratando de desplazar 110k documentos con size=10000, en algún lugar entre las iteraciones 5 a 7. con status=127, main ERROR Null object returned for RollingFile in Appenders, main ERROR Unable to locate appender "rolling" for logger config "root"No se registra en/var/log/elasticsearch/elasticsearch.log
Stelios

Para el registro, los clientes de Python implementan un scanasistente que hace el desplazamiento debajo del capó (desde la versión 5.xx al menos)
MCMZL

search_type = 'scan'es obsoleto. Un código similar funcionará sin eso, aunque hay algunas diferencias interesantes que están bien ocultas en la documentación anterior. elastic.co/guide/en/elasticsearch/reference/1.4/… En particular, al migrar para no usar search_type = scan, esa primera consulta de 'búsqueda' vendrá con el primer lote de resultados para procesar.
Harry Wood

12

Elasticsearch se volverá significativamente más lento si solo agrega un número grande como tamaño, un método para usar para obtener todos los documentos es usar ID de escaneo y desplazamiento.

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

En Elasticsearch v7.2, lo haces así:

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

Los resultados de esto contendrían un _scroll_id que debe consultar para obtener los siguientes 100 fragmentos.

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

1
Esta respuesta necesita más actualizaciones. search_type=scanahora está en desuso. Entonces debes eliminar eso, pero luego el comportamiento ha cambiado un poco. El primer lote de datos regresa de la llamada de búsqueda inicial. El enlace que proporciona muestra la forma correcta de hacerlo.
Harry Wood

1
Mi comentario fue realmente tener en cuenta que no se puede agregar cualquier número como tamaño, ya que sería mucho más lento. Así que eliminé el ejemplo de código y las personas pueden seguir el enlace para obtener el código correcto.
WoodyDRN

1
@WoodyDRN Es mejor tener el código en su respuesta (incluso si se vuelve viejo) para que todavía esté disponible cuando el enlace falle.
Trisped

11

use server:9200/_statstambién para obtener estadísticas sobre todos sus alias ... como tamaño y número de elementos por alias, eso es muy útil y proporciona información útil


2
Pero, por lo que recuerdo, ES solo permite obtener 16000 datos por solicitud. Entonces, si los datos están por encima de 16000, esta solución no es suficiente.
Aminah Nuraini

10

Si desea extraer muchos miles de registros, entonces ... algunas personas dieron la respuesta correcta de usar 'scroll' (Nota: Algunas personas también sugirieron usar "search_type = scan". Esto fue obsoleto y se eliminó en v5.0. No lo necesitas)

Comienza con una consulta de 'búsqueda', pero especificando un parámetro de 'desplazamiento' (aquí estoy usando un tiempo de espera de 1 minuto)

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

Eso incluye tu primer 'lote' de éxitos. Pero no hemos terminado aquí. La salida del comando curl anterior sería algo como esto:

{ "_Scroll_id": "c2Nhbjs1OzUyNjE6NU4tU3BrWi1UWkNIWVNBZW43bXV3Zzs1Mzc3OkhUQ0g3VGllU2FhemJVNlM5d2t0alE7NTI2Mjo1Ti1TcGtaLVRaQ0hZU0FlbjdtdXdnOzUzNzg6SFRDSDdUaWVTYWF6YlU2Uzl3a3RqUTs1MjYzOjVOLVNwa1otVFpDSFlTQWVuN211d2c7MTt0b3RhbF9oaXRzOjIyNjAxMzU3Ow ==", "tomó": 109, "timed_out": false, "_ fragmentos": { "total": 5, "éxito": 5, "no": 0}, "éxitos" : {"total": 22601357, "max_score": 0.0, "hits": []}}

Es importante tener _scroll_id a mano, ya que a continuación debe ejecutar el siguiente comando:

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

Sin embargo, pasar el scroll_id no es algo diseñado para hacerse manualmente. Su mejor opción es escribir código para hacerlo. Por ejemplo, en 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();

Ahora LOOP en el último comando usa SearchResponse para extraer los datos.


6

¡Simple! Puede usar sizey fromparámetro!

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

luego cambia fromgradualmente hasta obtener todos los datos.


44
nunca use este método si los datos contienen muchos documentos ... Cada vez que vaya a "la página siguiente" ¡Elastic será más y más lento! Utilice SearchAfter en su lugar
Joshlo

3
Además, esta solución no funcionará si el tamaño total de los datos es superior a 10 000. La opción size = 1000 & from = 10001 fallará.
iclman

2
De hecho falla. Parámetros from+ sizeno puede ser más que index.max_result_window configuración de índice que por defecto es 10,000
stelios

1
Si los datos contienen muchos miles de documentos, la respuesta correcta es utilizar una consulta de 'desplazamiento'.
Harry Wood

Con el enfoque fromy sizese encontrará con el problema de Paginación profunda. Use la API de desplazamiento para hacer un volcado de todos los documentos.
Daniel Schneiter

5

La mejor manera de ajustar el tamaño es usar size = number delante de la URL

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

Nota: el valor máximo que se puede definir en este tamaño es 10000. Para cualquier valor superior a diez mil, se espera que utilice la función de desplazamiento que minimizaría cualquier posibilidad de impacto en el rendimiento.


¿Desde qué versión se produce el tamaño máximo?
WoodyDRN

Ese puede ser el "mejor" camino hasta cierto punto, pero un poco asqueroso realmente. Si tiene muchos miles de registros, la mejor manera es una consulta de "desplazamiento".
Harry Wood

Con el enfoque from y size, te encontrarás con el problema Deep Pagination. Use la API de desplazamiento para hacer un volcado de todos los documentos.
Daniel Schneiter

5

Puede usar la _countAPI para obtener el valor del sizeparámetro:

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

Las devoluciones {count:X, ...}. Extraiga el valor 'X' y luego realice la consulta real:

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

1
Establecer el tamaño en X de esta manera, podría tener un sorprendente error de concurrencia: considere lo que sucede si se agrega un registro entre hacer el conteo y establecer el tamaño en su próxima consulta ... pero también si tiene muchos miles de registros para obtener , entonces es el enfoque equivocado. En su lugar, debe utilizar una consulta de "desplazamiento".
Harry Wood


4

size param aumenta los golpes mostrados desde el valor predeterminado (10) a 500.

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

Cambie el de paso a paso para obtener todos los datos.

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

3

Para Elasticsearch 6.x

Solicitud: GET /foo/_search?pretty=true

Respuesta: En Hits-> total, da el recuento de los documentos

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

3

Si se trata de un conjunto de datos pequeño (por ejemplo, registros 1K) , simplemente puede especificar size:

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

La consulta match all no es necesaria, ya que está implícita.

Si tiene un conjunto de datos de tamaño mediano, como registros 1M , es posible que no tenga suficiente memoria para cargarlo, por lo que necesita un desplazamiento .

Un desplazamiento es como un cursor en un DB. En Elasticsearch, recuerda dónde lo dejó y mantiene la misma vista del índice (es decir, evita que el buscador se vaya con una actualización , evita que los segmentos se fusionen ).

En cuanto a la API, debe agregar un parámetro de desplazamiento a la primera solicitud:

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

Vuelve a la primera página y una ID de desplazamiento:

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

Recuerde que tanto la ID de desplazamiento que obtiene como el tiempo de espera son válidos para la página siguiente . Un error común aquí es especificar un tiempo de espera muy grande (valor de scroll), que cubriría el procesamiento de todo el conjunto de datos (por ejemplo, registros 1M) en lugar de una página (por ejemplo, 100 registros).

Para obtener la siguiente página, complete la última ID de desplazamiento y un tiempo de espera que debería durar hasta obtener la siguiente página:

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

Si tiene mucho que exportar (p. Ej., Documentos 1B) , querrá paralelizar. Esto se puede hacer a través de desplazamiento en rodajas . Digamos que desea exportar en 10 hilos. El primer hilo emitiría una solicitud como esta:

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

Vuelve a la primera página y una ID de desplazamiento, exactamente como una solicitud de desplazamiento normal. Lo consumirías exactamente como un desplazamiento regular, excepto que obtienes 1/10 de los datos.

Otros hilos harían lo mismo, excepto que idserían 1, 2, 3 ...



2

Por defecto, Elasticsearch devuelve 10 registros, por lo que el tamaño debe proporcionarse explícitamente.

Agregue tamaño con la solicitud para obtener el número deseado de registros.

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

Nota: El tamaño máximo de la página no puede ser mayor que la configuración del índice index.max_result_window que está predeterminado en 10,000.


2

De Kibana DevTools es:

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

2

Una solución simple usando el paquete 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 también https://elasticsearch-dsl.readthedocs.io/en/latest/api.html#elasticsearch_dsl.Search.scan .


1

El resultado máximo que devolverá elasticSearch es 10000 al proporcionar el tamaño

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

Después de eso, debe usar la API de desplazamiento para obtener el resultado y obtener el valor _scroll_id y poner este valor en scroll_id

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

La API de desplazamiento debe usarse desde el principio con la primera solicitud.
Daniel Schneiter

1

¡La documentación oficial proporciona la respuesta a esta pregunta! Lo puedes encontrar aquí .

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

¡Simplemente reemplace el tamaño (1) con la cantidad de resultados que desea ver!


El autor de la pregunta estaba pidiendo "todos" los resultados, no una cantidad predefinida de resultados. Si bien es útil publicar un enlace a los documentos, los documentos no describen cómo lograrlo, tampoco su respuesta.
Maarten00

Con el enfoque from y size, te encontrarás con el problema Deep Pagination. Use la API de desplazamiento para hacer un volcado de todos los documentos.
Daniel Schneiter

0

Para devolver todos los registros de todos los índices que puede hacer:

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

Salida:

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

Si bien este fragmento de código puede resolver la pregunta, incluir una explicación realmente ayuda a mejorar la calidad de su publicación. Recuerde que está respondiendo la pregunta para los lectores en el futuro, y que esas personas podrían no conocer los motivos de su sugerencia de código.
Stamos

0

Ninguno, excepto @ Akira Sendoh, ha respondido cómo obtener TODOS los documentos. Pero incluso esa solución bloquea mi servicio ES 6.3 sin registros. Lo único que funcionó para mí usando la elasticsearch-pybiblioteca de bajo nivel fue mediante el asistente de escaneo 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

Sin embargo, la forma más limpia hoy en día parece ser a través de la elasticsearch-dslbiblioteca, que ofrece llamadas más abstractas y limpias, por ejemplo: http://elasticsearch-dsl.readthedocs.io/en/latest/search_dsl.html#hits


0

Si todavía alguien está buscando todos los datos para recuperar de Elasticsearch como yo para algunos casos de uso, esto es lo que hice. Además, todos los datos significan, todos los índices y todos los tipos de documentos. Estoy usando Elasticsearch 6.3

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

Referencia de Elasticsearch


0

esta es la consulta para lograr lo que desea (sugiero usar Kibana, ya que ayuda a comprender mejor las consultas)

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

Para obtener todos los registros, debe utilizar la consulta "match_all".

El tamaño es el número de registros que desea recuperar (tipo de límite). de forma predeterminada, ES solo devolverá 10 registros

from es como omitir, omitir los primeros 3 registros.

Si desea obtener exactamente todos los registros, simplemente use el valor del campo "total" del resultado una vez que haya accedido a esta consulta desde Kibana y luego úselo con "tamaño".


La limitación de esta consulta es que size + from debe ser menor o igual a "index.max_result_window". Para una gran cantidad de documentos (por defecto 10000+) esta consulta no es aplicable.
KarelHusa

0

Usando Elasticsearch 7.5.1

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

en caso de que también pueda especificar el tamaño de su matriz con & size = $ {number}

en caso de que no sepas que indexas

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

0

Se puede contribuir utilizando la consola kibana y my_index como índice para buscar lo siguiente. Si le pide al índice que solo devuelva 4 campos del índice, también puede agregar tamaño para indicar cuántos documentos desea que el índice le devuelva. A partir de ES 7.6, debe usar _source en lugar de filtrar, responderá más rápido.

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

-5

Puede usar size = 0 esto le devolverá todos los documentos de ejemplo

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

1
Esto devolverá una información acumulada, pero no los propios éxitos
user732456
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.