New

The executive guide to generative AI

Read more
About usPartnersSupport|Login
« 搜索分片路由 搜索模板 »
Elastic 文档 ›Elasticsearch 指南 [8.17] ›搜索您的数据 ›搜索 API

使用查询规则进行搜索

编辑

使用查询规则进行搜索

编辑

查询规则 允许自定义与指定条件元数据匹配的查询的搜索结果。这允许对结果进行更多控制，例如确保将与定义的条件匹配的提升文档返回到结果列表的顶部。元数据在查询规则中定义，并与查询条件进行匹配。查询规则使用元数据来匹配查询。元数据作为搜索请求的一部分以对象的形式提供，可以是任何有助于区分查询的内容，例如：

  • 用户输入的查询字符串
  • 关于用户的个性化元数据（例如，国家、语言等）
  • 特定主题
  • 引荐站点
  • 等等。

查询规则定义一个元数据键，该键将用于将 规则检索器 中提供的元数据与规则中指定的条件进行匹配。

当查询规则根据其定义的条件匹配规则元数据时，查询规则操作将应用于底层的 organic 查询。

例如，可以定义一个查询规则，以匹配用户输入的查询字符串 pugs 和国家 us，如果规则查询满足这两个条件，则推广可收养的收容所犬只。

规则使用 查询规则 API 进行定义，并使用 规则检索器 或 规则查询 进行搜索。

规则定义

编辑

在定义规则时，请考虑以下事项

规则类型

编辑

我们要应用的规则类型。我们支持以下规则类型

  • pinned 会将查询重写为 固定查询，将与查询规则匹配的指定结果固定在返回结果集的顶部。
  • exclude 会将指定的结果从返回的结果集中排除。

规则条件

编辑

此规则将匹配的条件。条件定义为 type、metadata 和 values。允许的条件类型有

类型 匹配要求

exact

规则元数据与指定的值完全匹配。

fuzzy

规则元数据在允许的 莱文斯坦编辑距离 内与指定的值匹配。

prefix

规则元数据以指定的值开头。

suffix

规则元数据以指定的值结尾。

contains

规则元数据包含指定的值。

lt

规则元数据小于指定的值。

lte

规则元数据小于或等于指定的值。

gt

规则元数据大于指定的值。

gte

规则元数据大于或等于指定的值。

always

始终匹配所有规则查询。

规则操作

编辑

当规则与查询匹配时要执行的操作

  • ids 将选择指定的 _ids。
  • docs 将选择指定索引中的指定文档。

在单个索引上搜索时使用 ids，在多个索引上搜索时使用 docs。ids 和 docs 不能在同一查询中组合使用。

添加查询规则

编辑

您可以使用 创建或更新查询规则集 调用来添加查询规则。这将添加一个规则集，其中包含一个或多个查询规则，这些规则将应用于与其指定条件匹配的查询。

以下命令将创建一个名为 my-ruleset 的查询规则集，其中包含两个查询规则

  • 第一个规则将生成一个 固定查询，当 query_string 元数据值与 puggles 或 pugs 进行模糊匹配 *并且* 用户的地理位置在美国时，将 _ids id1 和 id2 固定。
  • 第二个规则将生成一个查询，当 query_string 元数据值包含 beagles 时，具体地将 _id id3 从 my-index-000001 索引中排除，并将 id4 从 my-index-000002 索引中排除。
resp = client.query_rules.put_ruleset(
    ruleset_id="my-ruleset",
    rules=[
        {
            "rule_id": "rule1",
            "type": "pinned",
            "criteria": [
                {
                    "type": "fuzzy",
                    "metadata": "query_string",
                    "values": [
                        "puggles",
                        "pugs"
                    ]
                },
                {
                    "type": "exact",
                    "metadata": "user_country",
                    "values": [
                        "us"
                    ]
                }
            ],
            "actions": {
                "ids": [
                    "id1",
                    "id2"
                ]
            }
        },
        {
            "rule_id": "rule2",
            "type": "exclude",
            "criteria": [
                {
                    "type": "contains",
                    "metadata": "query_string",
                    "values": [
                        "beagles"
                    ]
                }
            ],
            "actions": {
                "docs": [
                    {
                        "_index": "my-index-000001",
                        "_id": "id3"
                    },
                    {
                        "_index": "my-index-000002",
                        "_id": "id4"
                    }
                ]
            }
        }
    ],
)
print(resp)
const response = await client.transport.request({
  method: "PUT",
  path: "/_query_rules/my-ruleset",
  body: {
    rules: [
      {
        rule_id: "rule1",
        type: "pinned",
        criteria: [
          {
            type: "fuzzy",
            metadata: "query_string",
            values: ["puggles", "pugs"],
          },
          {
            type: "exact",
            metadata: "user_country",
            values: ["us"],
          },
        ],
        actions: {
          ids: ["id1", "id2"],
        },
      },
      {
        rule_id: "rule2",
        type: "exclude",
        criteria: [
          {
            type: "contains",
            metadata: "query_string",
            values: ["beagles"],
          },
        ],
        actions: {
          docs: [
            {
              _index: "my-index-000001",
              _id: "id3",
            },
            {
              _index: "my-index-000002",
              _id: "id4",
            },
          ],
        },
      },
    ],
  },
});
console.log(response);
PUT /_query_rules/my-ruleset
{
  "rules": [
    {
      "rule_id": "rule1",
      "type": "pinned",
      "criteria": [
        {
          "type": "fuzzy",
          "metadata": "query_string",
          "values": [ "puggles", "pugs" ]
        },
        {
          "type": "exact",
          "metadata": "user_country",
          "values": [ "us" ]
        }
      ],
      "actions": {
        "ids": [
          "id1",
          "id2"
        ]
      }
    },
    {
      "rule_id": "rule2",
      "type": "exclude",
      "criteria": [
        {
          "type": "contains",
          "metadata": "query_string",
          "values": [ "beagles" ]
        }
      ],
      "actions": {
        "docs": [
          {
            "_index": "my-index-000001",
            "_id": "id3"
          },
          {
            "_index": "my-index-000002",
            "_id": "id4"
          }
        ]
      }
    }
  ]
}
Copy as curlTry in Elastic 

