Elasticsearch requête pour renvoyer tous les enregistrements

Je pense que lucene en charge la syntaxe de la sorte:

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

taille par défaut est de 10, de sorte que vous pouvez aussi avoir besoin &size=BIGNUMBER pour obtenir plus de 10 articles. (où BIGNUMBER est égal à un nombre que vous croyez est plus grand que votre dataset)

MAIS, elasticsearch documentation suggère pour les grands ensembles de résultats, l'utilisation du scanner, type de recherche.

Par exemple:

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

et puis garder demandant que par la documentation lien ci-dessus suggère.

EDIT: scan Obsolète dans 2.1.0.

scan ne fournit pas de prestations sur une régulière scroll demande triés par _doc. lien élastique docs (repéré par @christophe-roussy)

elasticsearch(ES) prend en charge un GET ou un POST de demande pour l'obtention des données de l'ES cluster index.

Quand nous faire un GET:

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

Lorsque l'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ère d'utiliser une INTERFACE utilisateur plugin avec elasticsearch http://mobz.github.io/elasticsearch-head/
Cela vous aidera à obtenir une meilleure sensation des indices vous créez et testez aussi vos indices.

C'est la meilleure solution que j'ai trouvé à l'aide de python client

  # 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

À l'aide de java client

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

Si vous voulez tirer plusieurs milliers de dossiers, puis... un peu de gens ont donné la bonne réponse de à l'aide de défilement (Note: Certaines personnes ont aussi suggéré d'utiliser "search_type=scan". C'était obsolète, et en v5.0 supprimées. Vous n'en avez pas besoin)

Commencer avec une "recherche" de la requête, mais la spécification d'un défilement de paramètre (ici, je suis à l'aide d'une 1 minute de délai d'attente):

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

Qui comprend votre première "batch" de hits. Mais nous ne sommes pas fait ici. La sortie de la ci-dessus commande curl serait quelque chose comme ceci:

{"_scroll_id":"c2Nhbjs1OzUyNjE6NU4tU3BrWi1UWkNIwvnbzw43bxv3zzs1mzc3okhuq0g3vgllu2fhemjvnlm5d2t0ale7nti2mjo1ti1tcgtalvraq0hzu0flbjdtdxdnozuznzg6sfrdsdduawvtywf6ylu2uzl3a3rquts1mjyzojvolvnwa1otvfpdsfltqwvun211d2c7mtt0b3rhbf9oaxrzojiynjaxmzu3ow==","took":109,"timed_out":false,"_shards":{"total":5,"successful":5,"failed":0},"hits":{"total":22601357,"max_score":0.0,"hits":[]}}

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

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

Cependant, le passage de la scroll_id autour n'est pas quelque chose conçu pour être effectué manuellement. Votre meilleur pari est d'écrire le 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();

Désormais en BOUCLE sur la dernière commande utiliser SearchResponse pour extraire les données.

Elasticsearch obtiendrez significative de plus si vous venez d'ajouter un peu de grand nombre que la taille, la méthode à utiliser pour obtenir tous les documents à l'aide d'analyse et de défilement id.

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

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

vous aurez besoin de spécifier la taille de la requête de paramètre par défaut est de 10

taille param augmente les résultats affichés à partir de la valeur par défaut(10) à 500.

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

Changer le de étape par étape pour obtenir toutes les données.

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

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

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

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

Il vous suffit de remplacer la taille (1) avec le nombre de résultats que vous voulez voir!

Le maximum de résultat, qui sera de retour en 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 le Défilement de l'API pour obtenir le résultat et obtenir le _scroll_id valeur et de mettre cette valeur dans scroll_id

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

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

Si encore quelqu'un est à la recherche de toutes les données récupérées à partir d'Elasticsearch comme moi, pour certains usecases, voici ce que j'ai fait. En outre, toutes les données, tous les indices et tous les autres 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": {}
    }
}
'

Elasticsearch référence

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

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

pour obtenir tous les enregistrements que vous avez à utiliser "match_all de la requête".

est la taille de l'absence de dossiers que vous souhaitez récupérer (sorte de limite).
par défaut, ES retournera seulement les 10 enregistrements

est comme sauter, sauter les 3 premiers enregistrements.

Si vous voulez vous procurer exactement tous les enregistrements, il suffit d'utiliser la valeur de "total" champ
à partir du résultat une fois que vous frappez cette requête à partir de Kibana et l'utiliser avec "taille".