Elasticsearch7.5 搜索条件说明

查询条件

复合查询

bool 查询
用于组合多个查询或聚合查询子句，查询参数有 must，should，must_not，或filter条款。
布尔查询允许我们利用布尔逻辑将较小的查询组合成较大的查询

boosting 查询
返回与positive查询匹配的文档，但减少与negative查询匹配的文档的分数。
一种复合查询，分为positive子查询和negitive子查询，两者的查询结构都会返回。
positive子查询的score保持不变，negetive子查询的值将会根据negative_boost的值做相应程度的降低。

constant_score 查询
一个查询，它包装另一个查询，但是在过滤器上下文中执行它。所有匹配的文档都被赋予相同的“常量” _score。
当我们不关心检索词频率TF（Term Frequency）对搜索结果排序的影响时，可以使用constant_score将查询语句query或者过滤语句filter包装起来

dis_max 查询
一个查询，它接受多个查询，并返回与任何查询子句匹配的任何文档。当bool查询合并所有匹配查询的分数时，dis_max查询将使用单个最佳匹配查询子句的分数。
分离最大化查询（Disjunction Max Query）指的是： 将任何与任一查询匹配的文档作为结果返回，但只将最佳匹配的评分作为查询的评分结果返回

function_score 查询
使用功能修改主查询返回的分数，以考虑诸如受欢迎程度，新近度，距离或使用脚本实现的自定义算法等因素。
在使用ES进行全文搜索时，搜索结果默认会以文档的相关度进行排序，而这个 “文档的相关度”，是可以透过 function_score 自己定义的，也就是说我们可以透过使用function_score，来控制文档排序

布尔值查询

must
子句（查询）必须出现在匹配的文档中，并将有助于得分

filter
子句（查询）必须出现在匹配的文档中。但是不像 must查询的分数将被忽略。Filter子句在filter过滤器中执行，这意味着计分被忽略，并且过滤器子句会被缓存

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

must_not
子句（查询）不得出现在匹配的文档中。子句在过滤器上下文中执行，这意味着计分被忽略，并且子句被视为用于缓存。由于忽略计分，因此将返回所有0分数的文档

POST _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
    }
  }
}

说明

1. must的两个条件都必须满足，should中的两个条件至少满足一个就可以

事例：

//以下案例都能查询status中包括active的文档

GET _search
{
  "query": {
    "bool": {
      "filter": {
        "term": {
          "status": "active"
        }
      }
    }
  }
}

GET _search
{
  "query": {
    "bool": {
      "must": {
        "match_all": {}
      },
      "filter": {
        "term": {
          "status": "active"
        }
      }
    }
  }
}

GET _search
{
  "query": {
    "constant_score": {
      "filter": {
        "term": {
          "status": "active"
        }
      }
    }
  }
}

提高查询

boosting参数

positive
（必需的查询对象）要运行的查询。返回的所有文档都必须与此查询匹配。

negative
（必需的查询对象）查询用于降低匹配文档的相关性得分
如果返回的文档与positive查询和该查询匹配，则该 boosting查询将如下计算该文档的最终相关性得分：

1. 从positive查询中获取原始的相关性分数
   将分数乘以negative_boost值

negative_boost
（必需，浮动）介于之间的浮点数0,1 用于降低与negative查询匹配的文档 的相关性得分

GET /_search
{
    "query": {
        "boosting" : {
            "positive" : {
                "term" : {
                    "text" : "apple"
                }
            },
            "negative" : {
                 "term" : {
                     "text" : "pie tart fruit crumble tree"
                }
            },
            "negative_boost" : 0.5
        }
    }
}

恒定分数查询

包装筛选器查询，并返回每个匹配的文档，其相关性得分等于boost参数值。

constant_score参数
filter
（必需的查询对象）过滤要运行的查询。返回的所有文档都必须与此查询匹配。
过滤查询不计算相关性分数。为了提高性能，Elasticsearch自动缓存经常使用的过滤器查询

