ElasticSearch多级父子聚合

Question 1

我有3个级别的父级/子级结构。比方说：

公司->员工->可用性

由于可用性（以及员工）在这里经常更新，因此我选择对嵌套使用父/子结构。搜索功能也可以正常工作（所有文档都位于正确的分片中）。

现在，我想对这些结果进行排序。根据公司（第一级）的元数据对它们进行排序很容易。但是我还需要按3级（可用性）进行排序。

我想要按以下方式排序的公司列表：

给定ASC到位置的距离
评分DESC
尽快供货ASC

例如：

公司A距离5英里，评级为4，并且其一名雇员最快在20小时内可用。公司B也距离5英里，也评级为4，但其一名雇员最快可以在5小时内可用。

因此排序结果必须为B，A。

我想对每个数据赋予特殊的权重，因此我开始编写聚合，以后可以在custom_score脚本中使用。

创建索引，导入数据和搜索的全部依据

现在，我设法编写了一个查询，该查询实际上返回了结果，但是可用性聚合存储桶为空。但是，我也将结果重新整理得井井有条，我想将它们弄平。

目前我回来了：

公司IDS->员工IDS->首次可用性

我想要像这样的聚合：

公司IDS->首次供货

这样，我就能执行custom_score脚本来计算分数并对其进行正确排序。

更简化的问题：
如何按多级（大）孩子进行排序/汇总并可能使结果平坦。

Question 2

您不需要进行聚合：

这些是排序标准：

距离ASC（公司位置）
评分DESC（company.rating_value）
不久的将来的可用性ASC（company.employee.availability.start）

如果忽略＃3，则可以运行相对简单的公司查询，如下所示：

GET /companies/company/_search
{
 "query": { "match_all" : {} },
 "sort": {
    "_script": {
        "params": {
            "lat": 51.5186,
            "lon": -0.1347
        },
        "lang": "groovy",
        "type": "number",
        "order": "asc",
        "script": "doc['location'].distanceInMiles(lat,lon)"
    },
    "rating_value": { "order": "desc" }
  }
}

＃3棘手，因为您需要向下查找每个与请求时间最接近的公司的可用性（公司>员工>可用性），并将该持续时间用作第三排序标准。

我们将function_score在孙级使用查询，以获取请求时间与匹配中每个可用性之间的时间差_score。（然后，我们将使用_score作为第三排序标准）。

为了达到孙辈，我们需要在has_child查询中使用has_child查询。

对于每家公司，我们都希望有最快的员工（当然还有他们最接近的可用性）。Elasticsearch 2.0会为我们"score_mode": "min"提供类似的解决方案，但就目前而言，由于我们仅限于"score_mode": "max"让孙子_score成为时差的倒数，因此。

          "function_score": {
            "filter": { 
              "range": { 
                "start": {
                  "gt": "2014-12-22T10:34:18+01:00"
                } 
              }
            },
            "functions": [
              {
                "script_score": {
                  "lang": "groovy",
                  "params": {
                      "requested": "2014-12-22T10:34:18+01:00",
                      "millisPerHour": 3600000
                   },
                  "script": "1 / ((doc['availability.start'].value - new DateTime(requested).getMillis()) / millisPerHour)"
                }
              }
            ]
          }

因此，现在_score每个孙子代（Availability）将是1 / number-of-hours-until-available（以便我们可以使用最长的互惠时间，直到每个Employee可用为止）和最大互惠（ly？）每个公司提供的员工）。

放在一起，我们继续查询公司，但使用公司>员工>可用性生成_score用作＃3排序标准：

GET /companies/company/_search
{
 "query": { 
    "has_child" : {
        "type" : "employee",
        "score_mode" : "max",
        "query": {
          "has_child" : {
            "type" : "availability",
            "score_mode" : "max",
            "query": {
              "function_score": {
                "filter": { 
                  "range": { 
                    "start": {
                      "gt": "2014-12-22T10:34:18+01:00"
                    } 
                  }
                },
                "functions": [
                  {
                    "script_score": {
                      "lang": "groovy",
                      "params": {
                          "requested": "2014-12-22T10:34:18+01:00",
                          "millisPerHour": 3600000
                       },
                      "script": "1/((doc['availability.start'].value - new DateTime(requested).getMillis()) / millisPerHour)"
                    }
                  }
                ]
              }
            }
          }
        }
    }
 },
 "sort": {
  "_script": {
    "params": {
        "lat": 51.5186,
        "lon": -0.1347
    },
    "lang": "groovy",
    "type": "number",
    "order": "asc",
    "script": "doc['location'].distanceInMiles(lat,lon)"
  },
  "rating_value": { "order": "desc" },
  "_score": { "order": "asc" }
 }
}

Question 3

您应该检出R-Tree数据结构https://en.wikipedia.org/wiki/R-tree。