在elasticsearch中按嵌套字段值之和查询文档

Question

在这里给ElasticSearch的初学者排名。

我有一个客户列表，他们的订单作为一个嵌套字段。假设文档结构如下：

[
  { customerId: 123,
    birthday: 1980-01-01,
    orders: [
      {
        orderValue: 1500,
        orderDate: 2018-12-18T12:18:12Z
      },
      [...]
    ]
  },
  [...]
}

我想查询的是：在两个日期之间订购了一定数量的用户列表。我希望能够将它与例如生日的范围查询结合起来。

我已经到了这样的地步，我可以使用聚合来获得每个订户在两个日期之间的排序总和：

{
  "size": 0,
  "aggs": {
    "foo": {
      "nested": {
        "path": "orders"
      },
      "aggs": {
        "grouped_by_customerId": {
          "terms": {
            "field": "orders.customerId.keyword"
          },
          "aggs": {
            "filtered_by_date": {
              "filter": {
                "range": {
                  "orders.orderDate": {
                    "from": "2018-01-28",
                    "to": null,
                    "include_lower": false,
                    "include_upper": true,
                    "format": "yyyy-MM-dd",
                    "boost": 1
                  }
                }
              },
              "aggs": {
                "sum": {
                  "sum": {
                    "field": "orders.orderValue"
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

但是，我想限制查询部分返回的结果，以便更好地与所有其他过滤器混合。

我的第一个想法是使用一个脚本过滤器，并将边界日期和最小值作为参数传递进来，但随后我必须迭代一个文档的嵌套文档，这似乎不起作用。

最后一个想法可能吗？如果可能，怎么可能？

谢了！

Answer 1

最后我自己解决了这个问题，使用如下函数得分查询：

{
  "query": {
    "bool": {
      "must": [
        {
          "function_score": {
            "min_score": 1,
            "query": {
              "nested": {
                "path": "orders",
                "ignore_unmapped": false,
                "score_mode": "min",
                "boost": 1,
                "query": {
                  "range": {
                    "orders.orderDate": {
                      "from": "2018-12-10",
                      "to": null,
                      "include_lower": true,
                      "include_upper": true,
                      "format": "yyyy-MM-dd",
                      "boost": 1
                    }
                  }
                }
              }
            },
            "functions": [
              {
                "filter": {
                  "match_all": {}
                },
                "script_score": {
                  "script": {
                    "source": "ArrayList x = params['_source']['orders'];if (x == null) { return 0 }long result = x.stream().filter(order -> {  if(params.startDate != null && !ZonedDateTime.parse(order.orderDate).isAfter(ZonedDateTime.parse(params.startDate))) return false; return true}).mapToLong(order->Long.parseLong(order.orderValue)).sum();if(params.operator == 'GT') return result > params.totalOrderValue ? 2 : 0;else if (params.operator == 'GE') return result >= params.totalOrderValue ? 3 : 0;else if (params.operator == 'LE') return result <= params.totalOrderValue ? 4 : 0;else if(params.operator == 'LT') return result < params.totalOrderValue ? 5 : 0;return result == params.totalOrderValue ? 6 : 0",
                    "lang": "painless",
                    "params": {
                      "totalOrderValue": 120,
                      "operator": "GE",
                      "startDate": "2012-12-10T23:00:00.000Z"
                    }
                  }
                }
              }
            ],
            "score_mode": "multiply",
            "max_boost": 3.4028235e+38,
            "boost": 1
          }
        }
      ],
      "adjust_pure_negative": true,
      "boost": 1
    }
  }
}

它产生的实际分数是测试运算符的调试输出，但是min_score为1意味着它们中的任何一个都匹配。使用_source相当慢。

如果function_score中没有查询，它可以工作，但需要20秒左右的时间来处理300万条记录。使用该查询，您只查看订单实际上与日期范围匹配的客户。

由于无痛脚本处理整个订单列表，它必须重做日期数学。一些优化做那里，但至少我有一个概念证明。

我以前见过这个问题没有令人满意的答案，所以希望有人发现这很有用。