SakuraTears的博客

越努力越幸运

Elasticsearch学习笔记（9）

发表于 分类于 阅读次数： Valine：
本文字数： 22k 阅读时长 ≈ 20 分钟

Elasticsearch 映射参数

analyzer

定义文本字段的分词器，默认对索引和查询都是有效的。

假设不用分词器，我们先来看一下索引的结果，创建一个索引并添加一个文档。

1
2
3
4
5
6
PUT blog

PUT blog/_doc/1
{
  "title":"定义文本字段的分词器，默认对索引和查询都是有效的。"
}

查看词条向量（term vectors）

1
2
3
4
GET blog/_termvectors/1
{
  "fields": ["title"]
}

查看结果如下：

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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
{
  "_index" : "blog",
  "_type" : "_doc",
  "_id" : "1",
  "_version" : 1,
  "found" : true,
  "took" : 124,
  "term_vectors" : {
    "title" : {
      "field_statistics" : {
        "sum_doc_freq" : 22,
        "doc_count" : 1,
        "sum_ttf" : 23
      },
      "terms" : {
        "义" : {
          "term_freq" : 1,
          "tokens" : [
            {
              "position" : 1,
              "start_offset" : 1,
              "end_offset" : 2
            }
          ]
        },
        "分" : {
          "term_freq" : 1,
          "tokens" : [
            {
              "position" : 7,
              "start_offset" : 7,
              "end_offset" : 8
            }
          ]
        },
        "和" : {
          "term_freq" : 1,
          "tokens" : [
            {
              "position" : 15,
              "start_offset" : 16,
              "end_offset" : 17
            }
          ]
        },
        "器" : {
          "term_freq" : 1,
          "tokens" : [
            {
              "position" : 9,
              "start_offset" : 9,
              "end_offset" : 10
            }
          ]
        },
        "字" : {
          "term_freq" : 1,
          "tokens" : [
            {
              "position" : 4,
              "start_offset" : 4,
              "end_offset" : 5
            }
          ]
        },
        "定" : {
          "term_freq" : 1,
          "tokens" : [
            {
              "position" : 0,
              "start_offset" : 0,
              "end_offset" : 1
            }
          ]
        },
        "对" : {
          "term_freq" : 1,
          "tokens" : [
            {
              "position" : 12,
              "start_offset" : 13,
              "end_offset" : 14
            }
          ]
        },
        "引" : {
          "term_freq" : 1,
          "tokens" : [
            {
              "position" : 14,
              "start_offset" : 15,
              "end_offset" : 16
            }
          ]
        },
        "效" : {
          "term_freq" : 1,
          "tokens" : [
            {
              "position" : 21,
              "start_offset" : 22,
              "end_offset" : 23
            }
          ]
        },
        "文" : {
          "term_freq" : 1,
          "tokens" : [
            {
              "position" : 2,
              "start_offset" : 2,
              "end_offset" : 3
            }
          ]
        },
        "是" : {
          "term_freq" : 1,
          "tokens" : [
            {
              "position" : 19,
              "start_offset" : 20,
              "end_offset" : 21
            }
          ]
        },
        "有" : {
          "term_freq" : 1,
          "tokens" : [
            {
              "position" : 20,
              "start_offset" : 21,
              "end_offset" : 22
            }
          ]
        },
        "本" : {
          "term_freq" : 1,
          "tokens" : [
            {
              "position" : 3,
              "start_offset" : 3,
              "end_offset" : 4
            }
          ]
        },
        "查" : {
          "term_freq" : 1,
          "tokens" : [
            {
              "position" : 16,
              "start_offset" : 17,
              "end_offset" : 18
            }
          ]
        },
        "段" : {
          "term_freq" : 1,
          "tokens" : [
            {
              "position" : 5,
              "start_offset" : 5,
              "end_offset" : 6
            }
          ]
        },
        "的" : {
          "term_freq" : 2,
          "tokens" : [
            {
              "position" : 6,
              "start_offset" : 6,
              "end_offset" : 7
            },
            {
              "position" : 22,
              "start_offset" : 23,
              "end_offset" : 24
            }
          ]
        },
        "索" : {
          "term_freq" : 1,
          "tokens" : [
            {
              "position" : 13,
              "start_offset" : 14,
              "end_offset" : 15
            }
          ]
        },
        "认" : {
          "term_freq" : 1,
          "tokens" : [
            {
              "position" : 11,
              "start_offset" : 12,
              "end_offset" : 13
            }
          ]
        },
        "词" : {
          "term_freq" : 1,
          "tokens" : [
            {
              "position" : 8,
              "start_offset" : 8,
              "end_offset" : 9
            }
          ]
        },
        "询" : {
          "term_freq" : 1,
          "tokens" : [
            {
              "position" : 17,
              "start_offset" : 18,
              "end_offset" : 19
            }
          ]
        },
        "都" : {
          "term_freq" : 1,
          "tokens" : [
            {
              "position" : 18,
              "start_offset" : 19,
              "end_offset" : 20
            }
          ]
        },
        "默" : {
          "term_freq" : 1,
          "tokens" : [
            {
              "position" : 10,
              "start_offset" : 11,
              "end_offset" : 12
            }
          ]
        }
      }
    }
  }
}