boost
（可选，float）浮点数用作与查询匹配的每个文档 的恒定 相关性得分filter。默认为1.0

GET /_search
{
    "query": {
        "constant_score" : {
            "filter" : {
                "term" : { "user" : "kimchy"}
            },
            "boost" : 1.2
        }
    }
}

折取最大值查询

返回与一个或多个包装查询（称为查询子句或子句）匹配的文档
如果返回的文档与多个查询子句匹配，则dis_max查询会为该文档分配来自任何匹配子句的最高相关性得分，再加上任何其他匹配子查询的平局打破增量
您可以使用dis_max来在以不同提升因子映射的字段中搜索术语

dis_max参数

queries
（必需的查询对象数组）包含一个或多个查询子句。返回的文档必须与这些查询中的一个或多个匹配。如果一个文档匹配多个查询，Elasticsearch将使用最高的相关性得分

tie_breaker
（可选，float）介于之间的浮点数0，1.0用于增加与多个查询子句匹配的文档的相关性得分。默认为0.0
您可以使用该tie_breaker值为多个字段中包含相同术语的文档分配比仅在多个字段中的最好术语中包含该术语的文档更高的相关性分数，而无需将其与多个字段中两个不同术语的更好情况相混淆
如果一个文档匹配多个子句，dis_max查询将计算该文档的相关性得分，如下所示：
从具有最高分数的匹配子句中获取相关性分数。
将任何其他匹配子句的分数乘以该tie_breaker值。
将最高分数加到相乘的分数上。
如果该tie_breaker值大于0.0，则所有匹配的子句都计数，但是得分最高的子句计数最多。

功能成绩查询

将function_score允许你修改的由查询检索文档的分数。例如，如果分数函数在计算上很昂贵，并且足以在过滤后的文档集上计算分数，则此功能很有用。

要使用function_score，用户必须定义一个查询和一个或多个函数，这些函数为查询返回的每个文档计算一个新分数

https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-function-score-query.html

match

简介：
该match查询是用于执行全文搜索（包括模糊匹配选项）的标准查询

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

//简化match请求
GET /_search
{
    "query": {
        "match" : {
            "message" : "this is a test"
        }
    }
}

//匹配查询 and|or

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

该match查询类型boolean。这意味着将对提供的文本进行分析，并且分析过程将从提供的文本中构造一个布尔查询。所述operator参数可以被设置为or或者and 以控制布尔条款（默认为or）

match_phrase

简介：
查询分析文本

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


GET /_search
{
    "query": {
        "match_phrase" : {
            "message" : {
                "query" : "this is a test",
                "analyzer" : "my_analyzer" //可设置自定义分析器，不设置则用默认
            }
        }
    }
}

match_phrase_prefix

简介：
文本前缀查询

GET /_search
{
    "query": {
        "match_phrase_prefix" : {
            "message" : {
                "query" : "quick brown f"
            }
        }
    }
}

multi_match

简介：
多字段查询

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

//查询某领域字段
GET /_search
{
  "query": {
    "multi_match" : {
      "query":    "Will Smith",
      "fields": [ "title", "*_name" ] 
    }
  }
}

//字段权重
GET /_search
{
  "query": {
    "multi_match" : {
      "query" : "this is a test",
      "fields" : [ "subject^3", "message" ] 
    }
  }
}
//该subject领域的重要性是该message领域的三倍

如果未提供fields，则multi_match查询默认为index.query.default_field 索引设置，而索引设置依次为*.*提取映射中符合词条查询条件的所有字段，并过滤元数据字段。然后将所有提取的字段组合起来以构建查询

默认查询的字段数有限制。它由indices.query.bool.max_clause_count 搜索设置定义 ，默认为1024

query_string

简介：
字符串查询

GET /_search
{
    "query": {
        "query_string" : {
            "query" : "(new york city) OR (big apple)",
            "default_field" : "content"
        }
    }
}

