Young Kbt blog
Young Kbt
2021-11-14
目录

ElasticSearch - 高级操作

# 数据准备

进行本内容的高级操作前，先往 ElasticSearch 插入一些数据，进行使用

先把上一个内容的 student 索引删除掉

在 Postman 中，向 ES 服务器发 DELETE 请求：http://127.0.0.1:9200/student

或者在 Kibana 里，向 ES 服务器发请求

DELETE /student
1

Postman

在 Postman 中，向 ES 服务器发五个 POST 请求：http://127.0.0.1:9200/student/_doc/100x，x分别是1，2，3，4，5，每次请求携带自己的请求体，请求体内容在下方代码块里

Kibana

五个数据分开请求插入

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
}
POST /student/_doc/1006
{
    "name":"zhangsan222",
    "nickname":"zhangsan222",
    "sex":"女",
    "age":30
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

# 高级查询

名词解释

分词：存到 ElasticSearch 的字符串数据是分开的单个的字符串，如可乐，在 ElasticSearch 的存储格式是可、乐，即无论查询可还是乐，都可以查询出可乐，类似于数据库的模糊查询。

2021-11-14 @Young Kbt

本内容基本都是对请求体进行配置，也是 ElasticSearch 的语法核心所在。

查询都是用 GET 请求。

# 分词查询

Postman

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

请求体内容：

{
    "query": {
        "match": {
            "name": "zhangsan2"
        }
    }
}
1
2
3
4
5
6
7

查询 name 包含 zhangsan2 的数据

image-20211115123041445

name 有 zhangsan2 的数据分别是 zhangsan2 和 zhangsan222

Kibana

GET /student/_search
{
    "query": {
        "match": {
            "name": "zhangsan2"
        }
    }
}
1
2
3
4
5
6
7
8

# 查询所有文档

Postman

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

请求体内容：

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

image-20211114224605061

返回结果分析：

{
    "took【查询花费时间，单位毫秒】" : 1116,
    "timed_out【是否超时】" : false,
    "_shards【分片信息】" : {
        "total【总数】" : 1,
        "successful【成功】" : 1,
        "skipped【忽略】" : 0,
        "failed【失败】" : 0
    },
    "hits【搜索命中结果】" : {
        "total【搜索条件匹配的文档总数】": {
            "value【总命中计数的值】": 3,
            "relation【计数规则】": "eq" # eq 表示计数准确， gte 表示计数不准确
        },
        "max_score【匹配度分值】" : 1.0,
        "hits【命中结果集合】" : [
            。。。
            }
        ]
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

Kibana

GET /student/_search
{
    "query": {
        "match_all": {}
    }
}
1
2
3
4
5
6

# 字段匹配查询

匹配查询用到 multi_match

Postman

multi_match 与 match 类似，不同的是它可以在多个字段中查询。

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

请求体内容：

{
    "query": {
        "multi_match": {
            "query": "zhangsan",
            "fields": ["name","nickname"]
        }
    }
}
1
2
3
4
5
6
7
8

查询 key 为 name 和 nickname，value 为 zhangsan 的数据

image-20211114225750116

Kibana

GET /student/_search
{
    "query": {
        "multi_match": {
            "query": "zhangsan",
            "fields": ["name","nickname"]
        }
    }
}
1
2
3
4
5
6
7
8
9

# 单关键字精确查询

term 查询，精确的关键词匹配查询，不对查询条件进行分词，即只能单关键字精确查询。

Postman

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

请求体内容：

{
    "query": {
        "term": {
            "name": {
                "value": "zhangsan"
            }
        }
    }
}
1
2
3
4
5
6
7
8
9

查询 key 为 name，value 为 zhangsan 的数据

image-20211114230213683

Kibana

GET /student/_search
{
    "query": {
        "term": {
            "name": {
                "value": "zhangsan"
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10

# 多关键字精确查询

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

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

Postman

Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

请求体内容：

{
    "query": {
        "terms": {
            "name": ["zhangsan","lisi"]
        }
    }
}
1
2
3
4
5
6
7

查询 key 为 name，value 分别为 zhangsan 和 lisi 的数据

image-20211114230941694

Kibana

GET /student/_search
{
    "query": {
        "terms": {
            "name": ["zhangsan","lisi"]
        }
    }
}
1
2
3
4
5
6
7
8

# 指定字段查询

默认情况下，Elasticsearch 在搜索的结果中，会把文档中保存在 _source 的所有字段都返回。

如果我们只想获取其中的部分字段，我们可以添加 _source 的过滤

Postman

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

请求体内容：

{
    "_source": ["name","nickname"], 
    "query": {
        "terms": {
            "nickname": ["zhangsan"]
        }
    }
}
1
2
3
4
5
6
7
8

只需要查询出 key 为 name 和 nickname，value 为 zhangsan 的数据

image-20211114231921257

Kibana

GET /student/_search
{
    "_source": ["name","nickname"], 
    "query": {
        "terms": {
            "nickname": ["zhangsan"]
        }
    }
}
1
2
3
4
5
6
7
8
9

# 过滤字段

用到的字段：

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

Postman

includes 使用

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

请求体内容：

{
    "_source": {
        "includes": ["name","nickname"]
    }, 
    "query": {
        "terms": {
            "nickname": ["zhangsan"]
        }
    }
}
1
2
3
4
5
6
7
8
9
10

指定想要 key 为 name 和 nickname，value 为 zhangsan 的数据

image-20211114232400510

excludes 使用

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

请求体内容：

{
    "_source": {
        "excludes": ["name","nickname"]
    }, 
    "query": {
        "terms": {
            "nickname": ["zhangsan"]
        }
    }
}
1
2
3
4
5
6
7
8
9
10

指定想要 key 不是 name 和 nickname，value 为 zhangsan 的数据

image-20211114232641258

Kibana

includes 使用

GET /student/_search
{
    "_source": {
        "includes": ["name","nickname"]
    }, 
    "query": {
        "terms": {
            "nickname": ["zhangsan"]
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11

excludes 使用

GET /student/_search
{
    "_source": {
        "excludes": ["name","nickname"]
    }, 
    "query": {
        "terms": {
            "nickname": ["zhangsan"]
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11

# 组合查询

bool 把各种其它查询通过 must（必须，类似 and）、must_not（必须不，类似 not）、should（应该 类似 or）的方式进行组合

Postman

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

请求体内容：

{
    "query": {
        "bool": {
            "must": [
                {
                    "match": {
                        "name": "zhangsan"
                    }
                }
            ],
            "must_not": [
                {
                    "match": {
                        "age": "40"
                    }
                }
            ],
            "should": [
                {
                    "match": {
                        "sex": "男"
                    }
                }
            ]
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

查询 name 必须为 zhangsan，age 不能是 40，sex 可以是男的数据

image-20211114234438909

Kibana

GET /student/_search
{
    "query": {
        "bool": {
            "must": [
                {
                    "match": {
                        "name": "zhangsan"
                    }
                }
            ],
            "must_not": [
                {
                    "match": {
                        "age": "40"
                    }
                }
            ],
            "should": [
                {
                    "match": {
                        "sex": "男"
                    }
                }
            ]
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# 范围查询

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

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

Postman

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

请求体内容：

{
    "query": {
        "range": {
            "age": {
                "gte": 30,
                "lte": 35
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10

查询年龄大于等于 30 小于等于 35 的数据

image-20211114235244496

Kibana

GET /student/_search
{
    "query": {
        "range": {
            "age": {
                "gte": 30,
                "lte": 35
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11

# 模糊查询

返回包含与搜索字词相似的字词的文档。使用的字段是 fuzzy

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

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

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

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

Postman

例子 1：在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

请求体内容：

{
    "query": {
        "fuzzy": {
            "name": {
                "value": "zhangsan"
            }
        }
    }
}
1
2
3
4
5
6
7
8
9

模糊查询 name 带有 zhangsan 的数据

image-20211115000204559

例子 2：在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

请求体内容：

{
    "query": {
        "fuzzy": {
            "name": {
                "value": "zhangsan",
                "fuzziness": 2
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10

image-20211115000841700

Kibana

例子 1

GET /student/_search
{
    "query": {
        "fuzzy": {
            "name": {
                "value": "zhangsan"
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10

例子 2：

GET /student/_search
{
    "query": {
        "fuzzy": {
            "name": {
                "value": "zhangsan"
                 "fuzziness": 2
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11

# 多IDs查询

Postman

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

请求体内容：

{
    "query": {
        "ids" : {
            "values" : ["1001", "1004", "1006"]
        }
    }
}
1
2
3
4
5
6
7

image-20211117164809178

Kibana

GET /student/_search
{
    "query": {
        "ids" : {
            "values" : ["1001", "1004", "1006"]
        }
    }
}
1
2
3
4
5
6
7
8

# 前缀查询

Postman

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

请求体内容：

{
    "query": {
        "prefix": {
            "name": {
                "value": "zhangsan"
            }
        }
    }
}
1
2
3
4
5
6
7
8
9

image-20211117165146146

Kibana

GET /student/_search
{
    "query": {
        "prefix": {
            "name": {
                "value": "zhangsan"
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10

# 单字段排序

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

Postman

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

请求体内容：

{
    "query": {
        "match": {
            "name":"zhangsan"
        }
    },
    "sort": [{
        "age": {
            "order":"desc"
        }
    }]
}
1
2
3
4
5
6
7
8
9
10
11
12

查询 name 有 zhangsan 的数据，并对年龄进行排序

image-20211115001848988

Kibana

GET /student/_search
{
    "query": {
        "match": {
            "name":"zhangsan"
        }
    },
    "sort": [{
        "age": {
            "order":"desc"
        }
    }]
}
1
2
3
4
5
6
7
8
9
10
11
12
13

# 多字段排序

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

Postman

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

{
    "query": {
        "match_all": {}
    },
    "sort": [
        {
            "age": {
                "order": "desc"
            }
        },
        {
            "_score":{
                "order": "desc"
            }
        }
    ]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

查询所有索引为 student 的数据，结果先按照年龄排序，然后按照相关性得分排序

image-20211115002053125

Kibana

GET /student/_search
{
    "query": {
        "match_all": {}
    },
    "sort": [
        {
            "age": {
                "order": "desc"
            }
        },
        {
            "_score":{
                "order": "desc"
            }
        }
    ]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 高亮查询

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

如图：

image-20211115005919399

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

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

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

Postman

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

请求体内容：

{
    "query": {
        "match": {
            "name": "zhangsan"
        }
    },
    "highlight": {
        "pre_tags": "<font color='red'>",
        "post_tags": "</font>",
        "fields": {
            "name": {}
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

分词查询 name 为 zhangsan，并给 zhangsan 高亮红色

image-20211115010155933

这里只是数据，渲染到页面自然会高亮

Kibana

GET /student/_search
{
    "query": {
        "match": {
            "name": "zhangsan"
        }
    },
    "highlight": {
        "pre_tags": "<font color='red'>",
        "post_tags": "</font>",
        "fields": {
            "name": {}
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 分页查询

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

size：每页显示多少条

Postman

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

请求体内容：

{
    "query": {
        "match_all": {}
    },
    "sort": [
        {
            "age": {
                "order": "desc"
            }
        }
    ],
    "from": 0,
    "size": 2
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

查询两条 student 索引的数据，对年龄进行排序，，从第一条数据开始获取，一共获取两条数据

image-20211115010758191

Kibana

GET /student/_search
{
    "query": {
        "match_all": {}
    },
    "sort": [
        {
            "age": {
                "order": "desc"
            }
        }
    ],
    "from": 0,
    "size": 2
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 聚合查询

聚合允许使用者对 es 文档进行统计分析，类似与关系型数据库中的 group by，当然还有很多其他的聚合，例如取最大值、平均值等等。

聚合查询 aggs 字段，该字段里的第一个字段是自定义名字，一个聚合/分组需要另一个聚合/分组需要用到自定义名字（嵌套查询）。第二个字段是聚合查询类型。查询结果不仅有聚合结果，也有设计到的详细数据。

结果长度 size 字段和 aggs 字段同级，代表只获取聚合结果，不获取涉及到的详细数据。

如图：（第一个是不用 size，第二个图用了 size）

image-20211115124042498

不用 size 图

image-20211115124134155

用了 size 图

# 简单聚合

  • 对某个字段取最大值 max

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

请求体内容：

{
    "aggs":{
        "max_age":{   // 自定义名字
            "max":{"field":"age"}
        }
    },
    "size":0  // 只获取聚合结果，不获取每一个数据
}
1
2
3
4
5
6
7
8

在 Kibana 中，向 ES 服务器发 GET 请求：

GET /student/_search
{
    "aggs":{
        "max_age":{  // 自定义名字
            "max":{"field":"age"}
        }
    },
    "size":0 // 只获取聚合结果，不获取每一个数据
}
1
2
3
4
5
6
7
8
9
  • 对某个字段取最小值 min

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

请求体内容：

{
    "aggs":{
        "min_age":{ // 自定义名字
            "min":{"field":"age"}
        }
    },
    "size":0 // 只获取聚合结果，不获取每一个数据
}
1
2
3
4
5
6
7
8

在 Kibana 中，向 ES 服务器发 GET 请求：

GET /student/_search
{
    "aggs":{
        "min_age":{ // 自定义名字
            "min":{"field":"age"}
        }
    },
    "size":0 // 只获取聚合结果，不获取每一个数据
}
1
2
3
4
5
6
7
8
9
  • 对某个字段求和 sum

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

请求体内容：

{
    "aggs":{
        "sum_age":{ // 自定义名字
            "sum":{"field":"age"}
        }
    },
    "size":0 // 只获取聚合结果，不获取每一个数据
}
1
2
3
4
5
6
7
8

在 Kibana 中，向 ES 服务器发 GET 请求：

GET /student/_search
{
    "aggs":{
        "sum_age":{ // 自定义名字
            "sum":{"field":"age"}
        }
    },
    "size":0 // 只获取聚合结果，不获取每一个数据
}
1
2
3
4
5
6
7
8
9
  • 对某个字段取平均值 avg

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

{
    "aggs":{
        "avg_age":{ // 自定义名字
            "avg":{"field":"age"}
        }
    },
    "size":0 // 只获取聚合结果，不获取每一个数据
}
1
2
3
4
5
6
7
8

在 Kibana 中，向 ES 服务器发 GET 请求：

GET /student/_search
{
    "aggs":{
        "avg_age":{ // 自定义名字
            "avg":{"field":"age"}
        }
    },
    "size":0 // 只获取聚合结果，不获取每一个数据
}
1
2
3
4
5
6
7
8
9
  • 对某个字段的值进行去重之后再取总数

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

{
    "aggs":{
        "distinct_age":{ // 自定义名字
            "cardinality":{"field":"age"}
        }
    },
    "size":0 // 只获取聚合结果，不获取每一个数据
}
1
2
3
4
5
6
7
8

在 Kibana 中，向 ES 服务器发 GET 请求：

GET /student/_search
{
    "aggs":{
        "distinct_age":{ // 自定义名字
            "cardinality":{"field":"age"}
        }
    },
    "size":0 // 只获取聚合结果，不获取每一个数据
}
1
2
3
4
5
6
7
8
9
  • State 聚合

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

在 Postman 中，向 ES 服务器发 GET 请求 ：http://127.0.0.1:9200/student/_search

{
    "aggs":{
        "stats_age":{ // 自定义名字a
            "stats":{"field":"age"}
        }
    },
    "size":0 // 只获取聚合结果，不获取每一个数据
}
1
2
3
4
5
6
7
8

在 Kibana 中，向 ES 服务器发 GET 请求：

GET /student/_search
{
    "aggs":{
        "stats_age":{ #// 自定义名字
            "stats":{"field":"age"}
        }
    },
    "size":0 // 只获取聚合结果，不获取每一个数据
}
1
2
3
4
5
6
7
8
9

# 桶聚合查询

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

  • terms 聚合，分组统计

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

{
    "aggs":{
        "age_groupby":{ // 自定义名字
            "terms":{"field":"age"}
        }
    },
    "size":0 // 只获取聚合结果，不获取每一个数据
}
1
2
3
4
5
6
7
8

对 age 进行分组，返回的结果部分：

"aggregations": {
    "age_groupby": {
        "doc_count_error_upper_bound": 0,
        "sum_other_doc_count": 0,
        "buckets": [
            {
                "key": 30,
                "doc_count": 3
            },
            {
                "key": 20,
                "doc_count": 1
            },
            {
                "key": 40,
                "doc_count": 1
            },
            {
                "key": 50,
                "doc_count": 1
            }
        ]
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

代表 age 为 30 的文档数据有 3 个，age 为 20、40、50 的文档数据各有 1 个。

在 Kibana 中，向 ES 服务器发 GET 请求：

GET /student/_search
{
    "aggs":{
        "age_groupby":{ // 自定义名字
            "terms":{"field":"age"}
        }
    },
    "size":0 // 只获取聚合结果，不获取每一个数据
}
1
2
3
4
5
6
7
8
9
  • 嵌套查询

在 Postman 中，向 ES 服务器发 GET 请求 ：http://127.0.0.1:9200/student/_search

{
    "aggs":{
        "age_groupby":{ // 自定义名字
            "terms":{
                "field": "age",
            },
            "aggs": {
                "average_age": {
                "avg": {
                    "field": "age"
                }
            }
      }
        }
    },
    "size":0 // 只获取聚合结果，不获取每一个数据
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在 Kibana 中，向 ES 服务器发 GET 请求：

GET /student/_search
{
    "aggs":{
        "age_groupby":{ // 自定义名字
            "terms":{
                "field": "age",
            },
            "aggs": {
                "average_balance": {
                "avg": {
                    "field": "age"
                }
            }
      }
        }
    },
    "size":0 // 只获取聚合结果，不获取每一个数据
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
  • 在 terms 分组下再进行聚合和排序

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

这里就用到了自定义的名字，如下 average_age 名代表对 age 去平均值，age_groupby 里先对 age 进行分组，再取平均值并且排序，所以需要 average_age 名。

{
    "aggs":{
        "age_groupby":{ // 自定义名字
            "terms":{
                "field": "age",
                "order": {
                	"average_age": "desc"
                }
            },
            "aggs": {
                "average_age": {
                "avg": {
                    "field": "age"
                }
            }
      }
        }
    },
    "size":0 // 只获取聚合结果，不获取每一个数据
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

在 Kibana 中，向 ES 服务器发 GET 请求：

GET /student/_search
{
    "aggs":{
        "age_groupby":{ // 自定义名字
            "terms":{
                "field": "age",
                "order": {
                	"average_balance": "desc"
                }
            },
            "aggs": {
                "average_balance": {
                "avg": {
                    "field": "age"
                }
            }
      }
        }
    },
    "size":0 // 只获取聚合结果，不获取每一个数据
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# 批量操作

# 批量查询 mget

单条查询 GET /test_index/_doc/1，如果查询多个id的文档一条一条查询，网络开销太大。

mget 批量查询

GET /_mget
{
   "docs" : [
      {
         "_index": "test_index",
         "_type": "_doc",
         "_id": 1
      },
      {
         "_index": "test_index",
         "_type": "_doc",
         "_id": 7
      }
   ]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

查询 test_index 索引的 _doc 文档，结果会返回 id 为 1 和 7 的数据。

去掉 type

因为新版 es 的文档只有一个，所以可以去掉 type

GET /_mget
{
   "docs" : [
      {
         "_index": "test_index",
         "_id":2
      },
      {
         "_index": "test_index",
         "_id": 3
      }
   ]
}
1
2
3
4
5
6
7
8
9
10
11
12
13

同一索引下批量查询

GET /test_index/_mget
{
   "docs" : [
      {
         "_id" :    2
      },
      {
         "_id" :    3
      }
   ]
}
1
2
3
4
5
6
7
8
9
10
11

搜索写法

post /test_index/_doc/_search
{
    "query": {
        "ids" : {
            "values" : ["1", "7"]
        }
    }
}
1
2
3
4
5
6
7
8

# 批量增删改 bulk

Bulk 操作解释将文档的增删改查一些列操作，通过一次请求全都做完。减少网络传输次数。

语法：

POST /_bulk
{"action": {"metadata"}}
{"data"}
1
2
3

如下操作，删除5，新增14，修改2。

POST /_bulk
{ "delete": { "_index": "test_index",  "_id": "5" }} 
{ "create": { "_index": "test_index",  "_id": "14" }}
{ "test_field": "test14" }
{ "update": { "_index": "test_index",  "_id": "2"} }
{ "doc" : {"test_field" : "bulk test"} }
1
2
3
4
5
6

功能：

  • delete：删除一个文档，只要1个json串就可以了
  • create：相当于强制创建 PUT /index/type/id/_create
  • index：普通的put操作，可以是创建文档，也可以是全量替换文档
  • update：执行的是局部更新partial update操作

格式：每个json不能换行。相邻json必须换行。

隔离：每个操作互不影响。操作失败的行会返回其失败信息。

实际用法：bulk请求一次不要太大，否则一下积压到内存中，性能会下降。所以，一次请求几千个操作、大小在几M正好。

编辑此页 (opens new window)
#搜索数据库
更新时间: 2023/10/23, 10:58:52
ElasticSearch - 基本操作
ElasticSearch - Java操作

← ElasticSearch - Java操作→

最近更新
01
技术随笔 - Element Plus 修改包名 原创
11-02
02
Reactor - 扩展性
11-02
03
Reactor - 最佳实践
11-02
更多文章>
Theme by Vdoing | Copyright © 2021-2024 Young Kbt | blog
桂ICP备2021009994号