सभी रिकॉर्ड्स को वापस करने के लिए Elasticsearch क्वेरी

Question

मेरे पास एलीटसर्च में एक छोटा सा डेटाबेस है और परीक्षण उद्देश्यों के लिए सभी रिकॉर्ड वापस खींचना चाहेंगे। मैं फ़ॉर्म के URL का उपयोग करने का प्रयास कर रहा हूं ...

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

क्या कोई मुझे वह URL दे सकता है जिसका उपयोग आप इसे पूरा करने के लिए करेंगे, कृपया?

Comments

... जहां "फू" उस इंडेक्स का नाम है जिसे आप सभी रिकॉर्ड दिखाना चाहते हैं।

— जोनाथन

Answer 1

मुझे लगता है कि ल्यूसिन सिंटैक्स का समर्थन किया जाता है:

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

आकार में 10 से चूक होती है, इसलिए आपको &size=BIGNUMBER10 से अधिक आइटम प्राप्त करने की आवश्यकता हो सकती है । (जहां BIGNUMBER आपके द्वारा अपने डेटासेट से बड़ा माना जाता है एक संख्या के बराबर है)

लेकिन, खोज परिणाम का उपयोग करके, बड़े परिणाम सेट के लिए elasticsearch प्रलेखन का सुझाव है ।

ईजी:

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

और फिर ऊपर दिए गए दस्तावेज़ीकरण लिंक के अनुसार अनुरोध करते रहें।

संपादित करें: scan2.1.0 में पदावनत

scanscrollद्वारा नियमित अनुरोध पर कोई लाभ प्रदान नहीं करता है _doc। लोचदार डॉक्स से लिंक (@ क्रिस्टोफ-रूसो द्वारा देखा गया)

Comments

धन्यवाद। यह वह फाइनल था जो मैं उस रिटर्न के साथ आया था, जो मुझे अभी के लिए चाहिए ... लोकलहोस्ट: 9200 / foo / _search? Size = 50 & pretty = true & q = *: *

— John Livermore

@ स्टीव के जवाब में जोड़ते हुए, आप उन मापदंडों की एक सूची पा सकते हैं, जो इलास्टिसर्च इस लिंक में समझता है elasticsearch.org/guide/reference/api/search/uri-request

— कार्तिक

आपके उत्तर के लिए धन्यवाद @ देखें। मुझे नहीं लगा कि यह एक नए प्रश्न के लिए पर्याप्त महत्वपूर्ण था। यह स्पष्ट रूप से कहीं भी नहीं कहा गया था, इसलिए मुझे लगा कि मैं यहाँ सत्यापित करने के लिए कहूंगा।

— चुरू

आपको वास्तव में स्कैन + स्क्रॉल-अनुरोधों का उपयोग करना चाहिए। यदि आप size = BIGNUMBER का उपयोग करते हैं, तो ध्यान दें कि ल्यूसीन उस संख्या के लिए स्कोर के लिए मेमोरी आवंटित करता है, इसलिए इसे अत्यधिक बड़ा न बनाएं। :)

— एलेक्स ब्रासेटविक

स्कैन 2.1.0 में पदावनत किया गया था: लोचदार.co

— क्रिस्टोफ़ रूसो

Answer 2

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

आकार पैराम पर ध्यान दें , जो डिफ़ॉल्ट (10) से प्रदर्शित हिट्स को बढ़ाकर 1000 प्रति शार्प कर देता है।

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

Comments

एक बात हालांकि ध्यान में रखें (एलेस्टिक्सखोज डॉक्स से): ध्यान दें कि + आकार, index.max_result_window इंडेक्स सेटिंग से अधिक नहीं हो सकता है जो 10,000 तक की चूक करता है।

— user3078523

यह 1000 वापस आएगा, सभी नहीं, user3078523 सही है, इस विधि की एक सीमा हैmax_result_window

— स्टेलिओस

इसकी एक अधिकतम है, और यह भी (यदि आपके पास पाने के लिए कई हजारों रिकॉर्ड हैं) यह एक अधिकतम भारी दृष्टिकोण है जो उस अधिकतम की ओर जा रहा है। इसके बजाय आपको "स्क्रॉल" क्वेरी का उपयोग करना चाहिए।

