Requête Elasticsearch pour renvoyer tous les enregistrements

J'ai une petite base de données dans Elasticsearch et à des fins de test, je voudrais retirer tous les enregistrements. J'essaie d'utiliser une URL du formulaire ...

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

Quelqu'un peut-il me donner l'URL que vous utiliseriez pour accomplir cela, s'il vous plaît?

Je pense que la syntaxe lucene est supportée donc:

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

la taille par défaut est 10, vous devrez donc peut-être également &size=BIGNUMBERobtenir plus de 10 articles. (où BIGNUMBER est égal à un nombre que vous pensez être plus grand que votre ensemble de données)

MAIS, la documentation elasticsearch suggère des jeux de résultats volumineux, en utilisant le type de recherche de scan.

PAR EXEMPLE:

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

puis continuez à demander selon le lien de documentation ci-dessus suggère.

EDIT: scanobsolète en 2.1.0.

scann'offre aucun avantage par rapport à une scrolldemande régulière triée par _doc. lien vers les documents élastiques (repéré par @ christophe-roussy)

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

Notez le paramètre de taille , qui augmente les hits affichés par défaut (10) à 1000 par fragment.

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

elasticsearch (ES) prend en charge à la fois une requête GET ou POST pour obtenir les données de l'index de cluster ES.

Quand nous faisons un GET:

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

Quand nous faisons un POST:

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

Je suggérerais d'utiliser un plugin d'interface utilisateur avec elasticsearch http://mobz.github.io/elasticsearch-head/ Cela vous aidera à avoir une meilleure idée des indices que vous créez et également à tester vos indices.

Remarque: La réponse concerne une ancienne version d'Elasticsearch 0.90. Les versions publiées depuis lors ont une syntaxe mise à jour. Veuillez vous reporter à d'autres réponses susceptibles de fournir une réponse plus précise à la dernière réponse que vous recherchez.

La requête ci-dessous retournerait les NO_OF_RESULTS que vous aimeriez être renvoyés.

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

Maintenant, la question ici est que vous voulez que tous les enregistrements soient retournés. Donc, naturellement, avant d'écrire une requête, vous ne connaîtrez pas la valeur de NO_OF_RESULTS .

Comment savons-nous combien d'enregistrements existent dans votre document? Tapez simplement la requête ci-dessous

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

Cela vous donnerait un résultat qui ressemble à celui ci-dessous

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

Le résultat total vous indique le nombre d'enregistrements disponibles dans votre document. C'est donc une bonne façon de connaître la valeur de NO_OF RESULTS

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

Rechercher tous les types dans tous les indices

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

Rechercher tous les types dans l'index foo

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

Rechercher tous les types dans les indices foo1 et foo2

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

Rechercher tous les types dans tous les indices commençant par f

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

Types de recherche utilisateur et tweet dans tous les index

C'est la meilleure solution que j'ai trouvée en utilisant le client 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

Utilisation du client 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 sera beaucoup plus lent si vous ajoutez simplement un grand nombre comme taille, une méthode à utiliser pour obtenir tous les documents consiste à utiliser les ID de numérisation et de défilement.

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

Dans Elasticsearch v7.2, vous le faites comme ceci:

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

Les résultats de cela contiendraient un _scroll_id que vous devez interroger pour obtenir les 100 prochains morceaux.

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

utilisez server:9200/_statségalement pour obtenir des statistiques sur tous vos alias .. comme la taille et le nombre d'éléments par alias, c'est très utile et fournit des informations utiles

Si vous souhaitez extraire plusieurs milliers d'enregistrements, alors ... quelques personnes ont donné la bonne réponse en utilisant "scroll" (Remarque: certaines personnes ont également suggéré d'utiliser "search_type = scan". Ceci était obsolète et supprimé dans la v5.0. Vous n'en avez pas besoin)

