本节内容会详细介绍一些查询操作过程中经常或者可能使用到一些 api。

查询行为分类

查询子句的行为取决于它是在 query context 中使用还是在 filter context 中使用：

查询：query context 中，query 子句可以评估文档与查询子句的匹配程度。同时，计算出一个表示两者匹配程度的分数 score。
过滤：filter context 中，query 子句仅判断文档是否与此 query 子句匹配，不计算分数。

Match All Query

最简单的查询，匹配所有文档，所有文档的分数均为 1.0。

语法：

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "match_all": { }
    }
}

# 匹配所有文档查询
curl -XGET "localhost:9200/match_all_index/_search?pretty" -H 'Content-Type: application/json' -d'
{
    "query": {
        "match_all": { }
    }
}'

{
  "took" : 181,
  "timed_out" : false,
  "terminated_early" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "_clusters" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0
  },
  "hits" : {
    "total" : 1,
    "max_score" : null,
    "hits" : [
      {
        "_index" : "match_all_index",
        "_type" : "default_type_",
        "_id" : "3",
        "_score" : null,
        "_source" : {
          "msg" : "no scheme",
          "url_address" : "developer.mozilla.org/en-US/search?q=URL"
        }
      }
    ]
  }
}

# 使用 boost 参数更改分数
curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "match_all": { "boost" : 1.2 }
    }
}

{
  ...
  "hits" : {
    "total" : 1,
    "max_score" : 1.2,
    "hits" : [
      {
        "_index" : "match_all_index",
        "_type" : "default_type_",
        "_id" : "3",
        "_score" : 1.2,
        "_source" : {
          "msg" : "no scheme",
          "url_address" : "developer.mozilla.org/en-US/search?q=URL"
        }
      }
    ]
  }
}

full text queries

Match Query

match query 可以查询文本/数字/日期类型的数据。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "match": { "message": "this is a test" }
    }
}

注意，message 是一个字段的名称，你可以用任何字段的名称来代替。

curl -XGET "localhost:9200/match_query_index/_search?pretty" -H 'Content-Type: application/json' -d'
{
    "query": {
        "match": { "url_address": "https://developer.mozilla.org" }
    }
}'

{
  "took" : 112,
  "timed_out" : false,
  "terminated_early" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "_clusters" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0
  },
  "hits" : {
    "total" : 1,
    "max_score" : 1.0893298,
    "hits" : [
      {
        "_index" : "match_query_index",
        "_type" : "default_type_",
        "_id" : "3",
        "_score" : 1.0893298,
        "_source" : {
          "msg" : "no scheme",
          "url_address" : "developer.mozilla.org/en-US/search?q=URL"
        }
      }
    ]
  }
}

参数说明

match query 对所提供的文本进行分析，根据所提供的文本构造一个布尔查询，属于一种布尔类型查询。

operator 参数：可以设置为 OR 或 AND 来控制布尔子句（默认为 OR），通过 operator 参数可以控制匹配关系。匹配的可选 should 子句的最小数量可以使用 minimum_should_match 参数来设置。下面是一个提供额外参数的示例（注意结构上的变化，message 是字段名）:
```
curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "match": {
            "message": { "query" : "this is a test"，
                         "operator" : "AND" }
        }
    }
}
```
analyzer 参数：可以设置为控制哪个 analyzer 将对文本执行分析过程。默认的 analyzer 是字段中的 mapping 显式定义的 analyzer 或 default search analyzer。

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

fuzziness 参数允许基于被查询字段的类型进行模糊匹配。在这种情况下，可以设置 prefix_length 和 max_expansion 来控制模糊过程。

注意，模糊匹配不适用于具有同义词的词项。
```
curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "match": {
            "message": { "query" : "this is a test"，
                         "fuzziness" : "AUTO" }
        }
    }
}
```

zero term query 参数

如果所使用的 analyzer 删除了查询中的所有词元，则不会匹配到任何文档。为了改变 zero_terms_query 参数的使用，它的默认值是 none，若设置为 all 则对应于 match_all 查询。
```
curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "match": {
            "message": { "query" : "this is a test"，
                         "zero_terms_query": "all" }
        }
    }
}
```