— हैरी वुड

Answer 3

elasticsearch (ES) ES क्लस्टर सूचकांक से डेटा प्राप्त करने के लिए GET या POST दोनों अनुरोधों का समर्थन करता है।

जब हम एक GET करते हैं:

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

जब हम एक POST करते हैं:

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

मैं elasticsearch http://mobz.github.io/elasticsearch-head/ के साथ एक यूआई प्लगइन का उपयोग करने का सुझाव दूंगा, इससे आपको अपने द्वारा बनाए गए सूचकांकों का बेहतर अहसास पाने में मदद मिलेगी और आपके सूचकांकों का भी परीक्षण होगा।

Comments

जैसा कि एक अन्य उपयोगकर्ता ने उल्लेख किया है: from+ इंडेक्स सेटिंग sizeसे अधिक नहीं हो सकता है index.max_result_windowजो 10,000 तक की चूक करता है

— स्टेलियोस

इस दृष्टिकोण में एक अधिकतम है, और यह भी (यदि आपके पास प्राप्त करने के लिए कई हजारों रिकॉर्ड हैं) यह उस अधिकतम की ओर बढ़ने के लिए एक बल्कि भारी भारी दृष्टिकोण है। इसके बजाय आपको

— हैरी वुड

अजीब तरह से, आधिकारिक डॉक्स दिखाते हैं curl -XGET ... -d '{...}'जो unअनुरोध की एक आधिकारिक मिश्रित शैली है। सही GET और POST प्रारूप दिखाने के लिए धन्यवाद।

— जेसी चिशोल्म

Answer 4

नोट: यह उत्तर एलिस्टिक्स खोज के पुराने संस्करण से संबंधित है 0.90। तब से जारी किए गए संस्करणों में एक अद्यतन सिंटैक्स है। कृपया उन अन्य उत्तरों को देखें जो आपके द्वारा खोजे जा रहे नवीनतम उत्तर के लिए अधिक सटीक उत्तर प्रदान कर सकते हैं।

नीचे दी गई क्वेरी NO_OF_RESULTS आपको लौटाएगी।

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

अब, यहाँ सवाल यह है कि आप चाहते हैं कि सभी रिकॉर्ड वापस आ जाएं। तो स्वाभाविक रूप से, एक प्रश्न लिखने से पहले, आप NO_OF_RESULTS का मूल्य नहीं जानते ।

हमें कैसे पता चलेगा कि आपके दस्तावेज़ में कितने रिकॉर्ड मौजूद हैं? बस नीचे क्वेरी टाइप करें

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

यह आपको एक परिणाम देगा जो नीचे दिए गए जैसा दिखता है

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

परिणाम कुल आपको बताता है कि आपके दस्तावेज़ में कितने रिकॉर्ड उपलब्ध हैं। तो, यह NO_OF परिणामों का मूल्य जानने का एक अच्छा तरीका है

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

सभी सूचकांकों में सभी प्रकार खोजें

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

फू इंडेक्स में सभी प्रकार खोजें

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

Foo1 और foo2 सूचकांकों में सभी प्रकार खोजें

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

किसी भी सूचकांक में सभी प्रकार खोजें f से शुरू

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

सभी प्रकार के उपयोगकर्ता खोजें और सभी सूचकांकों में ट्वीट करें

Comments

डिफ़ॉल्ट रूप से ES 10 परिणाम लौटाएगा जब तक कि आकार क्वेरी को आधार क्वेरी में शामिल नहीं किया जाता है।

— lfender6445

पिछली प्रतिक्रिया तीन साल पुरानी थी। इसे एक वर्तमान में अपडेट किया गया।

— vjpandian

Answer 5

यह सबसे अच्छा समाधान है जो मैंने पायथन क्लाइंट का उपयोग करके पाया

  # 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

जावा क्लाइंट का उपयोग करना

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

Comments

धन्यवाद मार्क, यह वही था जो मैं देख रहा था! मेरे मामले में (ELK 6.2.1, पायथन 3), search_type तर्क मान्य नहीं था और दस्तावेज़_

