New

The executive guide to generative AI

Read more
About usPartnersSupport|Login
« 全文查询 Match 查询 »
Elastic 文档 ›Elasticsearch 指南 [8.17] ›查询 DSL ›全文查询

间隔查询

编辑

间隔查询

编辑

根据匹配项的顺序和邻近度返回文档。

intervals 查询使用匹配规则，这些规则由一小组定义构成。然后，将这些规则应用于指定的 field 中的词项。

这些定义产生跨越文本主体中词项的最小间隔序列。这些间隔可以通过父源进一步组合和过滤。

示例请求

编辑

以下 intervals 搜索返回包含 my favorite food 且没有任何间隔的文档，后跟 hot water 或 cold porridge，这些词项位于 my_text 字段中。

此搜索将匹配 my_text 值为 my favorite food is cold porridge 的文档，但不匹配 when it's cold my favorite food is porridge 的文档。

resp = client.search(
    query={
        "intervals": {
            "my_text": {
                "all_of": {
                    "ordered": True,
                    "intervals": [
                        {
                            "match": {
                                "query": "my favorite food",
                                "max_gaps": 0,
                                "ordered": True
                            }
                        },
                        {
                            "any_of": {
                                "intervals": [
                                    {
                                        "match": {
                                            "query": "hot water"
                                        }
                                    },
                                    {
                                        "match": {
                                            "query": "cold porridge"
                                        }
                                    }
                                ]
                            }
                        }
                    ]
                }
            }
        }
    },
)
print(resp)
response = client.search(
  body: {
    query: {
      intervals: {
        my_text: {
          all_of: {
            ordered: true,
            intervals: [
              {
                match: {
                  query: 'my favorite food',
                  max_gaps: 0,
                  ordered: true
                }
              },
              {
                any_of: {
                  intervals: [
                    {
                      match: {
                        query: 'hot water'
                      }
                    },
                    {
                      match: {
                        query: 'cold porridge'
                      }
                    }
                  ]
                }
              }
            ]
          }
        }
      }
    }
  }
)
puts response
const response = await client.search({
  query: {
    intervals: {
      my_text: {
        all_of: {
          ordered: true,
          intervals: [
            {
              match: {
                query: "my favorite food",
                max_gaps: 0,
                ordered: true,
              },
            },
            {
              any_of: {
                intervals: [
                  {
                    match: {
                      query: "hot water",
                    },
                  },
                  {
                    match: {
                      query: "cold porridge",
                    },
                  },
                ],
              },
            },
          ],
        },
      },
    },
  },
});
console.log(response);
POST _search
{
  "query": {
    "intervals" : {
      "my_text" : {
        "all_of" : {
          "ordered" : true,
          "intervals" : [
            {
              "match" : {
                "query" : "my favorite food",
                "max_gaps" : 0,
                "ordered" : true
              }
            },
            {
              "any_of" : {
                "intervals" : [
                  { "match" : { "query" : "hot water" } },
                  { "match" : { "query" : "cold porridge" } }
                ]
              }
            }
          ]
        }
      }
    }
  }
}
Copy as curlTry in Elastic 

intervals 的顶层参数

编辑
<field>

(必需，规则对象) 您要搜索的字段。

此参数的值是一个规则对象，用于根据匹配的词项、顺序和邻近度来匹配文档。

有效的规则包括

match 规则参数

编辑

match 规则匹配已分析的文本。

query
(必需，字符串) 您希望在提供的 <field> 中查找的文本。
max_gaps

(可选，整数) 匹配项之间最大位置数。距离大于此值的词项不被视为匹配项。默认为 -1。

如果未指定或设置为 -1，则匹配没有宽度限制。如果设置为 0，则词项必须彼此相邻。

