« T 检验聚合 热门指标聚合 »
Elastic 文档 ›Elasticsearch 指南 [8.14] ›聚合 ›指标聚合

热门命中聚合

编辑

热门命中聚合编辑

top_hits 指标聚合器会跟踪正在聚合的最相关文档。此聚合器旨在用作子聚合器，以便可以按桶聚合最匹配的文档。

我们不建议将 top_hits 用作顶级聚合。如果要对搜索结果进行分组，请改用 collapse 参数。

top_hits 聚合器可以有效地用于通过桶聚合器按某些字段对结果集进行分组。一个或多个桶聚合器确定将结果集切片的属性。

选项编辑

  • from - 要获取的第一个结果的偏移量。
  • size - 要返回的每个桶的匹配程度最高的命中次数上限。默认情况下，返回匹配程度最高的前三个命中。
  • sort - 应如何对匹配程度最高的命中进行排序。默认情况下，命中按主查询的分数排序。

支持的每次命中功能编辑

top_hits 聚合返回常规搜索结果，因此可以支持许多每次命中的功能

如果仅需要 docvalue_fields、size 和 sort，则与热门命中聚合相比，热门指标 可能是更有效率的选择。

top_hits 不支持 rescore 参数。查询重新评分仅适用于搜索结果，不适用于聚合结果。要更改聚合使用的分数，请使用 function_score 或 script_score 查询。

示例编辑

在以下示例中，我们按类型对销售进行分组，并按类型显示上次销售。对于每次销售，源中仅包含日期和价格字段。

response = client.search(
  index: 'sales',
  size: 0,
  body: {
    aggregations: {
      top_tags: {
        terms: {
          field: 'type',
          size: 3
        },
        aggregations: {
          top_sales_hits: {
            top_hits: {
              sort: [
                {
                  date: {
                    order: 'desc'
                  }
                }
              ],
              _source: {
                includes: [
                  'date',
                  'price'
                ]
              },
              size: 1
            }
          }
        }
      }
    }
  }
)
puts response
POST /sales/_search?size=0
{
  "aggs": {
    "top_tags": {
      "terms": {
        "field": "type",
        "size": 3
      },
      "aggs": {
        "top_sales_hits": {
          "top_hits": {
            "sort": [
              {
                "date": {
                  "order": "desc"
                }
              }
            ],
            "_source": {
              "includes": [ "date", "price" ]
            },
            "size": 1
          }
        }
      }
    }
  }
}

可能的响应

{
  ...
  "aggregations": {
    "top_tags": {
       "doc_count_error_upper_bound": 0,
       "sum_other_doc_count": 0,
       "buckets": [
          {
             "key": "hat",
             "doc_count": 3,
             "top_sales_hits": {
                "hits": {
                   "total" : {
                       "value": 3,
                       "relation": "eq"
                   },
                   "max_score": null,
                   "hits": [
                      {
                         "_index": "sales",
                         "_id": "AVnNBmauCQpcRyxw6ChK",
                         "_source": {
                            "date": "2015/03/01 00:00:00",
                            "price": 200
                         },
                         "sort": [
                            1425168000000
                         ],
                         "_score": null
                      }
                   ]
                }
             }
          },
          {
             "key": "t-shirt",
             "doc_count": 3,
             "top_sales_hits": {
                "hits": {
                   "total" : {
                       "value": 3,
                       "relation": "eq"
                   },
                   "max_score": null,
                   "hits": [
                      {
                         "_index": "sales",
                         "_id": "AVnNBmauCQpcRyxw6ChL",
                         "_source": {
                            "date": "2015/03/01 00:00:00",
                            "price": 175
                         },
                         "sort": [
                            1425168000000
                         ],
                         "_score": null
                      }
                   ]
                }
             }
          },
          {
             "key": "bag",
             "doc_count": 1,
             "top_sales_hits": {
                "hits": {
                   "total" : {
                       "value": 1,
                       "relation": "eq"
                   },
                   "max_score": null,
                   "hits": [
                      {
                         "_index": "sales",
                         "_id": "AVnNBmatCQpcRyxw6ChH",
                         "_source": {
                            "date": "2015/01/01 00:00:00",
                            "price": 150
                         },
                         "sort": [
                            1420070400000
                         ],
                         "_score": null
                      }
                   ]
                }
             }
          }
       ]
    }
  }
}

字段折叠示例编辑