— type को

सही समाधान! धन्यवाद। मैं उपयोग कर रहा था elasticsearch_dsl==5.4.0और यह बिना काम करता है search_type = 'scan',।

— उस्मान मकबूल

ES 6.3। यह उदाहरण size=100005 वीं -7 वीं पुनरावृत्तियों के बीच कहीं पर, 110k दस्तावेज़ों को स्क्रॉल करने की कोशिश करते हुए, मेरी Elasticsearch सेवा बनाता है । साथ status=127, main ERROR Null object returned for RollingFile in Appenders, main ERROR Unable to locate appender "rolling" for logger config "root"नहीं में लॉग/var/log/elasticsearch/elasticsearch.log

— stelios

रिकॉर्ड के लिए, अजगर क्लाइंट एक scanहेल्पर्स को लागू करता है, जो कि हुड के नीचे स्क्रॉल करता है (चूंकि संस्करण 5.xx पर leat में)

— MCMZL

search_type = 'scan'पदावनत किया गया है। इसी तरह का कोड उसके बिना काम करेगा, हालांकि कुछ दिलचस्प अंतर हैं जो पुराने दस्तावेज में अच्छी तरह से दफन हैं। flex.co/guide/en/elasticsearch/reference/1.4/… विशेष रूप से, जब search_type = scan का उपयोग नहीं करने के लिए माइग्रेट किया जाता है, तो वह पहली 'खोज' क्वेरी प्रक्रिया के पहले बैच के साथ आएगी।

— हैरी वुड

Answer 6

इलास्टिसिपेट मिलेगा यदि आप बस आकार के रूप में कुछ बड़ी संख्या जोड़ते हैं, तो सभी दस्तावेजों को स्कैन और स्क्रॉल करने के लिए उपयोग करने के लिए उपयोग करने के लिए एक विधि को जोड़ने के महत्वपूर्ण धीमी ।

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

एलेस्टिक्स खोज v7.2 में, आप इसे इस तरह करते हैं:

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

इसके परिणामों में एक _scroll_id होगा जिसे आपको अगले 100 चंक प्राप्त करने के लिए क्वेरी करना होगा।

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

Comments

इस उत्तर को और अधिक अपडेट की आवश्यकता है। search_type=scanअब पदावनत हो गया है। इसलिए आपको उसे हटा देना चाहिए, लेकिन तब व्यवहार थोड़ा बदल गया है। डेटा का पहला बैच प्रारंभिक खोज कॉल से वापस आता है। आपके द्वारा प्रदान किया गया लिंक इसे करने का सही तरीका दिखाता है।

— हैरी वुड

मेरी टिप्पणी वास्तव में ध्यान देने वाली थी कि आप किसी भी संख्या को आकार के रूप में नहीं जोड़ सकते, क्योंकि यह काफी धीमी होगी। इसलिए मैंने कोड उदाहरण को हटा दिया और लोग सही कोड प्राप्त करने के लिए लिंक का अनुसरण कर सकते हैं।

— वुडीआरडीएन

@WoodyDRN आपके उत्तर में कोड होना बेहतर है (भले ही यह पुराना हो जाता है) इसलिए लिंक उपलब्ध होने पर यह अभी भी उपलब्ध है।

— त्रिशूल

Answer 7

server:9200/_statsअपने सभी उपनामों के बारे में आंकड़े प्राप्त करने के लिए भी उपयोग करें .. जैसे आकार और तत्वों की संख्या प्रति उपनाम, यह बहुत उपयोगी है और उपयोगी जानकारी प्रदान करता है

Comments

लेकिन, मुझे जो याद है, ईएस केवल प्रति अनुरोध 16000 डेटा प्राप्त करने की अनुमति देता है। इसलिए यदि डेटा 16000 से ऊपर है, तो यह समाधान पर्याप्त नहीं है।

— अमीना नूरैनी

Answer 8

यदि आप कई हजारों रिकॉर्ड खींचना चाहते हैं तो ... कुछ लोगों ने 'स्क्रॉल' का उपयोग करने का सही उत्तर दिया (नोट: कुछ लोगों ने "search_type = scan" का उपयोग करने का भी सुझाव दिया। यह पदावनत किया गया था, और v5.0 में हटा दिया गया था। आपको इसकी आवश्यकता नहीं है)

