全文查询

以下搜索包含一个filter规则。它返回包含单词hot和porridge在彼此10个位置以内，且中间没有单词salty的文档：

POST _search
{
  "query": {
    "intervals" : {
      "my_text" : {
        "match" : {
          "query" : "hot porridge",
          "max_gaps" : 10,
          "filter" : {
            "not_containing" : {
              "match" : {
                "query" : "salty"
              }
            }
          }
        }
      }
    }
  }
}

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

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：

POST _search
{
  "query": {
    "intervals" : {
      "my_text" : {
        "match" : {
          "query" : "salty",
          "filter" : {
            "contained_by" : {
              "match" : {
                "query" : "hot porridge"
              }
            }
          }
        }
      }
    }
  }
}

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

您可以通过结合和query参数来简化匹配查询语法。例如：

GET /_search
{
  "query": {
    "match": {
      "message": "this is a test"
    }
  }
}

The match query 是类型为 boolean 的查询。这意味着提供的文本会被分析，分析过程会从提供的文本中构造一个布尔查询。operator 参数可以设置为 or 或 and 来控制布尔子句（默认为 or）。可以通过使用 minimum_should_match 参数来设置匹配的最少可选 should 子句数量。

这里是一个使用operator参数的示例：

GET /_search
{
  "query": {
    "match": {
      "message": {
        "query": "this is a test",
        "operator": "and"
      }
    }
  }
}

可以设置analyzer来控制哪个分析器将对文本执行分析过程。它默认为字段的显式映射定义，或者默认的搜索分析器。

可以将 lenient 参数设置为 true 以忽略由数据类型不匹配引起的异常，例如尝试使用文本查询字符串查询数值字段。默认为 false。

fuzziness 允许基于被查询字段类型的模糊匹配。 请参阅 Fuzziness 以了解允许的设置。

在这种情况下，可以设置 prefix_length 和 max_expansions 来控制模糊过程。如果设置了模糊选项，查询将使用 top_terms_blended_freqs_${max_expansions} 作为其 重写方法，fuzzy_rewrite 参数允许控制查询如何被重写。

模糊转置（ab → ba）默认情况下是允许的，但可以通过将fuzzy_transpositions设置为false来禁用。

GET /_search
{
  "query": {
    "match": {
      "message": {
        "query": "this is a testt",
        "fuzziness": "AUTO"
      }
    }
  }
}

如果使用的分析器移除了查询中的所有标记，例如 stop 过滤器所做的那样，默认行为是匹配不到任何文档。为了改变这一点，可以使用 zero_terms_query 选项，该选项接受 none（默认）和 all，后者对应于 match_all 查询。

GET /_search
{
  "query": {
    "match": {
      "message": {
        "query": "to be or not to be",
        "operator": "and",
        "zero_terms_query": "all"
      }
    }
  }
}

The match query supports multi-terms synonym expansion with the synonym_graph token filter. When this filter is used, the parser creates a phrase query for each multi-terms synonyms. 例如，以下同义词："ny, new york" 将产生：

(ny OR ("纽约"))

也可以使用连词来匹配多词同义词：

GET /_search
{
   "query": {
       "match" : {
           "message": {
               "query" : "ny city",
               "auto_generate_synonyms_phrase_query" : false
           }
       }
   }
}

上面的示例创建了一个布尔查询：

(ny OR (new AND york)) city

匹配包含术语 ny 或连接词 new AND york 的文档。 默认情况下，参数 auto_generate_synonyms_phrase_query 设置为 true。

虽然易于设置，但使用 match_phrase_prefix 查询进行搜索自动补全有时会产生令人困惑的结果。

例如，考虑查询字符串 quick brown f。这个查询通过将 quick 和 brown 创建为一个短语查询来工作（即术语 quick 必须存在并且必须紧随术语 brown）。然后它查看排序后的术语字典，找到以 f 开头的第一个50个术语，并将这些术语添加到短语查询中。

问题在于前50个词可能不包括词项fox，因此短语quick brown fox将不会被找到。这通常不是问题，因为用户将继续输入更多字母，直到他们要找的词出现。

为了获得更好的即搜即得解决方案，请参阅 completion suggester 和 search_as_you_type 字段类型。

The combined_fields query 提供了一种跨多个 text 字段进行匹配和评分的原则性方法。为了支持这一点，它要求所有字段使用相同的搜索 analyzer。

如果你想要一个处理不同类型字段（如关键词或数字）的单一查询，那么multi_match查询可能更适合。它支持文本和非文本字段，并接受不共享相同分析器的文本字段。

主要的 multi_match 模式 best_fields 和 most_fields 采用了一种以字段为中心的查询视图。相比之下，combined_fields 是基于词项的：operator 和 minimum_should_match 是按词项应用的，而不是按字段应用的。具体来说，一个查询像

GET /_search
{
  "query": {
    "combined_fields" : {
      "query":      "database systems",
      "fields":     [ "title", "abstract"],
      "operator":   "and"
    }
  }
}

执行如下：

+(combined("database", fields:["title" "abstract"]))
+(combined("systems", fields:["title", "abstract"]))

