1

我有一个要计算聚合的产品目录。问题在于尝试使用包含嵌套和父字段的过滤器进行嵌套聚合。它要么给出错误的计数，要么给出 0 次命中。这是我的产品对象映射示例：

"Products": {
        "properties": {
           "ProductID": {
              "type": "long"
           },
           "ProductType": {
              "type": "long"
           },
           "ProductName": {
              "type": "string",
              "fields": {
                 "raw": {
                    "type": "string",
                    "index": "not_analyzed"
                 }
              }
           },
           "Prices": {
              "type": "nested",
              "properties": {
                 "CurrencyType": {
                    "type": "integer"
                 },
                 "Cost": {
                    "type": "double"                        
                 }
              }
          } 
      }
  }

这是我尝试在弹性中复制的 sql 查询的示例：

SELECT PRODPR.Cost AS PRODPR_Cost 
    ,COUNT(PROD.ProdcutID) AS PROD_ProductID_Count
FROM Products PROD WITH (NOLOCK)
LEFT OUTER JOIN Prices PRODPR WITH (NOLOCK) ON (PRODPR.objectid = PROD.objectid)
WHERE PRODPR.CurrencyType = 4
    AND PROD.ProductType IN (
        11273
        ,11293
        ,11294
        )
GROUP BY PRODPR.Cost

我想出的弹性搜索查询：第一个（以下查询返回正确的计数，仅使用 CurrencyType 作为过滤器，但是当我添加 ProductType 过滤器时，它给了我错误的计数）

GET /IndexName/Products/_search
{
  "aggs": {
    "price_agg": {
      "filter": {
        "bool": {
          **"must": [
            {
              "nested": {
                "path": "Prices",
                    "filter": {
                      "term": {
                        "Prices.CurrencyType": "8"
                      }
                }
              }
            },
            {
              "terms": {
                "ProductType": [
                  "11273",
                  "11293",
                  "11294"
                ]
              }
            }
          ]**
        }
      },
      "aggs": {
        "price_nested_agg": {
          "nested": {
            "path": "Prices"
          },
          "aggs": {
            "59316518_group_agg": {
              "terms": {
                "field": "Prices.Cost",
                "size": 0
              },
              "aggs": {
                "product_count": {
                    "reverse_nested": { },
                    "aggs": {
                        "ProductID_count_agg": {
                            "value_count": {
                                "field": "ProductID"
                            }
                        }
                    }
                }
              }
            }
          }
        }
      }
    }
  },
  "size": 0
}

第二个（以下查询返回正确的计数，仅使用 CurrencyType 作为过滤器，但是当我添加 ProductType 过滤器时，它给了我 0 次点击）：

GET /IndexName/Prodcuts/_search
{
  "aggs": {
    "price_agg": {
      "nested": {
        "path": "Prices"
      },
      "aggs": {
        "currency_filter": {
          "filter": {
              "bool": {
                  "must": [
                     {
                         "term": {
                            "Prices.CurrrencyType": "4"
                         }
                     },
                     {
                         "terms": {
                            "ProductType": [
                               "11273",
                               "11293"
                            ]
                         }
                     }
                  ]
              }
          },
          "aggs": {
            "59316518_group_agg": {
              "terms": {
                "field": "Prices.Cost",
                "size": 0
              },
              "aggs": {
                "product_count": {
                  "reverse_nested": {},
                  "aggs": {
                    "ProductID_count_agg": {
                      "value_count": {
                        "field": "ProductID"
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  },
  "size": 0
}

我尝试了更多查询，但以上两个是我想出的最接近的。有没有人遇到过这个用例？我究竟做错了什么？任何帮助表示赞赏。谢谢！

4

0 回答 0