Match Phrase Query

match_phrase 查询分析文本并根据分析的文本创建一个短语查询。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "match_phrase": { "message": "this is a test" }
    }
}

curl -X GET "localhost:9200/match_phrase_index/_search?&pretty" -H 'Content-Type: application/json' -d'
{
    "query": {
        "match_phrase": { "mtext": "Brown fox" }
   }
}'

{
  ...
  "hits" : {
    "total" : 2,
    "max_score" : 0.19932948,
    "hits" : [
      {
        "_index" : "match_phrase_index",
        "_type" : "default_type_",
        "_id" : "2",
        "_score" : 0.19932948,
        "_source" : {
          "mtext" : "Brown fox eat rabbits",
          "mkeyword" : "Brown fox eat rabbits"
        }
      },
      {
        "_index" : "match_phrase_index",
        "_type" : "default_type_",
        "_id" : "1",
        "_score" : 0.1325215,
        "_source" : {
          "mtext" : "The 2 QUICK Brown-Foxes jumped over the lazy dog's Bone.",
          "mkeyword" : "The 2 QUICK Brown-Foxes jumped over the lazy dog's Bone."
        }
      }
    ]
  }
}

slop 用于指定查询短语间的词项（term）间的距离，默认值是 0；analyzer 参数可以设置哪个 analyzer 将对文本执行分析过程；与 match query 一样，match phrase query 也可以接受 zero_terms_query 。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "match_phrase": {
            "message": { "query": "quick brown",
                         "slop": 10 }
        }
    }
}

Match Phrase Prefix Query

match phrase prefix query 与 match phrase query 相同，但是它多了一个特性，它允许对文本中的最后一个词进行前缀匹配。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "match_phrase_prefix": {
            "message": "quick brown f"
        }
    }
}

curl -X GET "localhost:9200/match_phrase_prefix_index/_search?&pretty" -H 'Content-Type: application/json' -d'
{
    "query": {
        "match_phrase_prefix": {
            "mtext": {"query": "quick brown f"}
        }
    }
}'

{
  ...
  "hits" : {
    "total" : 1,
    "max_score" : 3.2995868,
    "hits" : [
      {
        "_index" : "match_phrase_prefix_index",
        "_type" : "default_type_",
        "_id" : "1",
        "_score" : 3.2995868,
        "_source" : {
          "mtext" : "The 2 QUICK Brown-Foxes jumped over the lazy dog's Bone.",
          "mkeyword" : "The 2 QUICK Brown-Foxes jumped over the lazy dog's Bone."
        }
      }
    ]
  }
}

match phrase prefix 的 max_expansion 参数可以控制最后一项将扩展多少个后缀。建议将其设置为可接受的值以控制查询的执行时间。以 quick brown f 查询为例，它会先查找第一个与前缀 f 匹配的词，然后依次查找搜集与之匹配的词（按字母顺序），直到没有更多可匹配的词或当数量超过 max_expansions 时结束。但是 max_expansions 是作用在分片级别（shard level）的，这意味着即使设置为 1，依然有可能匹配到多个词。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "match_phrase_prefix": {
            "message": { "query": "quick brown f",
                         "max_expansions": 2 }
        }
    }
}

match phrase prefix query 非常容易使用，可以快速地开始搜索，但它的结果有时可能会不尽人意。

考虑查询字符串 quick brown f。该查询通过创建一个由 quick 和 brown 组成的查询语句来进行查询（即 quick 必须存在，并且必须后面跟着 brown）。然后，它查看排序后的词项字典，找到以 f 开头的前 50 个词项，并将这些词项添加到短语查询中。

问题是前 50 个词项中可能不包括 fox，这样短语 quick brown fox 就不会被查到。可以通过继续输入更多的字母的方法找到要找到的结果。

Multi Match Query

multi match query 建立在 match query 的基础上，允许多字段查询:

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "multi_match" : { "query": "this is a test",
                          "fields": [ "subject", "message" ] }
    }
}

curl -X GET "localhost:9200/multi_match_index/_search?pretty" -H 'Content-Type: application/json' -d'{
    "query": {
        "multi_match" : { "query": "mouse",
                          "fields": [ "lastname", "abstract" ] }
    }
}'

