Permintaan Elasticsearch untuk mengembalikan semua catatan

Saya memiliki database kecil di Elasticsearch dan untuk tujuan pengujian ingin menarik semua catatan kembali. Saya mencoba menggunakan URL formulir ...

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

Bisakah seseorang memberi saya URL yang akan Anda gunakan untuk mencapai ini, tolong?

Saya pikir sintaks lucene didukung sehingga:

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

ukuran default ke 10, jadi Anda mungkin juga perlu &size=BIGNUMBERmendapatkan lebih dari 10 item. (di mana BIGNUMBER sama dengan angka yang Anda yakini lebih besar dari dataset Anda)

TETAPI, dokumentasi elasticsearch menyarankan untuk set hasil yang besar, menggunakan tipe pencarian pindai.

MISALNYA:

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

dan kemudian terus meminta sesuai tautan dokumentasi di atas yang disarankan.

EDIT: scanTidak digunakan lagi dalam 2.1.0.

scantidak memberikan manfaat apa pun atas scrollpermintaan reguler yang diurutkan berdasarkan _doc. tautan ke dokumen elastis (terlihat oleh @ christophe-roussy)

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

Perhatikan param ukuran , yang meningkatkan hit yang ditampilkan dari default (10) menjadi 1000 per shard.

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

elasticsearch (ES) mendukung permintaan GET atau POST untuk mendapatkan data dari indeks cluster ES.

Ketika kami melakukan GET:

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

Ketika kami melakukan POST:

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

Saya akan menyarankan untuk menggunakan plugin UI dengan elasticsearch http://mobz.github.io/elasticsearch-head/ Ini akan membantu Anda mendapatkan perasaan yang lebih baik tentang indeks yang Anda buat dan juga menguji indeks Anda.

Catatan: Jawabannya terkait dengan versi Elasticsearch yang lebih lama 0.90. Versi yang dirilis sejak itu memiliki sintaks yang diperbarui. Silakan merujuk ke jawaban lain yang dapat memberikan jawaban yang lebih akurat untuk jawaban terbaru yang Anda cari.

Kueri di bawah ini akan mengembalikan NO_OF_RESULTS yang ingin Anda kembalikan ..

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

Sekarang, pertanyaannya di sini adalah Anda ingin semua catatan dikembalikan. Jadi secara alami, sebelum menulis kueri, Anda tidak akan tahu nilai NO_OF_RESULTS .

Bagaimana kami tahu berapa banyak catatan yang ada di dokumen Anda? Cukup ketik kueri di bawah ini

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

Ini akan memberi Anda hasil yang terlihat seperti di bawah ini

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

Hasil Total memberitahu Anda berapa banyak catatan yang tersedia dalam dokumen Anda. Jadi, itu cara yang bagus untuk mengetahui nilai HASIL NO_OF

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

Cari semua jenis di semua indeks

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

Cari semua jenis dalam indeks foo

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

Cari semua jenis dalam indeks foo1 dan foo2

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

Cari semua jenis dalam indeks yang dimulai dengan f

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

Jenis pencarian pengguna dan tweet di semua indeks

Ini adalah solusi terbaik yang saya temukan menggunakan klien 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

Menggunakan klien 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 akan menjadi lebih lambat secara signifikan jika Anda hanya menambahkan sejumlah besar sebagai ukuran, salah satu metode yang digunakan untuk mendapatkan semua dokumen adalah menggunakan pindai dan gulir id.

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

Di Elasticsearch v7.2, Anda melakukannya seperti ini:

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

Hasil dari ini akan berisi _scroll_id yang harus Anda query untuk mendapatkan 100 chunk berikutnya.

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

gunakan server:9200/_statsjuga untuk mendapatkan statistik tentang semua alias Anda .. seperti ukuran dan jumlah elemen per alias, itu sangat berguna dan memberikan informasi bermanfaat

Jika Anda ingin menarik ribuan catatan, maka ... beberapa orang memberikan jawaban yang benar menggunakan 'gulir' (Catatan: Beberapa orang juga menyarankan menggunakan "search_type = scan". Ini tidak digunakan lagi, dan pada v5.0 dihapus. Kamu tidak membutuhkannya)

Mulailah dengan permintaan 'pencarian', tetapi tentukan parameter 'gulir' (di sini saya menggunakan batas waktu 1 menit):

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

