Elasticsearch入门教程-中索引操作对比关系型数据库，创建索引就等同于创建数据库。创建基本语法：请求方

索引操作

对比关系型数据库，创建索引就等同于创建数据库。

创建

基本语法：

请求方式：PUT
请求路径：/索引库名，可以自定义
请求参数：无

格式：

PUT /索引库名

示例：

PUT /shopping

请求后，服务器返回响应：

{
	"acknowledged"【响应结果】: true, # true 操作成功
	"shards_acknowledged"【分片结果】: true, # 分片操作成功
	"index"【索引名称】: "shopping"
}

# 注意：创建索引库的分片数默认 1 片，在 7.0.0 之前的 Elasticsearch 版本中，默认 5 片

如果重复添加索引，会返回错误信息。

查询

1.查看所有索引

基本语法：

请求方式：GET
请求路径：/_cat/indices?v
请求参数：无

格式：

GET /_cat/indices?v

示例：

GET /_cat/indices?v

这里请求路径中的_cat 表示查看的意思，indices 表示索引，所以整体含义就是查看当前 ES 服务器中的所有索引，就好像 MySQL 中的 show tables 的感觉，服务器响应结果如下：

表头	含义
health	当前服务器健康状态： `green`(集群完整) `yellow`(单点正常、集群不完整) `red`(单点不正常)
status	索引打开、关闭状态
index	索引名
uuid	索引统一编号
pri	主分片数量
rep	副本数量
docs.count	可用文档数量
docs.deleted	文档删除状态（逻辑删除）
store.size	主分片和副分片整体占空间大小
pri.store.size	主分片占空间大小

2.查看单个索引

基本语法：

请求方式：GET
请求路径：/索引库名
请求参数：无

格式：

GET /索引库名

示例：

GET /shopping

查看索引向 ES 服务器发送的请求路径和创建索引是一致的。

请求后，服务器响应结果如下：

{
  "shopping" 【索引名】: {
    "aliases"【别名】: { },
    "mappings"【映射】 : { },
    "settings"【设置】 : {
      "index"【设置 - 索引】 : {
        "routing" : {
          "allocation" : {
            "include" : {
              "_tier_preference" : "data_content"
            }
          }
        },
        "number_of_shards"【设置 - 索引 - 主分片数量】 : "1",
        "provided_name"【设置 - 索引 - 名称】 : "shopping",
        "creation_date"【设置 - 索引 - 创建时间】 : "1698489268437",
        "number_of_replicas"【设置 - 索引 - 副分片数量】 : "1",
        "uuid"【设置 - 索引 - 唯一标识】 : "8cNM6dGVTTm7fw9xsrOKGg",
        "version"【设置 - 索引 - 版本】 : {
          "created" : "7120199"
        }
      }
    }
  }
}

删除

语法：

请求方式：DELETE
请求路径：/索引库名
请求参数：无

格式：

DELETE /索引库名

示例：

DELETE /shopping

重新访问索引时，服务器返回响应：索引不存在。

DELETE /shopping

总结：索引库操作有哪些？

创建索引库：PUT /索引库名

查询索引库：GET /索引库名

删除索引库：DELETE /索引库名

文档操作

创建

索引已经创建好了，接下来我们来创建文档，并添加数据。这里的文档可以类比为关系型数据库中的表数据，添加的数据格式为 JSON 格式

语法：

POST /索引库名/_doc/文档id
{
    "字段1": "值1",
    "字段2": "值2",
    "字段3": {
        "子属性1": "值3",
        "子属性2": "值4"
    },
}

示例：

POST /shopping/_doc
{
    "title": "小米手机",
    "category": "小米",
    "name": {
        "firstName": "云",
        "lastName": "赵"
    }
}

此处发送请求的方式必须为 POST，不能是 PUT，否则会发生错误。

服务器响应结果如下：

{
  "_index"【索引】 : "shopping",
  "_type"【类型-文档】 : "_doc",
  "_id"【唯一标识】 : "8OYHdosBftkcidS1CPym",	#可以类比为 MySQL 中的主键，随机生成
  "_version"【版本】 : 1,
  "result"【结果】 : "created",	#这里的 create 表示创建成功
  "_shards"【分片】 : {
    "total"【分片 - 总数】 : 2,
    "successful"【分片 - 成功】 : 1,
    "failed"【分片 - 失败】 : 0
  },
  "_seq_no" : 0,
  "_primary_term" : 1
}

上面的数据创建后，由于没有指定数据唯一性标识（ID），默认情况下，ES 服务器会随机生成一个。

如果想要自定义唯一性标识，需要在创建时指定。

POST /shopping/_doc/1
{
    "title": "华为手机",
    "category": "华为",
    "name": {
        "firstName": "蝉",
        "lastName": "貂"
    }
}

此处需要注意：如果增加数据时明确数据主键，那么请求方式也可以为 PUT。即使用 PUT 的方式创建文档需要指定文档的 ID

PUT books/_create/2
{
  "book_id": "4ee82463",
  "name": "时间简史",
  "author": "史蒂芬霍金",
  "intro": "探索时间和空间核心秘密的引人入胜的故事。"
}

# PUT 方式返回的结果
{
  "_index" : "books",
  "_type" : "_doc",
  "_id" : "2",
  "_version" : 1
  ......
}

查询

查看文档时，需要指明文档的唯一性标识，类似于 MySQL 中数据的主键查询。

根据rest风格，新增是post，查询应该是get，不过查询一般都需要条件，这里我们把文档id带上。

语法：

GET /{索引库名称}/_doc/{id}

示例：

GET /shopping/_doc/1

查询成功后，服务器响应结果：

{
  "_index"【索引】 : "shopping",
  "_type"【文档类型】 : "_doc",
  "_id" : "1",
  "_version" : 1,
  "_seq_no" : 1,
  "_primary_term" : 1,
  "found"【查询结果】 : true,		# true 表示查找到，false 表示未查找到
  "_source"【文档源信息】 : {
    "title" : "华为手机",
    "category" : "华为",
    "name" : {
      "firstName" : "蝉",
      "lastName" : "貂"
    }
  }
}

修改

修改有两种方式：

全量修改：直接覆盖原来的文档
局部修改：修改文档中的部分字段

1.全量修改

全量修改是覆盖原来的文档，其本质是两步操作：

根据指定的id删除文档
新增一个相同id的文档

注意：如果根据id删除时，id不存在，第二步的新增也会执行，也就从修改变成了新增操作了。

语法：

PUT /{索引库名}/_doc/文档id
{
    "字段1": "值1",
    "字段2": "值2",
    // ... 略
}

示例：

PUT /shopping/_doc/1
{
    "title": "华为手机",
    "category": "华为",
    "name": {
        "firstName": "蝉",
        "lastName": "貂"
    }
}

