Zapytanie Elasticsearch, aby zwrócić wszystkie rekordy

Mam małą bazę danych w Elasticsearch i do celów testowych chciałbym wycofać wszystkie rekordy. Próbuję użyć adresu URL formularza ...

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

Czy ktoś może mi podać adres URL, którego byś użył do osiągnięcia tego celu?

Myślę, że składnia Lucene jest obsługiwana, więc:

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

rozmiar domyślnie wynosi 10, więc może być konieczne &size=BIGNUMBERuzyskanie więcej niż 10 elementów. (gdzie BIGNUMBER to liczba, która Twoim zdaniem jest większa niż Twój zestaw danych)

ALE, dokumentacja elasticsearch sugeruje dla dużych zestawów wyników, używając typu wyszukiwania skanowania.

NA PRZYKŁAD:

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

a następnie nadal pytaj zgodnie z powyższym sugerowanym linkiem do dokumentacji.

EDYCJA: scanPrzestarzałe w 2.1.0.

scannie zapewnia żadnych korzyści w stosunku do zwykłego scrollzapytania posortowanego według _doc. link do elastycznych dokumentów (zauważonych przez @ christophe-roussy)

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

Zwróć uwagę na parametr wielkości , który zwiększa liczbę trafień wyświetlanych z wartości domyślnej (10) do 1000 na odłamek.

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

Elasticsearch (ES) obsługuje żądanie GET lub POST w celu uzyskania danych z indeksu klastrów ES.

Kiedy robimy GET:

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

Kiedy wykonujemy test 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 w lepszym odczuciu tworzonych indeksów, a także w testowaniu indeksów.

Uwaga: odpowiedź dotyczy starszej wersji Elasticsearch 0.90. Wersje wydane od tego czasu mają zaktualizowaną składnię. Proszę odnieść się do innych odpowiedzi, które mogą dostarczyć dokładniejszej odpowiedzi na najnowszą odpowiedź, której szukasz.

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

Pytanie dotyczy tego, czy chcesz zwrócić wszystkie rekordy. Oczywiście przed napisaniem zapytania nie poznasz wartości NO_OF_RESULTS .

Skąd wiemy, ile rekordów znajduje się 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 suma informuje, ile rekordów jest dostępnych w dokumencie. To dobry sposób na poznanie wartości WYNIKÓW BRAK

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

Wyszukaj wszystkie typy we wszystkich indeksach

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

Wyszukaj wszystkie typy w indeksie foo

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

Wyszukaj wszystkie typy w indeksach foo1 i foo2

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

Wyszukaj wszystkie typy w dowolnych indeksach zaczynających się na f

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

Typy wyszukiwania użytkownika i tweeta we wszystkich indeksach

To najlepsze rozwiązanie, jakie znalazłem za pomocą klienta 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

Korzystanie z klienta 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 będzie znacznie wolniejszy, jeśli dodasz dużą liczbę jako rozmiar, jedną z metod uzyskania wszystkich dokumentów jest użycie identyfikatorów skanowania i przewijania.

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

W Elasticsearch w wersji 7.2 robisz to w następujący sposób:

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

Wyniki z tego będą zawierać _scroll_id, który musisz zapytać, aby uzyskać kolejne 100 porcji.

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

użyj server:9200/_statsrównież, aby uzyskać statystyki dotyczące wszystkich twoich aliasów, takich jak rozmiar i liczba elementów na alias, co jest bardzo przydatne i dostarcza pomocnych informacji

Jeśli chcesz pobrać wiele tysięcy rekordów, to ... kilka osób udzieliło prawidłowej odpowiedzi przy użyciu „przewijania” (Uwaga: Niektóre osoby sugerowały również użycie „search_type = scan”. To było przestarzałe, a w wersji 5.0 usunięte. Nie potrzebujesz tego)

Zacznij od zapytania „szukaj”, ale określ parametr „przewijania” (tutaj używam limitu czasu 1 minuty):

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

Obejmuje to twoją pierwszą „serię” hitów. Ale nie skończyliśmy tutaj. Wyjście powyższego polecenia curl wyglądałoby mniej więcej tak:

{ "_Scroll_id": "c2Nhbjs1OzUyNjE6NU4tU3BrWi1UWkNIWVNBZW43bXV3Zzs1Mzc3OkhUQ0g3VGllU2FhemJVNlM5d2t0alE7NTI2Mjo1Ti1TcGtaLVRaQ0hZU0FlbjdtdXdnOzUzNzg6SFRDSDdUaWVTYWF6YlU2Uzl3a3RqUTs1MjYzOjVOLVNwa1otVFpDSFlTQWVuN211d2c7MTt0b3RhbF9oaXRzOjIyNjAxMzU3Ow ==", "wziął": 109, "timed_out": false, "_ odłamki": { "total": 5, "sukces": 5, "nie powiodło się": 0}, "hity" : {„total”: 22601357, „max_score”: 0,0, „hits”: []}}

Ważne jest, aby mieć przy sobie _scroll_id, ponieważ należy uruchomić następującą komendę:

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

Jednak przekazywanie scroll_id nie jest czymś, co można wykonać ręcznie. Najlepiej jest napisać kod, aby to zrobić. np. w 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();

Teraz LOOP dla ostatniego polecenia użyj SearchResponse, aby wyodrębnić dane.

Prosty! Możesz użyć sizei fromparametryzować!

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

następnie zmieniasz fromstopniowo, aż uzyskasz wszystkie dane.

Najlepszym sposobem dostosowania rozmiaru jest użycie size = liczba 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 wpływu na wydajność.

Możesz użyć _countinterfejsu API, aby uzyskać wartość sizeparametru:

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

Powraca {count:X, ...}. Wyodrębnij wartość „X”, a następnie wykonaj rzeczywiste zapytanie:

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

