es基础语法

version: es7+

# IK分词器

类似python中的jieba分词

两种分词模式

ik_smart

ik_max_word

不同分词效果

ik_smart: 为最少切分, 就是尽可能少的切分;

GET _analyze
{
  "analyzer": "ik_smart",
  "text": "go语言开发者"
}

go 语言  开发者

1
2
3
4
5
6
7

ik_max_word: 为最细粒度划分, 穷尽词库的可能;

GET _analyze
{
  "analyzer": "ik_max_word",
  "text": "go语言开发者"
}

go 语言 开发 开发者 者

1
2
3
4
5
6
7

和jieba分词可以配置用户字典: 配置文件路径在ik/config/IKAnalyzer.cfg.xml * 可以新建一个kuang.dic文件, 然后在IKAnalyzer.cfg.xml中添加配置 - <entry key="ext_dict">kuang.dic</entry> - <entry key="ext_stopwords">kuang_stop.dic</entry>

# 数据类型

字符串类型: text和keyword
数值类型: long, integer, short, byte, double, float, half float, scaled float
日期类型: date
te布尔值类型: boolean
二进制类型: binary

指定字段类型: 添加一个库并添加字段规则(类似mysql建表)

PUT /test2
{
  "mappings": {
    "properties": {
      "name": {
        "type": "text"
      },
      "age": {
        "type": "long"
      },
      "birthday": {
        "type": "date"
      }
    }
  }
}
# 返回结果发现acknowledged是true, 说明规则创建成功

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 映射

映射类似与MySQL中的表设计，包括约束指定字段的类型(text、keyword等)。text类型的字段支持分词，keyword类型的字段不支持分词、必须完全匹配。
keyword类型的字段才支持聚合查询(例如：分组)

通过type指定字段类型，通过index指定该字段是否可以被索引查询，当index为false时，将无法通过该字段进行查询。

GET /user/_mapping

{
    "properties":{
        "name":{
            "type": "text",
            "index": true
        },
        "sex":{
            "type": "text",
            "index": true
        },
        "tel":{
            "type": "text",
            "index": true
        },
        "province":{
            "type":"keyword",
            "index":"true"
        }                
    }
}

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

# 1. 创建mapping

方法1

PUT index
{
  "mappings": {
    "properties": { 
      "foo": {
        "type": "keyword"
      }
    }
  }
}

1
2
3
4
5
6
7
8
9
10

方法2

PUT index/_mappings
  "properties": { 
    "bar": {
      "type": "text"
    }
  }
}

1
2
3
4
5
6
7

# 2. 查询mapping

GET index/_mappings

# 分片

分片类似MySQL中的分表，创建索引时，默认3个分片，这个分片数量是可以修改的。
```
PUT 索引名/_settings
{
    "number_of_replicas":2
}
```
1
2
3
4

# 基础操作

# 1. 索引操作

创建索引

PUT  url/索引名

例：url/shopping

1
2
3

查看索引信息

GET  url/索引名

例：url/shopping

1
2
3

查看全部索引

GET  url/_cat/indices?v

例：url/_cat/indices?v

1
2
3

删除索引

DELETE url/索引名
 
例：url/shopping

1
2
3

# 2. 文档操作

# 2.1 创建文档

创建文档(指定文档id)

PUT: 创建文档(指定文档id), localhost:9200/索引名称/类型名称/文档ID
```
PUT /test1/type1/1
{
  "name": "狂神说",
  "age": 3
}
```
1
2
3
4
5
6
创建文档(随机文档id)

POST: 创建文档(随机文档id), localhost:9200/索引名称/类型名称
```
POST /test1/type1/1
{
  "name": "狂神说",
  "age": 3
}
```
1
2
3
4
5

# 2.3 查询文档

根据id查询

GET 索引名/_doc/文档id

例： shopping/_doc/1055

1
2
3

查询全部

GET 索引名/_search
 
例：shopping/_search

1
2
3

查询全部

将参数放在请求体里

GET 索引名/_search
{
    "query":{ 
        "match_all":{ 
        	"name":"xxx" # 条件查询
        } 
    } 
}

1
2
3
4
5
6
7
8

# 2.4 更新文档

全量更新

（相当于先删除，后创建，只是id没变）
```
POST/PUT 索引名/_doc/id

参数放请求体 {}
```
1
2
3

部分更新：

POST 索引名/_update/id
{
    "doc": {参数}
}

例：
POST  /shopping/_update/1056
{
    "doc":{
       "title":"华为手机"
    }
}

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

# 2.5 删除文档

DELETE 索引名/_doc/id 

例： shopping/_doc/1056

1
2
3

# 3. 条件查询 + 分页

条件查询

GET 索引名/_search?q=key:value
 
例：shopping/_search?q=title:华为

1
2
3

GET 索引名/_search
{
    "query":{ 
        "match_all":{ 
        	"name":"xxx" # 条件查询
        } 
    } 
}

1
2
3
4
5
6
7
8

分页

