web-dev-qa-db-fra.com

Elasticsearch requête pour renvoyer tous les enregistrements

J'ai une petite base de données dans Elasticsearch et, à des fins de test, j'aimerais récupérer 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 ceci, s'il vous plaît?

databaseelasticsearchbigdataquery-stringelasticsearch-dsl
399
John Livermore

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 aurez peut-être également besoin de &size=BIGNUMBER pour obtenir plus de 10 éléments. (où BIGNUMBER est égal à un nombre que vous croyez supérieur à votre jeu de données)

MAIS, elasticsearch documentation suggère pour les grands ensembles de résultats, en utilisant le type de recherche par balayage.

PAR EXEMPLE:

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

puis continuez à demander conformément au lien de la documentation suggéré ci-dessus.

EDIT: scan Obsolète en 2.1.0.

scan ne fournit aucun avantage par rapport à une demande scroll régulière triée par _doc. lien vers les documents élastiques (repéré par @ christophe-roussy)

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

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

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

116
lfender6445

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

Quand on fait un GET:

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

Quand on fait 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 plug-in 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 à tester vos indices. 

27
Prerak Diwan

La requête ci-dessous renverrait les NO_OF_RESULTS que vous souhaitez récupérer.

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

Maintenant, la question est que vous voulez tous les enregistrements doivent être 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. Donc, c’est une bonne façon de connaître la valeur de AUCUN RÉSULTAT 

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

Rechercher tous les types dans tous les index

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 index foo1 et foo2

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

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

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

Types de recherche utilisateur et Tweet dans tous les index

19
vjpan8564

C’est la meilleure solution que j’ai trouvée en utilisant un 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/fr/elasticsearch/client/Java-api/current/Java-search-scrolling.html

16
Akira Sendoh

utilisez également server:9200/_stats 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.

10
TheEnglishMe

Si vous voulez 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é de la v5.0. Vous n'en avez pas besoin)

Commencez avec une requête 'search', mais en spécifiant un paramètre 'scroll' (ici, j'utilise un délai d'une 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:

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

Cependant, faire passer le scroll_id n'est pas conçu pour être fait manuellement. Votre meilleur pari 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.

7
Somum

Simple! Vous pouvez utiliser les paramètres size et from!

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

vous modifiez ensuite la from progressivement jusqu'à obtenir toutes les données.

7
Aminah Nuraini

Elasticsearch ralentira significatif si vous ajoutez simplement un grand nombre en taille. L'une des méthodes à utiliser pour obtenir tous les documents consiste à utiliser les identifiants de numérisation et de défilement.

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

6
WoodyDRN

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

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

5
Edwin Ikechukwu

La meilleure façon de régler la taille est d'utiliser size = number devant l'URL. 

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

Remarque: la valeur maximale pouvant être définie dans cette taille est 10 000. Pour toute valeur supérieure à 10 000, il est prévu que vous utilisiez la fonction de défilement qui minimiserait les risques d’impact sur les performances.

5
akshay misra

Vous pouvez utiliser l'API _count pour obtenir la valeur du paramètre size:

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

Retourne {count:X, ...}. Extrayez la valeur 'X' puis effectuez la requête proprement dite:

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

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 = *: *

Changez le de pas à pas pour obtenir toutes les données.

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

La documentation officielle fournit 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!

2
christouandr7

De Kibana DevTools sa:

GET my_index_name/_search
{
  "query": {
    "match_all": {}
  }
}
1
belostoky
curl -X GET 'localhost:9200/foo/_search?q=*&pretty'
1
Dhruv Sharma

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

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

http: // {Host}: 9200/{nom_index}/_search? pretty = true & size = (nombre d'enregistrements)

Remarque : La taille maximale de la page ne peut pas dépasser index.max_result_window, dont le paramètre par défaut est 10 000.

1
Satyendra Sharma

Si quelqu'un cherche toujours à récupérer toutes les données d'Elasticsearch, comme moi pour certains cas d'utilisation, voici ce que j'ai fait. De plus, toutes les données, 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

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

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 est le nombre d'enregistrements que vous souhaitez récupérer (type de limite). par défaut, ES ne renverra que 10 enregistrements

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

0
niranjan harpale

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

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

Sortie:

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

Aucun, à l'exception de @Akira Sendoh, qui a expliqué comment obtenir TOUS les documents. Mais même cette solution bloque mon service ES 6.3 sans les journaux. La seule chose qui a fonctionné pour moi en utilisant la bibliothèque elasticsearch-py de bas niveau était via helper scan qui utilise 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 solution la plus propre semble actuellement être la bibliothèque elasticsearch-dsl, qui offre des appels plus abstraits et plus propres, par exemple: http://elasticsearch-dsl.readthedocs.io/en/latest/search_dsl.html#hits

0
chefarov

Une solution simple utilisant le paquet 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 aussi https://elasticsearch-dsl.readthedocs.io/en/latest/api.html#elasticsearch_dsl.Search.scan .

0
asmaier

Le résultat maximum qui sera renvoyé parasticSearch 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, obtenir la valeur _scroll_id et la mettre dans scroll_id.

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