Zapytanie Elasticsearch zwracające wszystkie rekordy

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

Zwróć uwagę na rozmiar param , który zwiększa wyświetlane trafienia z domyślnego (10) do 1000 na odłamek.

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

Elasticsearch (ES) obsługuje zarówno żądanie GET, jak i POST w celu uzyskania danych z indeksu klastra ES.

Kiedy robimy GET:

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

Kiedy robimy POST:

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

Sugerowałbym użycie wtyczki UI z elasticsearch http://mobz.github.io/elasticsearch-head / Pomoże Ci to lepiej poznać indeksy, które tworzysz, a także przetestować indeksy.

Poniższe zapytanie zwróci NO_OF_RESULTS, które chcesz zwrócić..

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

Teraz pytanie brzmi, że chcesz wszystkie zapisy mają być zwrócone. Tak więc naturalnie, przed napisaniem zapytania, nie poznasz wartości NO_OF_RESULTS.

Skąd wiemy, ile rekordów istnieje w Twoim dokumencie? Po prostu wpisz zapytanie poniżej

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

To daje wynik, który wygląda jak ten poniżej

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

Wynik total informuje, ile rekordów jest dostępnych w dokumencie. To dobry sposób na poznanie wartości NO_OF RESULTS

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

Przeszukaj wszystkie typy we wszystkich indeksach

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

Przeszukaj wszystkie typy w indeksie foo

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

Przeszukuj wszystkie typy indeksów foo1 i foo2

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

Przeszukuj wszystkie typy w dowolnych indeksach zaczynających się od f

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

Wyszukaj typy user i tweet we wszystkich indeksach

Jest to najlepsze rozwiązanie, jakie znalazłem używając klienta Pythona

  # 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

Using 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

Użyj server:9200/_stats również, aby uzyskać statystyki dotyczące wszystkich Twoich aliasów.. podobnie jak rozmiar i liczba elementów na alias, jest to bardzo przydatne i dostarcza przydatnych informacji

Proste! Możesz użyć parametru size i from!

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

Następnie zmieniasz from stopniowo, aż otrzymasz wszystkie dane.

Elasticsearch uzyska znaczące wolniej, jeśli dodasz dużą liczbę jako rozmiar, jedną z metod do uzyskania wszystkich dokumentów jest skanowanie i przewijanie identyfikatorów.

Więc twój telefon będzie:

GET /foo/_search?search_type=scan&scroll=1m
{
    "query": { "match_all": {}},
    "size":  1000
}

Zwróci to _scroll_id, którego możesz teraz użyć do uzyskania pierwszej partii dokumentów.

Https://www.elastic.co/guide/en/elasticsearch/guide/current/scan-scroll.html

Najlepszym sposobem dopasowania rozmiaru jest użycie size=number przed adresem URL

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

Uwaga: maksymalna wartość, którą można zdefiniować w tym rozmiarze to 10000. Dla każdej wartości powyżej dziesięciu tysięcy oczekuje się, że użyjesz funkcji przewijania, która zminimalizuje wszelkie szanse na uderzenia do wydajności.

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

Musisz podać parametr zapytania o rozmiar, ponieważ domyślnie jest to 10

Możesz użyć _count API, aby uzyskać wartość parametru size:

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

Zwraca {count:X, ...}. Wyodrębnij wartość "X", a następnie wykonaj rzeczywiste zapytanie:

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

Kilka z nich dało prawidłową odpowiedź za pomocą skanowania i przewijania, najwyraźniej nie mogłem pełnej odpowiedzi, która magicznie zadziałałaby. Gdy ktoś chce pobierać rekordy, należy uruchomić następujące polecenie curl.

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

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

Its important to have _scroll_id handy as the very next you SHD run the following command

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

Jednak nie wydaje mi się, że łatwo go uruchomić to ręcznie. Najlepszym rozwiązaniem jest napisanie kodu java, aby zrobić to samo.

    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();

Teraz pętla na ostatnim poleceniu użyj SearchResponse, aby wyodrębnić dane.

Dla Elasticsearch 6.x

Request: GET /foo/_search?pretty=true

Odpowiedź: w Hits - > total, podaj liczbę docs

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

Rozmiar param zwiększa wyświetlane trafienia z domyślnego (10) do 500.

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

Zmień z krok po kroku, aby uzyskać wszystkie dane.

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

Domyślnie Elasticsearch zwraca 10 rekordów, więc rozmiar powinien być podany jawnie.

Dodaj rozmiar z żądaniem, aby uzyskać pożądaną liczbę rekordów.

Http: / / {host}:9200/{index_name} / _search?pretty = true&size=(liczba rekordów)

Uwaga : Maksymalny rozmiar strony nie może być większy niż indeks.max_result_window ustawienie indeksu, które domyślnie wynosi 10,000.

Aby zwrócić wszystkie rekordy ze wszystkich indeksów możesz zrobić:

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

Wyjście:

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

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

Maksymalny wynik, który zwróci przez elasticSearch, wynosi 10000, podając rozmiar

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

Następnie musisz użyć API przewijania, aby uzyskać wynik i uzyskać wartość _scroll_id i umieścić tę wartość w scroll_id

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

Nikt oprócz @Akira Sendoh nie odpowiedział, jak właściwie zdobyć wszystkie dokumenty. Ale nawet to rozwiązanie powoduje awarię mojej ES 6.3 usługi bez logów. Jedyną rzeczą, która zadziałała dla mnie przy użyciu biblioteki elasticsearch-py niskiego poziomu, było użycie scan helper , który używa 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

Jednak w dzisiejszych czasach czystszą drogą wydaje się być Biblioteka elasticsearch-dsl, która oferuje bardziej abstrakcyjne, czystsze wywołania, np: http://elasticsearch-dsl.readthedocs.io/en/latest/search_dsl.html#hits

Jeśli nadal ktoś szuka wszystkich danych do pobrania z Elasticsearch jak ja dla niektórych zastosowań, oto, co zrobiłem. Ponadto wszystkie dane oznaczają wszystkie indeksy i wszystkie typy dokumentów. Używam Elasticsearch 6.3

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

Elasticsearch reference

Możesz użyć size=0 to zwróci ci wszystkie dokumenty przykład

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