database - Consulta de Elasticsearch para devolver todos los registros.
bigdata query-string (22)
¡Sencillo! Puedes usar size y from parámetro!
http://localhost:9200/[your index name]/_search?size=1000&from=0
luego cambias gradualmente de hasta que obtengas todos los datos.
Tengo una pequeña base de datos en Elasticsearch y para fines de prueba me gustaría recuperar 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 para:
http://localhost:9200/foo/_search?pretty=true&q=*:*
el tamaño predeterminado es 10, por lo que también puede necesitar &size=BIGNUMBER para obtener más de 10 elementos. (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 suggests grandes conjuntos de resultados, 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 seguir solicitando según el enlace de documentación anterior sugiere.
EDIT: scan obsoleto en 2.1.0.
scan no proporciona ningún beneficio sobre una solicitud de scroll regular ordenada por _doc . enlace a documentos elásticos (vistos por @ christophe-roussy)
El resultado máximo que devolverá con 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, tienes que 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" : ""
}''
Elasticsearch se volverá mucho más lento si solo agrega un número grande como tamaño, un método que puede usar para obtener todos los documentos es usar las identificaciones de escaneo y desplazamiento.
https://www.elastic.co/guide/en/elasticsearch/reference/current/search-request-scroll.html
Esta es la mejor solución que encontré usando el cliente de 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 java cliente
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
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 por encima de diez mil, se espera que use la función de desplazamiento que minimizaría cualquier posibilidad de impacto en el rendimiento.
La siguiente consulta devolverá los NO_OF_RESULTS que le gustaría 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 sabrá 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 que se parece al de abajo.
{
hits" : {
"total" : 2357,
"hits" : [
{
..................
El resultado total le indica cuántos registros están disponibles en su documento. Entonces, esa es una buena manera de saber el valor de NO_OF RESULTS
curl -XGET ''localhost:9200/_search'' -d ''
Buscar todos los tipos en todos los índices.
curl -XGET ''localhost:9200/foo/_search'' -d ''
Busca 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 de usuario y tweet en todos los índices.
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 me funcionó con la biblioteca elasticsearch-py bajo nivel fue a través de la ayuda de escaneo que usa la api scroll() :
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 elasticsearch-dsl biblioteca elasticsearch-dsl , que ofrece llamadas más abstractas y más limpias, por ejemplo: http://elasticsearch-dsl.readthedocs.io/en/latest/search_dsl.html#hits
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": [
{
Para devolver todos los registros de todos los índices puedes 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,
...
Por defecto, Elasticsearch devuelve 10 registros por lo que el tamaño debe proporcionarse explícitamente.
Añadir tamaño con solicitud para obtener el número de deseo de los 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 más que la configuración del índice index.max_result_window que por defecto es 10,000.
Puede usar la API _count para obtener el valor para el parámetro de size :
http://localhost:9200/foo/_count?q=<your query>
Devuelve {count:X, ...} . Extraiga el valor ''X'' y luego haga la consulta real:
http://localhost:9200/foo/_search?q=<your query>&size=X
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" : {}
}
}''
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 quedó en desuso y se eliminó en v5.0. No lo necesitas
Comience con una consulta de ''búsqueda'', pero especifique 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 hits. Pero no hemos terminado aquí. La salida del comando curl anterior sería algo como esto:
{"_scroll_id":"c2Nhbjs1OzUyNjE6NU4tU3BrWi1UWkNIWVNBZW43bXV3Zzs1Mzc3OkhUQ0g3VGllU2FhemJVNlM5d2t0alE7NTI2Mjo1Ti1TcGtaLVRaQ0hZU0FlbjdtdXdnOzUzNzg6SFRDSDdUaWVTYWF6YlU2Uzl3a3RqUTs1MjYzOjVOLVNwa1otVFpDSFlTQWVuN211d2c7MTt0b3RhbF9oaXRzOjIyNjAxMzU3Ow==","took":109,"timed_out":false,"_shards":{"total":5,"successful":5,"failed":0},"hits":{"total":22601357,"max_score":0.0,"hits":[]}}
Es importante tener a la mano _scroll_id 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. Tu mejor apuesta 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.
Si todavía alguien está buscando todos los datos para ser recuperados 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": {}
}
}
''
elasticsearch (ES) admite tanto una solicitud GET como una solicitud POST para obtener los datos del índice de agrupación de ES.
Cuando hacemos un GET:
http://localhost:9200/[your index name]/_search?size=[no of records you want]&q=*:*
Cuando hacemos un POST:
http://localhost:9200/[your_index_name]/_search
{
"size": [your value] //default 10
"from": [your start index] //default 0
"query":
{
"match_all": {}
}
}
Yo sugeriría usar un complemento de UI con elasticsearch http://mobz.github.io/elasticsearch-head/ Esto le ayudará a tener una mejor idea de los índices que crea y también a probar sus índices.
use server:9200/_stats también para obtener estadísticas sobre todos sus alias .. como el tamaño y la cantidad de elementos por alias, eso es muy útil y proporciona información útil
http://localhost:9200/foo/_search/ ? tamaño = 1000 y bonito = 1
Tendrá que especificar el parámetro de consulta de tamaño, ya que el valor predeterminado es 10
tamaño param aumenta los resultados mostrados desde el valor predeterminado (10) hasta 500.
http://localhost:9200/[indexName]/_search?pretty=true&size=500&q=*:*
Cambia el paso a paso para obtener todos los datos.
http://localhost:9200/[indexName]/_search?size=500&from=0
curl -X GET ''localhost:9200/foo/_search?q=*&pretty''
curl -XGET ''{{IP/localhost}}:9200/{{Index name}}/{{type}}/_search?scroll=10m&pretty'' -d ''{
"query": {
"filtered": {
"query": {
"match_all": {}
}}''
http://127.0.0.1:9200/foo/_search/?size=1000&pretty=1
^
Tenga en cuenta el tamaño param , que aumenta los resultados mostrados desde el valor predeterminado (10) a 1000 por fragmento.
http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-from-size.html