{
  ...
  "hits" : {
    "total" : 1,
    "max_score" : 1.8032517,
    "hits" : [
      {
        "_index" : "multi_match_index",
        "_type" : "default_type_",
        "_id" : "4",
        "_score" : 1.8032517,
        "_source" : {
          "firstname" : "Industrious",
          "abstract" : "mouse eat rices",
          "title" : "mouse are also Pets",
          "content" : "Why hamster is a pet, mouse is not a pet",
          "lastname" : "Dark"
        }
      }
    ]
  }
}

fields and per-field boosting

可以使用通配符指定字段

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "multi_match" : { "query": "Will Smith",
                          "fields": [ "title", "*_name" ] }
    }
}

单个字段可以使用符号(^)来增强，下面的例子表示 subject 字段的重要性是 message 字段的三倍。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "multi_match" : { "query" : "this is a test",
                          "fields" : [ "subject^3", "message" ] }
    }
}

如果没有提供字段，multi match query 默认为 "." 会将所有字段组合起来以构建一个查询。

Types of multi_match query

multi match query 在内部执行的方式取决于 type 参数，它可以设置为:
- best_fields：（默认值）查找匹配任何字段的文档，但取最大的匹配的score。
- most_fields：查找匹配任意字段的文档，并把每个字段的score相加。
- cross_fields：用相同的analyzer处理字段，查找任何领域的每个单词。
- phrase：对每个字段进行match phrase query，并取最大的匹配的score。
- phrase_prefix：对每个字段运行一个match phrase prefix query，并将每个字段的score相加。

best_fields

best_fields 类型为每个字段生成一个匹配查询，以找到唯一的最佳匹配字段。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "multi_match" : {"query": "brown fox",
                         "type": "best_fields",
                         "fields": [ "subject", "message" ] }
    }
}

most_fields

与 best_fields 不同之处在于相关性评分，best_fields 取最大匹配得分（max 计算），而 most_fields 取所有匹配之和（sum 计算）。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "multi_match" : { "query": "quick brown fox",
                          "type": "most_fields",
                          "fields": [ "title", "title.original", "title.shingles" ] }
    }
}

相当于执行以下查询语句：

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "bool": {
            "should": [ { "match": { "title":          "quick brown fox" }},
                        { "match": { "title.original": "quick brown fox" }},
                        { "match": { "title.shingles": "quick brown fox" }} ]
        }
    }
}

phrase and phrase_prefix

phrase 和 phrase_prefix 与 best_fields 类似，但它们使用的是 match_phrase query 或 match_phrase_prefix query，而不是 match query。

*curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "multi_match" : { "query": "quick brown f",
                          "type": "phrase_prefix",
                          "fields": [ "subject", "message" ]
        }
    }
}

cross_fields

cross_fields 对于需要匹配多个字段的结构化文档特别有用。例如，当查询 "Will Smith" 的 first_name 和 last_name 字段时，最好的匹配是一个字段中有 "Will"，另一个字段中有 "Smith"。

但是这种方法有个问题，与相关性有关：first_name 和 last_name 字段中的词项频率不同，可能会产生意想不到的结果。例如，假设有两个人："Will Smith" 和 "Smith Jones"。"Smith" 作为 last_name 是很常见的（因此不太重要），但 "Smith" 作为 first_name 是很少见的(因此很重要)。如果搜索 "Will Smith"，"Smith Jones" 文档可能会出现在更匹配的 "Will Smith" 之上，因为 first_name: Smith 的分数超过了 first_name: Will + last_name: Smith 的分数之和。

处理这类查询的一种方法是将 first_name 和 last_name 字段索引到单个 full_name 字段中。当然，这只能在创建索引时完成。

cross_field 试图在查询时解决这些问题。它首先将查询字符串分析为单个词项，然后在任何字段中查找每个词项，就像它们是一个大字段一样。
```
curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "multi_match" : { "query": "Will Smith",
                          "type": "cross_fields",
                          "fields": [ "first_name", "last_name" ],
                          "operator": "and" }
    }
}
```

Term level queries

Term Query

