समान नेस्टेड गुण मानों वाले दस्तावेज़ों को कैसे फ़िल्टर करें

Question 1

नीचे दिए गए दस्तावेज़ मैपिंग को देखते हुए, मैं उन source-string को कैसे फ़िल्टर कर सकता हूं जिनमें कम से कम 2 समान targetStrings.score मान हों?

PUT /source-string
{
  "mappings": {
    "properties": {
      "id": { "type": "keyword" },
      "targetStrings": {
        "type": "nested",
        "properties": {
          "id": { "type": "keyword" },
          "score": { "type": "integer" }
        }
      }
    }
  }
}

1 source-string के साथ उदाहरण अनुक्रमणिका जिसमें targetStrings 2 समान score 1 के साथ है। मैं चाहता हूं कि यह वापस आ जाए।

        "_index" : "source-string",
        "_type" : "_doc",
        "_id" : "VHS796CQKuFZo2GPmb1T",
        "_source" : {
          "id" : "VHS796CQKuFZo2GPmb1T",
          "targetStrings" : [
            {
              "score" : 1,
              "id" : "id1"
            },
            {
              "score" : 2,
              "id" : "id2"
            },
            {
              "score" : 1,
              "id" : "id3"
            }
          ]
        }
      }

elasticsearch

0

Morrowless 19 नवम्बर 2020, 04:44

Answer

आप का इस्तेमाल कर सकते हैं min_doc_count शर्तों के एकत्रीकरण के साथ, जो वापस कर देगा हिट की कॉन्फ़िगर की गई संख्या से अधिक मेल खाने वाले शब्द

अनुक्रमणिका डेटा, खोज क्वेरी और खोज परिणाम के साथ एक कार्यशील उदाहरण जोड़ना

सूचकांक डेटा:

{
  "id": "VHS796CQKuFZo2GPmb1W",
  "targetStrings": [
    {
      "score": 3,
      "id": "id1"
    },
    {
      "score": 2,
      "id": "id2"
    },
    {
      "score": 1,
      "id": "id3"
    }
  ]
}
{
  "id": "VHS796CQKuFZo2GPmb1T",
  "targetStrings": [
    {
      "score": 1,
      "id": "id1"
    },
    {
      "score": 2,
      "id": "id2"
    },
    {
      "score": 1,
      "id": "id3"
    }
  ]
}

खोज क्वेरी:

{
  "size": 0,
  "aggs": {
    "id_terms": {
      "terms": {
        "field": "id"
      },
      "aggs": {
        "nested_entries": {
          "nested": {
            "path": "targetStrings"
          },
          "aggs": {
            "targetStrings": {
              "terms": {
                "field": "targetStrings.score",
                "min_doc_count": 2
              }
            }
          }
        }
      }
    }
  }
}

खोज परिणाम:

"aggregations": {
    "id_terms": {
      "doc_count_error_upper_bound": 0,
      "sum_other_doc_count": 0,
      "buckets": [
        {
          "key": "VHS796CQKuFZo2GPmb1T",
          "doc_count": 1,
          "nested_entries": {
            "doc_count": 3,
            "targetStrings": {
              "doc_count_error_upper_bound": 0,
              "sum_other_doc_count": 0,
              "buckets": [
                {
                  "key": 1,
                  "doc_count": 2            <-- note this
                }
              ]
            }
          }
        },
        {
          "key": "VHS796CQKuFZo2GPmb1W",
          "doc_count": 1,
          "nested_entries": {
            "doc_count": 3,
            "targetStrings": {
              "doc_count_error_upper_bound": 0,
              "sum_other_doc_count": 0,
              "buckets": []
            }
          }
        }
      ]
    }

अपडेट 1:

आप उपयोग कर सकते हैं बकेट चयनकर्ता एकत्रीकरण यदि आप केवल उन दस्तावेज़ों को पुनः प्राप्त करना चाहते हैं जिनके ठीक 2 समान स्कोर हैं

{
  "size": 0,
  "aggs": {
    "id_terms": {
      "terms": {
        "field": "id"
      },
      "aggs": {
        "nested_entries": {
          "nested": {
            "path": "targetStrings"
          },
          "aggs": {
            "targetStrings": {
              "terms": {
                "field": "targetStrings.score"
              },
              "aggs": {
                "count_filter": {
                  "bucket_selector": {
                    "buckets_path": {
                      "values": "_count"
                    },
                    "script": "params.values == 2"
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

1

ESCoder 19 नवम्बर 2020, 06:31

Question 2