इलास्टिसिपेट करें केवल कुछ फ़ील्ड वापस करें?

Question

मैं अपने दस्तावेज़ों को अनुक्रमित करने के लिए elasticsearch का उपयोग कर रहा हूँ।

क्या यह संभव है कि वह अपने द्वारा जमा किए गए संपूर्ण json दस्तावेज़ के बजाय केवल विशेष फ़ील्ड वापस करने के लिए निर्देश दे?

Comments

elastic.co/guide/en/elasticsearch/reference/current/... , टिप्पणी बताने वाली तुम भी केवल कुछ क्षेत्रों को बाहर कर सकते

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

Answer 1

हां! स्रोत फिल्टर का उपयोग करें । यदि आप JSON के साथ खोज कर रहे हैं तो यह कुछ इस तरह दिखाई देगा:

{
    "_source": ["user", "message", ...],
    "query": ...,
    "size": ...
}

ES 2.4 और पूर्ववर्ती में, आप खोज API में फ़ील्ड विकल्प का भी उपयोग कर सकते हैं :

{
    "fields": ["user", "message", ...],
    "query": ...,
    "size": ...
}

यह ES 5+ में पदावनत है। और स्रोत फिल्टर वैसे भी अधिक शक्तिशाली हैं!

Comments

उन्हें "संग्रहीत" के रूप में परिभाषित करना सुनिश्चित करें: मानचित्रण में सच है। अन्यथा ES अभी भी _source दस्तावेज़ लोड करेगा और वहाँ से फ़ील्ड लोड करेगा। यदि डेटा लौटाया जा सकता है तो प्रदर्शन का प्रभाव पूरे दस्तावेज़ के आकार से अपेक्षाकृत छोटा होता है।

— ज़ार है

आपका मतलब है "स्टोर": सच

— sscarduzio

क्या ये फ़ाइल में बने हैं या बिल्कुल कहाँ हैं?

— vbNewbie

@vbNewbie: जहां कभी आप मैपिंग को परिभाषित कर रहे हैं। यदि आप स्पष्ट रूप से मैपिंग को परिभाषित नहीं कर रहे हैं और इसे बनाने के लिए ES पर निर्भर हैं, तो आपको उन फ़ील्ड के लिए मैपिंग को परिभाषित करना होगा, जिन्हें आप स्टोर करना चाहते हैं। आप केवल उन फ़ील्ड्स के लिए मैपिंग को परिभाषित कर सकते हैं, जहाँ आप विशेष व्यवहार चाहते हैं (जैसे "स्टोर": सही, "इंडेक्स": "not_analyzed") या सभी फ़ील्ड। अधिक विवरण के लिए मैपिंग डॉक्स में देखें।

— संघर्ष

फ़ील्ड अब नए संस्करणों पर समर्थित नहीं हैं। इसके बजाय store_fields का उपयोग करें :)

— सचिन शर्मा

Answer 2

मैंने डॉक्स get apiको सहायक होने के लिए पाया - विशेष रूप से दो खंड, स्रोत फ़िल्टरिंग और फ़ील्ड : https://www.elastic.co/guide/en/elasticsearch/reference/7.3/docs-get.html#get-source- छानने

वे स्रोत फ़िल्टरिंग के बारे में बताते हैं:

यदि आपको पूर्ण _source से केवल एक या दो फ़ील्ड की आवश्यकता है, तो आप उन भागों को शामिल करने या फ़िल्टर करने के लिए _source_include & _source_exclude पैरामीटर का उपयोग कर सकते हैं, जिनकी आपको आवश्यकता है। यह विशेष रूप से बड़े दस्तावेजों के साथ सहायक हो सकता है जहां आंशिक पुनर्प्राप्ति नेटवर्क ओवरहेड पर बचा सकता है

जिसने मेरे उपयोग के मामले को पूरी तरह से फिट कर दिया। मैंने अंत में स्रोत को छान मारा जैसे (आशुलिपि का उपयोग करके):

{
    "_source": ["field_x", ..., "field_y"],
    "query": {      
        ...
    }
}

FYI करें, वे क्षेत्र पैरामीटर के बारे में डॉक्स में बताते हैं :

प्राप्त ऑपरेशन, संग्रहीत फ़ील्ड के एक सेट को निर्दिष्ट करने की अनुमति देता है जिसे फ़ील्ड पैरामीटर पास करके वापस किया जाएगा।

ऐसा लगता है कि विशेष रूप से संग्रहित किए गए फ़ील्ड के लिए, जहाँ यह प्रत्येक फ़ील्ड को एक सरणी में रखता है। यदि निर्दिष्ट फ़ील्ड संग्रहीत नहीं किए गए हैं तो यह _source से प्रत्येक को लाएगा, जिसके परिणामस्वरूप 'धीमी' पुनर्प्राप्ति हो सकती है। मुझे टाइप ऑब्जेक्ट के फ़ील्ड्स को वापस करने के लिए इसे प्राप्त करने की कोशिश करने में भी परेशानी हुई।

