Elasticsearch笔记（四）：索引及Mapping管理

╰半橙微兮° 2022-04-01 03:26 281阅读 0赞

在之前的章节介绍了[集群规划及管理][Link 1]，本章讲从索引相关的方方面面开始介绍，它包索引管理、映射详解、数据类型、元数据、索引监控相关。

**目录**

一. index

1. 命名规则

2. 创建索引

3. 查看索引

4. Exists

5. 删除索引

6. 索引别名

7. 数据迁移Reindex

8. 打开关闭索引

9. 收缩索引

10. 拆分索引

11. Rollover Index

12. Index templates

13. 索引状态管理

13.1 Clear Cache

13.2 refresh

13.3 flush

13.4 Force Merge

二. type

二. mapping

1. 根对象

2. 动态映射

3. Types Exists

4. Put Mapping

5. Get Mapping

6. 删除映射类型

7. 映射参数

8. 动态模板

9. 缺省映射

四. 元数据

五. 数据类型

1.核心域类型

2. 复杂域类型

六. 索引监控

1. Indices Stats

2. Indices Segments

3. Indices Recovery

4. Indices Shard Stores

--------------------

# 一. index #

## 1. 命名规则 ##

<table> 
 <tbody> 
  <tr> 
   <td style="width:118px;">_index</td> 
   <td>命名必须小写，不能以下划线开头，不能包含逗号、</td> 
  </tr> 
  <tr> 
   <td style="width:118px;">_type</td> 
   <td>命名可以是大写或者小写，但是不能以下划线或者句号开头，不应该包含逗号， 并且长度限制为256个字符、</td> 
  </tr> 
  <tr> 
   <td style="width:118px;">_id</td> 
   <td>唯一确定的文档，要么提供自己的_id ，要么es会自动生成</td> 
  </tr> 
 </tbody> 
</table>

## 2. 创建索引 ##

如果你想禁止自动创建索引，在elasticsearch.yml配置action.auto\_create\_index: false，

<table> 
 <tbody> 
  <tr> 
   <td>number_of_shards</td> 
   <td style="width:592px;">分片数</td> 
  </tr> 
  <tr> 
   <td>number_of_replicas</td> 
   <td style="width:592px;">副本数</td> 
  </tr> 
  <tr> 
   <td>refresh_interval</td> 
   <td style="width:592px;">控制准实时的重要参数</td> 
  </tr> 
  <tr> 
   <td>index.write.wait_for_active_shards</td> 
   <td style="width:592px;">更改仅等待主分片通过索引设置</td> 
  </tr> 
  <tr> 
   <td>index.blocks.read_only</td> 
   <td style="width:592px;">设为true,则索引以及索引的元数据只可读</td> 
  </tr> 
  <tr> 
   <td>index.blocks.read_only_allow_delete</td> 
   <td style="width:592px;">设为true，只读时允许删除。</td> 
  </tr> 
  <tr> 
   <td>index.blocks.read</td> 
   <td style="width:592px;">设为true，则不可读。</td> 
  </tr> 
  <tr> 
   <td>index.blocks.write</td> 
   <td style="width:592px;">设为true，则不可写。</td> 
  </tr> 
  <tr> 
   <td>index.blocks.metadata</td> 
   <td style="width:592px;">设为true，则索引元数据不可读写。</td> 
  </tr> 
 </tbody> 
</table>

> 创建index时设置
> 
> PUT /blogs  
> \{  
>     "settings" : \{  
>         "number\_of\_shards" : 3,  
>         "number\_of\_replicas" : 2  
>     \}  
> \}
> 
> 修改index配置  
> PUT /blogs/\_settings  
> \{  
>     "index" : \{  
>         "number\_of\_replicas" : 1  
>     \}  
> \}

## 3. 查看索引 ##

> GET /blogs/\_settings  
> GET /twitter,kimchy/\_settings  
> GET /\_all/\_settings  
> GET /log\_2013\_\*/\_settings  
> GET /log\_2013\_-\*/\_settings/index.number\_\*

