ElasticSearch मल्टी लेवल पैरेंट-चाइल्ड एग्रीगेशन

Question 1

मेरे पास 3 स्तरों में माता-पिता / बच्चे की संरचना है। हम कहते हैं:

कंपनी -> कर्मचारी -> उपलब्धता

चूंकि उपलब्धता (और कर्मचारी भी) अक्सर यहां अपडेट की जाती है, मैं नेस्टेड के खिलाफ माता-पिता / बच्चे की संरचना का उपयोग करता हूं। और खोज फ़ंक्शन ठीक काम करता है (सभी दस्तावेज़ सही शार्क में)।

अब मैं उन परिणामों को क्रमबद्ध करना चाहता हूं। कंपनी (प्रथम स्तर) के मेटा डेटा द्वारा उन्हें क्रमबद्ध करना आसान है। लेकिन मुझे तीसरे स्तर (उपलब्धता) के हिसाब से भी छांटना होगा।

मैं उन कंपनियों की सूची चाहता हूं जो निम्न प्रकार से हैं:

स्थान से दूरी ASC दी
रेटिंग DESC
जल्द ही उपलब्धता ए.एस.सी.

उदाहरण के लिए:

कंपनी A 5 मील दूर है, रेटिंग 4 है और जल्द ही उनका एक कर्मचारी 20 घंटे में उपलब्ध है। कंपनी B 5 मील दूर भी है, रेटिंग 4 भी है लेकिन जल्द ही उनका एक कर्मचारी 5 घंटे में उपलब्ध है।

इसलिए सॉर्ट परिणाम बी, ए होना चाहिए।

मैं इस डेटा में से प्रत्येक के लिए विशेष वजन जोड़ना चाहूंगा, इसलिए मैंने एकत्रीकरण लिखना शुरू कर दिया, जिसे मैं बाद में अपनी custom_score स्क्रिप्ट में उपयोग कर सकता था।

सूचकांक बनाने, डेटा आयात करने और

अब खोज करने के लिए पूर्ण जिस्ट , मैं एक क्वेरी लिखने में कामयाब रहा हूं जो वास्तव में वापस परिणाम देता है, लेकिन उपलब्धता एकत्रीकरण बाल्टी खाली है। हालाँकि, मैं परिणाम भी वापस संरचित कर रहा हूँ, मैं उन्हें समतल करना चाहूँगा।

वर्तमान में मैं वापस मिल गया:

कंपनी आईडीएस -> कर्मचारी आईडीएस -> पहली उपलब्धता

मैं चाहता हूं कि एकत्रीकरण हो:

कंपनी आईडीएस -> पहली उपलब्धता

इस तरह मैं custom_scoreस्कोर की गणना करने और उन्हें ठीक से सॉर्ट करने के लिए अपनी स्क्रिप्ट करने में सक्षम हूं ।

अधिक सरलीकृत प्रश्न:
बहु स्तरीय (भव्य) बच्चों द्वारा किसी प्रकार को कैसे क्रमबद्ध / एकत्र किया जा सकता है और परिणाम को संभवत: समतल कर सकता है।

Question 2

आपको ऐसा करने के लिए एकत्रीकरण की आवश्यकता नहीं है:

ये क्रमबद्ध मापदंड हैं:

दूरी ASC (company.location)
रेटिंग DESC (company.rating_value)
सबसे पहले भविष्य की उपलब्धता ASC (company.employee.avucation.start)

यदि आप # 3 को अनदेखा करते हैं, तो आप इस तरह से अपेक्षाकृत सरल कंपनी क्वेरी चला सकते हैं :

GET /companies/company/_search
{
 "query": { "match_all" : {} },
 "sort": {
    "_script": {
        "params": {
            "lat": 51.5186,
            "lon": -0.1347
        },
        "lang": "groovy",
        "type": "number",
        "order": "asc",
        "script": "doc['location'].distanceInMiles(lat,lon)"
    },
    "rating_value": { "order": "desc" }
  }
}