एक 'खोज' क्वेरी के साथ शुरू करें, लेकिन एक 'स्क्रॉल' पैरामीटर निर्दिष्ट करें (यहां मैं 1 मिनट का टाइमआउट उपयोग कर रहा हूं):

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

जिसमें हिट का आपका पहला 'बैच' शामिल है। लेकिन हम यहां नहीं हैं। उपरोक्त कर्ल कमांड का आउटपुट कुछ इस तरह होगा:

{ "_Scroll_id": "c2Nhbjs1OzUyNjE6NU4tU3BrWi1UWkNIWVNBZW43bXV3Zzs1Mzc3OkhUQ0g3VGllU2FhemJVNlM5d2t0alE7NTI2Mjo1Ti1TcGtaLVRaQ0hZU0FlbjdtdXdnOzUzNzg6SFRDSDdUaWVTYWF6YlU2Uzl3a3RqUTs1MjYzOjVOLVNwa1otVFpDSFlTQWVuN211d2c7MTt0b3RhbF9oaXRzOjIyNjAxMzU3Ow ==", "लिया": 109, "timed_out": झूठे, "_ के टुकड़े": { "कुल": 5, "सफल": 5, "विफल": 0}, "हिट" : { "कुल": 22601357, "max_score": 0.0, "हिट": []}}

अगले आदेश को चलाने के बाद आपके पास _scroll_id होना महत्वपूर्ण है:

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

हालाँकि, स्क्रॉल_ड को पास करना कुछ ऐसा नहीं है जिसे मैन्युअल रूप से तैयार किया गया हो। आपका सर्वश्रेष्ठ दांव यह करने के लिए कोड लिखना है। जावा में जैसे:

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

अब अंतिम कमांड पर LOOP डेटा निकालने के लिए SearchResponse का उपयोग करते हैं।

Answer 9

सरल! आप उपयोग कर सकते हैं sizeऔर fromपैरामीटर!

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

तब fromतक आप धीरे-धीरे तब तक बदलते हैं जब तक आपको सभी डेटा नहीं मिल जाते।

Comments

यदि डेटा में कई दस्तावेज़ हैं तो इस पद्धति का उपयोग कभी न करें ... हर बार जब आप "अगले पृष्ठ पर" जाएंगे तो लोचदार धीमा और धीमा हो जाएगा! इसके बजाय SearchAfter का उपयोग करें

— जोशो

इसके अलावा, यह समाधान काम नहीं करेगा यदि समग्र डेटा आकार 10 000 से ऊपर है। विकल्प का आकार = 1000 और = 10001 से विफल हो जाएगा।

— iclman

वास्तव में विफल रहता है। पैरामीटर from+ sizeindex.max_result_window इंडेक्स सेटिंग से अधिक नहीं हो सकता है, जो 10,000 तक की चूक करता है

— stelios

यदि डेटा में कई हजारों दस्तावेज़ हैं, तो सही उत्तर 'स्क्रॉल' क्वेरी का उपयोग करना है।

— हैरी वुड

साथ fromऔर size-approach आप दीप पृष्ठांकन समस्या में पड़ जाएगा। सभी दस्तावेजों का डंप बनाने के लिए स्क्रॉल एपीआई का उपयोग करें।

— डैनियल श्नाइटर

Answer 10

आकार को समायोजित करने का सबसे अच्छा तरीका URL के सामने आकार = संख्या का उपयोग करना है

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

नोट: अधिकतम मूल्य जो इस आकार में परिभाषित किया जा सकता है, 10000 है। दस हजार से ऊपर के किसी भी मूल्य के लिए आपको स्क्रॉल फ़ंक्शन का उपयोग करने की उम्मीद है जो प्रदर्शन के प्रभावों की किसी भी संभावना को कम कर देगा।

Comments

अधिकतम आकार किस संस्करण से होता है?

— वुडीआरडीएन