可以看到，默认情况下，中文就是一个字一个字的分，这种分词方式没有任何意义。如果这样分词，查询就只能一个字一个字来查，如下，这样查询没有任何意义。

1
2
3
4
5
6
7
8
9
10
GET blog/_search
{
  "query": {
    "term": {
      "title": {
        "value": "定"
      }
    }
  }
}

所以我们要根据实际情况，配置合适的分词器。

给字段设定分词器。

1
2
3
4
5
6
7
8
9
10
11
PUT blog
{
  "mappings": {
    "properties": {
      "title":{
        "type": "text",
        "analyzer": "ik_smart"
      }
    }
  }
}

存储文档

1
2
3
4
PUT blog/_doc/1
{
  "title":"定义文本字段的分词器，默认对索引和查询都是有效的。"
}

查看词条向量。

1
2
3
4
GET blog/_termvectors/1
{
  "fields": ["title"]
}

结果如下：

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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
{
  "_index" : "blog",
  "_type" : "_doc",
  "_id" : "1",
  "_version" : 1,
  "found" : true,
  "took" : 121,
  "term_vectors" : {
    "title" : {
      "field_statistics" : {
        "sum_doc_freq" : 12,
        "doc_count" : 1,
        "sum_ttf" : 13
      },
      "terms" : {
        "分词器" : {
          "term_freq" : 1,
          "tokens" : [
            {
              "position" : 4,
              "start_offset" : 7,
              "end_offset" : 10
            }
          ]
        },
        "和" : {
          "term_freq" : 1,
          "tokens" : [
            {
              "position" : 8,
              "start_offset" : 16,
              "end_offset" : 17
            }
          ]
        },
        "字段" : {
          "term_freq" : 1,
          "tokens" : [
            {
              "position" : 2,
              "start_offset" : 4,
              "end_offset" : 6
            }
          ]
        },
        "定义" : {
          "term_freq" : 1,
          "tokens" : [
            {
              "position" : 0,
              "start_offset" : 0,
              "end_offset" : 2
            }
          ]
        },
        "对" : {
          "term_freq" : 1,
          "tokens" : [
            {
              "position" : 6,
              "start_offset" : 13,
              "end_offset" : 14
            }
          ]
        },
        "文本" : {
          "term_freq" : 1,
          "tokens" : [
            {
              "position" : 1,
              "start_offset" : 2,
              "end_offset" : 4
            }
          ]
        },
        "有效" : {
          "term_freq" : 1,
          "tokens" : [
            {
              "position" : 11,
              "start_offset" : 21,
              "end_offset" : 23
            }
          ]
        },
        "查询" : {
          "term_freq" : 1,
          "tokens" : [
            {
              "position" : 9,
              "start_offset" : 17,
              "end_offset" : 19
            }
          ]
        },
        "的" : {
          "term_freq" : 2,
          "tokens" : [
            {
              "position" : 3,
              "start_offset" : 6,
              "end_offset" : 7
            },
            {
              "position" : 12,
              "start_offset" : 23,
              "end_offset" : 24
            }
          ]
        },
        "索引" : {
          "term_freq" : 1,
          "tokens" : [
            {
              "position" : 7,
              "start_offset" : 14,
              "end_offset" : 16
            }
          ]
        },
        "都是" : {
          "term_freq" : 1,
          "tokens" : [
            {
              "position" : 10,
              "start_offset" : 19,
              "end_offset" : 21
            }
          ]
        },
        "默认" : {
          "term_freq" : 1,
          "tokens" : [
            {
              "position" : 5,
              "start_offset" : 11,
              "end_offset" : 13
            }
          ]
        }
      }
    }
  }
}