换句话说，每个术语必须至少出现在一个字段中，文档才能匹配。

The cross_fields multi_match mode also takes a term-centric approach and applies operator and minimum_should_match per-term. The main advantage of combined_fields over cross_fields is its robust and interpretable approach to scoring based on the BM25F algorithm.

The cross_field 类型只能在具有相同分析器的字段上以词为中心的模式工作。具有相同分析器的字段会像上面的例子一样分组在一起。如果有多个组，查询将使用任何组中的最佳分数。

例如，如果我们有一个first和last字段，它们使用相同的分析器，再加上一个first.edge和last.edge字段，它们都使用edge_ngram分析器，这个查询：

GET /_search
{
  "query": {
    "multi_match" : {
      "query":      "Jon",
      "type":       "cross_fields",
      "fields":     [
        "first", "first.edge",
        "last",  "last.edge"
      ]
    }
  }
}

将被执行为：

    blended("jon", fields: [first, last])
| (
    blended("j",   fields: [first.edge, last.edge])
    blended("jo",  fields: [first.edge, last.edge])
    blended("jon", fields: [first.edge, last.edge])
)

换句话说，first 和 last 将被分组在一起并作为一个单一字段处理，而 first.edge 和 last.edge 也将被分组在一起并作为一个单一字段处理。

拥有多个组是可以的，但当与operator或minimum_should_match结合使用时，它可能会遇到与most_fields或best_fields相同的问题。

你可以轻松地将这个查询重写为两个独立的cross_fields查询，并通过dis_max查询将它们组合起来，并将minimum_should_match参数仅应用于其中一个：

GET /_search
{
  "query": {
    "dis_max": {
      "queries": [
        {
          "multi_match" : {
            "query":      "Will Smith",
            "type":       "cross_fields",
            "fields":     [ "first", "last" ],
            "minimum_should_match": "50%" 
          }
        },
        {
          "multi_match" : {
            "query":      "Will Smith",
            "type":       "cross_fields",
            "fields":     [ "*.edge" ]
          }
        }
      ]
    }
  }
}

您可以通过在查询中指定analyzer参数，将所有字段强制分组到同一组中。

GET /_search
{
  "query": {
   "multi_match" : {
      "query":      "Jon",
      "type":       "cross_fields",
      "analyzer":   "standard", 
      "fields":     [ "first", "last", "*.edge" ]
    }
  }
}

将执行为：

blended("will",  fields: [first, first.edge, last.edge, last])
blended("smith", fields: [first, first.edge, last.edge, last])

默认情况下，每个基于项的blended查询将使用组中任何字段返回的最佳分数。然后，在组合跨组的分数时，查询将使用任何组中的最佳分数。tie_breaker参数可以改变这两个步骤的行为：

查询字符串“迷你语言”被用于 查询字符串以及 q查询字符串参数在搜索 API中。

查询字符串被解析成一系列的术语和操作符。一个术语可以是一个单独的词 — quick 或 brown — 或者是一个短语，用双引号包围 — "quick brown" — 它按顺序搜索短语中的所有单词。

运算符允许您自定义搜索——可用的选项如下所述。

qu?ck bro*

{
  "field": ""
}

{
  "field": null
}

name:/joh?n(ath[oa]n)/

/.*n/

quikc~ brwn~ foks~

quikc~1

"fox quick"~5

age:>10
age:>=10
age:<10
age:<=10

age:(>=10 AND <20)
age:(+>=10 +<20)

quick^2 fox

"john smith"^2   (foo bar)^4

quick brown +fox -news

{
    "bool": {
        "must":     { "match": "fox"         },
        "should":   { "match": "quick brown" },
        "must_not": { "match": "news"        }
    }
}

(quick OR brown) AND fox

status:(active OR pending) title:(full text search)^2

GET /my-index-000001/_search
{
  "query" : {
    "query_string" : {
      "query" : "kimchy\\!",
      "fields"  : ["user.id"]
    }
  }
}

field1:query_term OR field2:query_term | ...

GET /_search
{
  "query": {
    "query_string": {
      "fields": [ "content", "name" ],
      "query": "this AND that"
    }
  }
}

GET /_search
{
  "query": {
    "query_string": {
      "query": "(content:this OR name:this) AND (content:that OR name:that)"
    }
  }
}

GET /_search
{
  "query": {
    "query_string" : {
      "fields" : ["content", "name^5"],
      "query" : "this AND that OR thus",
      "tie_breaker" : 0
    }
  }
}

GET /_search
{
  "query": {
    "query_string" : {
      "fields" : ["city.*"],
      "query" : "this AND that OR thus"
    }
  }
}

GET /_search
{
  "query": {
    "query_string" : {
      "query" : "city.\\*:(this AND that OR thus)"
    }
  }
}

GET /_search
{
  "query": {
    "query_string" : {
      "fields" : ["content", "name.*^5"],
      "query" : "this AND that OR thus"
    }
  }
}