term query 查找包含倒排索引中指定的准确词项的文档。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "term" : {
            "user" : { "value": "Kimchy" }
        }
    }
}

curl -XGET "localhost:9200/term_query_index/_search?pretty" -H 'Content-Type: application/json' -d'
{
    "query": {
        "term": {
            "url_address": { "value": "https://www.google.com/" }
        }
    }
}'

{
  ...
  "hits" : {
    "total" : 1,
    "max_score" : 0.28004453,
    "hits" : [
      {
        "_index" : "term_query_index",
        "_type" : "default_type_",
        "_id" : "3",
        "_score" : 0.28004453,
        "_source" : {
          "msg" : "long",
          "url_address" : "https://www.google.com/search?q=url&sxsrf=APq-WBvQC6by6yojrKX42LpO9KpY5IEiBw%3A1646378551496"
        }
      }
    ]
  }
}

可以指定一个 boost 参数来给这个查询一个比其他查询更高的相关性评分。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "term": { "name": "Charlie Paul"
                  "boost": 3.0 }
    }
}

Terms Query

terms query 可以实现将一个字段，从多个 value 中检索的效果，

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "terms" : { "user" : ["kimchy", "Scope"] }
    }
}

curl -XGET "localhost:9200/search_index/_search?&pretty" -H 'Content-Type: application/json' -d'
{
    "query": {
        "terms": { "name.keyword": ["Charlie Puth"] }
    }
}'

{
  ...
  "hits" : {
    "total" : 1,
    "max_score" : 1.0,
    "hits" : [
      {
        "_index" : "search_index",
        "_type" : "default_type_",
        "_id" : "9",
        "_score" : 1.0,
        "_source" : {
          "name" : "Charlie Puth",
          "age" : 43,
          "hobby" : null
        }
      }
    ]
  }
}

Range Query

在一定范围内将文档与具有词项的字段进行匹配。Lucene 查询的类型取决于字段类型，对于字符串字段，是 TermRangeQuery，而对于数字/日期字段，是 NumericRangeQuery。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "range" : {
            "age" : { "gte" : 10,
                      "lte" : 20,
                      "boost" : 2.0 }
        }
    }
}

curl -X GET "localhost:9200/range_query_index/_search?&pretty&" -H 'Content-Type: application/json' -d'
{
    "query": {
        "range": {
            "age": { "gte": 10,
                     "lte": 24,
                     "boost": 2.0 }
        }
    }
}'

{
  ...
  "hits" : {
    "total" : 1,
    "max_score" : 2.0,
    "hits" : [
      {
        "_index" : "range_query_index",
        "_type" : "default_type_",
        "_id" : "2",
        "_score" : 2.0,
        "_source" : {
          "name" : "james",
          "age" : 23
        }
      }
    ]
  }
}

range query 接受以下这些参数:

gte：大于等于
gt：大于
lte：小于等于
lt：小于
boost：设置查询的增强值，默认为 1.0

日期查询

当对 date 类型的字段进行范围查询时，范围可以使用 date Math 指定:

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "range" : {
            "date" : { "gte" : "now-1d/d",
                       "lt" :  "now/d" }
        }
    }
}

日期四舍五入

当使用 date Math 将日期四舍五入到最近的日、月、小时等时，四舍五入的日期取决于范围的两端是包含的还是不包含的。

向上四舍五入移动到四舍五入范围的最后一毫秒，向下四舍五入到四舍五入范围的第一毫秒。

gt：大于四舍五入的日期:2014-11-18||/M变成2014-11-30T23:59:59.999，即不包括整个月。
gte：大于或等于四舍五入的日期:2014-11-18||/M为2014-11-01，即包括整个月。
lt：小于四舍五入的日期:2014-11-18||/M变成2014-11-01，即不包括整个月。
lte：小于或等于四舍五入的日期:2014-11-18||/M变为2014-11-30T23:59:59.999，即包括整个月。

日期格式

默认情况下，格式化的日期将使用 date 字段指定的格式进行解析，但它可以通过将 format 参数传递给 range query 来覆盖:

curl -XGET <host>:<port>/<index_name>/_search { "query": { "range" : { "born" : { "gte": "01/01/2012", "lte": "2013", "format": "dd/MM/yyyy||yyyy" } } } }