ordered
(可选，布尔值) 如果为 true，则匹配项必须按其指定的顺序出现。默认为 false。
analyzer
(可选，字符串) 用于分析 query 中词项的分析器。默认为顶层 <field> 的分析器。
filter
(可选，间隔过滤器规则对象) 一个可选的间隔过滤器。
use_field
(可选，字符串) 如果指定，则从此字段匹配间隔，而不是从顶层 <field> 匹配间隔。词项使用此字段的搜索分析器进行分析。这允许您像搜索同一字段一样跨多个字段进行搜索；例如，您可以将相同的文本索引到词干字段和非词干字段中，并搜索词干标记附近的非词干标记。

prefix 规则参数

编辑

prefix 规则匹配以指定字符集开头的词项。此前缀可以扩展为最多匹配 indices.query.bool.max_clause_count 搜索设置个词项。如果前缀匹配的词项过多，Elasticsearch 将返回错误。您可以使用字段映射中的 index-prefixes 选项来避免此限制。

prefix
(必需，字符串) 您希望在顶层 <field> 中查找的词项的起始字符。
analyzer
(可选，字符串) 用于规范化 prefix 的分析器。默认为顶层 <field> 的分析器。
use_field

(可选，字符串) 如果指定，则从此字段匹配间隔，而不是从顶层 <field> 匹配间隔。

prefix 使用此字段的搜索分析器进行规范化，除非单独指定了 analyzer。

wildcard 规则参数

编辑

wildcard 规则使用通配符模式匹配词项。此模式可以扩展为最多匹配 indices.query.bool.max_clause_count 搜索设置个词项。如果模式匹配的词项过多，Elasticsearch 将返回错误。

pattern

(必需，字符串) 用于查找匹配词项的通配符模式。

此参数支持两个通配符运算符

  • ?，它匹配任何单个字符
  • *，它可以匹配零个或多个字符，包括空字符

避免以 * 或 ? 开头的模式。这会增加查找匹配项所需的迭代次数，并降低搜索性能。

analyzer
(可选，字符串) 用于规范化 pattern 的分析器。默认为顶层 <field> 的分析器。
use_field

(可选，字符串) 如果指定，则从此字段匹配间隔，而不是从顶层 <field> 匹配间隔。

pattern 使用此字段的搜索分析器进行规范化，除非单独指定了 analyzer。

regexp 规则参数

编辑

regexp 规则使用正则表达式模式匹配词项。此模式可以扩展为最多匹配 indices.query.bool.max_clause_count 搜索设置个词项。如果模式匹配的词项过多，Elasticsearch 将返回错误。

pattern
(必需，字符串) 用于查找匹配词项的正则表达式模式。有关 regexp 模式支持的运算符列表，请参阅正则表达式语法。