修改成功后，服务器响应结果：

由于id为1的文档已经被删除，所以第一次执行时，得到的反馈是created：

所以如果执行第2次时，得到的反馈则是updated：

{
  "_index" : "shopping",
  "_type" : "_doc",
  "_id" : "1",
  "_version"【版本】 : 2,
  "result"【结果】 : "updated",		# updated 表示数据被更新
  "_shards" : {
    "total" : 2,
    "successful" : 1,
    "failed" : 0
  },
  "_seq_no" : 2,
  "_primary_term" : 1
}

2.局部修改

局部修改是只修改指定id匹配的文档中的部分字段。

语法：

POST /{索引库名}/_update/文档id
{
    "doc": {
         "字段名": "新的值",
    }
}

示例：

POST /shopping/_update/1
{
  "doc":{
    "name":{
      "firstName": "蝉1",
      "lastName": "貂2"
    }
  }
}

修改成功后，服务器响应结果：

根据唯一性标识，查询文档数据，文档数据已经更新。

GET /shopping/_doc/1

删除

删除一个文档不会立即从磁盘上移除，它只是被标记成已删除（逻辑删除）。

删除使用DELETE请求，同样，需要根据id进行删除：

语法：

DELETE /{索引库名}/_doc/id值

示例：

DELETE /shopping/_doc/1

删除成功，服务器响应结果：

{
  "_index" : "shopping",
  "_type" : "_doc",
  "_id" : "1",
  "_version"【版本】 : 4,	#对数据的操作，都会更新版本
  "result"【结果】 : "deleted",	# deleted 表示数据被标记为删除
  "_shards" : {
    "total" : 2,
    "successful" : 1,
    "failed" : 0
  },
  "_seq_no" : 3,
  "_primary_term" : 1
}

删除后再查询当前文档信息

GET /shopping/_doc/1

如果删除一个并不存在的文档

DELETE /shopping/_doc/1

{
  "_index" : "shopping",
  "_type" : "_doc",
  "_id" : "1",
  "_version" : 1,
  "result" :【结果】 "not_found",	# not_found 表示未查找到
  "_shards" : {
    "total" : 2,
    "successful" : 1,
    "failed" : 0
  },
  "_seq_no" : 4,
  "_primary_term" : 1
}

条件删除

一般删除数据都是根据文档的唯一性标识进行删除，实际操作时，也可以根据条件对多条数据进行删除。

首先分别增加多条数据:

POST /shopping/_doc/1
{
"title":"小米手机",
"category":"小米",
"images":"http://www.gulixueyuan.com/xm.jpg",
"price":4000.00
}

POST /shopping/_doc/2
{
"title":"华为手机",
"category":"华为",
"images":"http://www.gulixueyuan.com/hw.jpg",
"price":4000.00
}

向 ES 服务器发 POST 请求

POST /shopping/_delete_by_query
{
  "query":{
    "match":{
      "price":4000.00
    }
  }
}

删除成功后，服务器响应结果：

{
  "took"【耗时】 : 8,
  "timed_out"【是否超时】 : false,
  "total"【总数】 : 2,
  "deleted"【删除数量】 : 2,
  "batches" : 1,
  "version_conflicts" : 0,
  "noops" : 0,
  "retries" : {
    "bulk" : 0,
    "search" : 0
  },
  "throttled_millis" : 0,
  "requests_per_second" : -1.0,
  "throttled_until_millis" : 0,
  "failures" : [ ]
}

批处理

当我们需要写入多个文档的时候，如果每写一个文档就发起一个请求的话，多少有点浪费。这个时候我们可以使用 Bulk API 来批量处理文档。

Bulk API 支持在一次调用中操作不同的索引，使用时可以在 Body 中指定索引也可以在 URI 中指定索引。而且还可以同时支持 4 中类型的操作：

Index
Create
Update
Delete

Bulk API 的格式是用换行符分隔 JSON 的结构，第一行指定操作类型和元数据（索引、文档id等），紧接着的一行是这个操作的内容（文档数据，如果有的话。像简单的删除就没有。），其格式如下：

POST _bulk
# 第一行指定操作类型和元数据（索引、文档id等）
 { "index" : { "_index" : "books", "_id" : "1" } } 
# 紧接着的一行是这个操作的内容（文档数据，如果有的话。像简单的删除就没有）
 { "book_id": "4ee82462","name": "深入Linux内核架构", ......}

POST _bulk
 { "index" : { "_index" : "test", "_id" : "1" } }
 { "field1" : "value1" }
 { "delete" : { "_index" : "test", "_id" : "2" } }
 { "create" : { "_index" : "test", "_id" : "3" } }
 { "field1" : "value3" }
 { "update" : {"_id" : "1", "_index" : "test"} }
 { "doc" : {"field2" : "value2"} }

其中：

index代表新增操作
- _index：指定索引库名
- _id指定要操作的文档id
- { "field1" : "value1" }：则是要新增的文档内容
delete代表删除操作
- _index：指定索引库名
- _id指定要操作的文档id
update代表更新操作
- _index：指定索引库名
- _id指定要操作的文档id
- { "doc" : {"field2" : "value2"} }：要更新的文档字段

下面示例是在 Bulk API 中同时使用多种操作类型的例子：

 POST _bulk
# 指定操作类型和元数据（索引、文档id等）
 { "index" : { "_index" : "books", "_id" : "1" } }
 { "book_id": "4ee82462","name": "深入Linux内核架构","author": "Wolfgang Mauerer","intro": "内容全面深入，领略linux内核的无限风光。" }
#  指定操作类型和元数据（索引、文档id等）
 { "delete" : { "_index" : "books", "_id" : "2" } }
 { "create" : { "_index" : "books", "_id" : "3" } }
 { "book_id": "4ee82464","name": "深入Linux内核架构第三版","author": "Wolfgang Mauerer","intro": "内容全面深入，再次领略linux内核的无限风光。" }
# 指定操作类型和元数据（索引、文档id等）
 { "update" : {"_index" : "books", "_id" : "4"} } # 指定操作类型、索引、文档 id
 { "doc" : {"intro" : "书本的内容非常好，值得一看"} } # 指定文档内容

文档操作有哪些？

创建文档：POST /{索引库名}/_doc/文档id { json文档 }

查询文档：GET /{索引库名}/_doc/文档id

删除文档：DELETE /{索引库名}/_doc/文档id

修改文档：

全量修改：PUT /{索引库名}/_doc/文档id { json文档 }

局部修改：POST /{索引库名}/_update/文档id { "doc": {字段}}

映射操作

有了索引库，等于有了数据库中的 database。