注意，如果日期漏掉了年或月或日，则用 unix 时间的开始（1970年1月1日）来填充缺失的部分。这意味着，例如，当指定 dd 作为格式时，像 "gte": 10 这样的值将被转换为 1970-01-10T00:00:00.000Z。

时区

日期可以从另一个时区转换为 UTC，要么通过在日期值本身指定时区（如果格式接受），要么可以指定为 time_zone 参数:

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "range" : {
            "timestamp" : { "gte": "2015-01-01 00:00:00",
                            "lte": "now",
                            "time_zone": "+01:00" }
        }
    }
}

此日期将转换为 2014-12-31T23:00:00 UTC。

Exists Query

返回原始字段中至少有一个非空值的文档：

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "exists" : { "field" : "user" }
    }
}

要实现 missing query，要在 must_not 子句中使用 "exists" 查询。这个查询会返回 "user" 字段没有值的文档。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "bool": {
            "must_not": {
                "exists": { "field": "user" }
            }
        }
    }
}

Prefix Query

匹配具有包含具有指定前缀的词项的字段的文档（未被分析）。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "prefix" : { "user" : "ki" }
    }
}

curl -X GET "localhost:9200/prefix_index/_search?&pretty&" -H 'Content-Type: application/json' -d'
{
   "query": {
     "prefix": { "user": "ki" }
   }
}'

{
  ...
  "hits" : {
    "total" : 1,
    "max_score" : 1.0,
    "hits" : [
      {
        "_index" : "prefix_index",
        "_type" : "default_type_",
        "_id" : "3",
        "_score" : 1.0,
        "_source" : {
          "user" : "kimo"
        }
      }
    ]
  }
}

Wildcard Query

匹配具有匹配通配符表达式（未被分析）的字段的文档。支持的通配符是 "*"，匹配任何字符序列（包括空字符），和 "?"，匹配任何单个字符。注意，这个查询可能很慢，因为它需要遍历许多词项。为了使得 wildcard query 速度加快，通配符词项不应该以通配符 "*" 或 "?" 之一开头。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "wildcard" : { "user" : "ki*y" }
    }
}

curl  -X GET "localhost:9200/wildcard_index/_search?pretty" -H 'Content-Type: application/json' -d'
{
    "query": {
        "wildcard": { "lyricE": { "value": "s*" } }
    }
}'

{
  ...
  "hits" : {
    "total" : 1,
    "max_score" : 1.0,
    "hits" : [
      {
        "_index" : "wildcard_index",
        "_type" : "default_type_",
        "_id" : "1",
        "_score" : 1.0,
        "_source" : {
          "lyricC" : "你的眼里有星河闪烁",
          "lyricE" : "There are stars in your eyes"
        }
      }
    ]
  }
}

Regexp Query

regexp query 允许使用正则表达式进行查询。

注意：regexp query 的性能显著受到所选用的正则表达式的影响。使用如 .* 这样过于宽泛的正则表达式会导致查询速度缓慢。建议尽可能在正则表达式的开始部分采用较长的固定前缀，以优化查询性能。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "regexp":{ "name.first": "s.*y" }
    }
}

curl  -X GET "localhost:9200/regexp_index/_search?pretty" -H 'Content-Type: application/json' -d'
{
    "query": {
        "regexp": { "value": { "value": ".*.*..*" } }
    }
}'

{
  ...
  "hits" : {
    "total" : 1,
    "max_score" : 1.0,
    "hits" : [
      {
        "_index" : "regexp_index",
        "_type" : "default_type_",
        "_id" : "3",
        "_score" : 1.0,
        "_source" : {
          "value" : "aaba10aba20ab"
        }
      }
    ]
  }
}

可以使用 flag 参数，为正则表达式启用可选运算符

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "regexp":{
            "name.first": { "value": "s.*y",
                            "flags" : "INTERSECTION|COMPLEMENT|EMPTY" }
        }
    }
}

特殊标志有 ALL（默认），ANYSTRING, COMPLEMENT, EMPTY, INTERSECTION, INTERVAL 或 NONE。