Commencez par une requête de recherche, mais en spécifiant un paramètre de défilement (ici, j'utilise un délai de 1 minute):

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

Cela inclut votre premier «lot» de hits. Mais nous n'avons pas fini ici. La sortie de la commande curl ci-dessus ressemblerait à ceci:

{ "_Scroll_id": "c2Nhbjs1OzUyNjE6NU4tU3BrWi1UWkNIWVNBZW43bXV3Zzs1Mzc3OkhUQ0g3VGllU2FhemJVNlM5d2t0alE7NTI2Mjo1Ti1TcGtaLVRaQ0hZU0FlbjdtdXdnOzUzNzg6SFRDSDdUaWVTYWF6YlU2Uzl3a3RqUTs1MjYzOjVOLVNwa1otVFpDSFlTQWVuN211d2c7MTt0b3RhbF9oaXRzOjIyNjAxMzU3Ow ==", "a": 109, "timed_out": false, "_ tessons": { "total": 5, "avec succès": 5, "a échoué": 0}, "hits" : {"total": 22601357, "max_score": 0,0, "hits": []}}

Il est important d'avoir _scroll_id à portée de main car vous devez ensuite exécuter la commande suivante:

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

Cependant, passer le scroll_id n'est pas quelque chose conçu pour être fait manuellement. Le mieux est d'écrire du code pour le faire. par exemple 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();

Maintenant, LOOP sur la dernière commande utilise SearchResponse pour extraire les données.

Facile! Vous pouvez utiliser sizeet fromparamétrer!

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

puis vous modifiez fromprogressivement jusqu'à obtenir toutes les données.

La meilleure façon d'ajuster la taille est d'utiliser size = number devant l'URL

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

Remarque: la valeur maximale qui peut être définie dans cette taille est de 10000. Pour toute valeur supérieure à dix mille, elle attend de vous que vous utilisiez la fonction de défilement qui minimise les risques d'impact sur les performances.

Vous pouvez utiliser l' _countAPI pour obtenir la valeur du sizeparamètre:

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

Retours {count:X, ...}. Extrayez la valeur 'X' puis effectuez la requête réelle:

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

http: // localhost: 9200 / foo / _search / ? taille = 1000 et jolie = 1

vous devrez spécifier le paramètre de requête de taille car la valeur par défaut est 10

size param augmente les hits affichés de la valeur par défaut (10) à 500.

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

Modifier la de l' étape par étape pour obtenir toutes les données.

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

Pour Elasticsearch 6.x

Demande: GET /foo/_search?pretty=true

Réponse: dans Hits-> total, donnez le nombre de documents

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

S'il s'agit d'un petit ensemble de données (par exemple, 1 000 enregistrements) , vous pouvez simplement spécifier size:

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

La requête match all n'est pas nécessaire, car elle est implicite.

Si vous avez un ensemble de données de taille moyenne, comme des enregistrements 1M , vous n'avez peut-être pas assez de mémoire pour le charger, vous avez donc besoin d'un défilement .

Un défilement est comme un curseur dans une base de données. Dans Elasticsearch, il se souvient de l'endroit où vous vous êtes arrêté et conserve la même vue de l'index (c'est-à-dire empêche le chercheur de s'en aller avec un rafraîchissement , empêche les segments de fusionner ).

Côté API, vous devez ajouter un paramètre de défilement à la première requête:

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

Vous récupérez la première page et un ID de défilement:

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

N'oubliez pas que l'ID de défilement que vous récupérez et le délai d'expiration sont valides pour la page suivante . Une erreur courante consiste à spécifier un délai d'attente très important (valeur descroll ), qui couvrirait le traitement de l'ensemble de données (par exemple 1 million d'enregistrements) au lieu d'une page (par exemple 100 enregistrements).

Pour obtenir la page suivante, remplissez le dernier ID de défilement et un délai d'expiration qui devrait durer jusqu'à la récupération de la page suivante:

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

