• 按距离聚合

    按距离聚合

    按距离聚合对于类似“找出距我1公里内的所有pizza店”这样的检索场景很适合。
    检索结果需要确实地只返回距离用户1km内的文档，不过我们可以再加上一个“1-2km内的结果集”：

    2. GET /attractions/restaurant/_search
    3. {
    4.   "query": {
    5.     "filtered": {
    6.       "query": {
    7.         "match": { <1>
    8.           "name": "pizza"
    9.         }
    10.       },
    11.       "filter": {
    12.         "geo_bounding_box": {
    13.           "location": { <2>
    14.             "top_left": {
    15.               "lat":  40,8,
    16.               "lon": -74.1
    17.             },
    18.             "bottom_right": {
    19.               "lat":  40.4,
    20.               "lon": -73.7
    21.             }
    22.           }
    23.         }
    24.       }
    25.     }
    26.   },
    27.   "aggs": {
    28.     "per_ring": {
    29.       "geo_distance": { <3>
    30.         "field":    "location",
    31.         "unit":     "km",
    32.         "origin": {
    33.           "lat":    40.712,
    34.           "lon":   -73.988
    35.         },
    36.         "ranges": [
    37.           { "from": 0, "to": 1 },
    38.           { "from": 1, "to": 2 }
    39.         ]
    40.       }
    41.     }
    42.   },
    43.   "post_filter": { <4>
    44.     "geo_distance": {
    45.       "distance":   "1km",
    46.       "location": {
    47.         "lat":      40.712,
    48.         "lon":     -73.988
    49.       }
    50.     }
    51.   }
    52. }
    • <1> 主查询查找饭店名中包含了 “pizza” 的文档。
    • <2> 矩形框过滤器让结果集缩小到纽约区域。
    • <3> 距离聚合器计算距用户1km和1km-2km的结果数。
    • <4> 最后，后置过滤器（post_filter)再把结果缩小到距离用户1km的饭店。

    上例请求的返回结果如下：

    2. "hits": {
    3.   "total":     1,
    4.   "max_score": 0.15342641,
    5.   "hits": [ <1>
    6.      {
    7.         "_index": "attractions",
    8.         "_type":  "restaurant",
    9.         "_id":    "3",
    10.         "_score": 0.15342641,
    11.         "_source": {
    12.            "name": "Mini Munchies Pizza",
    13.            "location": [
    14.               -73.983,
    15.               40.719
    16.            ]
    17.         }
    18.      }
    19.   ]
    20. },
    21. "aggregations": {
    22.   "per_ring": { <2>
    23.      "buckets": [
    24.         {
    25.            "key":       "*-1.0",
    26.            "from":      0,
    27.            "to":        1,
    28.            "doc_count": 1
    29.         },
    30.         {
    31.            "key":       "1.0-2.0",
    32.            "from":      1,
    33.            "to":        2,
    34.            "doc_count": 1
    35.         }
    36.      ]
    37.   }
    38. }
    • <1> 后置过滤器（post_filter）已经结果集缩小到满足“距离用户1km”条件下的唯一一个pizza店。
    • <2> 聚合器包含了”距离用户2km”的pizza店的检索结果。

    这个例子中，我们统计了落到各个环形区域中的饭店数。
    当然，我们也可以使用子聚合器再在每个环形区域中进一步计算它们的平均价格，最流行，等等。