然后就可以通过词去搜索了。

1
2
3
4
5
6
7
8
9
10
GET blog/_search
{
  "query": {
    "term": {
      "title": {
        "value": "定义"
      }
    }
  }
}

search_analyzer

查询时候的分词器。默认情况下，如果没有配置 search_analyzer ，则查询时首先查看有没有 search_analyzer ，有的话，就用 search_analyzer 来进行分词，如果没有，则看看有没有 analyzer ，如果有，则用 analyzer 进行分词。否则使用 ES 默认的分词器。

1
2
3
4
5
6
7
8
9
10
11
12
PUT blog
{
  "mappings": {
    "properties": {
      "title":{
        "type": "text",
        "analyzer": "ik_smart",
        "search_analyzer": "ik_smart"
      }
    }
  }
}

normalizer

normalizer 参数用于解析前（索引或查询）的标准化配置。

比如说，在 ES 中，对于一些我们不想切分的字符串，我们会通常将其设为 keyword，搜索时也是使用整个词进行搜索。

比如 如果在索引前没有做好数据清洗，导致大小写不一致，例如 SakuraTears 和 sakuratears ，此时，我们就可以使用 normalizer 在索引之前以及查询之前进行文档的标准化。

反例，创建一个名为blog的索引，设置 author 字段类型为 keyword

1
2
3
4
5
6
7
8
9
10
PUT blog
{
  "mappings": {
    "properties": {
      "author":{
        "type": "keyword"
      }
    }
  }
}

添加两个文档，大小写不一致。

1
2
3
4
5
6
7
8
PUT blog/_doc/1
{
  "author":"sakuratears"
}
PUT blog/_doc/2
{
  "author":"SakuraTears"
}

然后进行搜索。

1
2
3
4
5
6
7
8
9
10
GET blog/_search
{
  "query": {
    "term": {
      "author": {
        "value": "sakuratears"
      }
    }
  }
}

可以看到只能搜索到一个文档，受字母大小写影响。

如果使用 normalizer，可以在索引和查询时分别对文档进行预处理。

normalizer定义方式如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
PUT blog
{
  "settings": {
    "analysis": {
      "normalizer":{
        "my_normalizer":{
          "type": "custom",
          "filter":["lowercase"]
        }
      }
    }
  }, 
  "mappings": {
    "properties": {
      "author":{
        "type": "keyword",
        "normalizer": "my_normalizer"
      }
    }
  }
}

在 settings 中定义 normalizer ，然后在 mappings 中引用。

测试方式和前面一致，可以看到此时大小写都可以查出两个文档。

因为无论索引还是查询，都会将大写转为小写。

boost

boost 参数可以设置字段的权重。

boost有两种使用思路，一种就是在定义mappings的时候使用，在指定字段类型时使用；另一种就是在查询时使用。

实际开发中建议使用后者，前者有问题：如果不重新索引文档，权重无法更改。

  • mappings 中使用 boost（不推荐）：
1
2
3
4
5
6
7
8
9
10
11
PUT blog
{
  "mappings": {
    "properties": {
      "content":{
        "type": "text",
        "boost": 2
      }
    }
  }
}
  • 查询时指定boost：
1
2
3
4
5
6
7
8
9
10
11
GET blog/_search
{
  "query": {
    "match": {
      "content": {
        "query": "你好",
        "boost": 2
      }
    }
  }
}

coerce

coerce 用来清除脏数据，默认为true。

例如一个数字，在 JSON 中，用户可能写错了：

1
{"age":"99"}

或者

1
{"age":"99.0"}

这些都不是正确的数字格式。