यह एक बिंदु तक "सबसे अच्छा" तरीका हो सकता है, लेकिन वास्तव में थोड़ा अजीब है। यदि आपके पास कई हजारों रिकॉर्ड हैं, तो सबसे अच्छा तरीका "स्क्रॉल" क्वेरी है।

— हैरी वुड

से और आकार-दृष्टिकोण से आप डीप पेजिनेशन समस्या में चलेंगे। सभी दस्तावेजों का डंप बनाने के लिए स्क्रॉल एपीआई का उपयोग करें।

— डैनियल श्नाइटर

Answer 11

पैरामीटर के _countलिए मान प्राप्त करने के लिए आप API का उपयोग कर सकते हैं size:

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

लौटता है {count:X, ...}। 'X' मान निकालें और फिर वास्तविक क्वेरी करें:

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

Comments

आकार को X की तरह सेट करने पर, एक आश्चर्यजनक संगोष्ठी गड़बड़ हो सकती है: गौर करें कि क्या होता है यदि गणना करने और अपनी अगली क्वेरी पर आकार सेट करने के बीच एक रिकॉर्ड जोड़ा जाता है ... लेकिन यह भी कि यदि आपके पास पाने के लिए कई हजारों रिकॉर्ड हैं , तो यह गलत तरीका है। इसके बजाय आपको "स्क्रॉल" क्वेरी का उपयोग करना चाहिए।

— हैरी वुड

Answer 12

http: // localhost: 9200 / foo / _search / ? आकार = 1000 और सुंदर = 1

डिफ़ॉल्ट आकार 10 होने पर आपको आकार क्वेरी पैरामीटर निर्दिष्ट करना होगा

Comments

से और आकार-दृष्टिकोण से आप डीप पेजिनेशन समस्या में चलेंगे। सभी दस्तावेजों का डंप बनाने के लिए स्क्रॉल एपीआई का उपयोग करें।

— डैनियल श्नाइटर

Answer 13

आकार पैराम डिफ़ॉल्ट (10) से प्रदर्शित हिट्स को बढ़ाकर 500 कर देता है।

http: // localhost: 9200 / [indexName] / _search सुंदर = सच और आकार = 500 & q = *: *

बदले से सभी डेटा प्राप्त करने के लिए कदम से कदम।

http: // localhost: 9200 / [indexName] / _search आकार = 500 और से = 0

Answer 14

इलास्टिसर्च 6.x के लिए

निवेदन: GET /foo/_search?pretty=true

प्रतिक्रिया: हिट्स-> कुल में, डॉक्स की गिनती दें

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

Answer 15

यदि यह एक छोटा डेटासेट है (उदाहरण 1K रिकॉर्ड) , तो आप बस निर्दिष्ट कर सकते हैं size:

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

मैच सभी क्वेरी की जरूरत नहीं है, के रूप में यह निहित है।

यदि आपके पास मध्यम आकार का डेटासेट है, तो 1M रिकॉर्ड की तरह , आपके पास इसे लोड करने के लिए पर्याप्त मेमोरी नहीं हो सकती है, इसलिए आपको स्क्रॉल की आवश्यकता है ।

एक स्क्रॉल एक डीबी में एक कर्सर की तरह है। इलास्टिक्स खोज में, यह याद रखता है कि आपने कहाँ छोड़ा था और सूचकांक का एक ही दृश्य रखता है (यानी खोजकर्ता को ताज़ा होने से रोकता है, खंडों को विलय से रोकता है )।

एपीआई-वार, आपको पहले अनुरोध पर एक स्क्रॉल पैरामीटर जोड़ना होगा:

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

आपको पहला पृष्ठ और एक स्क्रॉल आईडी मिलती है:

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

याद रखें कि स्क्रॉल आईडी आपको वापस मिल जाती है और टाइमआउट अगले पृष्ठ के लिए मान्य है । यहां एक सामान्य गलती एक बहुत बड़ी समय-सीमा (मान scroll) निर्दिष्ट करना है, जो एक पृष्ठ (जैसे 100 रिकॉर्ड) के बजाय पूरे डेटासेट (जैसे 1M रिकॉर्ड) को संसाधित करने के लिए कवर करेगी।

