› › ›

使用查询规则进行搜索

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

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

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

当查询规则根据其定义的条件匹配规则元数据时，查询规则操作将应用于底层的 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"
          }
        ]
      }
    }
  ]
}

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" ]
    }
  }
}

此规则查询将与定义的查询规则集中的 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"
                  }
                }
              }
            }
          ]
        }
      }
    }
  }
}

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

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