接下来就需要建索引库(index)中的映射了，类似于数据库(database)中的表结构(table)。创建数据库表需要设置字段名称，类型，长度，约束等；索引库也一样，需要知道这个类型下有哪些字段，每个字段有哪些约束信息，这就叫做映射(mapping)。

Index就类似数据库表，Mapping映射就类似表的结构。我们要向es中存储数据，必须先创建Index和Mapping

Mapping映射属性：

type：字段数据类型，常见的简单类型有：
- 字符串：text（可分词的文本）、keyword（精确值，例如：品牌、国家、ip地址）
- 数值：long、integer、short、byte、double、float、
- 布尔：boolean
- 日期：date
- 对象：object
index：是否创建索引，默认为true
analyzer：使用哪种分词器
properties：该字段的子字段

例如下面的json文档：

{
    "age": 21,
    "weight": 52.1,
    "isMarried": false,
    "info": "我是Java讲师",
    "email": "zy@itcast.cn",
    "score": [99.1, 99.5, 98.9],
    "name": {
        "firstName": "云",
        "lastName": "赵"
    }
}

对应的每个字段映射（Mapping）：

字段名	字段类型	类型说明	是否参与搜索	分词器
age	`integer`	整数		——
weight	`float`	浮点数		——
isMarried	`boolean`	布尔		——
info	`text`	字符串，但需要分词		IK
email	`keyword`	字符串，但是不分词		——
score	`float`	只看数组中元素类型		——
name	firstName	`keyword`	字符串，但是不分词		——
lastName	`keyword`	字符串，但是不分词		——

创建

语法：

PUT /索引库名称/_mapping
{
    "properties": {
      "字段名":{
        "type": "text",
        "analyzer": "ik_smart"
      },
      "字段名2":{
        "type": "keyword",
        "index": "false"
      },
      "字段名3":{
        "properties": {
          "子字段": {
            "type": "keyword"
          }
        }
      },
      // ...略
    }
}

向 ES 服务器发 PUT 请求

PUT /student/_mapping
{
  "properties":{
    "name":{
      "type": "text",
      "index": true
    },
    "sex":{
      "type": "text",
      "index": false
    },
    "age":{
      "type": "long",
      "index": false
    }
  }
}

服务器响应结果如下：

映射数据说明：

字段名：任意填写，下面指定许多属性，例如：title、subtitle、images、price
type：类型，Elasticsearch 中支持的数据类型非常丰富，说几个关键的：
- String 类型，又分两种：
  - text：可分词
  - keyword：不可分词，数据会作为完整字段进行匹配
- Numerical：数值类型，分两类
  - 基本数据类型：long、integer、short、byte、double、float、half_float
  - 浮点数的高精度类型：scaled_float
- Date：日期类型
- Array：数组类型
- Object：对象
index：是否索引，默认为 true，也就是说你不进行任何配置，所有字段都会被索引。
- true：字段会被索引，则可以用来进行搜索
- false：字段不会被索引，不能用来搜索
store：是否将数据进行独立存储，默认为 false

原始的文本会存储在_source 里面，默认情况下其他提取出来的字段都不是独立存储的，是从_source 里面提取出来的。当然你也可以独立的存储某个字段，只要设置 "store": true 即可，获取独立存储的字段要比从_source 中解析快得多，但是也会占用更多的空间，所以要根据实际业务需求来设置。

analyzer：分词器，这里的 ik_max_word 即使用 ik 分词器,后面会有专门的章节学习

查询

向 ES 服务器发 GET 请求

GET /student/_mapping

服务器响应结果如下：

索引映射关联

基本语法：

请求方式：PUT
请求路径：/索引库名，可以自定义
请求参数：mapping映射

格式：

PUT /索引库名称
{
	"settings": {},
  "mappings": {
    "properties": {
      "字段名":{
        "type": "text",
        "analyzer": "ik_smart"
      },
      "字段名2":{
        "type": "keyword",
        "index": "false"
      },
      "字段名3":{
        "properties": {
          "子字段": {
            "type": "keyword"
          }
        }
      },
      // ...略
    }
  }
}

示例：

PUT /student1
{
  "mappings": {
    "properties": {
      "info":{
        "type": "text",
        "analyzer": "ik_smart"
      },
      "email":{
        "type": "keyword",
        "index": "false"
      },
      "name":{
        "properties": {
          "firstName": {
            "type": "keyword"
          }
        }
      }
    }
  }
}

服务器响应结果如下：

DSL查询

DSL（Domain Specific Language）查询是 Elasticsearch 提供的一种用于构建复杂查询和聚合操作的查询语言。它使用了一种类似 JSON 的结构来描述查询条件、过滤条件、排序要求等。类似于 MySQL 的 SELECT 查询。

Elasticsearch 提供了基于 JSON 提供完整的查询 DSL 来定义查询。

这里列举一些常见的，例如：

全文检索查询（Full Text Queries）：利用分词器对用户输入搜索条件先分词，得到词条，然后再利用倒排索引搜索词条。例如：
- match：
- multi_match
精确查询（Term-level queries）：不对用户输入搜索条件分词，根据字段内容精确值匹配。但只能查找keyword、数值、日期、boolean类型的字段。例如：
- ids
- term
- range
地理坐标查询：用于搜索地理位置，搜索方式很多，例如：
- geo_bounding_box：按矩形搜索
- geo_distance：按点和半径搜索
...略

创建索引映射：

PUT /student
{
  "mappings": {
    "properties": {
      "name":{
        "type": "text"
        , "index": true
      },
       "nickname":{
        "type": "text"
        ,"index": true
      },
       "sex":{
        "type": "text"
        ,"index": true
      },
       "age":{
        "type": "long"
        ,"index": true
      }
    }
  }
}

定义数据：

POST /student/_doc/1001
{
  "name":"zhangsan",
  "nickname":"zhangsan",
  "sex":"男",
  "age":30
}

POST /student/_doc/1002
{
  "name":"lisi",
  "nickname":"lisi",
  "sex":"男",
  "age":20
}

POST /student/_doc/1003
{
  "name":"wangwu",
  "nickname":"wangwu",
  "sex":"女",
  "age":40
}

POST /student/_doc/1004
{
  "name":"zhangsan1",
  "nickname":"zhangsan1",
  "sex":"女",
  "age":50
}

POST /student/_doc/1005
{
  "name":"zhangsan2",
  "nickname":"zhangsan2",
  "sex":"女",
  "age":30
}

语法：

GET /{索引库名}/_search
{
  "query": {
    "查询类型": {
      // .. 查询条件
    }
  }
}

说明：

GET /{索引库名}/_search：其中的_search是固定路径，不能修改

全文检索查询

全文检索的种类也很多，详情可以参考官方文档：

www.elastic.co/guide/en/el…

常见的全文检索查询包括：