अगला पृष्ठ प्राप्त करने के लिए, अंतिम स्क्रॉल आईडी भरें और एक टाइमआउट जो कि अगले पृष्ठ को लाने तक चलेगा:

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

यदि आपके पास निर्यात करने के लिए बहुत कुछ है (उदाहरण के लिए 1 बी दस्तावेज़) , तो आप समानांतर करना चाहेंगे। यह कटा हुआ स्क्रॉल के माध्यम से किया जा सकता है । कहते हैं कि आप 10 धागे पर निर्यात करना चाहते हैं। पहला धागा इस तरह एक अनुरोध जारी करेगा:

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

आप पहले पृष्ठ और एक स्क्रॉल आईडी पर वापस आते हैं, बिल्कुल सामान्य स्क्रॉल अनुरोध की तरह। आप इसे एक नियमित स्क्रॉल की तरह ही उपभोग करेंगे, सिवाय इसके कि आपको डेटा का 1/10 वां हिस्सा मिलता है।

अन्य धागे भी ऐसा ही करेंगे, सिवाय इसके कि id1, 2, 3 ...

Answer 16

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

Answer 17

डिफ़ॉल्ट रूप से Elasticsearch 10 रिकॉर्ड लौटाता है, इसलिए आकार स्पष्ट रूप से प्रदान किया जाना चाहिए।

रिकॉर्ड की इच्छा संख्या प्राप्त करने के लिए अनुरोध के साथ आकार जोड़ें।

http: // {host}: 9200 / {index_name} / _search? सुंदर = सही और आकार = (रिकॉर्ड की संख्या)

नोट: अधिकतम पृष्ठ का आकार index.max_result_window इंडेक्स सेटिंग से अधिक नहीं हो सकता है जो 10,000 तक की चूक करता है।

Answer 18

किबना DevTools से इसकी:

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

Answer 19

अजगर पैकेज इलास्टिक्स-डीएसएल का उपयोग करते हुए एक सरल समाधान :

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)

यह भी देखें https://elasticsearch-dsl.readthedocs.io/en/latest/api.html#elasticsearch_dsl.Search.scan ।

Answer 20

लोचदार खोज द्वारा वापस आने वाला अधिकतम परिणाम आकार प्रदान करके 10000 है

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

उसके बाद, आपको परिणाम प्राप्त करने के लिए स्क्रॉल एपीआई का उपयोग करना होगा और _scroll_id मान प्राप्त करना होगा और इस मान को स्क्रॉल_आईडी में डाल दिया जाएगा

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

Comments

स्क्रॉल एपीआई को पहले ही अनुरोध के साथ शुरू से ही सही उपयोग किया जाना चाहिए।

— डैनियल श्नाइटर

Answer 21

आधिकारिक दस्तावेज इस प्रश्न का उत्तर प्रदान करता है! आप इसे यहाँ पा सकते हैं ।

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

आप बस आकार (1) को उन परिणामों की संख्या से बदलते हैं जिन्हें आप देखना चाहते हैं!

Comments

प्रश्न का लेखक 'सभी' परिणामों के लिए पूछ रहा था, परिणामों की पूर्व-निर्धारित राशि नहीं। यद्यपि यह डॉक्स के लिए एक लिंक पोस्ट करने में सहायक है, डॉक्स यह नहीं बताता है कि इसे कैसे प्राप्त किया जाए, न ही आपका उत्तर।

— Maarten00

से और आकार-दृष्टिकोण से आप डीप पेजिनेशन समस्या में चलेंगे। सभी दस्तावेजों का डंप बनाने के लिए स्क्रॉल एपीआई का उपयोग करें।

— डैनियल श्नाइटर

Answer 22

आप कर सकते हैं सभी सूचकांकों से सभी रिकॉर्ड वापस करने के लिए:

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

आउटपुट:

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

Answer 23

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

Comments

हालांकि यह कोड स्निपेट प्रश्न को हल कर सकता है, जिसमें स्पष्टीकरण सहित वास्तव में आपकी पोस्ट की गुणवत्ता में सुधार करने में मदद करता है। याद रखें कि आप भविष्य में पाठकों के लिए प्रश्न का उत्तर दे रहे हैं, और उन लोगों को आपके कोड सुझाव के कारणों का पता नहीं चल सकता है।

