Zapytanie Elasticsearch, aby zwrócić wszystkie rekordy

490

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?

John Livermore
źródło
1
... gdzie „foo” to nazwa indeksu, dla którego chcesz wyświetlić wszystkie rekordy.
jonatan

Odpowiedzi:

744

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)

Steve Casey
źródło
6
Dzięki. To był ostatni, jaki wymyśliłem, który zwraca to, czego teraz potrzebuję ... localhost: 9200 / foo / _search? Size = 50 & pretty = true & q = *: *
John Livermore
2
Dodając do odpowiedzi @ Steve'a, możesz znaleźć listę parametrów, które elasticsearch rozumie w tym linku elasticsearch.org/guide/reference/api/search/uri-request
Karthick
1
Dzięki @Steve za odpowiedź. Nie sądziłem, że to wystarczy na nowe pytanie. Nigdzie nie zostało to wyraźnie określone, więc pomyślałem, że poproszę tutaj o weryfikację.
Churro,
8
Naprawdę powinieneś użyć poleceń skanowania + przewijania. Jeśli użyjesz size = BIGNUMBER, zwróć uwagę, że Lucene przydziela pamięć dla wyników dla tej liczby, więc nie rób jej zbyt dużej. :)
Alex Brasetvik,
4
Skan został uznany za przestarzały w wersji 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
                                   ^

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

lfender6445
źródło
10
Należy jednak pamiętać o jednej rzeczy (z dokumentów Elasticsearch): Zauważ, że od + size nie może być więcej niż ustawienie indeksu index.max_result_window, które domyślnie wynosi 10.000.
user3078523
2
Zwróci 1000, nie wszystkie, użytkownik 3078523 ma rację, ta metoda ma limitmax_result_window
stelios
1
Ma maksimum, a także (jeśli masz wiele tysięcy rekordów do zdobycia) jest dość cholernie ciężkie podejście do osiągnięcia tego maksimum. Zamiast tego należy użyć zapytania „przewiń”.
Harry Wood,
37

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.

Prerak Diwan
źródło
3
Jak wspomniał inny użytkownik: from+ sizenie może być większe niż index.max_result_windowustawienie indeksu, które domyślnie
wynosi
To podejście ma maksimum, a także (jeśli masz wiele tysięcy rekordów do zdobycia) jest dość cholernie ciężkie podejście do osiągnięcia tego maksimum. Zamiast tego powinieneś użyć zapytania „przewijania”
Harry Wood,
Co dziwne, oficjalne dokumenty pokazują, że curl -XGET ... -d '{...}'jest to unoficjalny mieszany styl żądania. Dziękujemy za pokazanie poprawnych formatów GET i POST.
Jesse Chisholm
28

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

vjpandian
źródło
9
Domyślnie ES zwróci 10 wyników, chyba że parametr zapytania jest uwzględniony w zapytaniu podstawowym.
lfender6445
Poprzednia odpowiedź miała trzy lata. Zaktualizowałem go do aktualnego.
vjpandian
19

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

HungUnicorn
źródło
Dzięki, Mark, właśnie tego szukałem! W moim przypadku (ELK 6.2.1, python 3) argument search_type był niepoprawny i typ_dokumentu nie jest już potrzebny od ELK 6.0
Christoph Schranz
Idealne rozwiązanie! Dzięki. Używałem elasticsearch_dsl==5.4.0i działa bez search_type = 'scan',.
Usman Maqbool,
ES 6.3. Ten przykład powoduje awarię mojej usługi Elasticsearch, próbując przewinąć dokumenty o wielkości 110 000 dokumentów size=10000, gdzieś pomiędzy 5-7 iteracjami. z status=127, main ERROR Null object returned for RollingFile in Appenders, main ERROR Unable to locate appender "rolling" for logger config "root"Nie loguje się/var/log/elasticsearch/elasticsearch.log
Stelios
Dla scanprzypomnienia, klienci pythonów implementują pomocnika, który przewija pod maską (od wersji 5.xx
przynajmniej
search_type = 'scan'jest przestarzałe. Podobny kod będzie działał bez tego, chociaż istnieją pewne interesujące różnice, które są dobrze zakopane w starej dokumentacji. elastic.co/guide/en/elasticsearch/reference/1.4/… W szczególności, gdy migrujesz, aby nie używać search_type = scan, to pierwsze zapytanie „search” otrzyma pierwszą serię wyników do przetworzenia.
Harry Wood,
12

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>" 
}
WoodyDRN
źródło
1
Ta odpowiedź wymaga więcej aktualizacji. search_type=scanjest teraz przestarzałe Powinieneś to usunąć, ale potem zachowanie nieco się zmieniło. Pierwsza partia danych wraca z pierwszego wywołania wyszukiwania. Podany link pokazuje prawidłowy sposób, aby to zrobić.
Harry Wood,
1
Moim komentarzem było naprawdę zauważyć, że nie można po prostu dodać żadnej liczby jako rozmiaru, ponieważ byłoby to o wiele wolniejsze. Usunąłem więc przykładowy kod i ludzie mogą skorzystać z linku, aby uzyskać poprawny kod.
WoodyDRN,
1
@WoodyDRN Lepiej mieć kod w swojej odpowiedzi (nawet jeśli się zestarzeje), aby był nadal dostępny, gdy umiera link.
Trisped
11

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

