Intervals 查询 #

间隔查询根据匹配词的邻近度和顺序来匹配文档。它将一组匹配规则应用于指定字段中的词。该查询生成跨越文本中词的最小间隔序列。你可以组合间隔并按父源进行过滤。

考虑一个包含以下文档的索引：

PUT testindex/_doc/1
{
  "title": "key-value pairs are efficiently stored in a hash table"
}

PUT /testindex/_doc/2
{
  "title": "store key-value pairs in a hash map"
}

例如，以下查询搜索包含短语 key-value pairs （词之间没有间隔）后跟 hash table 或 hash map 的文档：

GET /testindex/_search
{
  "query": {
    "intervals": {
      "title": {
        "all_of": {
          "ordered": true,
          "intervals": [
            {
              "match": {
                "query": "key-value pairs",
                "max_gaps": 0,
                "ordered": true
              }
            },
            {
              "any_of": {
                "intervals": [
                  {
                    "match": {
                      "query": "hash table"
                    }
                  },
                  {
                    "match": {
                      "query": "hash map"
                    }
                  }
                ]
              }
            }
          ]
        }
      }
    }
  }
}

该查询返回两个文档：

{
  "took": 1011,
  "timed_out": false,
  "_shards": {
    "total": 1,
    "successful": 1,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": {
      "value": 2,
      "relation": "eq"
    },
    "max_score": 0.25,
    "hits": [
      {
        "_index": "testindex",
        "_id": "2",
        "_score": 0.25,
        "_source": {
          "title": "store key-value pairs in a hash map"
        }
      },
      {
        "_index": "testindex",
        "_id": "1",
        "_score": 0.14285713,
        "_source": {
          "title": "key-value pairs are efficiently stored in a hash table"
        }
      }
    ]
  }
}

参数说明 #

该查询将字段名称（ <field> ）作为顶级参数接受：

GET _search
{
  "query": {
    "intervals": {
      "<field>": {
        ...
      }
    }
  }
}

<field> 接受以下规则对象，这些规则对象用于根据词项、顺序和邻近度来匹配文档。

match 规则 #

match 规则匹配分析后的文本。下表列出了 match 规则支持的所有参数。

prefix 规则 #

prefix 规则匹配以指定字符集（前缀）开头的词项。前缀可以扩展以匹配最多 128 个词项。如果前缀匹配的词项超过 128 个，则返回错误。下表列出了 prefix 规则支持的所有参数。

wildcard 规则 #

wildcard 规则使用通配符模式匹配词项。通配符模式最多可以扩展匹配 128 个词项。如果模式匹配的词项超过 128 个，将返回错误。下表列出了 wildcard 规则支持的所有参数。

指定以 * 或 ? 开头的模式可能会降低搜索性能，因为它增加了匹配词项所需的迭代次数。

fuzzy 规则 #

fuzzy 规则匹配与提供的词项在指定编辑距离内相似的词项。模糊模式最多可以扩展以匹配 128 个词项。如果模式匹配的词项超过 128 个，则会返回错误。下表列出了 fuzzy 规则支持的所有参数。

all_of 规则 #

all_of 规则使用合取（ AND ）组合多个规则。下表列出了 all_of 规则支持的所有参数。

any_of 规则 #

any_of 规则使用合取（ OR ）组合多个规则。下表列出了 any_of 规则支持的所有参数。

filter 规则 #

filter 规则用于限制结果。下表列出了 filter 规则支持的所有参数。

示例：过滤器 #

以下查询搜索包含 pairs 和 hash 的文档，这两个词彼此相距不超过五个位置，并且它们之间不包含 efficiently 这个词：

POST /testindex/_search
{
  "query": {
    "intervals" : {
      "title" : {
        "match" : {
          "query" : "pairs hash",
          "max_gaps" : 5,
          "filter" : {
            "not_containing" : {
              "match" : {
                "query" : "efficiently"
              }
            }
          }
        }
      }
    }
  }
}

返回内容中只包含文档 2：

{
  "took": 2,
  "timed_out": false,
  "_shards": {
    "total": 1,
    "successful": 1,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": {
      "value": 1,
      "relation": "eq"
    },
    "max_score": 0.25,
    "hits": [
      {
        "_index": "testindex",
        "_id": "2",
        "_score": 0.25,
        "_source": {
          "title": "store key-value pairs in a hash map"
        }
      }
    ]
  }
}

示例：脚本过滤器 #

或者，您可以使用以下变量编写自己的脚本过滤器，并将其与 intervals 查询一起使用：

• interval.start : 间隔开始的位置（词编号）。
• interval.end : 间隔结束的位置（词编号）。
• interval.gap : 两个词之间的词数。

例如，以下查询在指定间隔内搜索相邻的 map 和 hash 这两个词。词的编号从 0 开始，所以在文本 store key-value pairs in a hash map 中， store 位于位置 0， key 位于位置 1 ，以此类推。指定的间隔应从 a 之后开始，并在字符串末尾之前结束：

POST /testindex/_search
{
  "query": {
    "intervals" : {
      "title" : {
        "match" : {
          "query" : "map hash",
          "filter" : {
            "script" : {
              "source" : "interval.start > 5 && interval.end < 8 && interval.gaps == 0"
            }
          }
        }
      }
    }
  }
}

返回内容包含文档 2：

{
  "took": 1,
  "timed_out": false,
  "_shards": {
    "total": 1,
    "successful": 1,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": {
      "value": 1,
      "relation": "eq"
    },
    "max_score": 0.5,
    "hits": [
      {
        "_index": "testindex",
        "_id": "2",
        "_score": 0.5,
        "_source": {
          "title": "store key-value pairs in a hash map"
        }
      }
    ]
  }
}

间隔最小化 #

为确保查询在线性时间内运行， intervals 查询会最小化间隔。例如，考虑一个包含文本a b c d c的文档。您可以使用以下查询来搜索被 a 和 c 包含的 d ：

POST /testindex/_search
{
  "query": {
    "intervals" : {
      "my_text" : {
        "match" : {
          "query" : "d",
          "filter" : {
            "contained_by" : {
              "match" : {
                "query" : "a c"
              }
            }
          }
        }
      }
    }
  }
}

该查询没有返回结果，因为它匹配了前两个词 a c ，并且在这两个词之间没有找到 d 。