« 全文查询 匹配查询 »
Elastic 文档 ›Elasticsearch 指南 [8.14] ›查询 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。

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

intervals 的顶层参数编辑

<field>

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

此参数的值是一个规则对象，用于根据匹配项、顺序和距离匹配文档。

有效的规则包括

match 规则参数编辑

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

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

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

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

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

prefix 规则参数编辑

prefix 规则匹配以指定字符集开头的术语。此前缀最多可以扩展以匹配 128 个术语。如果前缀匹配超过 128 个术语，Elasticsearch 会返回错误。您可以在字段映射中使用 index-prefixes 选项来避免此限制。

prefix
(必需，字符串) 您希望在顶层 <field> 中找到的术语的开头字符。
analyzer
(可选，字符串) 用于规范化 prefix 的 分析器。默认为顶层 <field> 的分析器。
use_field

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

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

wildcard 规则参数编辑

wildcard 规则使用通配符模式匹配术语。此模式最多可以扩展以匹配 128 个术语。如果模式匹配超过 128 个术语，Elasticsearch 会返回错误。

pattern

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

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

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

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

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

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

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

fuzzy 规则参数编辑

fuzzy 规则匹配与提供的术语相似的术语，在由 模糊度 定义的编辑距离内。如果模糊扩展匹配超过 128 个术语，Elasticsearch 会返回错误。

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

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

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

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

response = client.search(
  body: {
    query: {
      intervals: {
        my_text: {
          match: {
            query: 'hot porridge',
            max_gaps: 10,
            filter: {
              not_containing: {
                match: {
                  query: 'salty'
                }
              }
            }
          }
        }
      }
    }
  }
)
puts response
POST _search
{
  "query": {
    "intervals" : {
      "my_text" : {
        "match" : {
          "query" : "hot porridge",
          "max_gaps" : 10,
          "filter" : {
            "not_containing" : {
              "match" : {
                "query" : "salty"
              }
            }
          }
        }
      }
    }
  }
}

脚本过滤器编辑

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

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
POST _search
{
  "query": {
    "intervals" : {
      "my_text" : {
        "match" : {
          "query" : "hot porridge",
          "filter" : {
            "script" : {
              "source" : "interval.start > 10 && interval.end < 20 && interval.gaps == 0"
            }
          }
        }
      }
    }
  }
}

最小化编辑

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

response = client.search(
  body: {
    query: {
      intervals: {
        my_text: {
          match: {
            query: 'salty',
            filter: {
              contained_by: {
                match: {
                  query: 'hot porridge'
                }
              }
            }
          }
        }
      }
    }
  }
)
puts response
POST _search
{
  "query": {
    "intervals" : {
      "my_text" : {
        "match" : {
          "query" : "salty",
          "filter" : {
            "contained_by" : {
              "match" : {
                "query" : "hot porridge"
              }
            }
          }
        }
      }
    }
  }
}

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

另一个需要注意的限制是 any_of 规则包含重叠的子规则的情况。特别是，如果其中一个规则是另一个规则的严格前缀，则较长的规则永远不会匹配，这在与 max_gaps 结合使用时会导致意外情况。考虑以下查询，搜索紧随其后的 the big 或 big bad，紧随其后的 wolf

response = client.search(
  body: {
    query: {
      intervals: {
        my_text: {
          all_of: {
            intervals: [
              {
                match: {
                  query: 'the'
                }
              },
              {
                any_of: {
                  intervals: [
                    {
                      match: {
                        query: 'big'
                      }
                    },
                    {
                      match: {
                        query: 'big bad'
                      }
                    }
                  ]
                }
              },
              {
                match: {
                  query: 'wolf'
                }
              }
            ],
            max_gaps: 0,
            ordered: true
          }
        }
      }
    }
  }
)
puts response
POST _search
{
  "query": {
    "intervals" : {
      "my_text" : {
        "all_of" : {
          "intervals" : [
            { "match" : { "query" : "the" } },
            { "any_of" : {
                "intervals" : [
                    { "match" : { "query" : "big" } },
                    { "match" : { "query" : "big bad" } }
                ] } },
            { "match" : { "query" : "wolf" } }
          ],
          "max_gaps" : 0,
          "ordered" : true
        }
      }
    }
  }
}

与直觉相反，此查询不匹配文档 the big bad wolf，因为中间的 any_of 规则只为 big 生成间隔 - big bad 的间隔比 big 的间隔更长，而起始位置相同，因此被最小化。在这些情况下，最好重写查询，以便所有选项都在顶层显式列出

response = client.search(
  body: {
    query: {
      intervals: {
        my_text: {
          any_of: {
            intervals: [
              {
                match: {
                  query: 'the big bad wolf',
                  ordered: true,
                  max_gaps: 0
                }
              },
              {
                match: {
                  query: 'the big wolf',
                  ordered: true,
                  max_gaps: 0
                }
              }
            ]
          }
        }
      }
    }
  }
)
puts response
POST _search
{
  "query": {
    "intervals" : {
      "my_text" : {
        "any_of" : {
          "intervals" : [
            { "match" : {
                "query" : "the big bad wolf",
                "ordered" : true,
                "max_gaps" : 0 } },
            { "match" : {
                "query" : "the big wolf",
                "ordered" : true,
                "max_gaps" : 0 } }
           ]
        }
      }
    }
  }
}
« 全文查询 匹配查询 »