Itu termasuk 'gelombang' pertama Anda. Tapi kita belum selesai di sini. Output dari perintah curl di atas akan menjadi seperti ini:

{ "_Scroll_id": "c2Nhbjs1OzUyNjE6NU4tU3BrWi1UWkNIWVNBZW43bXV3Zzs1Mzc3OkhUQ0g3VGllU2FhemJVNlM5d2t0alE7NTI2Mjo1Ti1TcGtaLVRaQ0hZU0FlbjdtdXdnOzUzNzg6SFRDSDdUaWVTYWF6YlU2Uzl3a3RqUTs1MjYzOjVOLVNwa1otVFpDSFlTQWVuN211d2c7MTt0b3RhbF9oaXRzOjIyNjAxMzU3Ow ==", "mengambil": 109, "timed_out": false, "_ pecahan": { "total": 5, "sukses": 5, "gagal": 0}, "hits" : {"total": 22601357, "max_score": 0,0, "hits": []}}

Sangat penting untuk memiliki _scroll_id berguna karena selanjutnya Anda harus menjalankan perintah berikut:

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

Namun, meneruskan scroll_id bukanlah sesuatu yang dirancang untuk dilakukan secara manual. Taruhan terbaik Anda adalah menulis kode untuk melakukannya. misalnya dalam 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();

Sekarang LOOP pada perintah terakhir gunakan SearchResponse untuk mengekstrak data.

Sederhana! Anda dapat menggunakan sizedan fromparameter!

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

maka Anda mengubah fromsecara bertahap sampai Anda mendapatkan semua data.

Cara terbaik untuk menyesuaikan ukuran menggunakan ukuran = angka di depan URL

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

Catatan: nilai maksimum yang dapat didefinisikan dalam ukuran ini adalah 10000. Untuk nilai apa pun di atas sepuluh ribu, ia mengharapkan Anda untuk menggunakan fungsi gulir yang akan meminimalkan kemungkinan dampak pada kinerja.

Anda dapat menggunakan _countAPI untuk mendapatkan nilai untuk sizeparameter:

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

Pengembalian {count:X, ...}. Ekstrak nilai 'X' dan kemudian lakukan permintaan sebenarnya:

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

http: // localhost: 9200 / foo / _search / ? ukuran = 1000 & cantik = 1

Anda perlu menentukan parameter kueri ukuran karena standarnya adalah 10

param ukuran meningkatkan hit yang ditampilkan dari default (10) menjadi 500.

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

Mengubah dari langkah demi langkah untuk mendapatkan semua data.

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

Untuk Elasticsearch 6.x

Permintaan: GET /foo/_search?pretty=true

Tanggapan: Dalam jumlah Hits->, berikan hitungan pada dokumen

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

Jika ini adalah dataset kecil (mis. Rekaman 1K) , Anda dapat dengan mudah menentukan size:

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

The pertandingan semua permintaan tidak diperlukan, karena itu implisit.

Jika Anda memiliki dataset berukuran sedang, seperti catatan 1M , Anda mungkin tidak memiliki cukup memori untuk memuatnya, jadi Anda perlu sebuah gulir .

Gulir seperti kursor dalam DB. Dalam Elasticsearch, ia mengingat di mana Anda tinggalkan dan menjaga tampilan indeks yang sama (yaitu mencegah pencari pergi dengan refresh , mencegah segmen dari penggabungan ).

Dari sisi API, Anda harus menambahkan parameter gulir ke permintaan pertama:

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

Anda mendapatkan kembali halaman pertama dan ID gulir:

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

Ingat bahwa ID gulir yang Anda dapatkan kembali dan batas waktu berlaku untuk halaman berikutnya . Kesalahan umum di sini adalah untuk menentukan batas waktu yang sangat besar (nilaiscroll ), yang akan mencakup untuk memproses seluruh dataset (misalnya catatan 1M) alih-alih satu halaman (misalnya 100 catatan).

Untuk mendapatkan halaman berikutnya, isi ID gulir terakhir dan batas waktu yang akan berlangsung hingga mengambil halaman berikut:

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