match查询：单字段查询
multi_match查询：多字段查询，任意一个字段符合条件就算符合查询条件

查询所有

无条件查询的类型是：match_all，因此其查询语句如下：

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

"query"：这里的 query 代表一个查询对象，里面可以有不同的查询属性。
"match_all"：查询类型，例如：match_all(代表查询所有)， match，term ， range 等等
{查询条件}：查询条件会根据类型的不同，写法也有差异

服务器响应结果如下：

{
  "took"【查询花费时间，单位毫秒】 : 0,
  "timed_out"【是否超时】 : false,
  "_shards"【分片信息】 : {
    "total"【总数】 : 1,
    "successful"【成功】 : 1,
    "skipped"【忽略】 : 0,
    "failed"【失败】 : 0
  },
  "hits"【搜索命中结果】 : {
    "total"【搜索条件匹配的文档总数】 : {
      "value"【总命中计数的值】: 5,
      "relation"【计数规则】 : "eq"	# eq 表示计数准确， gte 表示计数不准确
    },
    "max_score"【匹配度分值】 : 1.0,
    "hits"【命中结果集合】 : [
     {
        "_index" : "student",
        "_type" : "_doc",
        "_id" : "1001",
        "_score" : 1.0,
        "_source" : {
          "name" : "zhangsan",
          "nickname" : "zhangsan",
          "sex" : "男",
          "age" : 30
        }
      },
      {
        "_index" : "student",
        "_type" : "_doc",
        "_id" : "1002",
        "_score" : 1.0,
        "_source" : {
          "name" : "lisi",
          "nickname" : "lisi",
          "sex" : "男",
          "age" : 20
        }
      },
      {
        "_index" : "student",
        "_type" : "_doc",
        "_id" : "1003",
        "_score" : 1.0,
        "_source" : {
          "name" : "wangwu",
          "nickname" : "wangwu",
          "sex" : "女",
          "age" : 40
        }
      },
      {
        "_index" : "student",
        "_type" : "_doc",
        "_id" : "1004",
        "_score" : 1.0,
        "_source" : {
          "name" : "zhangsan1",
          "nickname" : "zhangsan1",
          "sex" : "女",
          "age" : 50
        }
      },
      {
        "_index" : "student",
        "_type" : "_doc",
        "_id" : "1005",
        "_score" : 1.0,
        "_source" : {
          "name" : "zhangsan2",
          "nickname" : "zhangsan2",
          "sex" : "女",
          "age" : 30
        }
      }
    ]
  }
}

你会发现虽然是match_all，但是响应结果中并不会包含索引库中的所有文档，而是仅有10条。这是因为处于安全考虑，elasticsearch设置了默认的查询页数。

匹配查询

match 匹配类型查询，会把查询条件进行分词，然后进行查询，多个词条之间是 or 的关系

以全文检索中的match为例，语法如下：

GET /{索引库名}/_search
{
  "query": {
    "match": {
      "字段名": "搜索条件"
    }
  }
}

示例：

GET /student/_search
{
  "query": {
    "match": {
      "name":"zhangsan"
    }
  }
}

服务器响应结果为：

字段匹配查询

与match类似的还有multi_match，区别在于可以同时对多个字段搜索，而且多个字段都要满足，语法示例：

GET /{索引库名}/_search
{
  "query": {
    "multi_match": {
      "query": "搜索条件",
      "fields": ["字段1", "字段2"]
    }
  }
}

示例：

GET /student/_search
{
  "query": {
    "multi_match": {
      "query": "zhangsan",
      "fields": ["name","nickname"]
    }
  }
}

服务器响应结果：

精确查询

精确查询，英文是Term-level query，顾名思义，词条级别的查询。也就是说不会对用户输入的搜索条件再分词，而是作为一个词条，与搜索的字段内容精确值匹配。因此推荐查找keyword、数值、日期、boolean类型的字段。例如：id、price、城市、地名、人名等等，作为一个整体才有含义的字段。常见的有：

term：根据词条精确值查询
range：根据值的范围查询

term查询

因为精确查询的字段搜是不分词的字段，因此查询的条件也必须是不分词的词条。查询时，用户输入的内容跟自动值完全匹配时才认为符合条件。如果用户输入的内容过多，反而搜索不到数据。

在ES的Mapping Type 中 keyword , date ,integer, long , double , boolean or ip 这些类型不分词，只有text类型分词。

语法：

GET /{索引库名}/_search
{
  "query": {
    "term": {
      "字段名": {
        "value": "搜索条件"
      }
    }
  }
}

示例：

GET /student/_search
{
  "query": {
    "term": {
      "name": {
        "value": "zhangsan"
      }
    }
  }
}

服务器响应结果：

当你输入的搜索条件不是词条，而是短语时，由于不做分词，你反而搜索不到：

terms查询

terms 查询和 term 查询一样，但它允许你指定多值进行匹配。

如果这个字段包含了指定值中的任何一个值，那么这个文档满足条件，类似于 mysql 的 in。

语法：

POST /{索引库名}/_search
{
  "query": {
    "terms": {
      "字段名": [ # 数组，可以指定多个对应的值
        "搜索条件1",
        "搜索条件2"
      ]
    }
  }
}

示例：

POST /student/_search
{
  "query": {
    "terms": {
    "name": ["zhangsan","lisi"]
    }
  }
}

服务器响应结果：

range查询

range 查询找出那些落在指定区间内的数字或者时间。range 查询允许以下字符

操作符	说明
gt	大于>
gte	大于等于>=
lt	小于<
lte	小于等于<=

范围查询，一般应用在对数值类型做范围过滤的时候。比如做价格范围过滤。

再来看下range查询，语法如下：

GET /{索引库名}/_search
{
  "query": {
    "range": {
      "字段名": {
        "gte": {最小值},
        "lte": {最大值}
      }
    }
  }
}

示例：

GET /student/_search
{
  "query": {
    "range": {
      "age": {
        "gte": 30,
        "lte": 35
      }
    }
  }
}

服务器响应结果：

指定查询字段

默认情况下，Elasticsearch 在搜索的结果中，会把文档中保存在_source 的所有字段都返回。如果我们只想获取其中的部分字段，我们可以添加_source 的过滤。

语法：

POST /student/_search
{
  "_source": "{字段名}",
   "query": {
    "terms": {
      "字段名": [
        "值1",
        "值2"
      ]
    }
  }
}

示例：

POST /student/_search
{
  "_source": ["name","nickname"],
  "query": {
    "terms": {
      "nickname": ["zhangsan"]
    }
  }
}

服务器响应结果：

过滤字段

我们也可以通过：

includes：来指定想要显示的字段
excludes：来指定不想要显示的字段

语法：