正则表达式很容易意外地创建一个看起来无害的表达式，它需要大量的内部确定自动机状态（以及相应的 RAM 和 CPU）供 Lucene 执行。Lucene 使用 max_determinized_states 设置（默认为 10000）来阻止这些，可以提高这个限制以允许执行更复杂的正则表达式。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "regexp":{
            "name.first": { "value": "s.*y",
                            "flags" : "INTERSECTION|COMPLEMENT|EMPTY",
                            "max_determinized_states": 20000 }
        }
    }
}

Compound queries

Bool Query

一个查询，使用其他查询的布尔值组合进行匹配查询，它使用一个或多个布尔子句构建。

must：子句（查询）必须出现在匹配的文档中。

filter：子句（查询）必须出现在匹配的文档中。

should：子句（查询）应该出现在匹配的文档中。

must_not：子句（查询）不能出现在匹配的文档中。

bool query 采用 more-matches-is-better 方法，因此每个匹配的 must 或 should 子句的分数将被加在一起，为每个文档提供最终的分数。

curl -XPOST<host>:<port>/<index_name>/_search
{
    "query": {
        "bool" : {
            "must" : { "term" : { "user" : "kimchy" } },
        "filter": {
            "term" : { "tag" : "tech" } },
        "must_not" : { "range" : {"age" : { "gte" : 10, "lte" : 20 } } },
        "should" : [ { "term" : { "tag" : "wow" } },
                     { "term" : { "tag" : "elasticsearch" } } ],
        "minimum_should_match" : 1,
        "boost" : 1.0
        }
    }
}

curl  -X POST "localhost:9200/bool_index/_search?pretty" -H 'Content-Type: application/json' -d'
{
    "query": {
        "bool" : {
            "must_not" : {"range" : { "price" : { "lte" : 6.99 } } },
        "should" : [ { "term" : { "avaliable" : true } } ],
        "boost" : 2.0
        }
    }
}'

{
  ...
  "hits" : {
    "total" : 2,
    "max_score" : 0.26706278,
    "hits" : [
      {
        "_index" : "bool_index",
        "_type" : "default_type_",
        "_id" : "2",
        "_score" : 0.26706278,
        "_source" : {
          "name" : "Jump Ropes",
          "description" : "Lusuroi Jump Rope, Cable Adjustable Skipping Rope for Workout Fitness Exercise Training, Speed Jumping Rope for Kids Beginners Women Adults, Tangle-Free with Ball Bearings Gym Rope",
          "productID" : "C08H1P827X",
          "price" : 13.99,
          "avaliable" : true
        }
      },
      {
        "_index" : "bool_index",
        "_type" : "default_type_",
        "_id" : "3",
        "_score" : 0.26706278,
        "_source" : {
          "name" : "Beaded Jump Rope",
          "description" : "Beaded Jump Rope Tangle-Free with Ball Bearings Rapid Adjustable Skipping Rope Non-Slip Handle Speed Suitable for Fitness Workout Adult Kids Men Women-2 Packs",
          "productID" : "B087681ZJ2",
          "price" : 7.99,
          "avaliable" : true
        }
      }
    ]
  }
}

Minimum Should Match

mininum_should_match 参数可以有以下几种类型的值：

Integer：表示一个固定值，与可选子句的数量无关。
Negative integer：表示可选子句的总数减去这个数字应该是强制性的。
Percentage：表示该可选子句总数的百分比是必需的。从百分比计算的数字向下舍入并用作最小值。
Negative percentage：表示可能缺少可选子句总数的这个百分比。从百分比计算的数字向下舍入，然后从总数中减去以确定最小值。
Combination：一个正整数，后跟小于号。它表示如果可选子句的数量等于（或小于）整数，则它们都是必需的，但如果大于整数，则适用规范。
Multiple combinations：多个条件说明可以用空格分隔，每个条件仅对大于其前一个的数字有效。

Function Score Query

function_score 允许您修改查询检索到的文档的分数。要使用 function_score，用户必须定义一个查询和一个或多个函数，为查询返回的每个文档计算一个新分数。

GET /_search
{
    "query": {
        "function_score": {
            "query": { "match_all": {} },
            "boost": "5",
            "random_score": {},
            "boost_mode":"multiply"
        }
    }
}