Jika Anda memiliki banyak ekspor (mis. Dokumen 1B) , Anda ingin memparalelkan. Ini dapat dilakukan melalui scroll yang diiris . Katakanlah Anda ingin mengekspor pada 10 utas. Utas pertama akan mengeluarkan permintaan seperti ini:

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

Anda mendapatkan kembali halaman pertama dan ID gulir, persis seperti permintaan gulir normal. Anda akan mengkonsumsinya persis seperti gulungan biasa, kecuali bahwa Anda mendapatkan 1/10 data.

Utas lainnya akan melakukan hal yang sama, kecuali itu idadalah 1, 2, 3 ...

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

Secara default Elasticsearch mengembalikan 10 catatan sehingga ukuran harus disediakan secara eksplisit.

Tambahkan ukuran dengan permintaan untuk mendapatkan jumlah catatan keinginan.

http: // {host}: 9200 / {index_name} / _search? pretty = true & size = (jumlah catatan)

Catatan: Ukuran halaman maks. Tidak boleh lebih dari pengaturan indeks index.max_result_window yang default ke 10.000.

Dari Kibana DevTools-nya:

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

Sebuah solusi sederhana menggunakan paket 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)

Lihat juga https://elasticsearch-dsl.readthedocs.io/en/latest/api.html#elasticsearch_dsl.Search.scan .

Hasil maksimum yang akan dikembalikan oleh elasticSearch adalah 10.000 dengan memberikan ukuran

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

Setelah itu, Anda harus menggunakan Scroll API untuk mendapatkan hasilnya dan mendapatkan nilai _scroll_id dan memasukkan nilai ini ke scroll_id

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

Dokumentasi resmi memberikan jawaban untuk pertanyaan ini! Anda dapat menemukannya di sini .

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

Anda cukup mengganti ukuran (1) dengan jumlah hasil yang ingin Anda lihat!

Untuk mengembalikan semua catatan dari semua indeks yang dapat Anda lakukan:

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

Keluaran:

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

Tidak ada kecuali @Akira Sendoh telah menjawab bagaimana sebenarnya mendapatkan SEMUA dokumen. Tetapi bahkan solusi itu crash layanan ES 6.3 saya tanpa log. Satu-satunya hal yang berhasil bagi saya menggunakan elasticsearch-pypustaka tingkat rendah adalah melalui pemindai pembantu yang menggunakan 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

Namun, cara yang lebih bersih saat ini tampaknya melalui elasticsearch-dslperpustakaan, yang menawarkan panggilan yang lebih abstrak dan lebih bersih, misalnya: http://elasticsearch-dsl.readthedocs.io/en/latest/search_dsl.html#hits

Jika masih ada yang mencari semua data yang akan diambil dari Elasticsearch seperti saya untuk beberapa usecases, inilah yang saya lakukan. Terlebih lagi, semua data berarti, semua indeks dan semua jenis dokumen. Saya menggunakan Elasticsearch 6.3

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

Referensi penelitian Elastics

ini adalah kueri untuk mencapai apa yang Anda inginkan, (saya menyarankan untuk menggunakan Kibana, karena membantu memahami pertanyaan dengan lebih baik)

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

untuk mendapatkan semua catatan, Anda harus menggunakan kueri "match_all".

ukuran adalah jumlah catatan yang ingin Anda ambil (jenis batas). secara default, ES hanya akan mengembalikan 10 catatan

dari seperti melompat, lewati 3 rekaman pertama.

Jika Anda ingin mengambil persis semua catatan, cukup gunakan nilai dari bidang "total" dari hasil setelah Anda menekan kueri ini dari Kibana dan menggunakannya dengan "ukuran".

Menggunakan Elasticsearch 7.5.1

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

jika Anda juga dapat menentukan ukuran array Anda dengan & size = $ {number}

jika Anda tidak tahu indeks Anda

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

Menggunakan kibana console dan my_index sebagai indeks untuk mencari yang berikut ini dapat dikontribusikan. Meminta indeks untuk hanya mengembalikan 4 bidang indeks, Anda juga dapat menambahkan ukuran untuk menunjukkan berapa banyak dokumen yang ingin Anda kembalikan oleh indeks. Pada ES 7.6 Anda harus menggunakan _source daripada memfilternya akan merespons lebih cepat.

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

Anda dapat menggunakan ukuran = 0 ini akan mengembalikan Anda semua contoh dokumen

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