在上一章[集群篇][Link 2]讲过，也可以通过监控，[http://localhost:9200/\_cat/indices?v][http_localhost_9200_cat_indices_v]

## 4. Exists ##

> HEAD /blogs

HTTP status code 表示结果 404 不存在 ， 200 存在

## 5. 删除索引 ##

> DELETE /my\_index                       //删除单个          
> DELETE /index\_one,index\_two    //删除多个  
> DELETE /index\_\*                          //同上  
> DELETE /\_all                                //删除全部   
> DELETE /\*                                    //同上

如果想禁用这个命令，在elasticsearch.yml配置action.destructive\_requires\_name: true

## 6. 索引别名 ##

索引别名就像一个快捷方式或软连接，可以指向一个或多个索引，也可以给任何一个需要索引名的API来使用。\_alias用于单个操作，\_aliases用于执行多个原子级操作，有了它你的应用已经在零停机的情况下从旧索引迁移到新索引了

*  在运行的集群中可以无缝的从一个索引切换到另一个索引
 *  给多个索引分组
 *  给索引的一个子集创建视图

> PUT /my\_index\_v1                                  //创建索引my\_index\_v1  
> PUT /my\_index\_v1/\_alias/my\_index       //设置别名my\_index指向my\_index\_v1  
> GET /\*/\_alias/my\_index                           //检测这个别名指向哪一个索引  
> GET /my\_index\_v1/\_alias/                       //哪些别名指向这个索引  
> POST /\_aliases  
> \{    "actions": \[  
>         \{ "remove": \{ "index": "my\_index\_v1", "alias": "my\_index" \}\},  
>         \{ "add":    \{ "index": "my\_index\_v2", "alias": "my\_index" \}\}  
>     \]  
> \}

## 7. 数据迁移Reindex ##

尽管可以增加新的类型到索引中，或者增加新的字段到类型中，但是不能添加新的分析器或者对现有的字段做改动。如果你那么做的话，结果就是那些已经被索引的数据就不正确，搜索也不能正常工作。对现有数据的这类改变最简单的办法就是重新索引：用新的设置创建新的索引并把文档从旧的索引复制到新的索引。字段\_source的一个优点是在Elasticsearch中已经有整个文档。你不必从源数据中重建索引，而且那样通常比较慢。为了有效的重新索引所有在旧的索引中的文档，用scroll从旧的索引检索批量文档，然后用bulk API把文档推送到新的索引中。从Elasticsearch v2.3.0开始， Reindex API被引入。它能够对文档重建索引而不需要任何插件或外部工具。

> POST \_reindex  
> \{  
>     "source" : \{  
>              "index" : "twitter"     
>     \},  
>        "dest" : \{  
>              "index" : "new\_twitter",  
>              "version\_type" : "external"            
>     \}  
> \}  
> 它有很多可以提高性能的参数和手段：batch\_size、提高并发(slices大小=分片数)、减少复制带来重新索引的开销(副本数设置为0)、大量数据导入不要急于索引刷新(refresh\_interval为-1来禁用刷新，完成后不要忘记重新启用它)

## 8. 打开关闭索引 ##

开放和关闭索引API允许关闭索引，然后打开它。关闭索引几乎没有集群上的开销，并被阻止进行读/写操作。可以使用ignore\_unavailable = true参数禁用此行为。

> POST /my\_index/\_close  
> POST /my\_index/\_open

## 9. 收缩索引 ##

[收缩索引API][API]允许您将现有索引缩小为具有较少主分片的新索引。目标索引中请求的主分片数必须是源索引中分片数的一个因子。例如，具有8个主分片的索引可以缩小为4个，2个或1个主分片，或者具有15个主分片的索引可以缩小为5个，3个或1个。

> POST my\_source\_index/\_shrink/my\_target\_index  
> \{  
>   "settings": \{  
>     "index.number\_of\_replicas": 1,  
>     "index.number\_of\_shards": 1,   
>     "index.codec": "best\_compression"   
>   \},  
>   "aliases": \{  
>     "my\_search\_indices": \{\}  
>   \}  
> \}

## 10. 拆分索引 ##

[拆分索引API][API 1]允许您将现有索引拆分为新索引，其中每个原始主分片在新索引中拆分为两个或更多主分片。\_split API要求使用特定的number\_of\_routing\_shards创建源索引，以便将来拆分。此要求已在Elasticsearch 7.0中删除。可以拆分索引的次数（以及每个原始分片可以拆分成的分片数）由index.number\_of\_routing\_shards设置决定。路由分片的数量指定内部使用的散列空间，以便在具有一致散列的分片中分发文档。例如，将number\_of\_routing\_shards设置为30（5 x 2 x 3）的5个分片索引可以按因子2或3分割。换句话说，它可以按如下方式拆分：

*  5 → 10 → 30 (split by 2, then by 3)
 *  5 → 15 → 30 (split by 3, then by 2)
 *  5 → 30 (split by 6)

> POST my\_source\_index/\_split/my\_target\_index  
> \{  
>   "settings": \{  
>     "index.number\_of\_shards": 2  
>   \}  
> \}

## 11. Rollover Index ##

当现有索引被认为太大或太旧时，[翻转索引API][API 2]对于有时效性的索引数据，如日志，过一定时间后，老的索引数据就没有用了。我们可以像数据库中根据时间创建表来存放不同时段的数据一样，在ES中也可用建多个索引的方式来分开存放不同时段的数据。比数据库中更方便的是ES中可以通过别名滚动指向最新的索引的方式，让你通过别名来操作时总是操作的最新的索引。ES的rollover index API 让我们可以根据满足指定的条件（时间、文档数量、索引大小）创建新的索引，并把别名滚动指向新的索引。

## 12. Index templates ##

[索引模板][Link 3]允许您定义在创建新索引时自动应用的模板。为每个索引写定义信息可能是一件繁琐的事情，ES提供了索引模板功能，让你可以定义一个索引模板，模板中定义好settings、mapping、以及一个模式定义来匹配创建的索引。

## 13. 索引状态管理 ##

### 13.1 Clear Cache ###

*[Clear Cache][]，*默认会清理所有缓存，可指定清理query, fielddata or request 缓存。

> POST /\_cache/clear  
> POST /kimchy,elasticsearch/\_cache/clear

### 13.2 refresh ###

*[Refresh][]，*重新打开读取索引，[更多介绍][Link 4]

> POST /kimchy,elasticsearch/\_refresh  
> POST /\_refresh

### 13.3 flush ###

*[Flush][]，*将缓存在内存中的索引数据刷新到持久存储中。

**问题：如果没有用fsync把数据从文件系统缓存刷（flush）到硬盘，我们不能保证数据在断电甚至是程序正常退出之后依然存在？**

每秒刷新（refresh）实现了近实时搜索，es还引入了[事务日志（简称translog）][translog]，来解决两次提交之间发生变化的文档的丢失。translog提供所有还没有被刷到磁盘的操作的一个持久化纪录。它的用途主要有两种：

1.  当ES启动的时候它会从磁盘中使用最后一个提交点去恢复已知的段，并且会重放translog中所有在最后一次提交后发生的变更操作
2.  也被用来提供实时CRUD 。当你试着通过ID查询、更新、删除一个文档，它会在尝试从相应的段中检索之前，首先检查translog任何最近的变更。这意味着它总是能够实时地获取到文档的最新版本。

它的工作流程：

1.  一个文档被索引之后，就会被添加到内存缓冲区，并且追加到了translog
2.  刷新（refresh）完成后, 缓存被清空但是事务日志不会，此时已经被写一个新的段中，但没有进行fsync操作
3.  这个进程继续工作，更多的文档被添加到内存缓冲区和追加到事务日志
4.  每隔一段时间（flush操作的频率是通过translog的大小控制的，当translog大小达到一定值的时候就执行一次flush，对应参数为index.translog.flush\_threshold\_size，默认值是512mb），例如translog 变得越来越大，索引被flush（文件系统缓存通过fsync被刷新），在刷新flush之后，段被全量提交，并且老的translog被删除

**问题：Translog有多安全?**

translog本身是文件，也需要存储到磁盘，它的存储方式通过index.translog.durability和index.translog.sync\_interval（默认5秒）设定。

> index.translog.durability
> 
>  *  request，意为每次请求都会把translog写到磁盘。这种设定可以降低数据丢失的风险，但是磁盘IO开销会较大，**默认值**。
>  *  async，采用异步方式持久化translog，会采用index.translog.sync\_interval间隔提交一次

默认模式每次写请求完成之后执行，是可以配置的。因此，**重启节点或关闭索引之前执行flush有益于你的索引。**

索引的 flush 过程通过将数据刷新到索引存储并清除内部[trans log][trans_log]，基本上从索引中释放内存。默认情况下，ElasticSearch使用内存启发，以便根据需要自动触发刷新操作，以清除内存。

> POST /blogs/\_flush                        //手动刷新blogs索引  
> POST /\_flush?wait\_for\_ongoing    //手动刷新所有的索引并且并且等待所有刷新在返回前完成

### 13.4 Force Merge ###

*[Force Merge][]，*强制段合并

**问题：段是什么？**

再回顾下，每一个段本身都是一个倒排索引。 一个Lucene索引包含一个提交点（一个列出了所有已知段的文件）和三个段（被混淆的概念是：一个Lucene索引我们在ES称作分片，一个ES索引是分片的集合）。

**问题：为何要进行段合并呢？**

在之前[lucene的IndexWriter][lucene_IndexWriter]中讲过，由于自动刷新（refresh）流程每秒会创建一个新的段，这样会导致短时间内的段数量暴增。而段数目太多会带来较大的麻烦。每一个段都会消耗文件句柄、内存和cpu运行周期。更重要的是，每个搜索请求都必须逐段搜索，所以段越多，搜索也就越慢。

**问题：逐段搜索流程又是什么？**

当ES在索引中搜索的时候，它发送查询到每一个属于索引的分片（Lucene索引），然后所有已知的段按顺序被查询，词项统计会对所有段的结果进行聚合，以保证每个词和每个文档的关联都被准确计算。

1.  新文档被收集到内存索引缓存（包含新文档的Lucene索引）
2.  不时地，缓存被提交（可能是flush缓存操作）
3.  新的段被开启，让它包含的文档可见以被搜索
4.  内存缓存被清空，等待接收新的文档

**问题： 段怎么更新或删除呢？**

段是不可改变的。当一个文档被删除时，它实际上只是在.del文件中被标记删除，一个被标记删除的文档仍然可以被查询匹配到，但会在最终结果集被返回前从中移除。当一个文档被更新时，旧版本文档被标记删除，文档的新版本被索引到一个新的段中，可能两个版本的文档都会被一个查询匹配到，但被删除的那个旧版本文档在结果集返回前就已经被移除。

**问题： 怎样合并？**

ES通过在后台进行段合并（参阅Lucene的MergePolicy）来解决这个问题（小的段被合并到大的段，然后这些大的段再被合并到更大的段），它并不需要你做任何事，自动完成的。 段合并的时候会将那些旧的已删除文档从文件系统中清除。被删除的文档（或被更新文档的旧版本）不会被拷贝到新的大段中。

**问题： 合并要注意什么？**

合并大的段需要消耗大量的I/O和CPU资源，如果任其发展会影响搜索性能。ES在默认情况下会对合并流程进行资源限制，所以搜索仍然有足够的资源很好地执行。

# 二. type #

类型由名称和映射（像数据库中的 schema，描述了文档可能具有的字段或属性、每个字段的数据类型）组成。

**文档是怎样存取的？**

在Lucene中，一个文档由一组简单的键值对组成。Lucene不关心这些值是字符串、数字或日期--所有的值都被当做不透明字节。当我们在Lucene中索引一个文档时，每个字段的值都被添加到相关字段的倒排索引中。你也可以将未处理的原始数据存储起来，以便这些原始数据在之后也可以被检索到。

**类型如何被实现的？**

ES类型是以 Lucene处理文档的这个方式为基础来实现的，但Lucene没有文档类型的概念，每个文档的类型名被存储在一个叫\_type的元数据字段上。当我们要检索某个类型的文档时, ES通过在\_type字段上使用过滤器限制只返回这个类型的文档。

**映射如何被实现的？**

Lucene也没有映射的概念。映射是ES将复杂JSON文档映射成Lucene需要的**扁平化数据**的方式。

# 二. mapping #

在ES中创建一个mapping映射类似于在数据库中定义表结构，即表里面有哪些字段、字段是什么类型、字段的默认值等；

## 1. **根对象** ##

映射的最高一层被称为根对象，包含：一个properties节点，各种元数据字段（它们都以一个下划线开头如：\_type、\_id和\_source）

## 2. 动态映射 ##

ES最重要的功能之一是它试图摆脱你的方式，让你尽快开始探索你的数据。要索引文档，您不必首先创建索引，定义映射类型和定义字段 - 您只需索引文档，索引，类型和字段将自动生命。自动检测和添加新字段称为[动态映射][Link 5]。默认情况下，当在文档中找到以前未见过的字段时，ES会将新字段添加到类型映射中。通过将dynamic参数设置为false（忽略新字段）或strict（如果遇到未知字段则抛出异常），可以在文档和对象级别禁用此行为。

<table> 
 <tbody> 
  <tr> 
   <td style="vertical-align:top;"> <p><strong>JSON datatype</strong></p> </td> 
   <td style="vertical-align:top;"> <p><strong>Elasticsearch datatype</strong></p> </td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;"> <p><code>null</code></p> </td> 
   <td style="vertical-align:top;"> <p>No field is added.</p> </td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;"> <p><code>true</code>&nbsp;or&nbsp;<code>false</code></p> </td> 
   <td style="vertical-align:top;"> <p><a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/boolean.html" rel="nofollow"><code>boolean</code></a>&nbsp;field</p> </td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;"> <p>floating&nbsp;point&nbsp;number</p> </td> 
   <td style="vertical-align:top;"> <p><a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/number.html" rel="nofollow"><code>float</code></a>&nbsp;field</p> </td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;"> <p>integer</p> </td> 
   <td style="vertical-align:top;"> <p><a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/number.html" rel="nofollow"><code>long</code></a>&nbsp;field</p> </td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;"> <p>object</p> </td> 
   <td style="vertical-align:top;"> <p><a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/object.html" rel="nofollow"><code>object</code></a>&nbsp;field</p> </td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;"> <p>array</p> </td> 
   <td style="vertical-align:top;"> <p>Depends on the first non-<code>null</code>&nbsp;value in the array.</p> </td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;"> <p>string</p> </td> 
   <td style="vertical-align:top;"> <p>Either a&nbsp;<a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/date.html" rel="nofollow"><code>date</code></a>&nbsp;field (if the value passes&nbsp;<a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/dynamic-field-mapping.html#date-detection" rel="nofollow">date detection</a>), a&nbsp;<a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/number.html" rel="nofollow"><code>double</code></a>&nbsp;or&nbsp;<a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/number.html" rel="nofollow"><code>long</code></a>&nbsp;field (if the value passes&nbsp;<a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/dynamic-field-mapping.html#numeric-detection" rel="nofollow">numeric detection</a>) or a&nbsp;<a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/text.html" rel="nofollow"><code>text</code></a>&nbsp;field, with a&nbsp;<a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/keyword.html" rel="nofollow"><code>keyword</code></a>&nbsp;sub-field.</p> </td> 
  </tr> 
 </tbody> 
</table>

**日期检测**

如果启用了date\_detection（默认），则会检查新的字符串字段以查看其内容是否与dynamic\_date\_formats中指定的任何日期模式匹配。如果找到匹配项，则添加具有相应格式的新日期字段。

> 如果要禁用动态日期检测，可以通过date\_detection设置为false
> 
> PUT my\_index  
> \{  
>   "mappings": \{  
>     "\_doc": \{  
>       "date\_detection": false  
>     \}  
>   \}  
> \} 
> 
> 你也可以自定义规则，默认值为：\["strict\_date\_optional\_time","yyyy/MM/dd HH:mm:ss Z||yyyy/MM/dd Z"\]
> 
> PUT my\_index  
> \{  
>   "mappings": \{  
>     "\_doc": \{  
>       "dynamic\_date\_formats": \["MM/dd/yyyy"\]  
>     \}  
>   \}  
> \}

**数字检测**

虽然JSON支持本机浮点和整数数据类型，但某些应用程序或语言有时可能将数字呈现为字符串。通常，正确的解决方案是显式映射这些字段，但可以启用数字检测（默认情况下禁用）以自动执行此操作：

> PUT my\_index  
> \{  
>   "mappings": \{  
>     "\_doc": \{  
>       "numeric\_detection": true  
>     \}  
>   \}  
> \}  
> PUT my\_index/\_doc/1  
> \{  
>   "my\_float":   "1.0",   
>   "my\_integer": "1"   
> \}

## 3. Types Exists ##

> HEAD twitter/\_mapping/tweet

用于检查index中是否存在type，404表示它不存在，200表示它存在。

## 4. Put Mapping ##

可以增加一个存在的映射，你不能修改存在的域映射(该域的数据可能已经被索引，你意图修改这个域的映射，索引的数据可能会出错，不能被正常的搜索)

> PUT my\_index   
> \{  
>   "mappings": \{  
>     "\_doc": \{  
>       "properties": \{  
>         "name": \{  
>           "properties": \{  
>             "first": \{  
>               "type": "text"  
>             \}  
>           \}  
>         \},  
>         "user\_id": \{  
>           "type": "keyword"  
>         \}  
>       \}  
>     \}  
>   \}  
> \}
> 
> 更新映射，[更多][Link 6]
> 
> PUT my\_index/\_mapping/\_doc  
> \{  
>   "properties": \{  
>     "name": \{  
>       "properties": \{  
>         "last": \{   
>           "type": "text"  
>         \}  
>       \}  
>     \},  
>     "user\_id": \{  
>       "type": "keyword",  
>       "ignore\_above": 100   
>     \}  
>   \}  
> \}

## 5. Get Mapping ##

> GET /twitter/\_mapping/\_doc  
> GET /\_all/\_mapping  
> GET /\_mapping
> 
> 当然你也可以[获取字段映射][Link 7]
> 
> GET publications/\_mapping/\_doc/field/title  
> GET /twitter,kimchy/\_mapping/field/message  
> GET /\_all/\_mapping/\_doc,tweet,book/field/message,user.id  
> GET /\_all/\_mapping/\_do\*/field/\*.id

## 6. 删除映射类型 ##

在ES 6.0.0或更高版本中创建的索引可能只包含单个映射类型。在具有多种映射类型的5.x中创建的索引将继续像以前一样在Elasticsearch 6.x中运行。映射类型将在ES 7.0.0中完全删除。具体移除映射类型的情况，[详见][Link 8]

最初，我们谈到了一个“索引”类似于SQL数据库中的“数据库”，而“类型”等同于“表”。这是一个糟糕的比喻，导致错误的假设。在SQL数据库中，表彼此独立。一个表中的列与另一个表中具有相同名称的列无关。映射类型中的字段不是这种情况。在Elasticsearch索引中，不同映射类型中具有相同名称的字段在内部由相同的Lucene字段支持。换句话说，使用上面的示例，用户类型中的user\_name字段存储在与tweet类型中的user\_name字段完全相同的字段中，并且两个user\_name字段在两种类型中必须具有相同的映射（定义）。最重要的是，在同一索引中存储具有很少或没有共同字段的不同实体会导致稀疏数据并干扰Lucene有效压缩文档的能力。出于这些原因，我们决定从ES中删除映射类型的概念。

## 7. 映射参数 ##

以下映射参数对于某些或所有字段数据类型是通用的

*  [`analyzer`][analyzer]
 *  [`normalizer`][normalizer]
 *  [`boost`][boost]
 *  [`coerce`][coerce]
 *  [`copy_to`][copy_to]
 *  [`doc_values`][doc_values]
 *  [`dynamic`][dynamic]
 *  [`enabled`][enabled]
 *  [`fielddata`][fielddata]
 *  [`eager_global_ordinals`][eager_global_ordinals]
 *  [`format`][format]
 *  [`ignore_above`][ignore_above]
 *  [`ignore_malformed`][ignore_malformed]
 *  [`index_options`][index_options]
 *  [`index`][index]
 *  [`fields`][fields]
 *  [`norms`][norms]
 *  [`null_value`][null_value]
 *  [`position_increment_gap`][position_increment_gap]
 *  [`properties`][properties]
 *  [`search_analyzer`][search_analyzer]
 *  [`similarity`][similarity]
 *  [`store`][store]
 *  [`term_vector`][term_vector]

## 8. 动态模板 ##

dynamic\_templates可以完全控制新检测生成字段的映射，可以通过字段名称或数据类型来应用不同的映射，[了解更多][Link 9]。

> PUT /my\_index  
> \{"mappings": \{  
>         "my\_type": \{      
>             "dynamic\_templates": \[  
>                 \{ "es": \{                //以\_es结尾的字段名需要使用spanish分词器  
>                       "match":              "\*\_es",     //只匹配字段名称  
>                       "match\_mapping\_type": "string",  
>                       "mapping": \{  
>                           "type":           "string",  
>                           "analyzer":       "spanish"  
>                       \}  
>                 \}\},  
>                 \{ "en": \{                //所有其他字段使用english分词器  
>                       "match":              "\*",   
>                       "match\_mapping\_type": "string",  
>                       "mapping": \{  
>                           "type":           "string",  
>                           "analyzer":       "english"  
>                       \}  
>                 \}\}  
>             \]  
> \}\}\}

## 9. 缺省映射 ##

[\_default\_][default]映射更加方便地指定通用设置，而不是每次创建新类型时都要重复设置。\_default\_映射也是一个指定索引dynamic templates 的好方法。[enabled][]：适用于只想存储字段而不对其进行索引，只能应用于映射类型(type根节点)和对象字段(type的内部对象)

> \{    "mappings": \{  
>         "\_default\_": \{    //所有的类型禁用\_all字段  
>             "\_all": \{ "enabled":  false \}  
>         \},  
>         "blog": \{        //只在blog类型启用  
>             "\_all": \{ "enabled":  true  \}  
>         \}  
>     \}  
> \}

# 四. 元数据 #

每个文档都有与之关联的元数据，例如\_index， \_type和\_id元字段。创建映射类型时，可以自定义某些元字段的行为。

**标示类元数据**

<table> 
 <tbody> 
  <tr> 
   <td style="vertical-align:top;width:234px;"> <p><a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/mapping-index-field.html" rel="nofollow"><code>_index</code></a></p> </td> 
   <td style="vertical-align:top;width:615px;">文档所属的索引，_index作为虚拟字段公开 - 它不作为真实字段添加到Lucene索引中。</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;width:234px;"> <p><a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/mapping-uid-field.html" rel="nofollow"><code>_uid</code></a></p> </td> 
   <td style="vertical-align:top;width:615px;">由_type和_id组成的复合字段，被存储（可取回）和被索引（可搜索）</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;width:234px;"> <p><a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/mapping-type-field.html" rel="nofollow"><code>_type</code></a></p> </td> 
   <td style="vertical-align:top;width:615px;">文档的映射类型，被索引但是没有存储</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;width:234px;"> <p><a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/mapping-id-field.html" rel="nofollow"><code>_id</code></a></p> </td> 
   <td style="vertical-align:top;width:615px;"> <p>文档的ID，被索引但是没有存储</p> </td> 
  </tr> 
 </tbody> 
</table>

**文档存储源元数据**

<table> 
 <tbody> 
  <tr> 
   <td><a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/mapping-source-field.html" rel="nofollow"><code>_source</code></a></td> 
   <td style="width:613px;">表示文档正文的原始JSON，该字段先会压缩然后写入磁盘，但是可以配置禁用。</td> 
  </tr> 
  <tr> 
   <td><a href="https://www.elastic.co/guide/en/elasticsearch/plugins/6.2/mapper-size.html" rel="nofollow"><code>_size</code></a></td> 
   <td style="width:613px;">_source字段的大小（以字节为单位），由<a href="https://www.elastic.co/guide/en/elasticsearch/plugins/6.2/mapper-size.html" rel="nofollow"><code>mapper-size</code>&nbsp;plugin</a>插件提供</td> 
  </tr> 
 </tbody> 
</table>

**索引元数据**

<table> 
 <tbody> 
  <tr> 
   <td style="width:234px;"><a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/mapping-all-field.html" rel="nofollow"><code>_all</code></a></td> 
   <td style="width:615px;"> <p>一个catch-all字段，用于索引所有其他字段的值，默认情况下禁用。</p> <p>当搜索需求不明确(无明确字段)时，可使用_all(应急之策)，当索引一个文档的时候，同时把该文档的所有字段值拼接成一个字符串后，做分词，然后保存倒排索引，用于支持整个json的全文检索。</p> <p>_all这种需求适用的场景较少，可以通过_mapping中enabled将all字段关闭，节约存储成本和cpu开销。_mapping中include_in_all也可以控制_all包含的每个字段，默认值是true(所以字段都包含)。</p> <p>相关度算法中提到一个原则字段越短越重要，较短次出现在title字段比content字段更加重要，而字段长度的区别在_all中没有意义。</p> <p>注：_all仅仅是一个经过分词的text字段。它使用默认分词器来分析它的值，不管这个值原本所在字段指定的分词器。</p> 
    <blockquote> 
     <p>PUT /my_index/_mapping/my_type<br> { <br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;"my_type": { <br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;"_all": { "enabled": false }<br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}<br> }<br> PUT /my_index/my_type/_mapping<br> { <br> &nbsp;&nbsp;&nbsp;&nbsp;"my_type": { <br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;"include_in_all": false,<br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;"properties": { <br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;"title": { <br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;"type": &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;"string",<br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;"include_in_all": true<br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;},<br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;...<br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}<br> &nbsp;&nbsp;&nbsp;&nbsp;}<br> }&nbsp;&nbsp;&nbsp;<br> PUT /my_index/my_type/_mapping<br> { <br> &nbsp;&nbsp;&nbsp;&nbsp;"my_type": { &nbsp;//控制_all使用的分词器<br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;"_all": { "analyzer": "whitespace" }&nbsp;<br> &nbsp;&nbsp;&nbsp;&nbsp;}<br> }</p> 
    </blockquote> </td> 
  </tr> 
  <tr> 
   <td style="width:234px;"><a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/mapping-field-names-field.html" rel="nofollow"><code>_field_names</code></a></td> 
   <td style="width:615px;">文档中包含非空值的所有字段</td> 
  </tr> 
 </tbody> 
</table>

**路由元数据**

<table> 
 <tbody> 
  <tr> 
   <td style="width:234px;"><a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/mapping-routing-field.html" rel="nofollow"><code>_routing</code></a></td> 
   <td style="width:615px;">自定义路由值，用于将文档路由到特定分片</td> 
  </tr> 
 </tbody> 
</table>

**其他元数据**

<table> 
 <tbody> 
  <tr> 
   <td style="width:234px;"><a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/mapping-meta-field.html" rel="nofollow"><code>_meta</code></a></td> 
   <td style="width:615px;">特定应用元数据</td> 
  </tr> 
 </tbody> 
</table>

# 五. 数据类型 #

## 1.核心域类型 ##

<table> 
 <tbody> 
  <tr> 
   <td style="vertical-align:top;width:173px;"> <p>string</p> </td> 
   <td style="vertical-align:top;width:676px;"> <p><a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/text.html" rel="nofollow"><code>text</code></a>&nbsp;and&nbsp;<code><a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/keyword.html" rel="nofollow">keyword</a>，</code>注：ES5.0以后，string类型有重大变更，移除了string类型（继续使用会自动转为text），ES6.0不支持(会报错)。</p> <p><strong>text会分词，然后进行索引，支持模糊查询，适用于全文搜索（analyzed字符串）</strong></p> <p><strong>keyword不进行分词，直接索引，支持精确查询，适用于关键词搜索（not-analyzed字符串）</strong></p> 
    <ul> 
     <li>index：默认为true，可索引搜索</li> 
     <li>store：默认为true，不分开存储和检索字段值_source字段</li> 
     <li>analyzer：默认standard analyzer&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</li> 
     <li>fielddata：字段可以在内存字段数据中用于排序、聚合或脚本吗？接受true或false（默认）</li> 
     <li>fielddata_frequency_filter：</li> 
     <li>fields：多字段允许为不同的目的以多种方式对相同的字符串值进行索引，例如用于搜索的一个字段和用于排序和聚合的多个字段&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</li> 
     <li>index_options：哪些信息应该存储在索引,用于搜索和高亮显示。默认到positions</li> 
     <li>norms：默认为true（评分时应考虑字段长度）</li> 
     <li>position_increment_gap：默认为100（短语搜索应该小于100）</li> 
     <li>search_analyzer：默认为analyzer参数值，搜索使用的分析器</li> 
     <li>similarity：默认为BM25，相似度算法，Lucene4.0之后也可以选择使用BM25算法(默认是TF-IDF)</li> 
     <li>term_vector：默认为no，不开启配置mapping中field的term_vector(它包含term的位置、词频)属性，开启会增加索引的体积，主要用于相应的数据统计或开发其他功能，<br> &nbsp;</li> 
    </ul><p>ES中的一个字段既可以是text，又可以是keyword类型吗？是没有的&nbsp;</p> 
    <ul> 
     <li>index：不赘述</li> 
     <li>store：不赘述</li> 
     <li>fields：同上</li> 
     <li>doc_values：字段是否应该以列跨步的方式存储在磁盘上，以便稍后可以用于排序、聚合或脚本编制？接受true（默认）或false</li> 
     <li>eager_global_ordinals：</li> 
     <li>index_options：同上</li> 
     <li>ignore_above：默认值为2147483647，不要索引任何字符串的长度超过这个值</li> 
     <li>norms：默认为false（评分时不考虑字段长度）</li> 
     <li>null_value：同上</li> 
     <li>similarity：同上</li> 
     <li>normalizer：格式化，默认值为NULL，这意味着关键字按原样保存，如何在索引之前对关键词进行预处理</li> 
    </ul></td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;width:173px;"> <p><a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/number.html" rel="nofollow">Numeric datatypes</a></p> </td> 
   <td style="vertical-align:top;width:676px;"> <p>long, integer, short, byte, double, float, half_float, scaled_float</p> <p>其实一般可以视为not-analyzed，比keyword高效在于不做评分计算，此类型可视为已经忽略评分的语法。</p> 
    <ul> 
     <li>coerce：默认为true，将字符串转换为数字和一块截断分数为整数</li> 
     <li>ignore_malformed：默认false(非数字抛出一个异常并拒绝整个文档)，true(异常的数字将被忽略)</li> 
     <li>index：默认为true，不赘述</li> 
     <li>null_value：默认为null,这意味着该领域被视为missing</li> 
     <li>store：默认为false，不赘述</li> 
    </ul></td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;width:173px;"> <p><a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/date.html" rel="nofollow">Date datatype</a></p> </td> 
   <td style="vertical-align:top;width:676px;">date</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;width:173px;"> <p><a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/boolean.html" rel="nofollow">Boolean datatype</a></p> </td> 
   <td style="vertical-align:top;width:676px;"> <p>boolean</p> </td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;width:173px;"><a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/binary.html" rel="nofollow">Binary datatype</a></td> 
   <td style="vertical-align:top;width:676px;">binary</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;width:173px;"><a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/range.html" rel="nofollow">Range datatypes</a></td> 
   <td style="vertical-align:top;width:676px;"><code>integer_range</code>,&nbsp;<code>float_range</code>,&nbsp;<code>long_range</code>,&nbsp;<code>double_range</code>,&nbsp;<code>date_range</code></td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;width:173px;">null</td> 
   <td style="vertical-align:top;width:676px;">下面被认为是空的，它们将不会被索引<br> "null_value": &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;null,<br> "empty_array": &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[],<br> "array_with_null_value": &nbsp;&nbsp;&nbsp;[ null ]</td> 
  </tr> 
 </tbody> 
</table>

> "user": \{  
>         "type": "text",  
>         "fields": \{    //仅用于排序和聚合  
>             "keyword": \{  
>                 "type": "keyword",  
>                 "ignore\_above": 256    //长度超过256的字符串(字符个数),analyzer不会进行处理,所以就不会索引起来,最终搜索引擎搜索不到了  
>             \}  
>         \}  
> \}

## 2. 复杂域类型 ##

<table> 
 <tbody> 
  <tr> 
   <td style="vertical-align:top;width:173px;"> <p><a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/array.html" rel="nofollow">Array datatype</a></p> </td> 
   <td style="vertical-align:top;width:676px;">数组支持不需要专用类型（理解为动态的字符串或object类型）</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;width:173px;"> <p><a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/object.html" rel="nofollow">Object datatype</a></p> </td> 
   <td style="vertical-align:top;width:676px;"> <p>一般不需要显式地将字段类型设置为object，因为这是默认值。</p> 
    <ul> 
     <li>dynamic：默认为true(可以添加新字段)，false:忽略新的字段，strict:如果遇到新字段抛出异常</li> 
     <li>enabled：默认为true（对于对象字段给出的JSON值应该被解析和索引），false(完全忽略)</li> 
     <li>properties：对象中的字段，可以是任何数据类型，包括对象。可以将新属性添加到现有对象中。</li> 
    </ul></td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;width:173px;"><a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/nested.html" rel="nofollow">Nested datatype</a></td> 
   <td style="vertical-align:top;width:676px;"> <p>嵌套用于JSON对象数组，它允许对象数组彼此独立地被索引和查询。因为嵌套文档被索引为单独的文档，所以只能在nested查询、nested/reverse_nested聚合或嵌套内部命中的范围内访问它们。为了防止定义错误的映射，每个索引可以定义的nested类型的字段的数量被限制为50。</p> 
    <ul> 
     <li>&nbsp;dynamic：同上</li> 
     <li>&nbsp;properties：同上</li> 
    </ul></td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;width:173px;"><a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/geo-point.html" rel="nofollow">Geo-point datatype</a></td> 
   <td style="vertical-align:top;width:676px;">对于纬度/经度点</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;width:173px;"><a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/geo-shape.html" rel="nofollow">Geo-Shape datatype</a></td> 
   <td style="vertical-align:top;width:676px;">复杂的形状，如多边形</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;width:173px;"><a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/ip.html" rel="nofollow">IP datatype</a></td> 
   <td style="vertical-align:top;width:676px;">IPv4/IPv6&nbsp;</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;width:173px;"><a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/search-suggesters-completion.html" rel="nofollow">Completion datatype</a></td> 
   <td style="vertical-align:top;width:676px;">提供自动完成的建议</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;width:173px;"><a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/token-count.html" rel="nofollow">Token count datatype</a></td> 
   <td style="vertical-align:top;width:676px;">计算字符串中的标记数</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;width:173px;"><a href="https://www.elastic.co/guide/en/elasticsearch/reference/6.2/parent-join.html" rel="nofollow"><code>join</code>&nbsp;datatype</a></td> 
   <td style="vertical-align:top;width:676px;">为同一索引中的文档定义父/子关系</td> 
  </tr> 
 </tbody> 
</table>

> \{ "tweet":      "Elasticsearch is very flexible",  
>     "user": \{  
>         "id":     "@johnsmith",  
>         "age":    26,  
>         "name": \{  
>             "full": "John Smith"  
>         \}  
>     \}  
> \}  
> 上面对象的映射  
> \{"gb": \{  
>     "tweet": \{ //根对象   
>       "properties": \{  
>         "tweet":            \{ "type": "string" \},  
>         "user": \{ //内部对象  
>           "type":             "object",  
>           "properties": \{  
>             "id":           \{ "type": "string" \},  
>             "age":          \{ "type": "long"   \},  
>             "name":   \{ //内部对象  
>               "type":         "object",  
>               "properties": \{  
>                 "full":     \{ "type": "string" \}  
>               \}  
>             \}  
>           \}  
>         \}  
>       \}  
>     \}  
>   \}  
> \}

**思考这样一个问题，内部对象（user）及内部数组（followers****）****如何被索引？**

Lucene不理解内部对象，Lucene文档是由一组键值对列表组成的。

为了能让ES有效地索引内部类，它把文档转化："user.name.full": \[john, smith\]为内部对象数组时。也是同理（内部数组）扁平化处理，这样的话也有问题的（\{age: 35\}和 \{name:Mary White\}之间的相关性已经丢失了）！

要想解决必须使用嵌套对象(nested对象)

> \{  
>     "followers": \[  
>         \{ "age": 35, "name": "Mary White"\},  
>         \{ "age": 26, "name": "Alex Jones"\},  
>         \{ "age": 19, "name": "Lisa Smith"\}  
>     \]  
> \}
> 
> \{  
>     "followers.age":    \[19, 26, 35\],  
>     "followers.name":   \[alex, jones, lisa, smith, mary, white\]  
> \}

# 六. 索引监控 #

## 1. Indices Stats ##

[Indices Stats][]，索引状态提供有关索引上发生的不同操作的统计信息。API提供有关索引级别范围的统计信息（尽管也可以使用节点级别范围检索大多数统计信息），通过GET /\_stats

## 2. Indices Segments ##

[Indices Segments][]，提供构建Lucene索引（分片级别）的低级别段信息。允许用于提供有关分片和索引状态的更多信息，可能是优化信息，删除时“wasted”的数据，等等，通过GET /test/\_segments

## 3. Indices Recovery ##

[Indices Recovery][]，索引恢复API提供对正在进行的索引碎片恢复的深入了解。可以针对特定索引或群集范围报告恢复状态。例如，以下命令将显示索引“index1”和“index2”的恢复信息：

GET index1,index2/\_recovery?human

## 4. Indices Shard Stores ##

[Indices Shard Stores][]，提供索引的分片副本的存储信息。存储有关哪些节点分片副本存在的信息报告，分片副本分配ID，每个分片副本的唯一标识符以及打开分片索引时遇到的任何异常或早期引擎故障。

通过GET /test/\_shard\_stores

总结，es的索引这章干货非常多，非常值得花些时间慢慢研究的。![Link 2][]

[Link 1]: https://blog.csdn.net/itsoftchenfei/article/details/85332383
[Link 2]: /images/20220401/4d898a6f170d4a32bc6f3d28a65f5e29.png
[http_localhost_9200_cat_indices_v]: http://localhost:9200/_cat/indices?v
[API]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-shrink-index.html#indices-shrink-index
[API 1]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-split-index.html#indices-split-index
[API 2]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-rollover-index.html#indices-rollover-index
[Link 3]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-templates.html
[Clear Cache]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-clearcache.html
[Refresh]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-refresh.html
[Link 4]: https://blog.csdn.net/alex_xfboy/article/details/85332410#4.8%20referesh
[Flush]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-flush.html
[translog]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/index-modules-translog.html#index-modules-translog
[trans_log]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/index-modules-translog.html
[Force Merge]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-forcemerge.html
[lucene_IndexWriter]: https://blog.csdn.net/alex_xfboy/article/details/83376384#2.3%20%E6%A0%B8%E5%BF%83API
[Link 5]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/dynamic-mapping.html
[Link 6]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-put-mapping.html
[Link 7]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-get-field-mapping.html#indices-get-field-mapping
[Link 8]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/removal-of-types.html#_schedule_for_removal_of_mapping_types
[analyzer]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/analyzer.html
[normalizer]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/normalizer.html
[boost]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/mapping-boost.html
[coerce]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/coerce.html
[copy_to]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/copy-to.html
[doc_values]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/doc-values.html
[dynamic]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/dynamic.html
[enabled]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/enabled.html
[fielddata]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/fielddata.html
[eager_global_ordinals]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/eager-global-ordinals.html
[format]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/mapping-date-format.html
[ignore_above]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/ignore-above.html
[ignore_malformed]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/ignore-malformed.html
[index_options]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/index-options.html
[index]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/mapping-index.html
[fields]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/multi-fields.html
[norms]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/norms.html
[null_value]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/null-value.html
[position_increment_gap]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/position-increment-gap.html
[properties]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/properties.html
[search_analyzer]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/search-analyzer.html
[similarity]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/similarity.html
[store]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/mapping-store.html
[term_vector]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/term-vector.html
[Link 9]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/dynamic-templates.html
[default]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/default-mapping.html
[Indices Stats]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-stats.html
[Indices Segments]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-segments.html#indices-segments
[Indices Recovery]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-recovery.html
[Indices Shard Stores]: https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-shards-stores.html