ElasticSearch高级操作

LiJunYi 8/5/2022 ElasticSearch

# 数据准备

将ES中的索引全部删除
添加索引： PUT people
添加几个文档

# 高级查询

# 分词查询:_search

请求方式：GET 索引名/_search
请求体内容

{
    "query": {
        "match": {
            "name": "lisi"
        }
    }
}

1
2
3
4
5
6
7

ElasticSearch

# 查询所有文档:_search

请求方式：GET 索引名/_search
请求体内容

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

1
2
3
4
5
6
7
8

ElasticSearch

{
  "took": 0,
  "timed_out": false,
  "_shards": {
    "total": 1,
    "successful": 1,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": {
      "value": 6,
      "relation": "eq"
    },
    "max_score": 1,
    "hits": [
      {
        "_index": "people",
        "_id": "1001",
        "_score": 1,
        "_source": {
          "name": "zhangsan",
          "nickname": "zhangsan",
          "sex": "男",
          "age": 30
        }
      },
      {
        "_index": "people",
        "_id": "1002",
        "_score": 1,
        "_source": {
          "name": "lisi",
          "nickname": "lisi",
          "sex": "男",
          "age": 20
        }
      },
      {
        "_index": "people",
        "_id": "1003",
        "_score": 1,
        "_source": {
          "name": "wangwu",
          "nickname": "wangwu",
          "sex": "女",
          "age": 40
        }
      },
      {
        "_index": "people",
        "_id": "1004",
        "_score": 1,
        "_source": {
          "name": "zhangsan1",
          "nickname": "zhangsan1",
          "sex": "女",
          "age": 50
        }
      },
      {
        "_index": "people",
        "_id": "1005",
        "_score": 1,
        "_source": {
          "name": "zhangsan2",
          "nickname": "zhangsan2",
          "sex": "女",
          "age": 30
        }
      },
      {
        "_index": "people",
        "_id": "1006",
        "_score": 1,
        "_source": {
          "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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

# 字段匹配查询:multi_match

multi_match 与 match 类似，不同的是它可以在多个字段中查询。
请求方式：GET 索引名/_search
请求体内容

{
    "query": {
        "multi_match": {
            "query": "zhangsan",
            "fields": ["name","nickname"]
        }
    }
}

1
2
3
4
5
6
7
8

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

ElasticSearch

# 单关键字精确查询:term

term 查询，精确的关键词匹配查询，不对查询条件进行分词，即只能单关键字精确查询。
请求方式：GET 索引名/_search
请求体内容

{
"query": {
    "term": {
        "name": {
            "value": "zhangsan"
        }
    }
}
}

1
2
3
4
5
6
7
8
9

ElasticSearch

# 多关键字精确查询:terms

terms 查询和 term 查询一样，但它允许你指定多值进行匹配。如果这个字段包含了指定值中的任何一个值，那么这个文档满足条件，类似于 mysql 的 in
请求方式：GET 索引名/_search
请求体内容

{
    "query": {
        "terms": {
            "name": ["zhangsan","lisi"]
        }
    }
}

1
2
3
4
5
6
7

ElasticSearch

# 指定字段查询:_source

默认情况下，Elasticsearch 在搜索的结果中，会把文档中保存在 _source 的所有字段都返回。
如果我们只想获取其中的部分字段，我们可以添加 _source 的过滤
请求方式：GET 索引名/_search
请求体内容

{
    "_source": ["name","nickname"], 
    "query": {
        "terms": {
            "nickname": ["zhangsan"]
        }
    }
}

1
2
3
4
5
6
7
8

ElasticSearch

# 过滤字段:includes&excludes

includes：来指定想要显示的字段
excludes：来指定不想要显示的字段
请求方式：GET 索引名/_search
请求体内容

{
    "_source": {
        "includes": ["name","nickname"]
    }, 
    "query": {
        "terms": {
            "nickname": ["zhangsan"]
        }
    }
}

1
2
3
4
5
6
7
8
9
10

ElasticSearch

# 组合查询:bool

bool 把各种其它查询通过 must（必须，类似 and）、must_not（必须不，类似 not）、should（应该类似 or）的方式进行组合
请求方式：GET 索引名/_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

ElasticSearch

# 范围查询:range

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

操作符	说明
gt	>
gte	>=
lt	<
lte	<=

请求方式：GET 索引名/_search
请求体内容

{
    "query": {
        "range": {
            "age": {
                "gte": 30,
                "lte": 35
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10

ElasticSearch

# 模糊查询:fuzzy

fuzzy：返回包含与搜索字词相似的字词的文档，更多fuzzy有关解释请查看官方文档 (opens new window) -编辑距离是将一个术语转换为另一个术语所需的一个字符更改的次数。这些更改可以包括：
更改字符（box → fox）
删除字符（black → lack）
插入字符（sic → sick）
转置两个相邻字符（act → cat）
为了找到相似的术语，fuzzy 查询会在指定的编辑距离内创建一组搜索词的所有可能的变体或扩展。然后查询返回每个扩展的完全匹配。
通过 fuzziness 修改编辑距离。一般使用默认值 AUTO，根据术语的长度生成编辑距离。
请求方式：GET 索引名/_search
请求体内容

{
    "query": {
        "fuzzy": {
            "name": {
                "value": "zhangsan"
            }
        }
    }
}

1
2
3
4
5
6
7
8
9

ElasticSearch

结果JSON

{
  "took": 15,
  "timed_out": false,
  "_shards": {
    "total": 1,
    "successful": 1,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": {
      "value": 3,
      "relation": "eq"
    },
    "max_score": 1.540445,
    "hits": [
      {
        "_index": "people",
        "_id": "1001",
        "_score": 1.540445,
        "_source": {
          "name": "zhangsan",
          "nickname": "zhangsan",
          "sex": "男",
          "age": 30
        }
      },
      {
        "_index": "people",
        "_id": "1004",
        "_score": 1.3478894,
        "_source": {
          "name": "zhangsan1",
          "nickname": "zhangsan1",
          "sex": "女",
          "age": 50
        }
      },
      {
        "_index": "people",
        "_id": "1005",
        "_score": 1.3478894,
        "_source": {
          "name": "zhangsan2",
          "nickname": "zhangsan2",
          "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
43
44
45
46
47
48
49
50
51
52

ElasticSearch

结果JSON

{
  "took": 2,
  "timed_out": false,
  "_shards": {
    "total": 1,
    "successful": 1,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": {
      "value": 3,
      "relation": "eq"
    },
    "max_score": 1.540445,
    "hits": [
      {
        "_index": "people",
        "_id": "1001",
        "_score": 1.540445,
        "_source": {
          "name": "zhangsan",
          "nickname": "zhangsan",
          "sex": "男",
          "age": 30
        }
      },
      {
        "_index": "people",
        "_id": "1004",
        "_score": 1.3478894,
        "_source": {
          "name": "zhangsan1",
          "nickname": "zhangsan1",
          "sex": "女",
          "age": 50
        }
      },
      {
        "_index": "people",
        "_id": "1005",
        "_score": 1.3478894,
        "_source": {
          "name": "zhangsan2",
          "nickname": "zhangsan2",
          "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
43
44
45
46
47
48
49
50
51
52

# 多IDs查询:ids

请求方式：GET 索引名/_search
请求体内容

{
    "query": {
        "ids" : {
            "values" : ["1001", "1004", "1006"]
        }
    }
}

1
2
3
4
5
6
7

ElasticSearch

# 前缀查询:prefix

请求方式：GET 索引名/_search
请求体内容

{
    "query": {
        "prefix": {
            "name": {
                "value": "zhangsan"
            }
        }
    }
}

1
2
3
4
5
6
7
8
9

ElasticSearch

# 单字段排序:sort

sort 可以让我们按照不同的字段进行排序，并且通过 order 指定排序的方式。desc 降序，asc 升序
请求方式：GET 索引名/_search
请求体内容

{
    "query": {
        "match": {
            "name":"zhangsan"
        }
    },
    "sort": [{
        "age": {
            "order":"desc"
        }
    }]
}

1
2
3
4
5
6
7
8
9
10
11
12

ElasticSearch

# 多字段排序

假设我们想要结合使用 age 和 _score 进行查询，并且匹配的结果首先按照年龄排序，然后按照相关性得分排序
请求方式：GET 索引名/_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

ElasticSearch

结果JSON

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

# 高亮查询:highlight

在进行关键字搜索时，搜索出的内容中的关键字会显示不同的颜色，称之为高亮。
Elasticsearch 可以对查询内容中的关键字部分，进行标签和样式(高亮)的设置。

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

pre_tags：前置标签
post_tags：后置标签
fields：需要高亮的字段
title：这里声明 title 字段需要高亮，后面可以为这个字段设置特有配置，也可以为空
请求方式：GET 索引名/_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

ElasticSearch

# 分页查询:from&size

from：当前页的起始索引，默认从 0 开始。 from = (pageNum - 1) * size
size：每页显示多少条
请求方式：GET 索引名/_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

ElasticSearch

# 聚合查询:aggs

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

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

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

请求方式：GET 索引名/_search
请求体内容

{
    "aggs" : {//聚合操作
        "price_group":{ //名称，随意起名
            "terms":{   //分组操作
                "field":"age" //分组字段
            }
        }
    },
    "size":0
}

1
2
3
4
5
6
7
8
9
10

结果JSON

{
  "took": 2,
  "timed_out": false,
  "_shards": {
    "total": 1,
    "successful": 1,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": {
      "value": 6,
      "relation": "eq"
    },
    "max_score": null,
    "hits": []
  },
  "aggregations": {
    "price_group": {
      "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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

ElasticSearch

如果想求price的平均值,将terms改为avg
结果JSON

{
  "took": 0,
  "timed_out": false,
  "_shards": {
    "total": 1,
    "successful": 1,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": {
      "value": 6,
      "relation": "eq"
    },
    "max_score": null,
    "hits": []
  },
  "aggregations": {
    "price_group": {
      "value": 33.333333333333336
    }
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 简单聚合

对某个字段取最大值 max

请求体内容

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

1
2
3
4
5
6
7
8

对某个字段取最小值 min

请求体内容

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

1
2
3
4
5
6
7
8

对某个字段求和 sum

请求体内容

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

1
2
3
4
5
6
7
8

对某个字段取平均值 avg

请求体内容

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

1
2
3
4
5
6
7
8

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

请求体内容

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

1
2
3
4
5
6
7
8

State 聚合

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

请求体内容

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

1
2
3
4
5
6
7
8

# 桶聚合查询:terms

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

terms 聚合，分组统计

请求体内容

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

1
2
3
4
5
6
7
8

嵌套查询

请求体内容

{
    "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

在 terms 分组下再进行聚合和排序

请求体内容

{
    "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

ElasticSearch基本操作 ElasticSearch集成IK分词器

我的开发笔记

Choose mode