— स्टैमोस

Answer 24

@Akira Sendoh को छोड़कर किसी ने भी जवाब नहीं दिया कि वास्तव में सभी डॉक्स कैसे प्राप्त किए जा सकते हैं। लेकिन यह भी कि समाधान लॉग के बिना मेरी ES 6.3 सेवा को क्रैश कर देता है । केवल एक चीज जो मेरे लिए निम्न-स्तरीय elasticsearch-pyलाइब्रेरी का उपयोग करने के लिए काम करती थी वह स्कैन हेल्पर के माध्यम से थी जो scroll()एपीआई का उपयोग करती है :

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

हालाँकि, आजकल क्लीनर का तरीका elasticsearch-dslलाइब्रेरी के माध्यम से लगता है , जो अधिक सार, क्लीनर कॉल प्रदान करता है, जैसे: http://elasticsearch-dsl.readthedocs.io/en/latest/search_dsl.html#hits

Answer 25

यदि अभी भी कोई व्यक्ति कुछ यूकेसीज़ के लिए मेरे जैसे एलिस्टिक्स खोज से प्राप्त किए जाने वाले सभी डेटा की तलाश में है, तो यहां मैंने वही किया है। इसके अलावा, सभी डेटा का मतलब है, सभी सूचकांक और सभी दस्तावेज़ प्रकार। मैं Elasticsearch 6.3 का उपयोग कर रहा हूं

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

एलिटिक्स खोज

Answer 26

आप जो चाहते हैं उसे पूरा करने के लिए यह प्रश्न है, (मैं किबाना का उपयोग करने का सुझाव दे रहा हूं, क्योंकि यह प्रश्नों को बेहतर ढंग से समझने में मदद करता है)

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

सभी रिकॉर्ड प्राप्त करने के लिए आपको "match_all" क्वेरी का उपयोग करना होगा।

आकार उन रिकॉर्डों में से एक है जिन्हें आप लाना चाहते हैं (सीमा की तरह)। डिफ़ॉल्ट रूप से, ES केवल 10 रिकॉर्ड लौटाएगा

से स्किप की तरह है, पहले 3 रिकॉर्ड छोड़ें।

यदि आप वास्तव में सभी रिकॉर्ड प्राप्त करना चाहते हैं, तो परिणाम को "कुल" फ़ील्ड से मान का उपयोग करें एक बार जब आप किबाना से इस क्वेरी को हिट करते हैं और इसे "आकार" के साथ उपयोग करते हैं।

Comments

इस क्वेरी की सीमा यह है कि आकार + से कम या "index.max_result_window" के बराबर होना चाहिए। बड़ी संख्या में दस्तावेज़ों के लिए (डिफ़ॉल्ट रूप से 10000+) यह क्वेरी लागू नहीं है।

— कर्लहुसा

Answer 27

एलिटिक्स खोज 7.5.1 का उपयोग करना

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

यदि आप अपने सरणी के आकार को & आकार = $ {संख्या} के साथ निर्दिष्ट कर सकते हैं

अगर आपको पता नहीं है कि आप सूचकांक नहीं करते हैं

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

Answer 28

सूचकांक खोजने के लिए किबाना कंसोल और my_index का उपयोग करके निम्नलिखित योगदान दिया जा सकता है। सूचकांक के केवल 4 क्षेत्रों को वापस करने के लिए सूचकांक से पूछते हुए, आप यह संकेत देने के लिए भी आकार जोड़ सकते हैं कि आप कितने दस्तावेज़ों को सूचकांक द्वारा वापस करना चाहते हैं। ES 7.6 के रूप में आपको फ़िल्टर के बजाय _source का उपयोग करना चाहिए यह तेजी से प्रतिक्रिया देगा।

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

Answer 29

आप आकार = 0 का उपयोग कर सकते हैं यह आपको सभी दस्तावेजों का उदाहरण देगा

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

Comments

यह एक संचित जानकारी लौटाएगा, लेकिन खुद हिट नहीं

— user732456