ElasticSearch

Question

में केवल मिलान किए गए नेस्टेड ऑब्जेक्ट मानों से कुल मिलाकर मुझे क्वेरी से मेल खाने वाले नेस्टेड ऑब्जेक्ट्स पर केवल मानों को जोड़ना होगा। ऐसा लगता है कि लोचदार खोज क्वेरी से मेल खाने वाले दस्तावेजों को निर्धारित करती है और फिर सभी नेस्टेड ऑब्जेक्ट्स पर रकम करती है। नीचे की रूपरेखा से मैं nestedobjects.objtype = "ए" पर खोज करना चाहता हूं और केवल nestedobjects से मेल खाने के लिए objvalue की राशि वापस प्राप्त करना चाहता हूं, मैं मान 4 प्राप्त करना चाहता हूं। क्या यह संभव है? यदि हां, तो कैसे?

यहाँ मानचित्रण

{ 
    "myindex": { 
    "mappings": { 
     "mytype": { 
     "properties": { 
      "nestedobjects": { 
      "type": "nested", 
      "include_in_parent": true, 
      "properties": { 
       "objtype": { 
       "type": "string" 
       }, 
       "objvalue": { 
       "type": "integer" 
       } 
      } 
      } 
     } 
     } 
    } 
    } 
} 

यहाँ मेरी दस्तावेजों

PUT /myindex/mytype/1 
{ 
    "nestedobjects": [ 
    { "objtype": "A", "objvalue": 1 }, 
    { "objtype": "B", "objvalue": 2 } 
    ] 
} 
PUT /myindex/mytype/2 
{ 
    "nestedobjects": [ 
    { "objtype": "A", "objvalue": 3 }, 
    { "objtype": "B", "objvalue": 3 } 
    ] 
} 

यहाँ मेरी क्वेरी कोड है कर रहे हैं।

POST allscriptshl7/_search?search_type=count 
{ 
    "query": { 
    "filtered": { 
     "query": { 
     "query_string": { 
      "query": "nestedobjects.objtype:A" 
     } 
     } 
    } 
    }, 
    "aggregations": { 
    "my_agg": { 
     "sum": { 
     "field": "nestedobjects.objvalue" 
     } 
    } 
    } 
} 

Answer 1

के बाद से दोनों (बाह्य) दस्तावेजों हालत से मेल खाते हैं कि उनके भीतर दस्तावेजों में से एक क्वेरी से मेल खाते, दोनों बाहरी दस्तावेज लौटा दिए जाते हैं, और एकत्रीकरण उन बाहरी दस्तावेजों से संबंधित आंतरिक दस्तावेजों के सभी के खिलाफ गणना की जाती है। वाह।

वैसे भी, इस filter aggregation का उपयोग कर, आप क्या चाहते हैं कर रहे हैं, मुझे लगता है कि ऐसा करने के लिए लगता है:

http://sense.qbox.io/gist/c1494619ff1bd0394d61f3d5a16cb9dfc229113a

बहुत अच्छी तरह से:

POST /myindex/_search?search_type=count 
{ 
    "aggs": { 
     "nested_nestedobjects": { 
     "nested": { 
      "path": "nestedobjects" 
     }, 
     "aggs": { 
      "filtered_nestedobjects": { 
       "filter": { 
        "term": { 
        "nestedobjects.objtype": "a" 
        } 
       }, 
       "aggs": { 
        "my_agg": { 
        "sum": { 
         "field": "nestedobjects.objvalue" 
        } 
        } 
       } 
      } 
     } 
     } 
    } 
} 
... 
{ 
    "took": 4, 
    "timed_out": false, 
    "_shards": { 
     "total": 5, 
     "successful": 5, 
     "failed": 0 
    }, 
    "hits": { 
     "total": 2, 
     "max_score": 0, 
     "hits": [] 
    }, 
    "aggregations": { 
     "nested_nestedobjects": { 
     "doc_count": 4, 
     "filtered_nestedobjects": { 
      "doc_count": 2, 
      "my_agg": { 
       "value": 4, 
       "value_as_string": "4.0" 
      } 
     } 
     } 
    } 
} 

यहाँ कुछ कोड मैं इसे परीक्षण करने के लिए प्रयोग किया जाता है रास्ते से संरचित सवाल।