有父查询

编辑

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

由于它执行连接,与其他查询相比,has_parent 查询速度较慢。随着匹配的父文档数量的增加,其性能会下降。搜索中的每个 has_parent 查询都会显着增加查询时间。

请求示例

编辑

索引设置

编辑

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

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

查询示例

编辑
resp = client.search(
    index="my-index-000001",
    query={
        "has_parent": {
            "parent_type": "parent",
            "query": {
                "term": {
                    "tag": {
                        "value": "Elasticsearch"
                    }
                }
            }
        }
    },
)
print(resp)
const response = await client.search({
  index: "my-index-000001",
  query: {
    has_parent: {
      parent_type: "parent",
      query: {
        term: {
          tag: {
            value: "Elasticsearch",
          },
        },
      },
    },
  },
});
console.log(response);
GET /my-index-000001/_search
{
  "query": {
    "has_parent": {
      "parent_type": "parent",
      "query": {
        "term": {
          "tag": {
            "value": "Elasticsearch"
          }
        }
      }
    }
  }
}

has_parent 的顶级参数

编辑
parent_type
(必需,字符串)为 join 字段映射的父关系名称。
query
(必需,查询对象)您希望在 parent_type 字段的父文档上运行的查询。如果父文档与搜索匹配,则查询返回其子文档。
score

(可选,布尔值)指示是否将匹配的父文档的相关性得分聚合到其子文档中。默认为 false

如果为 false,则 Elasticsearch 将忽略父文档的相关性得分。Elasticsearch 还会为每个子文档分配一个等于 queryboost 的相关性得分,默认为 1

如果为 true,则匹配的父文档的相关性得分将聚合到其子文档的相关性得分中。

ignore_unmapped

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

如果为 false,则如果 parent_type 未映射,Elasticsearch 将返回错误。

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

注释

编辑

排序

编辑

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

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

resp = client.search(
    query={
        "has_parent": {
            "parent_type": "parent",
            "score": True,
            "query": {
                "function_score": {
                    "script_score": {
                        "script": "_score * doc['view_count'].value"
                    }
                }
            }
        }
    },
)
print(resp)
const response = await client.search({
  query: {
    has_parent: {
      parent_type: "parent",
      score: true,
      query: {
        function_score: {
          script_score: {
            script: "_score * doc['view_count'].value",
          },
        },
      },
    },
  },
});
console.log(response);
GET /_search
{
  "query": {
    "has_parent": {
      "parent_type": "parent",
      "score": true,
      "query": {
        "function_score": {
          "script_score": {
            "script": "_score * doc['view_count'].value"
          }
        }
      }
    }
  }
}