GET 索引名/_search
 
参数：
{
    "query":{
        "match_all":{
        }
    },
    "from": 2,
    "size": 2
}
 
from：表示第几条记录
size：表示每页多少记录
 
from=(页码-1)*size

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 4. 指定要查询的列

GET /索引名/_search
 
{
    "query":{
        "match_all":{
        }
    },
    "from": 2,
    "size": 2,
    "_source": ["title"]
}
 
# 通过 _source 指定只查询 title 字段

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

# 5. 排序

注意：如果排序时使用了分页查询，则是先排序，后分页。

GET /索引名/_search
 
{
    "query":{
        "match_all":{
        }
    },
    "from": 2,
    "size": 2,
    "_source": ["title","price"],
    "sort":{
        "price":{
            "order":"asc"
        }
    }
}
 
# sort表示要对查询结果进行排序
# price表示要排序的字段
# order指定排序方式，升序还是降序

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

# 6. 多条件查询

must (and) , should (or)

GET 索引名/_search
 
例： 查询category为华为的所有文档 must理解为：并且、同时成立
GET shopping/_search
{
    "query":{
        "bool":{
            "must":[
              {
                "match":{
                    "category":"华为"
                }
              }
            ]
        }
    }    
}
 
例：查询category为华为并且price为3888的文档
GET shopping/_search
{
    "query":{
        "bool":{
            "must":[
              {
                "match":{
                    "category":"华为"
                }
              },
              {
                "match":{
                    "price":"3888"
                }
              }              
            ]
        }
    }
}
 
 
例：查询category为华为或OPPO的文档,并按price排序 should可以理解为：或
GET shopping/_search
{
    "query":{
        "bool":{
            "should":[
              {
                "match":{
                    "category":"华为"
                }
              },
              {
                "match":{
                    "category":"OPPO"
                }
              }
            ]
        }
    },
    "sort":{
        "price":{
            "order":"asc"
        }
    }  
}
 
 
例：查询 查询category为华为或小米或OPPO的手机，并且价格大于5000，此处使用filter，gt表示大于，lt表示小于。
GET shopping/_search
{
    "query":{
        "bool":{
            "should":[
              {
                "match":{
                    "category":"华为"
                }
              },
              {
                "match":{
                    "category":"小米"
                }
              },
              {
                "match":{
                    "category":"OPPO"
                }
              }                          
            ],
            "filter":{
                "range":{
                    "price":{
                        "gt":5000
                    }
                }
            }
        }
    }
}

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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

# 7. match、match_phrase

match：分词搜索，会把查询关键词先进行分词，然后进行搜索

例：下面的查询会把category含有小或含有华的都查出来
GET /shoppting/_search
{
    "query":{
        "match":{
            "category":"小华"
        }
    }
}

1
2
3
4
5
6
7
8
9

match_phrase：精确查询（完全匹配）

例：下面的查询指挥查询category为小米的文档
GET /shoppting/_search
{
    "query":{
        "match_phrase":{
            "category":"小米"
        }
    }
}

1
2
3
4
5
6
7
8
9

# 8. 聚合查询

aggregations：聚合

significant：重要

# 8.1 分组查询

# 按price字段进行分组
GET /shopping/_search
{
    "aggs":{
        "category_group":{
            "terms":{
                "field": "price"
            }
        }
    }
}
 
# 默认会一并将所有文档信息也查出来，如果不需要查询文档信息，可以指定size为0
GET /shopping/_search
{
    "aggs":{
        "category_group":{
            "terms":{
                "field": "price"
            }
        }
    },
    "size": 0
}

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

# 8.2 求平均数

#查询所有文档price的平均值
GET /shopping/_search
{
    "aggs":{
        "category_avg":{
            "avg":{
                "field": "price"
            }
        }
    }
}
 
#不查询文档详细信息
GET /shopping/_search
{
    "aggs":{
        "category_avg":{
            "avg":{
                "field": "price"
            }
        }
    },
    "size": 0
}

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

# 9. 索引模板

# 9.1 查看全部索引模板

ip/_template

# 9.2 查看某个索引模板的内容

ip/_template/索引模板名称*

# 9.3 创建索引模板

注意！！！es7以后，一个索引不再支持多个数据类型，只有一个默认的_doc。

# 创建一个名为mytemplate的索引模板，当创建名为mysqlaudit-开头的索引时生效。

PUT /_template/mytemplate

{
"order":1,
"index_patterns":["mysqlaudit-*"],
"mappings":{
   "properties":{
     "middleware_name":{
        "type":"keyword",
        "index":true
     },
     "k8s_pod_namespace":{
        "type":"keyword",
        "index":true
     },
     "query":{
        "type":"text",
        "index":true,
        "analyzer":"ik_max_word"
     }
    }
},
"settings":{
   "index": {
      "max_result_window": "30000000"
    } 
} 
}

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

#数据库 #

上次更新: 2023/04/16, 18:35:33

← es基本概念 es倒排索引→