POST /student/_search
{
  "_source": {
  "includes": ["name","nickname"]
  },
   "query": {
    "terms": {
      "字段名": [
        "值1",
        "值2"
      ]
    }
  }
}

示例：includes

POST /student/_search
{
  "_source": {
    "includes": ["name","nickname"]
  },
  "query": {
    "terms": {
      "nickname": ["zhangsan"]
    }
  }
}

服务器响应结果：

**示例：**excludes

POST /student/_search
{
  "_source": {
    "excludes": ["name","nickname"]
  },
  "query": {
    "terms": {
      "nickname": ["zhangsan"]
    }
  }
}

服务器响应结果：

地理坐标查询

所谓的地理坐标查询，其实就是根据经纬度查询，官方文档：www.elastic.co/guide/en/el…

常见的使用场景包括：

携程：搜索我附近的酒店
滴滴：搜索我附近的出租车
微信：搜索我附近的人

矩形范围查询

矩形范围查询，也就是geo_bounding_box查询，查询坐标落在某个矩形范围的所有文档：

查询时，需要指定矩形的左上、右下两个点的坐标，然后画出一个矩形，落在该矩形内的都是符合条件的点。

语法如下：

GET /indexName/_search
{
  "query": {
    "geo_bounding_box": {
      "FIELD": {
        "top_left": { // 左上点
          "lat": 31.1,
          "lon": 121.5
        },
        "bottom_right": { // 右下点
          "lat": 30.9,
          "lon": 121.7
        }
      }
    }
  }
}

这种并不符合“附近的人”这样的需求，所以我们就不做了。

附近查询

附近查询，也叫做距离查询（geo_distance）：查询到指定中心点小于某个距离值的所有文档。

换句话来说，在地图上找一个点作为圆心，以指定距离为半径，画一个圆，落在圆内的坐标都算符合条件：

语法说明：

GET /indexName/_search
{
  "query": {
    "geo_distance": {
      "distance": "15km", // 半径
      "FIELD": "31.21,121.5" // 圆心
    }
  }
}

示例：

我们先搜索陆家嘴附近15km的酒店：

发现共有47家酒店。

然后把半径缩短到3公里：

可以发现，搜索到的酒店数量减少到了5家。

复合查询

复合查询大致可以分为两类：

第一类：基于逻辑运算组合叶子查询，实现组合条件，例如
- bool
第二类：基于某种算法修改查询时的文档相关性算分，从而改变文档排名。例如：
- function_score
- dis_max

算分函数查询

当我们利用match查询时，文档结果会根据与搜索词条的关联度打分（_score），返回结果时按照分值降序排列。

例如，我们搜索 "手机"，结果如下：

从elasticsearch5.1开始，采用的相关性打分算法是BM25算法，公式如下：

基于这套公式，就可以判断出某个文档与用户搜索的关键字之间的关联度，还是比较准确的。但是，在实际业务需求中，常常会有竞价排名的功能。不是相关度越高排名越靠前，而是掏的钱多的排名靠前。

例如在百度中搜索Java培训，排名靠前的就是广告推广：

要想认为控制相关性算分，就需要利用elasticsearch中的function score 查询了。

基本语法：

function score 查询中包含四部分内容：

原始查询条件：query部分，基于这个条件搜索文档，并且基于BM25算法给文档打分，原始算分（query score)
过滤条件：filter部分，符合该条件的文档才会重新算分
算分函数：符合filter条件的文档要根据这个函数做运算，得到的函数算分（function score），有四种函数
- weight：函数结果是常量
- field_value_factor：以文档中的某个字段值作为函数结果
- random_score：以随机数作为函数结果
- script_score：自定义算分函数算法
运算模式：算分函数的结果、原始查询的相关性算分，两者之间的运算方式，包括：
- multiply：相乘
- replace：用function score替换query score
- 其它，例如：sum、avg、max、min

function score的运行流程如下：

1）根据原始条件查询搜索文档，并且计算相关性算分，称为原始算分（query score）
2）根据过滤条件，过滤文档
3）符合过滤条件的文档，基于算分函数运算，得到函数算分（function score）
4）将原始算分（query score）和函数算分（function score）基于运算模式做运算，得到最终结果，作为相关性算分。

因此，其中的关键点是：

过滤条件：决定哪些文档的算分被修改
算分函数：决定函数算分的算法
运算模式：决定最终算分结果

示例：给IPhone这个品牌的手机算分提高十倍，分析如下：

过滤条件：品牌必须为IPhone
算分函数：常量weight，值为10
算分模式：相乘multiply

对应代码如下：

GET /hotel/_search
{
  "query": {
    "function_score": {
      "query": {  .... }, // 原始查询，可以是任意条件
      "functions": [ // 算分函数
        {
          "filter": { // 满足的条件，品牌必须是Iphone
            "term": {
              "brand": "Iphone"
            }
          },
          "weight": 10 // 算分权重为2
        }
      ],
      "boost_mode": "multipy" // 加权模式，求乘积
    }
  }
}

bool查询

bool查询，即布尔查询。就是利用逻辑运算来组合一个或多个查询子句的组合。bool查询支持的逻辑运算有：

must：必须匹配每个子查询，类似“与”
should：选择性匹配子查询，类似“或”
must_not：必须不匹配，不参与算分，类似“非”
filter：必须匹配，不参与算分

bool查询的语法如下：

GET /items/_search
{
  "query": {
    "bool": {
      "must": [
        {"match": {"name": "手机"}}
      ],
      "should": [
        {"term": {"brand": { "value": "vivo" }}},
        {"term": {"brand": { "value": "小米" }}}
      ],
      "must_not": [
        {"range": {"price": {"gte": 2500}}}
      ],
      "filter": [
        {"range": {"price": {"lte": 1000}}}
      ]
    }
  }
}

示例

GET /student/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "name": "zhangsan"
          }
        }
      ],
      "must_not": [
        {
         "match": {
           "age": "40"
         }
        }
      ],
      "should": [
        {
          "match": {
            "sex": "男"
          }
        }
      ]
    }
  }
}

服务器响应结果：

模糊查询

用来模糊查询含有指定关键字的文档。

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

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

为了找到相似的术语，fuzzy 查询会在指定的编辑距离内创建一组搜索词的所有可能的变体或扩展。然后查询返回每个扩展的完全匹配。

通过 fuzziness 修改编辑距离。一般使用默认值 AUTO，根据术语的长度生成编辑距离。

Fuzziness参数可以配置为以下值：

0、1、2：允许对术语进行的编辑量。
AUTO：根据输入项的大小，定义编辑次数。

注意: fuzzy 模糊查询最大模糊错误必须在0-2之间

搜索关键词长度为 2 不允许存在模糊
搜索关键词长度为3-5 允许一次模糊
搜索关键词长度大于5 允许最大2模糊