# 3 मुश्किल है क्योंकि आपको नीचे पहुंचने और अनुरोध के समय के लिए प्रत्येक कंपनी के लिए उपलब्धता ( कंपनी> कर्मचारी> उपलब्धता ) खोजने की आवश्यकता है और उस अवधि को तीसरे प्रकार की कसौटी के रूप में उपयोग करें ।

हम function_scoreअनुरोध समय और हिट में प्रत्येक उपलब्धता के बीच समय अंतर लेने के लिए पोते के स्तर पर एक क्वेरी का उपयोग करने जा रहे हैं _score। (फिर हम _scoreतीसरे प्रकार की कसौटी के रूप में उपयोग करेंगे)।

पोते तक पहुँचने के लिए हमें एक has_childक्वेरी के अंदर एक has_childक्वेरी का उपयोग करने की आवश्यकता है ।

प्रत्येक कंपनी के लिए हम जल्द से जल्द उपलब्ध कर्मचारी चाहते हैं (और निश्चित रूप से उनकी निकटतम उपलब्धता)। Elasticsearch 2.0 हमें एक दे देंगे "score_mode": "min"क्योंकि हम तक सीमित किया गया इस तरह के मामलों के लिए है, लेकिन अब के लिए, "score_mode": "max"हम बना देंगे पोता _scoreहो पारस्परिक समय अंतर का।

          "function_score": {
            "filter": { 
              "range": { 
                "start": {
                  "gt": "2014-12-22T10:34:18+01:00"
                } 
              }
            },
            "functions": [
              {
                "script_score": {
                  "lang": "groovy",
                  "params": {
                      "requested": "2014-12-22T10:34:18+01:00",
                      "millisPerHour": 3600000
                   },
                  "script": "1 / ((doc['availability.start'].value - new DateTime(requested).getMillis()) / millisPerHour)"
                }
              }
            ]
          }

तो अब _scoreप्रत्येक पोते के लिए ( उपलब्धता ) होगा 1 / number-of-hours-until-available(ताकि हम कर्मचारी के प्रति उपलब्ध होने तक अधिकतम पारस्परिक समय का उपयोग कर सकें , और अधिकतम प्रतिपूर्ति (ly?) उपलब्ध कर्मचारी प्रति कंपनी)।

यह सब एक साथ रखें, हम क्वेरी करने के लिए जारी कंपनी लेकिन उपयोग कंपनी> कर्मचारी> की उपलब्धता उत्पन्न करने के लिए _scoreके रूप में उपयोग करने के लिए # 3 तरह कसौटी:

GET /companies/company/_search
{
 "query": { 
    "has_child" : {
        "type" : "employee",
        "score_mode" : "max",
        "query": {
          "has_child" : {
            "type" : "availability",
            "score_mode" : "max",
            "query": {
              "function_score": {
                "filter": { 
                  "range": { 
                    "start": {
                      "gt": "2014-12-22T10:34:18+01:00"
                    } 
                  }
                },
                "functions": [
                  {
                    "script_score": {
                      "lang": "groovy",
                      "params": {
                          "requested": "2014-12-22T10:34:18+01:00",
                          "millisPerHour": 3600000
                       },
                      "script": "1/((doc['availability.start'].value - new DateTime(requested).getMillis()) / millisPerHour)"
                    }
                  }
                ]
              }
            }
          }
        }
    }
 },
 "sort": {
  "_script": {
    "params": {
        "lat": 51.5186,
        "lon": -0.1347
    },
    "lang": "groovy",
    "type": "number",
    "order": "asc",
    "script": "doc['location'].distanceInMiles(lat,lon)"
  },
  "rating_value": { "order": "desc" },
  "_score": { "order": "asc" }
 }
}

Question 3

आपको आर-ट्री डेटा संरचना https://en.wikipedia.org/wiki/R-tree की जांच करनी चाहिए ।