Si vous avez beaucoup à exporter (par exemple des documents 1B) , vous voudrez paralléliser. Cela peut être fait via un rouleau en tranches . Supposons que vous souhaitiez exporter sur 10 threads. Le premier thread émettrait une requête comme celle-ci:

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

Vous récupérez la première page et un ID de défilement, exactement comme une demande de défilement normale. Vous le consommeriez exactement comme un défilement normal, sauf que vous obtenez 1 / 10ème des données.

D'autres threads feraient de même, sauf que ce idserait 1, 2, 3 ...

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

Par défaut, Elasticsearch renvoie 10 enregistrements, la taille doit donc être indiquée explicitement.

Ajoutez la taille avec la demande pour obtenir le nombre d'enregistrements souhaité.

http: // {hôte}: 9200 / {index_name} / _search? pretty = true & size = (nombre d'enregistrements)

Remarque: la taille de page maximale ne peut pas être supérieure au paramètre d'index index.max_result_window, qui est par défaut 10 000.

De Kibana DevTools c'est:

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

Une solution simple utilisant le package 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)

Voir également https://elasticsearch-dsl.readthedocs.io/en/latest/api.html#elasticsearch_dsl.Search.scan .

Le résultat maximum qui sera renvoyé par ElasticSearch est 10000 en fournissant la taille

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

Après cela, vous devez utiliser l'API Scroll pour obtenir le résultat et obtenir la valeur _scroll_id et mettre cette valeur dans scroll_id

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

La documentation officielle apporte la réponse à cette question! vous pouvez le trouver ici .

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

Vous remplacez simplement la taille (1) par le nombre de résultats que vous souhaitez voir!

Pour renvoyer tous les enregistrements de tous les index, vous pouvez:

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

Production:

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

Aucun, sauf @Akira Sendoh a répondu comment obtenir TOUS les documents. Mais même cette solution plante mon service ES 6.3 sans journaux. La seule chose qui a fonctionné pour moi en utilisant la elasticsearch-pybibliothèque de bas niveau était grâce à l'aide à l'analyse qui utilise l' 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

Cependant, la manière la plus propre de nos jours semble être la elasticsearch-dslbibliothèque, qui propose des appels plus abstraits et plus propres, par exemple: http://elasticsearch-dsl.readthedocs.io/en/latest/search_dsl.html#hits

Si quelqu'un cherche encore toutes les données à récupérer dans Elasticsearch comme moi pour quelques cas d'utilisation, voici ce que j'ai fait. De plus, toutes les données signifient, tous les index et tous les types de documents. J'utilise Elasticsearch 6.3

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

Référence Elasticsearch

c'est la requête pour accomplir ce que vous voulez, (je suggère d'utiliser Kibana, car cela aide à mieux comprendre les requêtes)

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

pour obtenir tous les enregistrements, vous devez utiliser la requête "match_all".

taille correspond au nombre d'enregistrements que vous souhaitez récupérer (type de limite). par défaut, ES ne renverra que 10 enregistrements

est comme sauter, sauter les 3 premiers enregistrements.

Si vous voulez récupérer exactement tous les enregistrements, utilisez simplement la valeur du champ "total" du résultat une fois que vous avez frappé cette requête de Kibana et utilisez-la avec "taille".

Utilisation d'Elasticsearch 7.5.1

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

dans le cas où vous pouvez également spécifier la taille de votre tableau avec & size = $ {number}

au cas où vous ne savez pas que vous indexez

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

L'utilisation de la console kibana et de my_index comme index pour rechercher les éléments suivants peut être apportée. En demandant à l'index de ne renvoyer que 4 champs de l'index, vous pouvez également ajouter une taille pour indiquer le nombre de documents que vous souhaitez renvoyer par l'index. À partir d'ES 7.6, vous devriez utiliser _source plutôt que filtrer, il répondra plus rapidement.

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

Vous pouvez utiliser size = 0 cela vous renverra tous les documents exemple

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