字段折叠或结果分组是一项功能，可以将结果集逻辑分组，并按组返回热门文档。组的顺序由组中第一个文档的相关性决定。在 Elasticsearch 中，这可以通过包装 top_hits 聚合器作为子聚合器的桶聚合器来实现。

在下面的示例中，我们搜索抓取的网页。对于每个网页，我们存储网页所属的正文和域。通过在 domain 字段上定义 terms 聚合器，我们按域对网页的结果集进行分组。然后将 top_hits 聚合器定义为子聚合器，以便为每个桶收集匹配程度最高的命中。

还定义了一个 max 聚合器，terms 聚合器的 order 功能使用该聚合器按桶中最相关文档的相关性顺序返回桶。

response = client.search(
  index: 'sales',
  body: {
    query: {
      match: {
        body: 'elections'
      }
    },
    aggregations: {
      top_sites: {
        terms: {
          field: 'domain',
          order: {
            top_hit: 'desc'
          }
        },
        aggregations: {
          top_tags_hits: {
            top_hits: {}
          },
          top_hit: {
            max: {
              script: {
                source: '_score'
              }
            }
          }
        }
      }
    }
  }
)
puts response
POST /sales/_search
{
  "query": {
    "match": {
      "body": "elections"
    }
  },
  "aggs": {
    "top_sites": {
      "terms": {
        "field": "domain",
        "order": {
          "top_hit": "desc"
        }
      },
      "aggs": {
        "top_tags_hits": {
          "top_hits": {}
        },
        "top_hit" : {
          "max": {
            "script": {
              "source": "_score"
            }
          }
        }
      }
    }
  }
}

目前，需要 max（或 min）聚合器来确保 terms 聚合器中的桶按每个域中最相关网页的分数排序。遗憾的是，top_hits 聚合器尚不能在 terms 聚合器的 order 选项中使用。

嵌套或 reverse_nested 聚合器中的 top_hits 支持编辑

如果 top_hits 聚合器包装在 nested 或 reverse_nested 聚合器中，则返回嵌套命中。从某种意义上说，嵌套命中是隐藏的微型文档，它们是常规文档的一部分，在映射中配置了嵌套字段类型。top_hits 聚合器能够取消隐藏这些文档，如果它包装在 nested 或 reverse_nested 聚合器中。在 嵌套类型映射 中阅读有关嵌套的更多信息。

如果已配置嵌套类型，则单个文档实际上会被索引为多个 Lucene 文档，并且它们共享相同的 ID。为了确定嵌套命中的身份，需要的不仅仅是 ID，因此嵌套命中还包括其嵌套身份。嵌套身份保存在搜索结果中的 _nested 字段下，并包含数组字段和嵌套命中所属的数组字段中的偏移量。偏移量从零开始。

让我们看看它如何与真实样本一起工作。考虑以下映射

response = client.indices.create(
  index: 'sales',
  body: {
    mappings: {
      properties: {
        tags: {
          type: 'keyword'
        },
        comments: {
          type: 'nested',
          properties: {
            username: {
              type: 'keyword'
            },
            comment: {
              type: 'text'
            }
          }
        }
      }
    }
  }
)
puts response
PUT /sales
{
  "mappings": {
    "properties": {
      "tags": { "type": "keyword" },
      "comments": {                           
        "type": "nested",
        "properties": {
          "username": { "type": "keyword" },
          "comment": { "type": "text" }
        }
      }
    }
  }
}

comments 是一个数组，它在 product 对象下保存嵌套文档。

和一些文档

response = client.index(
  index: 'sales',
  id: 1,
  refresh: true,
  body: {
    tags: [
      'car',
      'auto'
    ],
    comments: [
      {
        username: 'baddriver007',
        comment: 'This car could have better brakes'
      },
      {
        username: 'dr_who',
        comment: "Where's the autopilot? Can't find it"
      },
      {
        username: 'ilovemotorbikes',
        comment: 'This car has two extra wheels'
      }
    ]
  }
)
puts response
PUT /sales/_doc/1?refresh
{
  "tags": [ "car", "auto" ],
  "comments": [
    { "username": "baddriver007", "comment": "This car could have better brakes" },
    { "username": "dr_who", "comment": "Where's the autopilot? Can't find it" },
    { "username": "ilovemotorbikes", "comment": "This car has two extra wheels" }
  ]
}

