Requête Elasticsearch pour renvoyer tous les enregistrements

490

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?

John Livermore
la source
1
... où "foo" est le nom de l'index pour lequel vous souhaitez afficher tous les enregistrements.
jonatan

Réponses:

744

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)

Steve Casey
la source
6
Merci. C'est la finale que j'ai trouvée qui retourne ce dont j'ai besoin pour l'instant ... localhost: 9200 / foo / _search? Size = 50 & pretty = true & q = *: *
John Livermore
2
En ajoutant à la réponse de @ Steve, vous pouvez trouver une liste de paramètres que elasticsearch comprend dans ce lien elasticsearch.org/guide/reference/api/search/uri-request
Karthick
1
Merci @Steve pour votre réponse. Je ne pensais pas que c'était suffisamment important pour une nouvelle question. Ce n'était explicitement indiqué nulle part, alors j'ai pensé que je demanderais ici juste pour vérifier.
Churro
8
Vous devriez vraiment utiliser les requêtes scan + scroll. Si vous utilisez size = BIGNUMBER, notez que Lucene alloue de la mémoire pour les scores de ce nombre, alors ne le rendez pas excessivement grand. :)
Alex Brasetvik
4
Scan déconseillé en déconseillé 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
                                   ^

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

lfender6445
la source
10
Une chose à garder à l'esprit cependant (à partir des documents Elasticsearch): Notez que la taille de + ne peut pas être supérieure au paramètre d'index index.max_result_window qui par défaut est 10 000.
user3078523
2
Cela retournera 1000, pas tous, user3078523 a raison, cette méthode a une limite demax_result_window
stelios
1
Il a un maximum, et aussi (si vous avez plusieurs milliers d'enregistrements à obtenir), c'est une approche assez lourde de tête pour aller vers ce maximum. Au lieu de cela, vous devez utiliser une requête "scroll".
Harry Wood du
37

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.

Prerak Diwan
la source
3
Comme un autre utilisateur l'a mentionné: from+ sizene peut pas être supérieur au index.max_result_windowparamètre d'index qui est par défaut 10 000
stelios
Cette approche a un maximum, et aussi (si vous avez plusieurs milliers d'enregistrements à obtenir), c'est une approche lourde plutôt nodeuse pour aller vers ce maximum. Au lieu de cela, vous devriez utiliser une requête "scroll"
Harry Wood
Curieusement, les documents officiels montrent curl -XGET ... -d '{...}'qui est un unstyle de demande mixte officiel. Merci d'avoir montré les bons formats GET et POST.
Jesse Chisholm
28

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

vjpandian
la source
9
Par défaut, ES renvoie 10 résultats sauf si un paramètre de taille est inclus dans la requête de base.
lfender6445
La réponse précédente avait trois ans. Mis à jour à un actuel.
vjpandian
19

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

HungUnicorn
la source
Merci Mark, c'est exactement ce que je cherchais! Dans mon cas (ELK 6.2.1, python 3), l'argument search_type n'était pas valide et le document_type n'est plus nécessaire depuis ELK 6.0
Christoph Schranz
Solution parfaite! Merci. J'utilisais elasticsearch_dsl==5.4.0et ça marche sans search_type = 'scan',.
Usman Maqbool
ES 6.3. Cet exemple fait planter mon service Elasticsearch, essayant de faire défiler 110 000 documents avec size=10000, entre les 5e et 7e itérations. avec status=127, main ERROR Null object returned for RollingFile in Appenders, main ERROR Unable to locate appender "rolling" for logger config "root"Aucun fichier journal/var/log/elasticsearch/elasticsearch.log
de
Pour mémoire, les clients python implémentent un scanhelpers` qui fait défiler sous le capot (depuis la version 5.xx au moins)
MCMZL
search_type = 'scan'est obsolète. Un code similaire fonctionnera sans cela, bien qu'il existe des différences intéressantes qui sont bien enfouies dans l'ancienne documentation. elastic.co/guide/en/elasticsearch/reference/1.4/… En particulier, lors de la migration pour ne pas utiliser search_type = scan, cette première requête de «recherche» viendra avec le premier lot de résultats à traiter.
Harry Wood du
12

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>" 
}
WoodyDRN
la source
1
Cette réponse a besoin de plus de mises à jour. search_type=scanest désormais obsolète. Vous devez donc supprimer cela, mais le comportement a ensuite légèrement changé. Le premier lot de données revient de l'appel de recherche initial. Le lien que vous fournissez montre la bonne façon de le faire.
Harry Wood du
1
Mon commentaire était vraiment de noter que vous ne pouvez pas simplement ajouter un nombre comme taille, car cela serait beaucoup plus lent. J'ai donc supprimé l'exemple de code et les gens peuvent suivre le lien pour obtenir le code correct.
WoodyDRN du
1
@WoodyDRN Il est préférable d'avoir le code dans votre réponse (même s'il vieillit) afin qu'il soit toujours disponible lorsque le lien s'éteint.
Trisped
11

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

Oussama L.
la source
2
Mais, d'après ce dont je me souviens, ES ne permet d'obtenir que 16 000 données par demande. Donc, si les données dépassent 16 000, cette solution n'est pas suffisante.
Aminah Nuraini
10

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.

Somum
la source
6

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.

Aminah Nuraini
la source
4
n'utilisez jamais cette méthode si les données contiennent de nombreux documents ... A chaque fois que vous allez à "la page suivante" Elastic sera de plus en plus lent! Utilisez plutôt SearchAfter
Joshlo
3
En outre, cette solution ne fonctionnera pas si la taille globale des données est supérieure à 10 000. La taille de l'option = 1000 et from = 10001 échouerait.
iclman
2
En effet échoue. Les paramètres from+ sizene peuvent pas être supérieurs au paramètre d'index index.max_result_window qui est par défaut 10 000
stelios
1
Si les données contiennent plusieurs milliers de documents, la bonne réponse consiste à utiliser une requête de «défilement».
Harry Wood du
Avec l' approche fromet sizevous rencontrerez le problème de pagination profonde. Utilisez l'API scroll pour effectuer un vidage de tous les documents.
Daniel Schneiter
5

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.

akshay misra
la source
Depuis quelle version la taille maximale se produit-elle?
WoodyDRN
C'est peut-être le «meilleur» moyen jusqu'à un certain point, mais vraiment un petit signe de tête. Si vous avez plusieurs milliers d'enregistrements, la meilleure façon est une requête "scroll".
Harry Wood du
Avec l'approche from et size, vous rencontrerez le problème de pagination profonde. Utilisez l'API scroll pour effectuer un vidage de tous les documents.
Daniel Schneiter
5

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
Daniel
la source
1
Définir la taille sur X comme ceci pourrait avoir un problème de concurrence surprenant: réfléchissez à ce qui se passe si un enregistrement est ajouté entre le comptage et la définition de la taille dans votre prochaine requête ... mais aussi si vous avez plusieurs milliers d'enregistrements à obtenir , alors c'est la mauvaise approche. Au lieu de cela, vous devez utiliser une requête "scroll".
Harry Wood du
4

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

Edwin Ikechukwu Okonkwo
la source
Avec l'approche from et size, vous rencontrerez le problème de pagination profonde. Utilisez l'API scroll pour effectuer un vidage de tous les documents.
Daniel Schneiter
4

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
Prasanna Jathan
la source
3

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": [
          {
Anurag
la source
3

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

Radu Gheorghe
la source
2
curl -X GET 'localhost:9200/foo/_search?q=*&pretty' 
Dhruv Sharma
la source
2

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.

Satyendra Sharma
la source
2

De Kibana DevTools c'est:

GET my_index_name/_search
{
  "query": {
    "match_all": {}
  }
}
belostoky
la source
2

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 .

asmaier
la source
1

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" : "" 
}'
RAHUL JAIN
la source
L'API scroll doit être utilisée dès le début avec la toute première demande.
Daniel Schneiter
1

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!

christouandr7
la source
L'auteur de la question demandait «tous» les résultats, pas une quantité prédéfinie de résultats. Bien qu'il soit utile de publier un lien vers les documents, les documents ne décrivent pas comment y parvenir, pas plus que votre réponse.
Maarten00
Avec l'approche from et size, vous rencontrerez le problème de pagination profonde. Utilisez l'API scroll pour effectuer un vidage de tous les documents.
Daniel Schneiter
0

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,
       ...
exceltior
la source
0
curl -XGET '{{IP/localhost}}:9200/{{Index name}}/{{type}}/_search?scroll=10m&pretty' -d '{
"query": {
"filtered": {
"query": {
"match_all": {}
}}'
aditya
la source
Bien que cet extrait de code puisse résoudre la question, y compris une explication aide vraiment à améliorer la qualité de votre message. N'oubliez pas que vous répondrez à la question des lecteurs à l'avenir et que ces personnes ne connaissent peut-être pas les raisons de votre suggestion de code.
Stamos
0

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

stelios
la source
0

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

Santosh Kumar Arjunan
la source
0

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

niranjan harpale
la source
La limitation de cette requête est que la taille + de doit être inférieure ou égale à "index.max_result_window". Pour un grand nombre de documents (par défaut 10000+), cette requête n'est pas applicable.
KarelHusa
0

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
Tiago Medici
la source
0

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":{ }
    }   
 }
Gregory Neely
la source
-5

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" : {}
    }
}'
premkumar
la source
1
Cela retournera une information accumulée, mais pas les hits eux
user732456