Oussama L.
źródło
2
Ale z tego, co pamiętam, ES zezwala na uzyskanie tylko 16000 danych na żądanie. Jeśli więc dane przekraczają 16000, to rozwiązanie nie wystarczy.
Aminah Nuraini
10

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.

Somum
źródło
6

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.

Aminah Nuraini
źródło
4
nigdy nie używaj tej metody, jeśli dane zawierają wiele dokumentów ... Za każdym razem, gdy przejdziesz do „następnej strony”, elastyczna będzie wolniejsza i wolniejsza! Zamiast tego użyj SearchAfter
Joshlo,
3
Ponadto to rozwiązanie nie będzie działać, jeśli ogólny rozmiar danych przekroczy 10 000. Błąd opcji = 1000 i from = 10001 nie powiedzie się.
iclman
2
Rzeczywiście zawodzi. Parametry from+ sizenie mogą być większe niż index.max_result_window ustawienie indeksu, które domyślnie
wynosi
1
Jeśli dane zawierają wiele tysięcy dokumentów, poprawną odpowiedzią jest użycie zapytania „przewijanego”.
Harry Wood,
Z podejściem fromi sizenatkniesz się na problem głębokiej paginacji. Użyj przewijanego interfejsu API, aby wykonać zrzut wszystkich dokumentów.
Daniel Schneiter
5

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

akshay misra
źródło
Od której wersji występuje maksymalny rozmiar?
WoodyDRN
To może być „najlepsza” droga do punktu, ale naprawdę trochę cholernie. Jeśli masz wiele tysięcy rekordów, najlepszym sposobem jest zapytanie „przewiń”.
Harry Wood,
Z podejściem od i podejściem napotkasz problem głębokiej paginacji. Użyj przewijanego interfejsu API, aby wykonać zrzut wszystkich dokumentów.
Daniel Schneiter
5

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
Daniel
źródło
1
Ustawienie rozmiaru na X w ten sposób może mieć zaskakującą usterkę współbieżności: Zastanów się, co się stanie, jeśli rekord zostanie dodany pomiędzy liczeniem a ustawieniem rozmiaru przy następnym zapytaniu ... ale także, jeśli masz wiele tysięcy rekordów do zdobycia , to jest złe podejście. Zamiast tego należy użyć zapytania „przewiń”.
Harry Wood,
4

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

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

Edwin Ikechukwu Okonkwo
źródło
Z podejściem od i podejściem napotkasz problem głębokiej paginacji. Użyj przewijanego interfejsu API, aby wykonać zrzut wszystkich dokumentów.
Daniel Schneiter
4

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
Prasanna Jathan
źródło
3

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": [
          {
Anurag
źródło
3

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

Radu Gheorghe
źródło
2
curl -X GET 'localhost:9200/foo/_search?q=*&pretty' 
Dhruv Sharma
źródło
2

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.

Satyendra Sharma
źródło
2

Od Kibana DevTools jego:

GET my_index_name/_search
{
  "query": {
    "match_all": {}
  }
}
belostoky
źródło
2

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 .

asmaier
źródło
1

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" : "" 
}'
RAHUL JAIN
źródło
Interfejs API przewijania powinien być używany od samego początku przy pierwszym żądaniu.
Daniel Schneiter
1

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ć!

christouandr7
źródło
Autor pytania prosił o „wszystkie” wyniki, a nie o wcześniej określoną liczbę wyników. Chociaż opublikowanie linku do dokumentów jest pomocne, dokumenty nie opisują, jak to osiągnąć, podobnie jak twoja odpowiedź.
Maarten00,
Z podejściem od i podejściem napotkasz problem głębokiej paginacji. Użyj przewijanego interfejsu API, aby wykonać zrzut wszystkich dokumentów.
Daniel Schneiter
0

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,
       ...
exceltior
źródło
0
curl -XGET '{{IP/localhost}}:9200/{{Index name}}/{{type}}/_search?scroll=10m&pretty' -d '{
"query": {
"filtered": {
"query": {
"match_all": {}
}}'
aditya
źródło
Ten fragment kodu może rozwiązać pytanie, ale wyjaśnienie naprawdę pomaga poprawić jakość posta. Pamiętaj, że w przyszłości odpowiadasz na pytanie czytelników, a ci ludzie mogą nie znać przyczyn Twojej sugestii kodu.
Stamos
0

Ż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

stelios
źródło
0

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

Santosh Kumar Arjunan
źródło
0

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

Niranjan Harpale
źródło
Ograniczeniem tego zapytania jest to, że rozmiar + from musi być mniejszy lub równy „index.max_result_window”. W przypadku dużej liczby dokumentów (domyślnie 10000+) to zapytanie nie ma zastosowania.
KarelHusa,
0

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
Tiago Medici
źródło
0

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":{ }
    }   
 }
Gregory Neely
źródło
-5

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" : {}
    }
}'
premkumar
źródło
1
Zwróci