通过coerce 可以解决该问题。

默认情况下，以下操作没问题，就是 coerce 在起作用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
PUT blog
{
  "mappings": {
    "properties": {
      "age":{
        "type": "integer"
      }
    }
  }
}
  
POST blog/_doc
{
  "age":"99.0"
}

如果需要修改 coerce ，方式如下：

1
2
3
4
5
6
7
8
9
10
11
PUT blog
{
  "mappings": {
    "properties": {
      "age":{
        "type": "integer",
        "coerce": false
      }
    }
  }
}

当 coerce 设为 false 后 ，age 字段传入 数字字符串就会报错。

copy_to

这个属性可以将多个字段的值，复制到同一个字段中。

定义方式如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
PUT blog
{
  "mappings": {
    "properties": {
      "title":{
        "type": "text",
        "copy_to": "full_content"
      },
      "content":{
        "type": "text",
        "copy_to": "full_content"
      },
      "full_content":{
        "type": "text"
      }
    }
  }
}

添加文档：

1
2
3
4
5
PUT blog/_doc/1
{
  "title":"你好，sakuratears",
  "content":"Elasticsearch 学习笔记"
}

查询：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
GET blog/_search
{
  "query": {
    "term": {
      "full_content": {
        "value": "记"
      }
    }
  }
}

GET blog/_search
{
  "query": {
    "term": {
      "full_content": {
        "value": "你"
      }
    }
  }
}

doc_values 和 fielddata

ES 中的搜索主要是用到倒排索引，doc_values 参数是为了加快排序、聚合操作而生的。当建立倒排索引的时候，会额外增加列式存储映射。

doc_values 默认是开启的，如果确定某个字段不需要排序或者不需要聚合，那么可以关闭doc_values 以节省空间。

大部分的字段在索引时都会生成 doc_values，除了 text 。 text 字段在查询时会生成一个fielddata 的数据结构，fielddata 在字段首次被 聚合、排序的时候生成。

doc_valuesfielddata
索引时创建使用时动态创建
磁盘内存
不占用内存不占用磁盘
索引速度稍低文档很多时，动态创建慢，占内存

doc_values 默认开启，fielddata默认关闭。

doc_values 举例：

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
PUT user

PUT user/_doc/1
{
  "age": 100
}

PUT user/_doc/2
{
  "age": 99
}

PUT user/_doc/3
{
  "age": 98
}

PUT user/_doc/4
{
  "age": 101
}


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

由于 doc_values 默认开启的，所以可以直接使用 age 进行排序，如果想关闭 doc_values ，如下：

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
PUT user
{
  "mappings": {
    "properties": {
      "age":{
        "type": "integer",
        "doc_values": false
      }
    }
  }
}
PUT user/_doc/1
{
  "age": 100
}

PUT user/_doc/2
{
  "age": 99
}

PUT user/_doc/3
{
  "age": 98
}

PUT user/_doc/4
{
  "age": 101
}


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

dynamic

dynamic 有三种取值：

  • true ： 默认，自动添加新字段。
  • false： 忽略新字段。
  • strict： 严格模式，发现新字段，会抛出异常。

见学习笔记 （7）

enabled

ES 默认会索引所有的字段，但是有的字段可能只需要存储，不需要索引。此时可以通过 enabled 来进行控制。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
PUT blog
{
  "mappings": {
    "properties": {
      "url":{
        "enabled":false
      }
    }
  }
}

PUT blog/_doc/1
{
  "url":"sakuratears"
}

GET blog/_search
{
  "query": {
    "term": {
      "url": "sakuratears"
    }
  }
}

设置了 enabled 为 false 之后，就不可以通过 该字段搜索了。

format

日期格式。format 规范日期格式，而且一次可以定义多个 format。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
PUT user
{
  "mappings": {
    "properties": {
      "birthday":{
        "type": "date",
        "format": "yyyy-MM-dd||yyyy-MM-dd HH:mm:ss"
      }
    }
  }
}

PUT user/_doc/2
{
  "birthday":"2021-11-03"
}

  • 多个日期格式之间使用 || 符号连接，注意没有空格。

  • 如果用户没有指定日期的format，默认的日期格式 是 strict_date_optional_time||epoch_mills