http: // localhost: 9200 / foo / _search / ? rozmiar = 1000 i ładny = 1

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

size param zwiększa liczbę wyświetlanych trafień z wartości domyślnej (10) do 500.

http: // localhost: 9200 / [nazwa_indeksu] / _search? pretty = true i rozmiar = 500 i q = *: *

Zmiana z krok po kroku, aby uzyskać wszystkie dane.

http: // localhost: 9200 / [nazwa_indeksu] / _search? rozmiar = 500 i od = 0

Dla Elasticsearch 6.x

Żądanie: GET /foo/_search?pretty=true

Odpowiedź: W Hits-> total, podaj liczbę dokumentów

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

Jeśli jest to mały zestaw danych (np. Rekordy 1K) , możesz po prostu określić size:

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

Zapytania cały mecz nie jest potrzebna, ponieważ jest niejawny.

Jeśli masz średni zestaw danych, na przykład rekordy 1M , możesz nie mieć wystarczającej ilości pamięci, aby go załadować, więc potrzebujesz przewijania .

Przewijanie jest jak kursor w DB. W Elasticsearch zapamiętuje miejsce, w którym zostało przerwane i zachowuje ten sam widok indeksu (tj. Zapobiega wyszukiwaniu odejść z odświeżeniem , zapobiega scalaniu segmentów ).

Pod względem API musisz dodać parametr przewijania do pierwszego żądania:

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

Otrzymujesz pierwszą stronę i identyfikator przewijania:

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

Pamiętaj, że zarówno odzyskany identyfikator przewijania, jak i limit czasu są ważne na następnej stronie . Częstym błędem jest tutaj określenie bardzo dużego limitu czasu (wartości scroll), który obejmowałby przetwarzanie całego zestawu danych (np. 1M rekordów) zamiast jednej strony (np. 100 rekordów).

Aby uzyskać następną stronę, wpisz ostatni identyfikator przewijania i limit czasu, który powinien trwać do momentu pobrania następującej strony:

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

Jeśli masz dużo do wyeksportowania (np. Dokumenty 1B) , zrób to równolegle. Można to zrobić za pomocą przewijania w plasterkach . Powiedz, że chcesz wyeksportować 10 wątków. Pierwszy wątek wysłałby takie żądanie:

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

Otrzymujesz pierwszą stronę i identyfikator przewijania, dokładnie tak jak normalne żądanie przewijania. Zużyłbyś go dokładnie tak, jak zwykły zwój, z tą różnicą, że dostajesz 1/10 danych.

Inne wątki zrobiłyby to samo, z wyjątkiem id1, 2, 3 ...

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

Domyślnie Elasticsearch zwraca 10 rekordów, więc rozmiar należy podać jawnie.

Dodaj rozmiar z prośbą o uzyskanie pożądanej liczby rekordów.

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

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

Od Kibana DevTools jego:

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

Proste rozwiązanie wykorzystujące pakiet 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)

Zobacz także https://elasticsearch-dsl.readthedocs.io/en/latest/api.html#elasticsearch_dsl.Search.scan .

Maksymalny wynik, który zwróci 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ć interfejsu API przewijania, aby uzyskać wynik, uzyskać wartość _scroll_id i umieścić tę wartość w scroll_id

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

Oficjalna dokumentacja zawiera odpowiedź na to pytanie! możesz to znaleźć tutaj .

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

Po prostu zastępujesz rozmiar (1) liczbą wyników, które chcesz zobaczyć!

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

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

Wynik:

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

Żaden oprócz @Akira Sendoh nie odpowiedział, jak faktycznie uzyskać WSZYSTKIE dokumenty. Ale nawet to rozwiązanie powoduje awarię usługi ES 6.3 bez dzienników. Jedyną rzeczą, która działała dla mnie przy użyciu elasticsearch-pybiblioteki niskiego poziomu, był pomocnik skanowania korzystający z scroll()interfejsu 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 obecnie bardziej przejrzystym sposobem wydaje się być elasticsearch-dslbiblioteka, która oferuje więcej abstrakcyjnych, czystszych wywołań, np .: http://elasticsearch-dsl.readthedocs.io/en/latest/search_dsl.html#hits

Jeśli nadal ktoś szuka wszystkich danych do pobrania z Elasticsearch, takich jak ja, w niektórych przypadkach użycia, 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": {}
    }
}
'

Odwołanie do Elasticsearch

to jest zapytanie, aby osiągnąć to, czego chcesz (sugeruję użyć Kibany, ponieważ pomaga lepiej zrozumieć zapytania)

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

aby uzyskać wszystkie rekordy, musisz użyć zapytania „match_all”.

rozmiar to liczba rekordów, które chcesz pobrać (rodzaj limitu). domyślnie ES zwróci tylko 10 rekordów

od jest jak pomiń, pomiń pierwsze 3 rekordy.

Jeśli chcesz pobrać dokładnie wszystkie rekordy, po prostu użyj wartości z pola „suma” z wyniku po trafieniu tego zapytania z Kibany i użyj go z „rozmiarem”.

Korzystanie z Elasticsearch 7.5.1

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

w przypadku, gdy możesz również określić rozmiar tablicy za pomocą & size = $ {liczba}

na wypadek, gdybyś nie indeksował

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

Można użyć konsoli kibana i my_index jako indeksu do wyszukiwania następujących elementów. Prosząc indeks, aby zwrócił tylko 4 pola indeksu, możesz także dodać rozmiar, aby wskazać, ile dokumentów chcesz zwrócić przez indeks. Począwszy od wersji ES 7.6 powinieneś używać _source zamiast filtrować, ponieważ zareaguje szybciej.

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

Możesz użyć size = 0, aby otrzymać przykład wszystkich dokumentów

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