इसलिए सारांश में, आपके पास दो विकल्प हैं, हालांकि स्रोत फ़िल्टरिंग या [संग्रहीत] फ़ील्ड।

Comments

मेरे लिए छल किया। मुझे "फ़ील्ड" का उपयोग करके जियो_ पॉइंट वापस करने में समस्या थी, लेकिन "_source" ठीक काम करता है, धन्यवाद!

— योनली

Answer 3

For the ES versions 5.X and above you can a ES query something like this

    GET /.../...
    {
      "_source": {
        "includes": [ "FIELD1", "FIELD2", "FIELD3" ... " ]
      },
      .
      .
      .
      .
    }

Answer 4

एलेस्टिक्स खोज में 5.x उपर्युक्त दृष्टिकोण अपदस्थ है। आप _ स्रोत स्रोत का उपयोग कर सकते हैं, लेकिन कुछ स्थितियों में यह किसी क्षेत्र को संग्रहीत करने के लिए समझ में आता है। उदाहरण के लिए, यदि आपके पास कोई शीर्षक, दिनांक और बहुत बड़ी सामग्री फ़ील्ड वाला कोई दस्तावेज़ है, तो आप उन फ़ील्डों को बड़े _source फ़ील्ड से निकालने के बिना बस शीर्षक और दिनांक पुनर्प्राप्त करना चाह सकते हैं:

इस स्थिति में, आप उपयोग करेंगे:

{  
   "size": $INT_NUM_OF_DOCS_TO_RETURN,
   "stored_fields":[  
      "doc.headline",
      "doc.text",
      "doc.timestamp_utc"
   ],
   "query":{  
      "bool":{  
         "must":{  
            "term":{  
               "doc.topic":"news_on_things"
            }
         },
         "filter":{  
            "range":{  
               "doc.timestamp_utc":{  
                  "gte":1451606400000,
                  "lt":1483228800000,
                  "format":"epoch_millis"
               }
            }
         }
      }
   },
   "aggs":{  

   }
}

संग्रहीत फ़ील्ड को अनुक्रमित करने के तरीके के बारे में दस्तावेज़ देखें। हमेशा एक Upvote के लिए खुश!

Answer 5

here you can specify whichever field you want in your output and also which you don't.

  POST index_name/_search
    {
        "_source": {
            "includes": [ "field_name", "field_name" ],
            "excludes": [ "field_name" ]
        },
        "query" : {
            "match" : { "field_name" : "value" }
        }
    }

Answer 6

response_filtering

सभी REST API एक फ़िल्टर_पथ पैरामीटर स्वीकार करते हैं, जिसका उपयोग इलास्टिक्स खोज द्वारा दी गई प्रतिक्रिया को कम करने के लिए किया जा सकता है। यह पैरामीटर डॉट नोटेशन के साथ व्यक्त किए गए फ़िल्टर की अल्पविराम से अलग की गई सूची लेता है।

https://stackoverflow.com/a/35647027/844700

Answer 7

यहाँ एक और समाधान, अब एक मैच अभिव्यक्ति का उपयोग कर

स्रोत फ़िल्टरिंग
यह नियंत्रित करने की अनुमति देता है कि _source फ़ील्ड को हर हिट के साथ कैसे लौटाया जाए।

Elastiscsearch संस्करण 5.5 के साथ परीक्षण किया गया

कीवर्ड "शामिल करता है " निर्दिष्ट क्षेत्रों को परिभाषित करता है।

GET /my_indice/my_indice_type/_search
{
    "_source": {
        "includes": [ "my_especific_field"]
        },
        "query": {
        "bool": {
                "must": [
                {"match": {
                    "_id": "%my_id_here_without_percent%"
                    }
                }
            ]
        }
    }
}

Answer 8

REST API GET अनुरोध '_source' पैरामीटर के साथ किया जा सकता है।

उदाहरण अनुरोध

http://localhost:9200/opt_pr/_search?q=SYMBOL:ITC AND OPTION_TYPE=CE AND TRADE_DATE=2017-02-10 AND EXPIRY_DATE=2017-02-23&_source=STRIKE_PRICE

प्रतिक्रिया

{
"took": 59,
"timed_out": false,
"_shards": {
    "total": 5,
    "successful": 5,
    "failed": 0
},
"hits": {
    "total": 104,
    "max_score": 7.3908954,
    "hits": [
        {
            "_index": "opt_pr",
            "_type": "opt_pr_r",
            "_id": "AV3K4QTgNHl15Mv30uLc",
            "_score": 7.3908954,
            "_source": {
                "STRIKE_PRICE": 160
            }
        },
        {
            "_index": "opt_pr",
            "_type": "opt_pr_r",
            "_id": "AV3K4QTgNHl15Mv30uLh",
            "_score": 7.3908954,
            "_source": {
                "STRIKE_PRICE": 185
            }
        },
        {
            "_index": "opt_pr",
            "_type": "opt_pr_r",
            "_id": "AV3K4QTgNHl15Mv30uLi",
            "_score": 7.3908954,
            "_source": {
                "STRIKE_PRICE": 190
            }
        },
        {
            "_index": "opt_pr",
            "_type": "opt_pr_r",
            "_id": "AV3K4QTgNHl15Mv30uLm",
            "_score": 7.3908954,
            "_source": {
                "STRIKE_PRICE": 210
            }
        },
        {
            "_index": "opt_pr",
            "_type": "opt_pr_r",
            "_id": "AV3K4QTgNHl15Mv30uLp",
            "_score": 7.3908954,
            "_source": {
                "STRIKE_PRICE": 225
            }
        },
        {
            "_index": "opt_pr",
            "_type": "opt_pr_r",
            "_id": "AV3K4QTgNHl15Mv30uLr",
            "_score": 7.3908954,
            "_source": {
                "STRIKE_PRICE": 235
            }
        },
        {
            "_index": "opt_pr",
            "_type": "opt_pr_r",
            "_id": "AV3K4QTgNHl15Mv30uLw",
            "_score": 7.3908954,
            "_source": {
                "STRIKE_PRICE": 260
            }
        },
        {
            "_index": "opt_pr",
            "_type": "opt_pr_r",
            "_id": "AV3K4QTgNHl15Mv30uL5",
            "_score": 7.3908954,
            "_source": {
                "STRIKE_PRICE": 305
            }
        },
        {
            "_index": "opt_pr",
            "_type": "opt_pr_r",
            "_id": "AV3K4QTgNHl15Mv30uLd",
            "_score": 7.381078,
            "_source": {
                "STRIKE_PRICE": 165
            }
        },
        {
            "_index": "opt_pr",
            "_type": "opt_pr_r",
            "_id": "AV3K4QTgNHl15Mv30uLy",
            "_score": 7.381078,
            "_source": {
                "STRIKE_PRICE": 270
            }
        }
    ]
}

}

Comments

यह मेरे लिए बहुत उपयोग है।

— तृप्ति इंदुनील

Answer 9

हाँ स्रोत फ़िल्टर का उपयोग करके आप इसे पूरा कर सकते हैं, यहाँ डॉक्टर स्रोत फ़िल्टरिंग है

उदाहरण अनुरोध

POST index_name/_search
 {
   "_source":["field1","filed2".....] 
 }

आउटपुट होगा

{
  "took": 57,
  "timed_out": false,
  "_shards": {
    "total": 5,
    "successful": 5,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": 1,
    "max_score": 1,
    "hits": [
      {
        "_index": "index_name",
        "_type": "index1",
        "_id": "1",
        "_score": 1,
        "_source": {
          "field1": "a",
          "field2": "b"
        },
        {
          "field1": "c",
          "field2": "d"
        },....
      }
    ]
  }
}

Answer 10

जावा में आप इस तरह setFetchSource का उपयोग कर सकते हैं:

client.prepareSearch(index).setTypes(type)
            .setFetchSource(new String[] { "field1", "field2" }, null)

Answer 11

उदाहरण के लिए, आपके पास तीन फ़ील्ड के साथ एक डॉक्टर है:

PUT movie/_doc/1
{
  "name":"The Lion King",
  "language":"English",
  "score":"9.3"
}

यदि आप वापस लौटना चाहते हैं nameऔर scoreआप निम्न कमांड का उपयोग कर सकते हैं:

GET movie/_doc/1?_source_includes=name,score

यदि आप कुछ क्षेत्रों को प्राप्त करना चाहते हैं जो एक पैटर्न से मेल खाते हैं:

GET movie/_doc/1?_source_includes=*re

शायद कुछ क्षेत्रों को छोड़ दें:

GET movie/_doc/1?_source_excludes=score

Answer 12

जावा एपीआई का उपयोग करते हुए, मैं विशेष क्षेत्र के सेट से सभी रिकॉर्ड प्राप्त करने के लिए निम्नलिखित का उपयोग करता हूं:

public List<Map<String, Object>> getAllDocs(String indexName) throws IOException{
    int scrollSize = 1000;
    List<Map<String,Object>> data = new ArrayList<>();
    SearchResponse response = null;
    while( response == null || response.getHits().getHits().length != 0){
        response = client.prepareSearch(indexName)
            .setTypes("typeName")  // The document types to execute the search against. Defaults to be executed against all types.
        .setQuery(QueryBuilders.matchAllQuery())
        .setFetchSource(new String[]{"field1", "field2"}, null)
        .setSize(scrollSize)
        .execute()
        .actionGet();
        for(SearchHit hit : response.getHits()){
            System.out.println(hit.getSourceAsString());
        }
    }
    return data;
}