API 响应根据这是新的还是编辑的规则集返回 created 或 updated 的结果。

每个规则集最多可以包含 100 个规则。可以使用 xpack.applications.rules.max_rules_per_ruleset 集群设置将其增加到 1000 个。

{
  "result": "created"
}

您可以使用 获取查询规则集 调用来检索您刚刚创建的规则集，使用 列出查询规则集 调用来检索所有查询规则集的摘要，以及使用 删除查询规则集 调用来删除查询规则集。

使用查询规则进行搜索

编辑

定义一个或多个查询规则集后，您可以使用 规则检索器 或 规则查询 来搜索这些规则集。检索器是使用规则查询的推荐方法，因为它们可以开箱即用地与其他重新排序检索器（如 倒数排名融合）一起使用。

规则集按顺序进行评估，因此您指定的第一个规则集中的规则将在任何后续规则集之前应用。

上面定义的 my-ruleset 的示例查询是

resp = client.search(
    index="my-index-000001",
    retriever={
        "rule": {
            "retriever": {
                "standard": {
                    "query": {
                        "query_string": {
                            "query": "puggles"
                        }
                    }
                }
            },
            "match_criteria": {
                "query_string": "puggles",
                "user_country": "us"
            },
            "ruleset_ids": [
                "my-ruleset"
            ]
        }
    },
)
print(resp)
const response = await client.search({
  index: "my-index-000001",
  retriever: {
    rule: {
      retriever: {
        standard: {
          query: {
            query_string: {
              query: "puggles",
            },
          },
        },
      },
      match_criteria: {
        query_string: "puggles",
        user_country: "us",
      },
      ruleset_ids: ["my-ruleset"],
    },
  },
});
console.log(response);
GET /my-index-000001/_search
{
  "retriever": {
    "rule": {
      "retriever": {
        "standard": {
          "query": {
            "query_string": {
              "query": "puggles"
            }
          }
        }
      },
      "match_criteria": {
        "query_string": "puggles",
        "user_country": "us"
      },
      "ruleset_ids": [ "my-ruleset" ]
    }
  }
}
Copy as curlTry in Elastic 

此规则查询将与定义的查询规则集中的 rule1 匹配，并将有机查询转换为固定查询，其中 id1 和 id2 固定为最高匹配项。来自有机查询的任何其他匹配项都将返回在固定结果下方。

一个规则集中可能有多个规则与单个 规则查询 匹配。在这种情况下，规则按以下顺序应用

  • 匹配的规则在规则集中的出现位置
  • 如果在单个规则中指定了多个文档，则按它们指定的顺序
  • 如果一个文档同时被 pinned 规则和 exclude 规则匹配，则 exclude 规则优先

您可以在规则查询中指定重新排序检索器，如 rrf 或 text_similarity_reranker，以在已重新排序的结果上应用查询规则。以下是一个示例

resp = client.search(
    index="my-index-000001",
    retriever={
        "rule": {
            "match_criteria": {
                "query_string": "puggles",
                "user_country": "us"
            },
            "ruleset_ids": [
                "my-ruleset"
            ],
            "retriever": {
                "rrf": {
                    "retrievers": [
                        {
                            "standard": {
                                "query": {
                                    "query_string": {
                                        "query": "pugs"
                                    }
                                }
                            }
                        },
                        {
                            "standard": {
                                "query": {
                                    "query_string": {
                                        "query": "puggles"
                                    }
                                }
                            }
                        }
                    ]
                }
            }
        }
    },
)
print(resp)
const response = await client.search({
  index: "my-index-000001",
  retriever: {
    rule: {
      match_criteria: {
        query_string: "puggles",
        user_country: "us",
      },
      ruleset_ids: ["my-ruleset"],
      retriever: {
        rrf: {
          retrievers: [
            {
              standard: {
                query: {
                  query_string: {
                    query: "pugs",
                  },
                },
              },
            },
            {
              standard: {
                query: {
                  query_string: {
                    query: "puggles",
                  },
                },
              },
            },
          ],
        },
      },
    },
  },
});
console.log(response);
GET my-index-000001/_search
{
  "retriever": {
    "rule": {
      "match_criteria": {
        "query_string": "puggles",
        "user_country": "us"
      },
      "ruleset_ids": [
        "my-ruleset"
      ],
      "retriever": {
        "rrf": {
          "retrievers": [
            {
              "standard": {
                "query": {
                  "query_string": {
                    "query": "pugs"
                  }
                }
              }
            },
            {
              "standard": {
                "query": {
                  "query_string": {
                    "query": "puggles"
                  }
                }
              }
            }
          ]
        }
      }
    }
  }
}
Copy as curlTry in Elastic 

这将在由 RRF 重新排序的内容之上应用固定和排除查询规则。

« 搜索分片路由 搜索模板 »

On this page

Was this helpful?
Feedback