语法：

GET /{索引库名}/_search
{
  "query": {
    "fuzzy": {
      "字段名": {
        "value": "值",
        "fuzziness": "编辑次数"
      }
    }
  }
}

示例：

我们首先输入如下的一个文档到 book 索引中：

PUT /book/_doc/1
{
  "text": "I tore to the book page"
}

Fuzines：0

等于 0 的编辑次数仅允许完全匹配。在下面的示例中，只有完全匹配会返回结果，如果术语是 “bok”，则不会返回任何结果。

GET /book/_search
{
  "query": {
    "fuzzy": {
      "text": {
        "value": "book",	book->book
        "fuzziness": "0"
      }
    }
  }
}

服务器响应结果：

GET /book/_search
{
  "query": {
    "fuzzy": {
      "text": {
        "value": "bok",		#bok->①book
        "fuzziness": "0"
      }
    }
  }
}

服务器响应结果：

Fuziness：1

当我们只允许 1 个编辑时，我们将在术语为 “bok”（bok->book）时获得文档。如果术语是 “bak”，查询将不会返回文档，因为最小编辑数将为 2。

GET /book/_search
{
  "query": {
    "fuzzy": {
      "text": {
        "value": "bok",  #bok->①book
        "fuzziness": "1"
      }
    }
  }
}

服务器响应结果：

GET /book/_search
{
  "query": {
    "fuzzy": {
      "text": {
        "value": "bak",  #bak->①bok->②book
        "fuzziness": "1"
      }
    }
  }
}

服务器响应结果：

Fuziness：2

允许两次编辑，我们将能够在术语 “bak”（bak -> book）时获得文档。

GET /book/_search
{
  "query": {
    "fuzzy": {
      "text": {
        "value": "bak",
        "fuzziness": "2"
      }
    }
  }
}

服务器响应结果：

Fuzziness：AUTO

首先先创建索引数据：

PUT /idx_fuzzy

POST /idx_fuzzy/_doc
{
  "text": "The city is more beautiful in summer"
}

AUTO 设置允许你调整编辑和术语大小之间的关系。默认情况下，该设置为 "AUTO:3,6"，也就是说，大小为 6 的术语最多允许 1 个编辑。

在下面的第一个示例中，我们将配置 "AUTO:4,6"，即具有最小 4 和最大 6 大小的术语长度。我们将只能获得 1 个编辑。

GET /idx_fuzzy/_search
{
  "query": {
    "fuzzy": {
      "text": {
        "value": "sumer",
        "fuzziness": "AUTO:4,6"
      }
    }
  }
}

服务器响应结果：

GET /idx_fuzzy/_search
{
  "query": {
    "fuzzy": {
      "text": {
        "value": "suer",  
        "fuzziness": "AUTO:4,6"  
      }
    }
  }
}

服务器响应结果：

解释说明： 因为sumer的长度是5，介于4-6之间，所以能编辑1次。而suer的长度是小于等于4，所以必须完全匹配。

根据术语的长度生成编辑距离。可以选择提供低距离和高距离参数 AUTO:[low],[high]。如果未指定，则默认值为 3 和 6，相当于 AUTO:3,6 的长度：

值长度	编辑次数
0-2	必须完全匹配
3-5	允许一次编辑
>5	允许两次编辑

在上面，我们设置 AUTO 为 4,6，也就是说长度在 0-3，必须完全匹配，在 4-5 之间的，允许一次编辑，长度大于 5 的，允许两次编辑。上面的 sumer 长度为 5，它可以允许有一次编辑。下面的搜索也将会是成功的：

GET /idx_fuzzy/_search
{
  "query": {
    "fuzzy": {
      "text": {
        "value": "summem",
        "fuzziness": "AUTO:4,6"
      }
    }
  }
}

它需要两次的编辑，因为 summem 的长度为 6。

如果把上面的配置修改为AUTO: 6,7，那么如下的搜索：

GET /idx_fuzzy/_search
{
  "query": {
    "match": {
      "text": {
        "query": "sumer",
        "fuzziness": "AUTO:6,7"
      }
    }
  }
}

将不会得到任何的结果，因为 sumer 的长度为 5。对于小于 5 的长度而言，必须完全匹配。

排序

elasticsearch默认是根据相关度算分（_score）来排序，但是也支持自定义方式对搜索结果排序。不过分词字段无法排序，能参与排序字段类型有：keyword类型、数值类型、地理坐标类型、日期类型等。

单字段排序

sort 可以让我们按照不同的字段进行排序，并且通过 order 指定排序的方式。desc 降序，asc 升序 。

语法：

GET /索引名/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "排序字段": {
        "order": "排序方式asc和desc"
      }
    }
  ]
}

示例：

GET /student/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "age": {
        "order": "desc"
      }
    }
  ]
}

服务器响应结果：

{
  "took" : 0,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 5,
      "relation" : "eq"
    },
    "max_score" : null,
    "hits" : [
      {
        "_index" : "student",
        "_type" : "_doc",
        "_id" : "1004",
        "_score" : null,
        "_source" : {
          "name" : "zhangsan1",
          "nickname" : "zhangsan1",
          "sex" : "女",
          "age" : 50
        },
        "sort" : [
          50
        ]
      },
      {
        "_index" : "student",
        "_type" : "_doc",
        "_id" : "1003",
        "_score" : null,
        "_source" : {
          "name" : "wangwu",
          "nickname" : "wangwu",
          "sex" : "女",
          "age" : 40
        },
        "sort" : [
          40
        ]
      },
      {
        "_index" : "student",
        "_type" : "_doc",
        "_id" : "1001",
        "_score" : null,
        "_source" : {
          "name" : "zhangsan",
          "nickname" : "zhangsan",
          "sex" : "男",
          "age" : 30
        },
        "sort" : [
          30
        ]
      },
      {
        "_index" : "student",
        "_type" : "_doc",
        "_id" : "1005",
        "_score" : null,
        "_source" : {
          "name" : "zhangsan2",
          "nickname" : "zhangsan2",
          "sex" : "女",
          "age" : 30
        },
        "sort" : [
          30
        ]
      },
      {
        "_index" : "student",
        "_type" : "_doc",
        "_id" : "1002",
        "_score" : null,
        "_source" : {
          "name" : "lisi",
          "nickname" : "lisi",
          "sex" : "男",
          "age" : 20
        },
        "sort" : [
          20
        ]
      }
    ]
  }
}

多字段排序

假定我们想要结合使用 age 和 _score 进行查询，并且匹配的结果首先按照年龄排序，然后按照相关性得分排序

GET /student/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "age": {
        "order": "desc"
      }
    },
    {
    "_score":{
      "order": "desc"
      }
    }
  ]
}

服务器响应结果：

