Consulta Elasticsearch para devolver todos los registros

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?

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)

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

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.

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

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

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

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

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.

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

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.

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

http: // localhost: 9200 / foo / _search / ? tamaño = 1000 y bonita = 1

deberá especificar el parámetro de consulta de tamaño ya que el valor predeterminado es 10

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

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

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

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

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.

De Kibana DevTools es:

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

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 .

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

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

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

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

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

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

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

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

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