时间戳

首页 > 解决方案 > Elasticsearch 按搜索条件分组/聚合响应

java - Elasticsearch 按搜索条件分组/聚合响应

问题描述

我有一个具有属性 categoryIds 的产品。

"id" : 1,
"title" : "product",
"price" : "1100.00",
"categories" : [ the ids of the product's categories],
"tags" : [ the ids of the product's tags ],
"variants" : [ nested type with properties: name, definition, maybe in the future availability dates]

我想根据查询中的类别对产品 ID 进行分组。在 POST _search 中，我询问属于特定类别的产品（例如 [1, 2, 3]），我还可以使用变体来限制它们。如何对我的答案进行分组/聚合以获取某个类别的 productId 列表？我想要得到什么：

{
    "productsForCategories": {
        "1": [
            "product-1",
            "product-2",
            "product-3"
        ],
        "2": [
            "product-1",
            "product-3",
            "product-4"
        ],
        "3": [
            "product-5",
            "product-6"
        ]
    }
}

提前感谢所有答案。

java生成了什么。

curl --location --request POST 'https://localhost:9200/products/_search' \
--header 'Content-Type: application/json' \
--data-raw '{
    "size": 0,
    "query": {
        "bool": {
            "must": [
                {
                    "bool": {
                        "should": [
                            {
                                "term": {
                                    "categories": {
                                        "value": 7,
                                        "boost": 1.0
                                    }
                                }
                            }
                        ],
                        "adjust_pure_negative": true,
                        "minimum_should_match": "1",
                        "boost": 1.0,
                        "_name": "fromRawQuery"
                    }
                }
            ],
            "filter": [
                {
                    "bool": {
                        "adjust_pure_negative": true,
                        "boost": 1.0,
                        "_name": "filterPart"
                    }
                }
            ],
            "adjust_pure_negative": true,
            "boost": 1.0,
            "_name": "queryPart"
        }
    },
    "_source": {
        "includes": [
            "categories",
            "productType",
            "relations"
        ],
        "excludes": []
    },
    "stored_fields": "_id",
    "sort": [
        {
            "_score": {
                "order": "desc"
            }
        }
    ],
    "aggregations": {
        "agg": {
            "global": {},
            "aggregations": {
                "categories": {
                    "terms": {
                        "field": "categories",
                        "size": 2147483647,
                        "min_doc_count": 1,
                        "shard_min_doc_count": 0,
                        "show_term_doc_count_error": false,
                        "order": [
                            {
                                "_count": "desc"
                            },
                            {
                                "_key": "asc"
                            }
                        ]
                    },
                    "aggregations": {
                        "productsForCategories": {
                            "terms": {
                                "field": "_id",
                                "size": 2147483647,
                                "min_doc_count": 1,
                                "shard_min_doc_count": 0,
                                "show_term_doc_count_error": false,
                                "order": [
                                    {
                                        "_count": "desc"
                                    },
                                    {
                                        "_key": "asc"
                                    }
                                ]
                            }
                        }
                    }
                }
            }
        }
    }
}'```

标签： javaelasticsearchelasticsearch-aggregation

解决方案

我相信你想要的是每个类别对应的产品。正如 Bhavya 提到的，您可以使用术语聚合。

GET products/_search
{
  "size": 0, //<===== If you need only aggregated results, set this to 0. It represents query result size.
  "aggs": {
    "categories": {
      "terms": {
        "field": "cat_ids", // <================= Equivalent of group by Cat_ids
        "size": 10
      },"aggs": {
        "products": {
          "terms": {
            "field": "name.keyword",//<============= For Each category group by products
            "size": 10
          }
        }
      }
    }
  }
}

结果：

  "aggregations" : {
"categories" : {
  "doc_count_error_upper_bound" : 0,
  "sum_other_doc_count" : 0,
  "buckets" : [
    {
      "key" : 1,       //<========== category id
      "doc_count" : 2, //<========== For the given category id 2 products
      "products" : {
        "doc_count_error_upper_bound" : 0,
        "sum_other_doc_count" : 0,
        "buckets" : [
          {
            "key" : "p1",  //<========= for cat_id=1, p1 is there
            "doc_count" : 1
          },
          {
            "key" : "p2", //<========= for cat_id=1, p2 is there
            "doc_count" : 1
          }
        ]
      }
    },
    {
      "key" : 2,
      "doc_count" : 2,
      "products" : {
        "doc_count_error_upper_bound" : 0,
        "sum_other_doc_count" : 0,
        "buckets" : [
          {
            "key" : "p1",
            "doc_count" : 1
          },
          {
            "key" : "p2",
            "doc_count" : 1
          }
        ]
      }
    },
    {
      "key" : 3,
      "doc_count" : 1,
      "products" : {
        "doc_count_error_upper_bound" : 0,
        "sum_other_doc_count" : 0,
        "buckets" : [
          {
            "key" : "p1",
            "doc_count" : 1
          }
        ]
      }
    }
  ]
}

}

详细信息以评论的形式出现。请删除评论并尝试运行查询。

过滤聚合结果： 见这个

推荐阅读