{
  "took" : 0,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 5,
      "relation" : "eq"
    },
    "max_score" : null,
    "hits" : [
      {
        "_index" : "student",
        "_type" : "_doc",
        "_id" : "1004",
        "_score" : 1.0,
        "_source" : {
          "name" : "zhangsan1",
          "nickname" : "zhangsan1",
          "sex" : "女",
          "age" : 50
        },
        "sort" : [
          50,
          1.0
        ]
      },
      {
        "_index" : "student",
        "_type" : "_doc",
        "_id" : "1003",
        "_score" : 1.0,
        "_source" : {
          "name" : "wangwu",
          "nickname" : "wangwu",
          "sex" : "女",
          "age" : 40
        },
        "sort" : [
          40,
          1.0
        ]
      },
      {
        "_index" : "student",
        "_type" : "_doc",
        "_id" : "1001",
        "_score" : 1.0,
        "_source" : {
          "name" : "zhangsan",
          "nickname" : "zhangsan",
          "sex" : "男",
          "age" : 30
        },
        "sort" : [
          30,
          1.0
        ]
      },
      {
        "_index" : "student",
        "_type" : "_doc",
        "_id" : "1005",
        "_score" : 1.0,
        "_source" : {
          "name" : "zhangsan2",
          "nickname" : "zhangsan2",
          "sex" : "女",
          "age" : 30
        },
        "sort" : [
          30,
          1.0
        ]
      },
      {
        "_index" : "student",
        "_type" : "_doc",
        "_id" : "1002",
        "_score" : 1.0,
        "_source" : {
          "name" : "lisi",
          "nickname" : "lisi",
          "sex" : "男",
          "age" : 20
        },
        "sort" : [
          20,
          1.0
        ]
      }
    ]
  }
}

地理坐标排序

地理坐标排序略有不同。

语法说明：

GET /indexName/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "_geo_distance" : {
          "FIELD" : "纬度，经度", // 文档中geo_point类型的字段名、目标坐标点
          "order" : "asc", // 排序方式
          "unit" : "km" // 排序的距离单位
      }
    }
  ]
}

这个查询的含义是：

指定一个坐标，作为目标点
计算每一个文档中，指定字段（必须是geo_point类型）的坐标到目标点的距离是多少
根据距离排序

示例：

需求描述：实现对酒店数据按照到你的位置坐标的距离升序排序

提示：获取你的位置的经纬度的方式：lbs.amap.com/demo/jsapi-…

假设我的位置是：31.034661，121.612282，寻找我周围距离最近的酒店。

高亮查询

原理

在进行关键字搜索时，搜索出的内容中的关键字会显示不同的颜色，称之为高亮。

在百度搜索"京东"

Elasticsearch 可以对查询内容中的关键字部分，进行标签和样式(高亮)的设置。

在使用 match 查询的同时，加上一个 highlight 属性：

pre_tags：前置标签
post_tags：后置标签
fields：需要高亮的字段
title：这里声明 title 字段需要高亮，后面可以为这个字段设置特有配置，也可以空

观察页面源码，你会发现两件事情：

高亮词条都被加了<em>标签
<em>标签都添加了红色样式

css样式肯定是前端实现页面的时候写好的，但是前端编写页面的时候是不知道页面要展示什么数据的，不可能给数据加标签。而服务端实现搜索功能，要是有elasticsearch做分词搜索，是知道哪些词条需要高亮的。

因此词条的高亮标签肯定是由服务端提供数据的时候已经加上的。

因此实现高亮的思路就是：

用户输入搜索关键字搜索数据
服务端根据搜索关键字到elasticsearch搜索，并给搜索结果中的关键字词条添加html标签
前端提前给约定好的html标签添加CSS样式

实现

事实上elasticsearch已经提供了给搜索关键字加标签的语法，无需我们自己编码。

基本语法如下：

GET /{索引库名}/_search
{
  "query": {
    "match": {
      "搜索字段": "搜索关键字"
    }
  },
  "highlight": {
    "fields": {
      "高亮字段名称": {
        "pre_tags": "<em>",
        "post_tags": "</em>"
      }
    }
  }
}

注意：

搜索必须有查询条件，而且是全文检索类型的查询条件，例如match

参与高亮的字段必须是text类型的字段

默认情况下参与高亮的字段要与搜索字段一致，除非添加：required_field_match=false

示例：

GET /student/_search
{
  "query": {
    "match": {
      "name": "zhangsan"
    }
  },
  "highlight": {
    "pre_tags": "<em>",
    "post_tags": "</em>"
  }
}

服务器响应结果：

分页查询

elasticsearch 默认情况下只返回top10的数据。而如果要查询更多数据就需要修改分页参数了。

基础分页

elasticsearch中通过修改from、size参数来控制要返回的分页结果：

from：当前页的起始索引，默认从 0 开始。 from = (pageNum - 1) * size
size：每页显示多少条

类似于mysql中的limit ?, ?

语法如下：

GET /items/_search
{
  "query": {
    "match_all": {}
  },
  "from": 0, // 分页开始的位置，默认为0
  "size": 10,  // 每页文档数量，默认10
  "sort": [
    {
      "price": {
        "order": "desc"
      }
    }
  ]
}

示例：

GET /student/_search
{
  "query": {
    "match_all": {}
  },
  "from": 0, 
  "size": 2,  
  "sort": [
    {
      "age": {
        "order": "desc"
      }
    }
  ]
}

服务器响应结果：

深度分页

elasticsearch的数据一般会采用分片存储，也就是把一个索引中的数据分成N份，存储到不同节点上。这种存储方式比较有利于数据扩展，但给分页带来了一些麻烦。

比如一个索引库中有100000条数据，分别存储到4个分片，每个分片25000条数据。现在每页查询10条，查询第99页。那么分页查询的条件如下：

GET /items/_search
{
  "from": 990, // 从第990条开始查询
  "size": 10, // 每页查询10条
  "sort": [
    {
      "price": "asc"
    }
  ]
}

从语句来分析，要查询第990~1000名的数据。

从实现思路来分析，肯定是将所有数据排序，找出前1000名，截取其中的990~1000的部分。但问题来了，我们如何才能找到所有数据中的前1000名呢？

要知道每一片的数据都不一样，第1片上的第900~~1000，在另1个节点上并不一定依然是900~~1000名。所以我们只能在每一个分片上都找出排名前1000的数据，然后汇总到一起，重新排序，才能找出整个索引库中真正的前1000名，此时截取990~1000的数据即可。

如图：

试想一下，假如我们现在要查询的是第999页数据呢，是不是要找第9990~10000的数据，那岂不是需要把每个分片中的前10000名数据都查询出来，汇总在一起，在内存中排序？如果查询的分页深度更深呢，需要一次检索的数据岂不是更多？

