New

The executive guide to generative AI

Read more
About usPartnersSupport|Login
« 嵌套查询 Has parent 查询 »
Elastic 文档 ›Elasticsearch 指南 [8.17] ›查询 DSL ›连接查询

Has child 查询

编辑

Has child 查询

编辑

返回其连接的子文档与提供的查询匹配的父文档。您可以使用join字段映射在同一索引中的文档之间创建父子关系。

由于它执行连接操作，因此与其他查询相比，has_child 查询速度较慢。当指向唯一父文档的匹配子文档数量增加时，其性能会下降。搜索中的每个 has_child 查询都会显著增加查询时间。

如果您关心查询性能，请不要使用此查询。如果您需要使用 has_child 查询，请尽可能少地使用它。

示例请求

编辑

索引设置

编辑

要使用 has_child 查询，您的索引必须包含 join 字段映射。例如

resp = client.indices.create(
    index="my-index-000001",
    mappings={
        "properties": {
            "my-join-field": {
                "type": "join",
                "relations": {
                    "parent": "child"
                }
            }
        }
    },
)
print(resp)
response = client.indices.create(
  index: 'my-index-000001',
  body: {
    mappings: {
      properties: {
        "my-join-field": {
          type: 'join',
          relations: {
            parent: 'child'
          }
        }
      }
    }
  }
)
puts response
const response = await client.indices.create({
  index: "my-index-000001",
  mappings: {
    properties: {
      "my-join-field": {
        type: "join",
        relations: {
          parent: "child",
        },
      },
    },
  },
});
console.log(response);
PUT /my-index-000001
{
  "mappings": {
    "properties": {
      "my-join-field": {
        "type": "join",
        "relations": {
          "parent": "child"
        }
      }
    }
  }
}
Copy as curlTry in Elastic 

示例查询

编辑
resp = client.search(
    query={
        "has_child": {
            "type": "child",
            "query": {
                "match_all": {}
            },
            "max_children": 10,
            "min_children": 2,
            "score_mode": "min"
        }
    },
)
print(resp)
const response = await client.search({
  query: {
    has_child: {
      type: "child",
      query: {
        match_all: {},
      },
      max_children: 10,
      min_children: 2,
      score_mode: "min",
    },
  },
});
console.log(response);
GET /_search
{
  "query": {
    "has_child": {
      "type": "child",
      "query": {
        "match_all": {}
      },
      "max_children": 10,
      "min_children": 2,
      "score_mode": "min"
    }
  }
}
Copy as curlTry in Elastic 

has_child 的顶层参数

编辑
type
（必需，字符串）为join字段映射的子关系名称。
query
（必需，查询对象）您希望在 type 字段的子文档上运行的查询。如果子文档与搜索匹配，则查询将返回父文档。
ignore_unmapped

（可选，布尔值）指示是否忽略未映射的 type，并且不返回任何文档，而不是返回错误。默认为 false。

如果 false，则如果 type 未映射，Elasticsearch 将返回错误。

您可以使用此参数查询可能不包含 type 的多个索引。

max_children
（可选，整数）返回的父文档允许匹配 query 的子文档的最大数量。如果父文档超出此限制，则会将其从搜索结果中排除。
min_children
（可选，整数）匹配返回的父文档的查询所需的匹配 query 的子文档的最小数量。如果父文档不满足此限制，则会将其从搜索结果中排除。
score_mode

（可选，字符串）指示匹配的子文档的分数如何影响根父文档的相关性分数。有效值为

none（默认）
不使用匹配子文档的相关性分数。查询为父文档分配 0 的分数。
avg
使用所有匹配的子文档的平均相关性分数。
max
使用所有匹配的子文档的最高相关性分数。
min
使用所有匹配的子文档的最低相关性分数。
sum
将所有匹配的子文档的相关性分数加在一起。

备注

编辑

排序

编辑

您不能使用标准的排序选项对 has_child 查询的结果进行排序。

如果您需要按子文档中的字段对返回的文档进行排序，请使用 function_score 查询，并按 _score 排序。例如，以下查询按其子文档的 click_count 字段对返回的文档进行排序。

resp = client.search(
    query={
        "has_child": {
            "type": "child",
            "query": {
                "function_score": {
                    "script_score": {
                        "script": "_score * doc['click_count'].value"
                    }
                }
            },
            "score_mode": "max"
        }
    },
)
print(resp)
const response = await client.search({
  query: {
    has_child: {
      type: "child",
      query: {
        function_score: {
          script_score: {
            script: "_score * doc['click_count'].value",
          },
        },
      },
      score_mode: "max",
    },
  },
});
console.log(response);
GET /_search
{
  "query": {
    "has_child": {
      "type": "child",
      "query": {
        "function_score": {
          "script_score": {
            "script": "_score * doc['click_count'].value"
          }
        }
      },
      "score_mode": "max"
    }
  }
}
Copy as curlTry in Elastic 
« 嵌套查询 Has parent 查询 »

On this page

Was this helpful?
Feedback