避免使用通配符模式，例如 .* 或 .*?+`。这会增加查找匹配项所需的迭代次数，并降低搜索性能。

analyzer
(可选，字符串) 用于规范化 pattern 的分析器。默认为顶层 <field> 的分析器。
use_field

(可选，字符串) 如果指定，则从此字段匹配间隔，而不是从顶层 <field> 匹配间隔。

pattern 使用此字段的搜索分析器进行规范化，除非单独指定了 analyzer。

fuzzy 规则参数

编辑

fuzzy 规则匹配与提供的词项相似的词项，其编辑距离由模糊性定义。如果模糊扩展匹配的词项多于 indices.query.bool.max_clause_count 搜索设置个词项，Elasticsearch 将返回错误。

term
(必需，字符串) 要匹配的词项
prefix_length
(可选，整数) 创建扩展时保持不变的起始字符数。默认为 0。
transpositions
(可选，布尔值) 指示编辑是否包括两个相邻字符的换位 (ab → ba)。默认为 true。
fuzziness
(可选，字符串) 允许匹配的最大编辑距离。有关有效值和更多信息，请参阅模糊性。默认为 auto。
analyzer
(可选，字符串) 用于规范化 term 的分析器。默认为顶层 <field> 的分析器。
use_field

(可选，字符串) 如果指定，则从此字段匹配间隔，而不是从顶层 <field> 匹配间隔。

term 使用此字段的搜索分析器进行规范化，除非单独指定了 analyzer。

range 规则参数

编辑

range 规则匹配包含在提供的范围内的词项。此范围可以扩展为最多匹配 indices.query.bool.max_clause_count 搜索设置个词项。如果范围匹配的词项过多，Elasticsearch 将返回错误。

gt
(可选，字符串) 大于：匹配大于提供的词项的词项。
gte
(可选，字符串) 大于或等于：匹配大于或等于提供的词项的词项。
lt
(可选，字符串) 小于：匹配小于提供的词项的词项。
lte
(可选，字符串) 小于或等于：匹配小于或等于提供的词项的词项。

必须提供 gt 或 gte 参数之一。必须提供 lt 或 lte 参数之一。

analyzer
(可选，字符串) 用于规范化 pattern 的分析器。默认为顶层 <field> 的分析器。
use_field
(可选，字符串) 如果指定，则从此字段匹配间隔，而不是从顶层 <field> 匹配间隔。

all_of 规则参数

编辑

all_of 规则返回跨越其他规则组合的匹配项。

intervals
(必需，规则对象数组) 要组合的规则数组。所有规则都必须在文档中产生匹配项，才能使整个源匹配。
max_gaps

(可选，整数) 匹配项之间最大位置数。由规则产生的间隔距离大于此值的不被视为匹配项。默认为 -1。

如果未指定或设置为 -1，则匹配没有宽度限制。如果设置为 0，则词项必须彼此相邻。

ordered
(可选，布尔值) 如果为 true，则规则产生的间隔应按其指定的顺序出现。默认为 false。
filter
(可选，间隔过滤器规则对象) 用于过滤返回的间隔的规则。

any_of 规则参数

编辑

any_of 规则返回其任何子规则产生的间隔。

intervals
(必需，规则对象数组) 要匹配的规则数组。
filter
(可选，间隔过滤器规则对象) 用于过滤返回的间隔的规则。

filter 规则参数

编辑

filter 规则根据查询返回间隔。有关示例，请参阅过滤器示例。

after
(可选，查询对象) 用于返回来自 filter 规则的间隔之后的间隔的查询。
before
(可选，查询对象) 用于返回来自 filter 规则的间隔之前的间隔的查询。
contained_by
(可选，查询对象) 用于返回包含在来自 filter 规则的间隔内的间隔的查询。
containing
(可选，查询对象) 用于返回包含来自 filter 规则的间隔的间隔的查询。
not_contained_by
(可选，查询对象) 用于返回 不 包含在来自 filter 规则的间隔内的间隔的查询。
not_containing
(可选，查询对象) 用于返回 不 包含来自 filter 规则的间隔的间隔的查询。
not_overlapping
(可选，查询对象) 用于返回与来自 filter 规则的间隔 不 重叠的间隔的查询。
overlapping
(可选，查询对象) 用于返回与来自 filter 规则的间隔重叠的间隔的查询。
script
(可选，脚本对象) 用于返回匹配文档的脚本。此脚本必须返回布尔值，true 或 false。有关示例，请参阅脚本过滤器。

说明

编辑

过滤器示例

编辑

以下搜索包含一个 filter 规则。它返回的文档中，单词 hot 和 porridge 彼此之间相距不超过 10 个位置，并且之间没有单词 salty

resp = client.search(
    query={
        "intervals": {
            "my_text": {
                "match": {
                    "query": "hot porridge",
                    "max_gaps": 10,
                    "filter": {
                        "not_containing": {
                            "match": {
                                "query": "salty"
                            }
                        }
                    }
                }
            }
        }
    },
)
print(resp)
response = client.search(
  body: {
    query: {
      intervals: {
        my_text: {
          match: {
            query: 'hot porridge',
            max_gaps: 10,
            filter: {
              not_containing: {
                match: {
                  query: 'salty'
                }
              }
            }
          }
        }
      }
    }
  }
)
puts response
const response = await client.search({
  query: {
    intervals: {
      my_text: {
        match: {
          query: "hot porridge",
          max_gaps: 10,
          filter: {
            not_containing: {
              match: {
                query: "salty",
              },
            },
          },
        },
      },
    },
  },
});
console.log(response);
POST _search
{
  "query": {
    "intervals" : {
      "my_text" : {
        "match" : {
          "query" : "hot porridge",
          "max_gaps" : 10,
          "filter" : {
            "not_containing" : {
              "match" : {
                "query" : "salty"
              }
            }
          }
        }
      }
    }
  }
}
Copy as curlTry in Elastic 

脚本过滤器

编辑

您可以使用脚本根据间隔的起始位置、结束位置和内部间隙计数来过滤间隔。以下 filter 脚本使用 interval 变量以及 start、end 和 gaps 方法

resp = client.search(
    query={
        "intervals": {
            "my_text": {
                "match": {
                    "query": "hot porridge",
                    "filter": {
                        "script": {
                            "source": "interval.start > 10 && interval.end < 20 && interval.gaps == 0"
                        }
                    }
                }
            }
        }
    },
)
print(resp)
response = client.search(
  body: {
    query: {
      intervals: {
        my_text: {
          match: {
            query: 'hot porridge',
            filter: {
              script: {
                source: 'interval.start > 10 && interval.end < 20 && interval.gaps == 0'
              }
            }
          }
        }
      }
    }
  }
)
puts response
const response = await client.search({
  query: {
    intervals: {
      my_text: {
        match: {
          query: "hot porridge",
          filter: {
            script: {
              source:
                "interval.start > 10 && interval.end < 20 && interval.gaps == 0",
            },
          },
        },
      },
    },
  },
});
console.log(response);
POST _search
{
  "query": {
    "intervals" : {
      "my_text" : {
        "match" : {
          "query" : "hot porridge",
          "filter" : {
            "script" : {
              "source" : "interval.start > 10 && interval.end < 20 && interval.gaps == 0"
            }
          }
        }
      }
    }
  }
}
Copy as curlTry in Elastic 

最小化

编辑

间隔查询始终会最小化间隔，以确保查询可以在线性时间内运行。这有时可能会导致令人惊讶的结果，尤其是在使用 max_gaps 限制或过滤器时。例如，以下查询搜索短语 hot porridge 中包含的 salty

resp = client.search(
    query={
        "intervals": {
            "my_text": {
                "match": {
                    "query": "salty",
                    "filter": {
                        "contained_by": {
                            "match": {
                                "query": "hot porridge"
                            }
                        }
                    }
                }
            }
        }
    },
)
print(resp)
response = client.search(
  body: {
    query: {
      intervals: {
        my_text: {
          match: {
            query: 'salty',
            filter: {
              contained_by: {
                match: {
                  query: 'hot porridge'
                }
              }
            }
          }
        }
      }
    }
  }
)
puts response
const response = await client.search({
  query: {
    intervals: {
      my_text: {
        match: {
          query: "salty",
          filter: {
            contained_by: {
              match: {
                query: "hot porridge",
              },
            },
          },
        },
      },
    },
  },
});
console.log(response);
POST _search
{
  "query": {
    "intervals" : {
      "my_text" : {
        "match" : {
          "query" : "salty",
          "filter" : {
            "contained_by" : {
              "match" : {
                "query" : "hot porridge"
              }
            }
          }
        }
      }
    }
  }
}
Copy as curlTry in Elastic 

此查询 不 匹配包含短语 hot porridge is salty porridge 的文档，因为 hot porridge 的匹配查询返回的间隔仅覆盖此文档中的前两个术语，并且这些间隔与覆盖 salty 的间隔不重叠。

« 全文查询 Match 查询 »