लोचदार खोज अतिरिक्त पहलू डेटा

Question

मै मैपिंग में एक आईडी द्वारा परिणामों को देखने के लिए अपने लोचदार खोज कार्यान्वयन को कॉन्फ़िगर किया है और जब मैं उस पहलू को उपयोगकर्ता को प्रदर्शित करता हूं तो मुझे इसका प्रतिनिधित्व करने वाले मानव-पठनीय नाम को दिखाने में सक्षम होना चाहिए। मुझे आवश्यक डेटा मैपिंग में मौजूद है, लेकिन मुझे यकीन नहीं है कि मैं इसे पहलू के हिस्से के रूप में कैसे वापस कर सकता हूं। निश्चित रूप से यह संभव है?

निम्न उदाहरण देखते हुए, मैं पहलू करना चाहते हैं मुझे किसी तरह thingIdthingName करने के लिए (या किसी अन्य thing संपत्ति है कि आवश्यकता हो सकती है) सहसंबंधी देने के लिए:

मानचित्रण

{ 
    thingId, 
    thingName 
} 

पहलू क्वेरी

{ 
    "facets":{ 
    "things":{ "terms":{ "field":"thingId" } } 
    } 
}  

परिणाम

{ 
    "hits":{ 
    "total":3, 
    "max_score":1.0, 
    "hits":[ 
     ... 
    ] 
    }, 
    "facets":{ 
    "things":{ 
     "_type":"terms", 
     "missing":0, 
     "total":3, 
     "other":0, 
     "terms":[ 
     { 
      "term":"5", 
      "count":1 
     }, 
     { 
      "term":"4", 
      "count":1 
     }, 
     { 
      "term":"2", 
      "count":1 
     } 
     ] 
    } 
    } 
} 

संपादित

This answer Solr के बारे में पता चलता है कि मैं दोनों गुण (thingName और thingId) और फिर बस दोनों पहलू परिणाम सेट पर पाश पहलू, यह सोचते हैं कि वस्तुओं के आदेश होगा ऐसे ही बनें। मुझे नहीं पता कि यह कितना विश्वसनीय होगा, लेकिन यह एक विकल्प है।

संपादित 2

This answer चलता है कि यह एकल मूल्य में दो क्षेत्रों के संयोजन और उस पर Faceting के बिना मैं क्या चाहते हो पाना संभव नहीं है: thingId|thingName। आदर्श नहीं।

संपादित 3

This answer एक भी क्षेत्र है और उस पर faceting में एक साथ मूल्यों के संयोजन (ऊपर के रूप में) से पता चलता है, लेकिन यह सूचकांक संयुक्त करने के लिए संयोजन को प्राप्त करने के एक मामले स्क्रिप्ट का उपयोग करता है, इस प्रकार मुझे जरूरत नहीं मूल्यों का रूप। अभी भी सही नहीं है, लेकिन कम से कम क्रैपी विकल्प प्रतीत होता है।

Answer 1

यदि आप स्क्रिप्टिंग शर्तों का उपयोग करके खुश नहीं हैं, तो एक और विकल्प nested aggregations का उपयोग करना होगा, मान लें कि आप 1.0.0 का उपयोग करने में सक्षम हैं।

आपका एकत्रीकरण तो कुछ इस तरह दिखेगा: की तरह

{ 
    "query": { 
     "match_all": {} 
    }, 
    "aggs": { 
     "theIds": { 
      "terms" : { 
       "field": "thingId" 
      }, 
      "aggs":{ 
       "theNames": { 
        "terms": { 
         "field": "thingName" 
        } 
       } 
      } 
     } 
    } 
} 

और प्रतिक्रिया होगा कुछ:

"aggregations": { 
     "theIds": { 
     "buckets": [ 
      { 
       "key": "1", 
       "doc_count": 5, 
       "theNames": { 
        "buckets": [ 
        { 
         "key": "AAA", 
         "doc_count": 3 
        }, 
        { 
         "key": "BBB", 
         "doc_count": 3 
        }, 
        { 
         "key": "CCC", 
         "doc_count": 2 
        } 
        ] 
       } 
      }, 
      { 
       "key": "2", 
       "doc_count": 2, 
       "theNames": { 
        "buckets": [ 
        { 
         "key": "AAA", 
         "doc_count": 2 
        } 
        ] 
       } 
      } 
     ] 
     } 
    }