另外，所有的日期格式都可以在 https://www.elastic.co/guide/en/elasticsearch/reference/current/mapping-date-format.html 网址查看。

ignore_above

ignore_above 用于指定分词和索引的字符串最大长度，超过最大长度的话，该字段将不会被索引，这个字段只适用于 keyword 类型。

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
PUT blog
{
  "mappings": {
    "properties": {
      "title":{
        "type": "keyword",
        "ignore_above": 10
      }
    }
  }
}

PUT blog/_doc/1
{
  "title":"sakuratears"
}

PUT blog/_doc/2
{
  "title":"sakura"
}

GET blog/_search
{
  "query": {
    "terms": {
      "title": [
        "sakura",
        "sakuratears"
      ]
    }
  }
}

上例中 查询 sakuratears 是无结果的，因为其未被索引，但是文档是存在的。

ignore_malformed

ignore_malformed 可以忽略不规则的数据，该参数默认为 false 。

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
PUT users
{
  "mappings": {
    "properties": {
      "birthday":{
        "type": "date",
        "format": "yyyy-MM-dd||yyyy-MM-dd HH:mm:ss"
      },
      "age":{
        "type": "integer",
        "ignore_malformed": true
      }
    }
  }
}

PUT users/_doc/1
{
  "birthday":"2021-06-10",
  "age":99
}
PUT users/_doc/2
{
  "birthday":"2021-06-10",
  "age":"abc"
}

doc 2 可以被存储，不会出错，但是 abc 不能被索引。

include_in_all

这个是针对 _all字段的，但是在 ES7 中，该字段已经被废弃了。

替代品是 copy_to ， 原先ES 会将所有字段存储在一个叫 xxx_all字段里，当我们只知道词，并不知道其属于哪个 field，ES查询的时候会方便。

index

index 指定一个字段是否被索引。该属性为true表示该字段被索引，false表示该字段不被索引。

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
PUT users
{
  "mappings": {
    "properties": {
      "age":{
        "type": "integer",
        "index": false
      }
    }
  }
}

PUT users/_doc/1
{
  "age": 20
}

GET users/_search
{
  "query": {
    "term": {
      "age": {
        "value": "20"
      }
    }
  }
}

查询会报错，提示age字段未被索引。index 为 false，不能通过对应的字段搜索。

index_options

index_options 控制索引时哪些信息被存储到倒排索引中（用在text字段中），有四种取值：

index_options备注
docs只存储文档编号，默认
freqs在 docs的基础上，存储词项频率
positions在 freqs基础上，存储词项偏移位置
offsets在positions基础上，存储词项开始和结束的字符位置

norms

norms 对字段评分有用，text上默认开启 norms，如果不是特别需要，不要开启norms。

null_value

在 ES 中，值为 null 的字段，不索引也不可以被搜索，null_value 可以让值为 null 的字段显式的可索引、可搜索。

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
PUT users
{
  "mappings": {
    "properties": {
      "name":{
        "type": "keyword",
        "null_value": "-"
      }
    }
  }
}

PUT users/_doc/1
{
  "name": null
}

GET users/_search
{
  "query": {
    "term": {
      "name": {
        "value": "-"
      }
    }
  }
}

相当于用 “-” 字符串去代替null。

position_increment_gap

被解析的text字段会将 term 的位置考虑进去，目的是为了支持近似查询和短语查询，当我们去索引一个含有多个值的text字段时，会在各个值之间添加一个假想的空间，将值隔开，这样就可以避免一些无意义的短语匹配，间隔大小通过 position_increment_gap 来控制，默认是100.

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

PUT users/_doc/1
{
  "names": ["zhang san","Li si"]
}

GET users/_search
{
  "query": {
    "match_phrase": {
      "names": "san li"
    }
  }
}
  • san Li 搜索不到，因为两个短语之间有一个假想的空隙，为100。
1
2
3
4
5
6
7
8
9
10
11
GET users/_search
{
  "query": {
    "match_phrase": {
      "names": {
        "query": "san Li",
        "slop": 100
      }
    }
  }
}

可以通过 slop 指定容忍的空隙大小。