The query_string query supports multi-terms synonym expansion with the synonym_graph token filter. When this filter is used, the parser creates a phrase query for each multi-terms synonyms. For example, the following synonym: ny, new york would produce:

(ny OR ("纽约"))

也可以使用连词来匹配多词同义词：

GET /_search
{
   "query": {
       "query_string" : {
           "default_field": "title",
           "query" : "ny city",
           "auto_generate_synonyms_phrase_query" : false
       }
   }
}

上面的示例创建了一个布尔查询：

(ny OR (new AND york)) city

匹配包含术语 ny 或连接词 new AND york 的文档。 默认情况下，参数 auto_generate_synonyms_phrase_query 设置为 true。

The query_string 将查询按每个运算符分割，以创建整个输入的布尔查询。您可以使用 minimum_should_match 来控制结果查询中应匹配的“should”子句的数量。

GET /_search
{
  "query": {
    "query_string": {
      "fields": [
        "title"
      ],
      "query": "this that thus",
      "minimum_should_match": 2
    }
  }
}

上面的示例创建了一个布尔查询：

(title:this title:that title:thus)~2

匹配在单个字段 title 中至少包含两个术语 this、that 或 thus 的文档。

GET /_search
{
  "query": {
    "query_string": {
      "fields": [
        "title",
        "content"
      ],
      "query": "this that thus",
      "minimum_should_match": 2
    }
  }
}

上面的示例创建了一个布尔查询：

((内容:这个内容:那个内容:如此) | (标题:这个标题:那个标题:如此))

匹配在字段 title 和 content 上使用最大并集的文档。这里不能应用 minimum_should_match 参数。

GET /_search
{
  "query": {
    "query_string": {
      "fields": [
        "title",
        "content"
      ],
      "query": "this OR that OR thus",
      "minimum_should_match": 2
    }
  }
}

添加显式运算符会强制将每个术语视为单独的子句。

上面的示例创建了一个布尔查询：

((内容:这个 | 标题:这个) (内容:那个 | 标题:那个) (内容:如此 | 标题:如此))~2

匹配至少满足三个“应该”子句中的两个的文档，每个子句由每个术语在字段上的析取最大值组成。

在 type 字段中，cross_fields 值表示当输入被分析时，使用相同分析器的字段会被分组在一起。

GET /_search
{
  "query": {
    "query_string": {
      "fields": [
        "title",
        "content"
      ],
      "query": "this OR that OR thus",
      "type": "cross_fields",
      "minimum_should_match": 2
    }
  }
}

上面的示例创建了一个布尔查询：

(blended(terms:[field2:this, field1:this]) blended(terms:[field2:that, field1:that]) blended(terms:[field2:thus, field1:thus]))~2

匹配至少包含三个单项混合查询中两个的文档。

查询字符串查询可以在内部转换为前缀查询，这意味着如果如此处所述禁用了前缀查询，则该查询将不会执行，并且会抛出异常。

The simple_query_string 查询支持以下操作符：

要按字面意思使用这些字符之一，请在其前面加上反斜杠（\）进行转义。

这些运算符的行为可能会根据default_operator的值而有所不同。例如：

GET /_search
{
  "query": {
    "simple_query_string": {
      "fields": [ "content" ],
      "query": "foo bar -baz"
    }
  }
}

此搜索旨在仅返回包含 foo 或 bar 且不包含 baz 的文档。然而，由于 default_operator 为 OR，此搜索实际上返回了包含 foo 或 bar 的文档以及任何不包含 baz 的文档。要按预期返回文档，请将查询字符串更改为 foo bar +-baz。

您可以使用 flags 参数来限制简单查询字符串语法支持的操作符。

要显式启用特定操作符，请使用 | 分隔符。例如，flags 值为 OR|AND|PREFIX 将禁用除 OR、AND 和 PREFIX 之外的所有操作符。

GET /_search
{
  "query": {
    "simple_query_string": {
      "query": "foo | bar + baz*",
      "flags": "OR|AND|PREFIX"
    }
  }
}

字段可以使用通配符指定，例如：

GET /_search
{
  "query": {
    "simple_query_string" : {
      "query":    "Will Smith",
      "fields": [ "title", "*_name" ] 
    }
  }
}

可以使用插入符号（^）符号来提升单个字段：

GET /_search
{
  "query": {
    "simple_query_string" : {
      "query" : "this is a test",
      "fields" : [ "subject^3", "message" ] 
    }
  }
}

默认情况下，simple_query_string 查询解析器会为查询字符串中的每个 多位置标记创建一个 match_phrase 查询。 例如，解析器会为多词同义词 ny, new york 创建一个 match_phrase 查询：

(ny OR ("纽约"))

要使用 AND 连接符匹配多位置标记，请将 auto_generate_synonyms_phrase_query 设置为 false：

GET /_search
{
  "query": {
    "simple_query_string": {
      "query": "ny city",
      "auto_generate_synonyms_phrase_query": false
    }
  }
}

对于上述示例，解析器创建了以下 bool 查询：

(ny OR (new AND york)) city)

这个 bool 查询匹配包含术语 ny 或连接词 new AND york 的文档。