由此可知，当查询分页深度较大时，汇总数据过多，对内存和CPU会产生非常大的压力。

因此elasticsearch会禁止from+ size 超过10000的请求。

针对深度分页，elasticsearch提供了两种解决方案：

search after：分页时需要排序，原理是从上一次的排序值开始，查询下一页数据。官方推荐使用的方式。
scroll：原理将排序后的文档id形成快照，保存下来，基于快照做分页。官方已经不推荐使用。

总结：

大多数情况下，我们采用普通分页就可以了。查看百度、京东等网站，会发现其分页都有限制。例如百度最多支持77页，每页不足20条。京东最多100页，每页最多60条。

因此，一般我们采用限制分页深度的方式即可，无需实现深度分页。

数据聚合

聚合（aggregations）可以让我们极其方便的实现对数据的统计、分析、运算。例如：

什么品牌的手机最受欢迎？
这些手机的平均价格、最高价格、最低价格？
这些手机每月的销售情况如何？

实现这些统计功能的比数据库的sql要方便的多，而且查询速度非常快，可以实现近实时搜索效果。

聚合常见的有三类：

桶（Bucket） 聚合：用来对文档做分组
- TermAggregation：按照文档字段值分组，例如按照品牌值分组、按照国家分组
- Date Histogram：按照日期阶梯分组，例如一周为一组，或者一月为一组
度量（Metric） 聚合：用以计算一些值，比如：最大值、最小值、平均值等
- Avg：求平均值
- Max：求最大值
- Min：求最小值
- Stats：同时求max、min、avg、sum等
管道（pipeline） 聚合：其它聚合的结果为基础做聚合

注意： 参加聚合的字段必须是keyword、日期、数值、布尔类型

桶聚合查询

桶聚和相当于 sql 中的 group by 语句

terms 聚合，分组统计，其实就是以分类（category）字段对数据分组。category值一样的放在同一组，属于Bucket聚合中的Term聚合。

基本语法如下：

GET /索引名/_search
{
  "size": 0, 
  "aggs": {
    "category_agg": {
      "terms": {
        "field": "category",
        "size": 20
      }
    }
  }
}

语法说明：

size：设置size为0，就是每页查0条，则结果中就不包含文档，只包含聚合
aggs：定义聚合
- category_agg：聚合名称，自定义，但不能重复
  - terms：聚合的类型，按分类聚合，所以用term
    - field：参与聚合的字段名称
    - size：希望返回的聚合结果的最大数量

示例：

GET /student/_search
{
  "size": 0, 
  "aggs": {
    "age_groupby": {
      "terms": {
        "field": "age"
      }
    }
  }
}

服务器响应结果：

条件聚合

默认情况下，Bucket聚合是对索引库的所有文档做聚合，例如我们统计商品中所有的品牌，结果如下：

可以看到统计出的品牌非常多。

但真实场景下，用户会输入搜索条件，因此聚合必须是对搜索结果聚合。那么聚合必须添加限定条件。

例如，我想知道价格高于3000元的手机品牌有哪些，该怎么统计呢？

我们需要从需求中分析出搜索查询的条件和聚合的目标：

搜索查询条件：
- 价格高于3000
- 必须是手机
聚合目标：统计的是品牌，肯定是对brand字段做term聚合

语法如下：

GET /items/_search
{
  "query": {
    "bool": {
      "filter": [
        {
          "term": {
            "category": "手机"
          }
        },
        {
          "range": {
            "price": {
              "gte": 300000
            }
          }
        }
      ]
    }
  }, 
  "size": 0, 
  "aggs": {
    "brand_agg": {
      "terms": {
        "field": "brand",
        "size": 20
      }
    }
  }
}

聚合结果如下：

{
  "took" : 2,
  "timed_out" : false,
  "hits" : {
    "total" : {
      "value" : 13,
      "relation" : "eq"
    },
    "max_score" : null,
    "hits" : [ ]
  },
  "aggregations" : {
    "brand_agg" : {
      "doc_count_error_upper_bound" : 0,
      "sum_other_doc_count" : 0,
      "buckets" : [
        {
          "key" : "华为",
          "doc_count" : 7
        },
        {
          "key" : "Apple",
          "doc_count" : 5
        },
        {
          "key" : "小米",
          "doc_count" : 1
        }
      ]
    }
  }
}

可以看到，结果中只剩下3个品牌了。

Metric聚合

stats 聚合，对某个字段一次性返回 count，max，min，avg 和 sum 五个指标

语法如下：

GET /student/_search
{
  "size": 0, 
  "aggs": {
    "stats_age": {
      "stats": {
        "field": "age"
      }
    }
  }
}

服务器响应结果：

对某个字段取最大值 max

GET /student/_search
{
  "size": 0, 
  "aggs": {
    "max_age": {
      "max": {
        "field": "age"
      }
    }
  }
}

服务器响应结果：

对某个字段取最小值 min

GET /student/_search
{
  "size": 0, 
  "aggs": {
    "max_age": {
      "min": {
        "field": "age"
      }
    }
  }
}

服务器响应结果：

对某个字段求和 sum

GET /student/_search
{
  "size": 0, 
  "aggs": {
    "max_age": {
      "sum": {
        "field": "age"
      }
    }
  }
}

服务器响应结果：

对某个字段取平均值 avg

GET /student/_search
{
  "size": 0, 
  "aggs": {
    "max_age": {
      "avg": {
        "field": "age"
      }
    }
  }
}

服务器响应结果：

对某个字段的值进行去重之后再取总数

GET /student/_search
{
  "size": 0, 
  "aggs": {
    "max_age": {
      "cardinality": {
        "field": "age"
      }
    }
  }
}

服务器响应结果：

GET /items/_search
{
  "query": {
    "bool": {
      "filter": [
        {
          "term": {
            "category": "手机"
          }
        },
        {
          "range": {
            "price": {
              "gte": 300000
            }
          }
        }
      ]
    }
  }, 
  "size": 0, 
  "aggs": {
    "brand_agg": {
      "terms": {
        "field": "brand",
        "size": 20
      },
      "aggs": {
        "stats_meric": {
          "stats": {
            "field": "price"
          }
        }
      }
    }
  }
}

query部分就不说了，我们重点解读聚合部分语法。

可以看到我们在brand_agg聚合的内部，我们新加了一个aggs参数。这个聚合就是brand_agg的子聚合，会对brand_agg形成的每个桶中的文档分别统计。

stats_meric：聚合名称
- stats：聚合类型，stats是metric聚合的一种
  - field：聚合字段，这里选择price，统计价格

由于stats是对brand_agg形成的每个品牌桶内文档分别做统计，因此每个品牌都会统计出自己的价格最小、最大、平均值。