也可以在定义索引的时候指定空隙：

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
PUT users
{
  "mappings": {
    "properties": {
      "names":{
        "type": "text",
        "position_increment_gap": 0
      }
    }
  }
}

PUT users/_doc/1
{
  "names": ["zhang san","Li si"]
}

GET users/_search
{
  "query": {
    "match_phrase": {
      "names": {
        "query": "san Li"
      }
    }
  }
}

properties

略

similarity

similarity 指定文档的评分模型，默认有三种。

similarity备注
BM25ES和Lucene默认的评分模型
classicTF/IDF 评分
booleanboolean 评分模型

store

默认情况下，字段会被索引，也可以搜索，但是不会存储。虽然不会被存储，但是 _source中有一个字段的备份。

如果想将字段存储下来，可以通过配置 store 来实现。

term_vector

term_vector 是通过分词器产生的信息，包括：

  • 一组 terms
  • 每个 term 的位置
  • term 的首字符/尾字符与原始字符串原点的偏移量

term_vector 取值如下：

term_vector备注
no不存储信息，默认
yesterm被存储
with_positions在yes的基础上增加位置信息
with_offsets在yes的基础上增加偏移信息
with_positions_offsetsterm、位置、偏移信息都存储

fields

fields 参数可以让同一字段有多种不同的索引方式。例如：

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
PUT blog
{
  "mappings": {
    "properties": {
      "title":{
        "type": "text",
        "fields": {
          "raw":{
            "type":"keyword"
          }
        }
      }
    }
  }
}

PUT blog/_doc/1
{
  "title": "sakura"
}

GET blog/_search
{
  "query": {
    "term": {
      "title": {
        "value": "sakura"
      }
    }
  }
}
GET blog/_search
{
  "query": {
    "term": {
      "title.raw": {
        "value": "sakura"
      }
    }
  }
}

Mapping 参数 地址 ： https://www.elastic.co/guide/en/elasticsearch/reference/current/mapping-params.html

Elasticsearch 映射模板

ES 中有动态映射，但有的时候默认的动态映射规则并不能满足我们的需求，这个时候可以通过映射模板来解决。

例子，将所有的数字默认映射为integer。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
PUT blog
{
  "mappings": {
    "dynamic_templates":[
      {
        "long2integer":{
          "match_mapping_type":"long",
          "mapping":{
            "type":"integer"
          }
        }
      }
      ]
  }
}

PUT blog/_doc/1
{
  "count":99
}

GET blog/_mapping

存储完成后，默认会被识别为long类型的数据，现在就被识别为integer了。

例子：

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
PUT blog
{
  "mappings": {
    "dynamic_templates":[
      {
        "string2integer":{
          "match_mapping_type":"string",
          "match":"num_*",
          "unmatch":"*_text",
          "mapping":{
            "type":"integer"
          }
        }
      }
      ]
  }
}

PUT blog/_doc/1
{
  "num_count":"99",
  "num_text": "sakura"
}


PUT blog/_doc/2
{
  "num_count":"99",
  "num_text": "sakura",
  "num_aaa": 999
}

GET blog/_mapping
  • num_count 字段为字符串 99 ，会进入 匹配逻辑，99变为 integer。
  • num_text 满足unmatch ，不会变为 integer，按照默认的text处理
  • num_aaa 字段为 999，不是字符串，不进入匹配逻辑，按默认的long处理。

结果如下：

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
{
  "blog" : {
    "mappings" : {
      "dynamic_templates" : [
        {
          "string2integer" : {
            "match" : "num_*",
            "unmatch" : "*_text",
            "match_mapping_type" : "string",
            "mapping" : {
              "type" : "integer"
            }
          }
        }
      ],
      "properties" : {
        "num_aaa" : {
          "type" : "long"
        },
        "num_count" : {
          "type" : "integer"
        },
        "num_text" : {
          "type" : "text",
          "fields" : {
            "keyword" : {
              "type" : "keyword",
              "ignore_above" : 256
            }
          }
        }
      }
    }
  }
}



-------------文章结束啦 ~\(≧▽≦)/~ 感谢您的阅读-------------

您的支持就是我创作的动力！

欢迎关注我的其它发布渠道