现在可以执行以下 top_hits 聚合（包装在 nested 聚合中）

response = client.search(
  index: 'sales',
  body: {
    query: {
      term: {
        tags: 'car'
      }
    },
    aggregations: {
      by_sale: {
        nested: {
          path: 'comments'
        },
        aggregations: {
          by_user: {
            terms: {
              field: 'comments.username',
              size: 1
            },
            aggregations: {
              by_nested: {
                top_hits: {}
              }
            }
          }
        }
      }
    }
  }
)
puts response
POST /sales/_search
{
  "query": {
    "term": { "tags": "car" }
  },
  "aggs": {
    "by_sale": {
      "nested": {
        "path": "comments"
      },
      "aggs": {
        "by_user": {
          "terms": {
            "field": "comments.username",
            "size": 1
          },
          "aggs": {
            "by_nested": {
              "top_hits": {}
            }
          }
        }
      }
    }
  }
}

包含嵌套命中的热门命中响应片段，该片段位于数组字段 comments 的第一个位置

{
  ...
  "aggregations": {
    "by_sale": {
      "by_user": {
        "buckets": [
          {
            "key": "baddriver007",
            "doc_count": 1,
            "by_nested": {
              "hits": {
                "total" : {
                   "value": 1,
                   "relation": "eq"
                },
                "max_score": 0.3616575,
                "hits": [
                  {
                    "_index": "sales",
                    "_id": "1",
                    "_nested": {
                      "field": "comments",  
                      "offset": 0 
                    },
                    "_score": 0.3616575,
                    "_source": {
                      "comment": "This car could have better brakes", 
                      "username": "baddriver007"
                    }
                  }
                ]
              }
            }
          }
          ...
        ]
      }
    }
  }
}

包含嵌套命中的数组字段的名称

嵌套命中在包含数组中的位置

嵌套命中的来源

如果请求 _source，则仅返回嵌套对象源的一部分，而不是文档的整个源。还可以通过驻留在 nested 或 reverse_nested 聚合器中的 top_hits 聚合器访问嵌套内部对象级别的存储字段。

只有嵌套命中在命中中具有 _nested 字段，非嵌套（常规）命中没有 _nested 字段。

如果未启用 _source，则 _nested 中的信息也可用于在其他地方解析原始源。

如果在映射中定义了多级嵌套对象类型，则 _nested 信息也可以是分层的，以便表达深度为两层或更多层的嵌套命中的身份。

在下面的示例中，嵌套命中位于字段 nested_grand_child_field 的第一个位置，该字段位于 nested_child_field 字段的第二个位置

...
"hits": {
 "total" : {
     "value": 2565,
     "relation": "eq"
 },
 "max_score": 1,
 "hits": [
   {
     "_index": "a",
     "_id": "1",
     "_score": 1,
     "_nested" : {
       "field" : "nested_child_field",
       "offset" : 1,
       "_nested" : {
         "field" : "nested_grand_child_field",
         "offset" : 0
       }
     }
     "_source": ...
   },
   ...
 ]
}
...

在管道聚合中的使用编辑

top_hits 可用于管道聚合中，这些聚合每个桶使用一个值，例如应用每个桶过滤的 bucket_selector，类似于在 SQL 中使用 HAVING 子句。这需要将 size 设置为 1，并为要传递给包装聚合器的值指定正确的路径。后者可以是 _source、_sort 或 _score 值。例如

POST /sales/_search?size=0
{
  "aggs": {
    "top_tags": {
      "terms": {
        "field": "type",
        "size": 3
      },
      "aggs": {
        "top_sales_hits": {
          "top_hits": {
            "sort": [
              {
                "date": {
                  "order": "desc"
                }
              }
            ],
            "_source": {
              "includes": [ "date", "price" ]
            },
            "size": 1
          }
        },
        "having.top_salary": {
          "bucket_selector": {
            "buckets_path": {
              "tp": "top_sales_hits[_source.price]"
            },
            "script": "params.tp < 180"
          }
        }
      }
    }
  }
}

bucket_path 使用 top_hits 名称 top_sales_hits 和提供聚合值的字段的关键字，即上面示例中的 _source 字段 price。其他选项包括 top_sales_hits[_sort]，用于过滤上面的排序值 date，以及 top_sales_hits[_score]，用于过滤热门命中的分数。

« T 检验聚合 热门指标聚合 »