Elasticsearch 聚合子文檔字段值

Question

我面臨以下基於其子文檔的聚合值選擇和排序父文檔的問題。 聚合（例如 sum）本身取決於查詢字符串，即哪些子文檔與聚合相關。

示例：給定文檔購物籃 A和購物籃 B ，對於每個basket document ，如果name字段與我的查詢匹配，我希望對其fruit子項的number字段求和，例如apples 。

PUT /baskets/_doc/0
{
  "name": "basket A", 
  "fruit": [
    {
      "name": "apples",
      "number": 2
    },
    {
      "name": "oranges",
      "number": 3
    }
  ]
}

PUT /baskets/_doc/1
{
  "name": "basket B",
  "fruit": [
    {
      "name": "apples",
      "number": 3
    },
    {
      "name": "apples",
      "number": 3
    }
  ]
}

映射：

PUT /baskets
{
  "mappings": {
    "properties": {
      "name": { "type": "text" },
      "fruit": { 
        "type": "nested",
        "properties": {
          "name": { "type": "text" },
          "number": { "type": "long" }
        }
      }
    }
  }
}

• 用例 1：哪個籃子（嚴格）有超過 5 個蘋果？ 只期望籃子 B
• 用例 2：按蘋果數量對籃子進行排序。 預計籃子 B總共有 6 個蘋果，然后籃子 A總共有 2 個蘋果。

如何使用 Elasticsearch (7.8.0) 查詢 DSL 來實現這一點？

到目前為止，我已經嘗試過使用嵌套查詢和聚合但沒有成功。

謝謝！

編輯：添加映射

編輯：更新了數字以更好地反映問題

*編輯：為用例 2添加了可能的答案（請參閱@joe 對答案的評論）：

GET /profiles/_search
{
  "aggs": {
    "aggs_baskets": {
      "terms": {
        "field": "name",
        "order": {"nest > fruit_filter > fruit_sum": "desc"}
      },
      "aggs": {
        "nest":{
          "nested":{
            "path": "fruit"
          },
          "aggs":{
            "fruit_filter":{
              "filter": {
                "term": {"fruit.name": "apple"}
              },
              "aggs":{
                "fruit_sum":{
                  "sum": {"field": "fruit.number"}
                }
              }
            }
          }
        }
      }
    }
  }
}

Answer 1

用例 1：

GET baskets/_search
{
  "query": {
    "nested": {
      "path": "fruit",
      "inner_hits": {}, 
      "query": {
        "bool": {
          "must": [
            {
              "term": {
                "fruit.name": {
                  "value": "apples"
                }
              }
            },
            {
              "range": {
                "fruit.number": {
                  "gte": 5
                }
              }
            }
          ]
        }
      }
    }
  }
}

嚴格超過 5 --> gt ; >=5 --> gte 。

還要注意inner_hits部分——這為您提供了實際的嵌套子文檔，它導致這個特定的籃子與查詢匹配。 這不是必需的，但很好知道。

用例 2：

GET baskets/_search
{
  "sort": [
    {
      "fruit.number": {
        "nested_path": "fruit",
        "order": "desc"
      }
    }
  ]
}

用例 2 編輯：

可能有更干凈的方法可以做到這一點，但我會 go 使用以下內容：

GET baskets/_search
{
  "size": 0,
  "aggs": {
    "multiply_and_add": {
      "scripted_metric": {
        "params": {
          "only_fruit_name": "apples"
        },
        "init_script": "state.by_basket_name = [:]",
        "map_script": """
          def basket_name = params._source['name'];
          def fruits = params._source['fruit'].findAll(group -> group.name == params.only_fruit_name);
          
          for (def fruit_group : fruits) {
            def number = fruit_group.number;
            
            if (state.by_basket_name.containsKey(basket_name)) {
              state.by_basket_name[basket_name] += number;
            } else {
              state.by_basket_name[basket_name] = number;
            }
          }
        """,
        "combine_script": "return state.by_basket_name",
        "reduce_script": "return states"
      }
    }
  }
}

產生一個 hash map 沿線

{
  ...
  "aggregations":{
    "multiply_and_add":{
      "value":[
        {
          "basket A":2,
          "basket B":6
        }
      ]
    }
  }
}

排序可以在reduce_script或 ES 響應后處理管道中完成。 您當然可以選擇 go w/（排序）列表和lambdas ...

注意所需的nested_path 。

Answer 2

經過一段時間的搜索和測試，這里（除了@joe 對用例 2的回答）可能對這兩個用例進行查詢。 請注意，這兩個用例都需要將字段name的映射更改為keyword類型。

用例 1 ：哪個籃子（嚴格）有超過 5 個蘋果？ 只期望籃子 B

有關按聚合值過濾結果的更多信息，請參閱桶選擇器

GET /baskets/_search
{
  "aggs": {
    "aggs_baskets": {
      "terms": {
        "field": "name"
      },
      "aggs": {
        "nest":{
          "nested":{
            "path": "fruit"
          },
          "aggs":{
            "fruit_filter":{
              "filter": {
                "match": {"fruit.name": "apples"}
              },
              "aggs":{
                "fruit_sum":{
                  "sum": {"field": "fruit.number"}
                }
              }
            }
          }
        },
        "basket_sum_filter":{
          "bucket_selector":{
            "buckets_path":{
              "fruitSum":"nest > fruit_filter > fruit_sum"
            },
            "script":"params.fruitSum > 5"
          }
        }
      }
    }
  }
}

... 屈服

...,

"buckets": [
    {
        "key": "basket B",
        "doc_count": 1,
        "nest": {
            "doc_count": 2,
            "fruit_filter": {
                "doc_count": 2,
                "fruit_sum": {
                    "value": 6
                }
            }
        }
    }
]

用例 2 ：按蘋果數量對籃子進行排序。 預計籃子 B總共有 6 個蘋果，然后籃子 A總共有 2 個蘋果。

GET /baskets/_search
{
  "aggs": {
    "aggs_baskets": {
      "terms": {
        "field": "name",
        "order": {"nest > fruit_filter > fruit_sum": "desc"}
      },
      "aggs": {
        "nest":{
          "nested":{
            "path": "fruit"
          },
          "aggs":{
            "fruit_filter":{
              "filter": {
                "term": {"fruit.name": "apple"}
              },
              "aggs":{
                "fruit_sum":{
                  "sum": {"field": "fruit.number"}
                }
              }
            }
          }
        }
      }
    }
  }
}

... 屈服

...,

"buckets": [
    {
        "key": "basket B",
        "doc_count": 1,
        "nest": {
            "doc_count": 2,
            "fruit_filter": {
                "doc_count": 2,
                "fruit_sum": {
                    "value": 6
                }
            }
        }
    },
    {
        "key": "basket A",
        "doc_count": 1,
        "nest": {
            "doc_count": 2,
            "fruit_filter": {
                "doc_count": 1,
                "fruit_sum": {
                    "value": 2
                }
            }
        }
    }
]