运行以下搜索时，query_string查询分为(new york
city) OR (big apple)两部分：new york city和big apple。content然后，该 字段的分析器在返回匹配的文档之前，将每个部分独立地转换为令牌。由于查询语法不使用空格作为运算符，new york city因此按原样传递给分析器

如果查询字符串中未提供任何字段，则为您要搜索的默认字段

range

简介：
范围查询

GET _search
{
    "query": {
        "range" : {
            "age" : {
                "gte" : 10,
                "lte" : 20,
                "boost" : 2.0
            }
        }
    }
}

支持格式

gt
（可选）大于

gte
（可选）大于或等于

lt
（可选）小于

lte
（可选）小于或等于

format
（可选，字符串）用于转换date查询中的值的日期格式

2012年所有天数:
date:[2012-01-01 TO 2012-12-31]

数字1到5
count:[1 TO 5]

alpha和之间的标签omega，但不包括alpha和omega:
tag:{alpha TO omega}

从10以上的数字
count:[10 TO *]

2012年之前的日期
date:{* TO 2012-01-01}

圆括号和方括号可以组合使用:
从1到但不包括5的数字
count:[1 TO 5}

一侧无界的范围可以使用以下语法:
age:>10
age:>=10
age:<10
age:<=10

要将上限和下限与简化语法结合在一起，您需要使用AND运算符将两个子句连接起来：
age:(>=10 AND <20)
age:(+>=10 +<20)

simple_query_string

简介：
简单的字符串查询

GET /_search
{
  "query": {
    "simple_query_string" : {
        "query": "\"fried eggs\" +(eggplant | potato) -frittata",
        "fields": ["title^5", "body"],
        "default_operator": "and"
    }
  }
}

支持的运算符

• 表示与运算
  | 表示或运算

• 取反单个令牌
  “” 包装许多标记以表示要搜索的短语

• 字词末尾表示前缀查询
  ( and ) 表示优先
  ~N 单词表示编辑距离（模糊性）后
  ~N 在短语表示斜线数量之后

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

//极限运算符
GET /_search
{
    "query": {
        "simple_query_string" : {
            "query" : "foo | bar + baz*",
            "flags" : "OR|AND|PREFIX"
        }
    }
}
//可以使用该flags参数来限制简单查询字符串语法的支持运算符

可用的标志是：

ALL （默认）
启用所有可选的运算符

AND
启用+AND运算符

ESCAPE
启用\作为转义字符

FUZZY
~N在一个单词后 启用运算符，其中N整数表示允许匹配的编辑距离。请参阅模糊性

NEAR
~N在一个短语之后 启用运算符，其中where N是匹配标记之间允许的最大位置数。的同义词SLOP

NONE
禁用所有运算符

NOT
启用-NOT运算符

OR
启用|OR运算符

PHRASE
启用""用于搜索短语的引号运算符

PRECEDENCE
使(和)运算符可以控制运算符优先级

PREFIX
启用*前缀运算符

SLOP
~N在一个短语之后 启用运算符，其中where N是匹配标记之间允许的最大位置数。的同义词NEAR

WHITESPACE
启用空格作为分割字符

匹配所有查询

GET /_search
{
    "query": {
        "match_all": {}
    }
}

//不匹配查询
GET /_search
{
    "query": {
        "match_none": {}
    }
}

模糊查询

GET /_search
{
    "query": {
        "fuzzy": {
            "user": {
                "value": "ki"
            }
        }
    }
}

GET /_search
{
    "query": {
        "fuzzy": {
            "user": {
                "value": "ki",
                "fuzziness": "AUTO",
                "max_expansions": 50,
                "prefix_length": 0,
                "transpositions": true,
                "rewrite": "constant_score"
            }
        }
    }
}

编辑距离是将一个术语转换为另一个术语所需的一个字符更改的次数。这些更改可以包括：

更改字符(box → fox)
删除字符 (black → lack)
插入字符(sic → sick)
转置两个相邻字符(act → cat)

ids

简介：
根据其ID返回文档。该查询使用存储在_id字段中的文档ID

GET /_search
{
    "query": {
        "ids" : {
            "values" : ["1", "4", "100"]
        }
    }
}

prefix

简介：
前缀查询

GET /_search
{
    "query": {
        "prefix": {
            "user": {
                "value": "ki"
            }
        }
    }
}

您可以使用index_prefixes mapping参数加快前缀查询的速度。如果启用，Elasticsearch会在一个单独的字段中索引2到5个字符之间的前缀。这使Elasticsearch可以以更大的索引为代价更有效地运行前缀查询

regexp

简介：
正则表达式

GET /_search
{
    "query": {
        "regexp": {
            "user": {
                "value": "k.*y",
                "flags" : "ALL",
                "max_determinized_states": 10000,
                "rewrite": "constant_score"
            }
        }
    }
}

其中该user字段包含以开头k和结尾的任何术语y。的.*运营商匹配任何长度的任何字符，包括无字符。匹配条件可以包括ky，kay，和kimchy

默认情况下，正则表达式限制为1,000个字符。您可以使用index.max_regex_length 设置更改此限制

term

简介：
精准查询

GET _search?pretty
{
  "query": {
    "term": {
      "full_text": "Quick Brown Foxes!"
    }
  }
}

GET /_search
{
    "query": {
        "term": {
            "user": {
                "value": "Kimchy",
                "boost": 1.0
            }
        }
    }
}

避免term对text字段使用查询
默认情况下，Elasticsearch更改text字段的值作为analysis的一部分,这会使查找text字段值的精确匹配变得困难
要搜索text字段值，请改用match查询

terms

简介：
精准查询多值

GET /_search
{
    "query" : {
        "terms" : {
            "user" : ["kimchy", "elasticsearch"],
            "boost" : 1.0
        }
    }
}

默认情况下，Elasticsearch将terms查询限制为最多65,536个词。您可以使用index.max_terms_count设置更改此限制

案例：

//创建索引
PUT my_index
{
    "mappings" : {
        "properties" : {
            "color" : { "type" : "keyword" }
        }
    }
}

//插入数据
PUT my_index/_doc/1
{
  "color":   ["blue", "green"]
}

PUT my_index/_doc/2
{
  "color":   "blue"
}

//将terms查询与术语查找参数一起使用，以查找包含一个或多个与文档2相同的术语的文档。包括该pretty 参数，以使响应更具可读性
GET my_index/_search?pretty
{
  "query": {
    "terms": {
        "color" : {
            "index" : "my_index",
            "id" : "2",
            "path" : "color"
        }
    }
  }
}

//因为文档2和文档1都blue在该color 字段中包含作为值，所以Elasticsearch返回两个文档
{
  "took" : 17,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 2,
      "relation" : "eq"
    },
    "max_score" : 1.0,
    "hits" : [
      {
        "_index" : "my_index",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : 1.0,
        "_source" : {
          "color" : [
            "blue",
            "green"
          ]
        }
      },
      {
        "_index" : "my_index",
        "_type" : "_doc",
        "_id" : "2",
        "_score" : 1.0,
        "_source" : {
          "color" : "blue"
        }
      }
    ]
  }
}

wildcard

简介：
通配符查询

GET /_search
{
    "query": {
        "wildcard": {
            "user": {
                "value": "ki*y",
                "boost": 1.0,
                "rewrite": "constant_score" //（可选，字符串）用于重写查询的方法
            }
        }
    }
}
//以下搜索返回文档，其中该user字段包含以开头ki和结尾的术语y。这些匹配条件可以包括kiy， kity或kimchy

count

简介：
总数查询

PUT /twitter/_doc/1?refresh
{
    "user": "kimchy"
}

GET /twitter/_count?q=user:kimchy

GET /twitter/_count
{
    "query" : {
        "term" : { "user" : "kimchy" }
    }
}

//return 返回数据
{
    "count" : 1,
    "_shards" : {
        "total" : 1,
        "successful" : 1,
        "skipped" : 0,
        "failed" : 0
    }
}