Elasticsearch7.5 元字段说明

https://www.elastic.co/guide/en/elasticsearch/reference/current/cat-nodeattrs.html

详细参数

查看节点（每个命令都接受一个查询字符串参数v以打开详细输出）
v
127.0.0.1:9200/_cat/master?v

帮助

每个命令都接受一个查询字符串参数help
help
http://127.0.0.1:9200/_cat/master?help

字段

显示节点对应数据（ip 端口 占比 名称）（每个命令都接受一个查询字符串参数h）
h
http://127.0.0.1:9200/_cat/nodes?h=ip,port,heapPercent,name
 *（所有列）

格式

查看所有索引信息(所有分片使用的存储，而不是文档数量)
format
http://127.0.0.1:9200/_cat/indices?v
已json格式显示
http://127.0.0.1:9200/_cat/indices?format=json&pretty
支持的格式
text (default) - json - smile - yaml - cbor

字节单位

用于显示字节值的单位（b、mb、g）
bytes
127.0.0.1:9200/_cat/master?v&bytes=b

排序

排序控制
s
http://127.0.0.1:9200/_cat/templates?v&s=order:desc,index_patterns

节点参数

http://127.0.0.1:9200/_cat/allocation?v

shards                      1
disk.indices               260b
disk.used                  47.3gb
disk.avail                  43.4gb
disk.total                  100.7gb
disk.percent             46
host                         127.0.0.1
ip                             127.0.0.1
node                        CSUXak2

查看文档数量

http://127.0.0.1:9200/_cat/count/<index>?v

返回集群中每个数据节点上的字段数据当前使用的堆内存量

http://127.0.0.1:9200/_cat/fielddata?v

指定字段

http://127.0.0.1:9200/_cat/fielddata/body,soul?v

查看节点健康状态

http://127.0.0.1:9200/_cat/health?v
去除时间与排序
http://127.0.0.1:9200/_cat/health?v&ts=false

查看索引列表信息

http://127.0.0.1:9200/_cat/indices?v
查看单个索引信息
http://127.0.0.1:9200/_cat/indices/org?v

查看有关主节点的信息，包括ID，绑定的IP地址和名称

127.0.0.1:9200/_cat/master?v

返回有关自定义节点属性的信息

http://127.0.0.1:9200/_cat/nodeattrs?v

查看节点信息

http://127.0.0.1:9200/_cat/nodes?v

返回尚未执行的集群级更改

http://127.0.0.1:9200/_cat/pending_tasks?v

返回在集群的每个节点上运行的插件列表

http://127.0.0.1:9200/_cat/plugins?v

返回有关正在进行和已完成的分片恢复的信息

http://127.0.0.1:9200/_cat/recovery/<index>

返回集群的快照存储库

http://127.0.0.1:9200/_cat/repositories?v

创建索引

索引名称必须满足以下条件：
仅小写
不能包括\，/，*，?，"，<，>，|，``（空格字符）， ,，#
7.0之前的索引可能包含冒号（:），但已弃用，并且在7.0+中不支持
无法下手-，_，+
不能为.或..
不能超过255个字节（请注意它是字节，因此多字节字符将更快地计入255个限制）

创建索引参数内容
aliases
（可选，别名对象）包括索引的索引别名。请参阅更新索引别名。
mappings
（可选，映射对象）映射索引中的字段。如果指定，则此映射可以包括：
栏位名称
字段数据类型
映射参数
请参阅映射。

settings
（可选，索引设置对象）索引的配置选项。请参阅索引设置

索引设置编辑

创建的每个索引都可以具有与之关联的特定设置，这些设置在主体中定义

详细版本

PUT /twitter
{
    "settings" : {
        "index" : {
            "number_of_shards" : 3, 
            "number_of_replicas" : 2 
        }
    }
}

简化版本

PUT /twitter
{
    "settings" : {
        "number_of_shards" : 3,
        "number_of_replicas" : 2
    }
}

默认为number_of_shards1

默认number_of_replicas值为1（即每个主分片一个副本）

注意创建索引详细说明：
https://www.elastic.co/guide/en/elasticsearch/reference/current/index-modules.html

创建索引API允许提供映射定义（创建索引，并定义字段）

PUT /test
{
    "settings" : {
        "number_of_shards" : 1
    },
    "mappings" : {
        "properties" : {
            "field1" : { "type" : "text" }
        }
    }
}

注意 7.0之后不建议在请求中指定类型，但是如果设置了请求参数include_type_name，仍然可以提供一种类型
字段类型： https://www.elastic.co/guide/en/elasticsearch/reference/current/mapping-types.html

创建索引API还允许提供一组别名

PUT /test
{
    "aliases" : {
        "alias_1" : {},
        "alias_2" : {
            "filter" : {
                "term" : {"user" : "kimchy" }
            },
            "routing" : "kimchy"
        }
    }
}

元字段
简介：
在创建索引时，需要定义多个元字段行为

_index：文档所属的索引

_type：文档的映射类型

_id：文档索引

文档源元字段编辑
_source：表示文档正文的原始JSON。
_size：插件_source提供 的字段大小（以字节为单位） 
[需安装mapper-size插件]
(https://www.elastic.co/guide/en/elasticsearch/plugins/7.5/mapper-size.html)


索引元字段编辑
_field_names：文档中包含非空值的所有字段（已被弃用，并将在以后的主要版本中将其删除）
_ignored：由于导致索引时间被忽略的文档中的所有字段 
[需安装ignore_malformed插件]
（https://www.elastic.co/guide/en/elasticsearch/reference/current/ignore-malformed.html）

路由元字段编辑
_routing：一个自定义的路由值，用于将文档路由到特定的分片

其他元场编辑
_meta：特定于应用程序的元数据

详细说明

_id

简介：
每个文档都有一个_id唯一标识它的索引

PUT my_index/_doc/1
{
  "text": "Document with ID 1"
}

PUT my_index/_doc/2?refresh=true
{
  "text": "Document with ID 2"
}

GET my_index/_search
{
  "query": {
    "terms": {
      "_id": [ "1", "2" ] 
    }
  }
}

字段说明：

id值长度为512个字节，超出长度会被拒绝
_id也可以通过聚合或排序来访问该字段的值，但不建议这样做，因为它需要在内存中加载大量数据

_index

简介：用于存放数据文档的索引

PUT index_1/_doc/1
{
  "text": "Document in index 1"
}

PUT index_2/_doc/2?refresh=true
{
  "text": "Document in index 2"
}

GET index_1,index_2/_search
{
  "query": {   //数据常规查询
    "terms": {
      "_index": ["index_1", "index_2"] 
    }
  },
  "aggs": { //聚合查询
    "indices": {
      "terms": {
        "field": "_index", 
        "size": 10
      }
    }
  },
  "sort": [  //排序
    {
      "_index": { 
        "order": "asc"
      }
    }
  ],
  "script_fields": {   //查看索引中的字段
    "index_name": {
      "script": {
        "lang": "painless",
        "source": "doc['_index']" 
      }
    }
  }
}

字段说明：

指定诸如的远程索引名称时cluster_1:index_3，查询必须包含分隔符:
例如：对的wildcard查询cluster_:index_3将匹配远程索引中的文档，但是，查询查询clusterindex_1仅与本地索引匹配，因为不存在分隔符

_meta

简介：
在ES中，Index的mapping结构，配置，持久化状态等就属于meta信息；集群的一些配置信息也属于meta。这个meta信息非常重要，如果某个index的meta信息丢失了，那么集群就认为这个index不再存在了，
在索引创建、修改时可以新增、编辑自定义的meta数据

PUT my_index
{
  //创建版本信息
  "mappings": {
    "_meta": { 
      "class": "MyApp::User",
      "version": {
        "min": "1.0",
        "max": "1.3"
      }
    }
  }
}

//更新版本信息
PUT my_index/_mapping
{
  "_meta": {
    "class": "MyApp2::User3",
    "version": {
      "min": "1.3",
      "max": "1.5"
    }
  }
}

_routing

简介：
ES的路由说明，我们可以通过自定义路由的公式去设置索引的分片路径

PUT my_index/_doc/1?routing=user1&refresh=true   //本文档使用user1其路由值代替其ID
{
  "title": "This is a document"
}

GET my_index/_doc/1?routing=user1 


GET my_index/_search  
{
  "query": {
    "terms": {
      "_routing": [ "user1" ]   //获取、删除或更新文档routing时，需要提供相同的值
    }
  }
}

公式说明
官方默认路由公式

shard_num = hash(_routing) % num_primary_shards

_routing

代表提供路由的字段.默认情况下,为文档的ID

num_primary_shards

代表的为primary_shard的个数,这个在每个索引类型创建之前就被设置了.可以手动设置,也可以让ES默认设置.因为ES版本不同,设置的默认值也不同.该值在第一次创建索引类型被设置完成之后,是无法无法修改的,这一点很重要,后面会说为什么该值被设置之后无法修改.

shard_num

代表数据落在的shard的编号.ES在决定document落在哪个分片上时,首先用路由字段通过hash()函数计算一个数字,然后拿这个数字和primary shard求余,获得的结果值在0~(primary_shard - 1)之间,这也解释了,为什么primary shard被设置之后无法修改.

//自定义路由
GET my_index/_search?routing=user1,user2 //该搜索请求将仅在与user1和user2路由值关联的分片上执行
{
  "query": {
    "match": {
      "title": "document"
    }
  }
}

自定义路由不均匀说明
在自定义路由的情况下会出现索引分布不均匀的情况，我们可以通过设置routing_partition_size进行处理

shard_num = (hash(_routing) + hash(_id) % routing_partition_size) % num_primary_shards

要启用此功能，index.routing_partition_size值应大于1且小于index.number_of_shards，
启用后，分区索引将具有以下限制：
不能在其中创建具有join字段关系的映射
索引中的所有映射都必须具有_routing标记为必填字段
从上面的值公式可以看出,会使用_id字段再做一次计算,这样让文档的分布更加均匀

//创建自定义路由请求值
PUT my_index2
{
  "mappings": {
    "_routing": {
      "required": true   //_doc文档需要路由
    }
  }
}

PUT my_index2/_doc/1 //此索引请求时抛出routing_missing_exception
{
  "text": "No routing value provided"
}

自定义路由请求值说明
使用自定义路由时，重要的是在索引，获取，删除或更新文档时提供路由值。

忘记路由值可能导致文档在多个分片上建立索引。作为保护措施，可以配置_routing字段，使所有CRUD操作都需要自定义路由值:

_source

简介：
_source字段包含在索引时间传递的原始JSON文档正文。 _source字段本身没有编入索引（因此不可搜索），但它被存储，以便在执行获取请求（如get或search）时可以返回它。
默认_source字段是开启的，也就是说，默认情况下存储文档的原始值

//禁用source
PUT tweets
{
  "mappings": {
    "_source": {
      "enabled": false
    }
  }
}

禁用说明
如果该_source字段不可用，则不支持许多功能

update，update_by_query和reindexAPI不可用
无法高亮显示
从一个Elasticsearch索引重新索引到另一索引的能力，以更改映射或分析，或将索引升级到新的主要版本
通过查看索引时使用的原始文档来调试查询或聚合的能力。
无法使用自动修复索引损坏

如需要考虑磁盘空间，需要提高压缩等级
https://www.elastic.co/guide/en/elasticsearch/reference/current/index-modules.html#index-codec

//修改索引中字段
PUT logs
{
  "mappings": {
    "_source": {
      "includes": [
        "*.count",
        "meta.*"
      ],
      "excludes": [
        "meta.description",
        "meta.other.*"
      ]
    }
  }
}

PUT logs/_doc/1
{
  "requests": {
    "count": 10,
    "foo": "bar" //这些字段将从存储的_source字段中删除
  },
  "meta": {
    "name": "Some metric",
    "description": "Some metric description", //这些字段将从存储的_source字段中删除
    "other": {
      "foo": "one", //这些字段将从存储的_source字段中删除
      "baz": "two" //这些字段将从存储的_source字段中删除
    }
  }
}

GET logs/_search
{
  "query": {
    "match": {
      "meta.other.foo": "one" //即使它不在存储的中，我们仍然可以在该字段上搜索_source
    }
  }
}

修改说明

仅限专家的功能是能够_source 在对文档建立索引之后但在_source存储字段之前修剪字段的内容

_type（6.0已弃用）

在6.0.0中已弃用

PUT my_index/_doc/1?refresh=true
{
  "text": "Document with type 'doc'"
}

GET my_index/_search
{
  "query": {
    "term": {
      "_type": "_doc"  
    }
  },
  "aggs": {
    "types": {
      "terms": {
        "field": "_type", 
        "size": 10
      }
    }
  },
  "sort": [
    {
      "_type": { 
        "order": "desc"
      }
    }
  ],
  "script_fields": {
    "type": {
      "script": {
        "lang": "painless",
        "source": "doc['_type']" 
      }
    }
  }
}

映射参数

分析器/analyzer

简介：
通过分析器将字符串类型数据，切分成单个单词


PUT /my_index
{
  "mappings": {
    "properties": {
      "text": { //该text字段使用默认的standard分析器
        "type": "text",
        "fields": {
          "english": { //所述text.english多场使用english分析仪，其去除停止词，并应用所产生
            "type":     "text",
            "analyzer": "english"
          }
        }
      }
    }
  }
}

GET my_index/_analyze //这将返回令牌：the，quick，brown，foxes
{
  "field": "text",
  "text": "The quick Brown Foxes."
}

GET my_index/_analyze //这将返回令牌：quick，brown，fox
{
  "field": "text.english",
  "text": "The quick Brown Foxes."
}

分析器说明
在索引时，Elasticsearch将按以下顺序查找分析器：

analyzer在字段映射定义
default在索引设置中命名的分析器
该standard分析仪

在查询时的顺序

将analyzer在规定的全文查询
search_analyzer在字段映射定义
analyzer在字段映射定义
default_search在索引设置中命名的分析器
default在索引设置中命名的分析器
该standard分析仪

//指定分析器
PUT my_index
{
   "settings":{
      "analysis":{
         "analyzer":{
            "my_analyzer":{ //my_analyzer分析器，标记所有术语，包括停用词
               "type":"custom",
               "tokenizer":"standard",
               "filter":[
                  "lowercase"
               ]
            },
            "my_stop_analyzer":{ //删除停止字的分析器
               "type":"custom",
               "tokenizer":"standard",
               "filter":[
                  "lowercase",
                  "english_stop"
               ]
            }
         },
         "filter":{
            "english_stop":{
               "type":"stop",
               "stopwords":"_english_"
            }
         }
      }
   },
   "mappings":{
       "properties":{
          "title": {
             "type":"text",
             "analyzer":"my_analyzer", //指向于my_analyzer分析词
             "search_analyzer":"my_stop_analyzer", 
             "search_quote_analyzer":"my_analyzer"  //确保不从短语查询中删除停用词
         }
      }
   }
}

PUT my_index/_doc/1
{
   "title":"The Quick Brown Fox"
}

PUT my_index/_doc/2
{
   "title":"A Quick Brown Fox"
}

GET my_index/_search
{
   "query":{
      "query_string":{
         "query":"\"the quick brown fox\"" 
      }
   }
}

最后一次查询说明
由于查询是用引号引起来的，因此它被检测为短语查询，因此search_quote_analyzer可以插入并确保不将停用词从查询中删除。所述my_analyzer然后分析器将返回以下令牌[ the，quick，brown，fox]将匹配的文件之一。同时，术语查询将使用my_stop_analyzer分析器进行分析，分析器会过滤掉停用词。因此，一个搜索或者 The quick brown fox或A quick brown fox将返回两个文件，因为这两个文件包含以下标记[ quick，brown，fox。如果没有，search_quote_analyzer则无法对词组查询进行精确匹配，因为词组查询中的停用词将被删除，从而导致两个文档都匹配

normalizer

简介：
字段的normalizer属性与之keyword相似， analyzer不同之处在于它保证字符串产生单个标记

PUT index
{
  "settings": {
    "analysis": {
      "normalizer": {
        "my_normalizer": {
          "type": "custom",
          "char_filter": [],
          "filter": ["lowercase", "asciifolding"]
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "foo": {
        "type": "keyword",
        "normalizer": "my_normalizer"
      }
    }
  }
}

PUT index/_doc/1
{
  "foo": "BÀR"
}

PUT index/_doc/2
{
  "foo": "bar"
}

PUT index/_doc/3
{
  "foo": "baz"
}

POST index/_refresh

GET index/_search
{
  "query": {
    "term": {
      "foo": "BAR"
    }
  }
}

GET index/_search
{
  "query": {
    "match": {
      "foo": "BAR"
    }
  }
}

return/返回参数
{
  "took": $body.took,
  "timed_out": false,
  "_shards": {
    "total": 1,
    "successful": 1,
    "skipped" : 0,
    "failed": 0
  },
  "hits": {
    "total" : {
        "value": 2,
        "relation": "eq"
    },
    "max_score": 0.47000363,
    "hits": [
      {
        "_index": "index",
        "_type": "_doc",
        "_id": "1",
        "_score": 0.47000363,
        "_source": {
          "foo": "BÀR"
        }
      },
      {
        "_index": "index",
        "_type": "_doc",
        "_id": "2",
        "_score": 0.47000363,
        "_source": {
          "foo": "bar"
        }
      }
    ]
  }
}

上面的查询匹配文档1和2，因为BÀR它们bar在索引和查询时间都被转换为同一标识

//聚合查询
GET index/_search
{
  "size": 0,
  "aggs": {
    "foo_terms": {
      "terms": {
        "field": "foo"
      }
    }
  }
}

return/返回参数
{
  "took": 43,
  "timed_out": false,
  "_shards": {
    "total": 1,
    "successful": 1,
    "skipped" : 0,
    "failed": 0
  },
  "hits": {
    "total" : {
        "value": 3,
        "relation": "eq"
    },
    "max_score": null,
    "hits": []
  },
  "aggregations": {
    "foo_terms": {
      "doc_count_error_upper_bound": 0,
      "sum_other_doc_count": 0,
      "buckets": [
        {
          "key": "bar",
          "doc_count": 2
        },
        {
          "key": "baz",
          "doc_count": 1
        }
      ]
    }
  }
}

boost/字段权重（5.0已弃用）

简介：
用于设置字段查询权重值

PUT my_index
{
  "mappings": {
    "properties": {
      "title": {
        "type": "text",
        "boost": 2 //该title字段上的匹配项的权重是该content字段上的权重的两倍 ，默认boost值为1
      },
      "content": {
        "type": "text"
      }
    }
  }
}

coerce

简介：
字段类型强制转换

PUT my_index
{
  "mappings": {
    "properties": {
      "number_one": {
        "type": "integer"
      },
      "number_two": {
        "type": "integer",
        "coerce": false
      }
    }
  }
}

PUT my_index/_doc/1
{
  "number_one": "10" //该number_one字段将包含整数10
}

PUT my_index/_doc/2
{
  "number_two": "10" //由于禁用了强制，因此该文档将被拒绝
}

全局强制转换
PUT my_index
{
  "settings": {
    "index.mapping.coerce": false //设置全局强制转换
  },
  "mappings": {
    "properties": {
      "number_one": {
        "type": "integer",
        "coerce": true
      },
      "number_two": {
        "type": "integer"
      }
    }
  }
}

PUT my_index/_doc/1
{ "number_one": "10" } //该number_one字段将覆盖索引级别设置以启用强制

PUT my_index/_doc/2
{ "number_two": "10" } //该文档将被拒绝，因为该number_two字段继承了索引级强制设置

字段说明

coerce值可通过put进行修改

copy_to

简介：
该copy_to参数允许您将多个字段的值复制到组字段中，然后可以将其作为单个字段进行查询

PUT my_index
{
  "mappings": {
    "properties": {
      "first_name": {
        "type": "text",
        "copy_to": "full_name" 
      },
      "last_name": {
        "type": "text",
        "copy_to": "full_name" //first_name和last_name字段的值将复制到该 full_name字段
      },
      "full_name": {
        "type": "text"
      }
    }
  }
}

PUT my_index/_doc/1
{
  "first_name": "John",
  "last_name": "Smith"
}

GET my_index/_search
{
  "query": {
    "match": {
      "full_name": { //该first_name和last_name领域仍可以分别查询了第一个名字和姓氏，但full_name现场可以查询两个姓和名
        "query": "John Smith",
        "operator": "and"
      }
    }
  }
}

字段说明

复制的是字段值，而不是术语（由分析过程得出）
原始_source字段不会被修改以显示复制的值
可以将相同的值复制到多个字段， “copy_to”: [ “field_1”, “field_2” ]
您不能通过中介领域递归复制，如copy_to在 field_1以field_2和copy_to上field_2至field_3期望的索引到field_1会落空的field_3，而是使用copy_to直接从原始场多个字段

doc_values

简介：
是一个序列化了的列式存储结构，非常适合排序、聚合以及字段相关的脚本操作（倒排索引）


PUT my_index
{
  "mappings": {
    "properties": {
      "status_code": { 
        "type":       "keyword" //默认情况下，该status_code字段已doc_values启用
      },
      "session_id": { 
        "type":       "keyword",
        "doc_values": false  //	在session_id已doc_values禁用，但仍然可以查询
      }
    }
  }
}

字段说明

默认情况下，所有支持doc值的字段均已启用它们。如果确定不需要对字段进行排序或聚合，也不需要通过脚本访问字段值，则可以禁用doc值以节省磁盘空间
text不知道doc_values

dynamic

简介：
在已有的索引中，动态得将新字段添加到文档内部

PUT my_index/_doc/1 //本文档介绍了字符串字段username，对象字段 name以及name对象下面的两个字符串字段，可以将其称为name.first和name.last
{
  "username": "johnsmith",
  "name": {
    "first": "John",
    "last": "Smith"
  }
}

GET my_index/_mapping 

PUT my_index/_doc/2 //本文档添加了两个字符串字段：email和name.middle
{
  "username": "marywhite",
  "email": "mary@white.com",
  "name": {
    "first": "Mary",
    "middle": "Alice",
    "last": "White"
  }
}

GET my_index/_mapping

dynamic参数

true

新检测到的字段将添加到映射中。（默认）

false

新检测到的字段将被忽略。这些字段将不会被索引，因此将无法搜索，但仍会出现在_source返回的匹配项中。这些字段不会添加到映射中，必须显式添加新字段。

strict

如果检测到新字段，则会引发异常并拒绝文档。必须将新字段显式添加到映射中。

PUT my_index
{
  "mappings": {
    "dynamic": false, //在类型级别禁用动态映射，因此不会动态添加新的顶级字段
    "properties": {
      "user": { //该user对象继承类型级别设置
        "properties": {
          "name": {
            "type": "text"
          },
          "social_networks": { //该user.social_networks对象启用动态映射，因此可以将新字段添加到此内部对象
            "dynamic": true,
            "properties": {}
          }
        }
      }
    }
  }
}

字段说明

dynamic可通过put mapping 进行修改

enabled

简介：
允许字段不创建索引

PUT my_index
{
  "mappings": {
    "properties": {
      "user_id": {
        "type":  "keyword"
      },
      "last_updated": {
        "type": "date"
      },
      "session_data": { //该session_data字段被禁用
        "type": "object",
        "enabled": false
      }
    }
  }
}

PUT my_index/_doc/session_1
{
  "user_id": "kimchy",
  "session_data": { //任何任意数据都可以传递到该session_data字段，因为它将被完全忽略
    "arbitrary_object": {
      "some_array": [ "foo", "bar", { "baz": 2 } ]
    }
  },
  "last_updated": "2015-12-06T18:20:22"
}

PUT my_index/_doc/session_2
{
  "user_id": "jpountz",
  "session_data": "none", //该session_data也将忽略不是JSON对象的值
  "last_updated": "2015-12-06T18:22:13"
}

//顶级映射取消索引
PUT my_index
{
  "mappings": {
    "enabled": false //整个映射被禁用
  }
}

PUT my_index/_doc/session_1
{
  "user_id": "kimchy",
  "session_data": {
    "arbitrary_object": {
      "some_array": [ "foo", "bar", { "baz": 2 } ]
    }
  },
  "last_updated": "2015-12-06T18:20:22"
}

GET my_index/_doc/session_1 //可以检索该文档

GET my_index/_mapping //检查映射显示没有添加任何字段

//由于Elasticsearch完全跳过了对字段内容的解析，因此可以将非对象数据添加到禁用的字段中
PUT my_index
{
  "mappings": {
    "properties": {
      "session_data": {
        "type": "object",
        "enabled": false
      }
    }
  }
}

PUT my_index/_doc/session_1
{
  "session_data": "foo bar" //session_data包含非对象数据，该文档也已成功添加
}

字段说明

enabled设置仅可应用于顶级映射定义和object字段，从而使Elasticsearch完全跳过对字段内容的解析

eager_global_ordinals

简介：全局预加载

PUT my_index/_mapping
{
  "properties": {
    "tags": {
      "type": "keyword",
      "eager_global_ordinals": true
    }
  }
}

字段说明

就其加载时间和内存使用而言，全局序号不会带来很大的开销。但是，对于具有大碎片的索引，或者如果字段包含大量唯一项值，则加载全局序号可能会增加内存开销，因为全局序号为分片上的所有分段提供了统一的映射，所以当新的分段变为可见时，还需要完全重建它们
当eager_global_ordinals启用时，全球的序号都建当碎片被刷新 - Elasticsearch暴露更改索引的内容之前，总是加载它们。这将构建全局索引的成本从搜索转移到了索引时间。当创建新的分片副本时，Elasticsearch也会急切地构建全局序号，这可能会在增加副本数或将分片重新放置到新节点上时发生
在冻结索引（frozen index）上，全局序号在每次搜索后被丢弃，并在需要时重新构建。这意味着 eager_global_ordinals不应将其用于冻结索引：这将导致在每次搜索时重新加载全局序号。相反，在冻结之前，应将索引强制合并到单个段。这样可以避免完全建立全局序号（更多细节可以在下一节中找到）

在某些情况下，可以完全避免全局序数加载：

terms，sampler和significant_terms聚合支持一个参数 execution_hint ，有助于桶的收集方式控制。它默认为global_ordinals，但可以设置为map直接使用术语值。
如果某个分片已被强制合并为单个片段，则该分片的序号对于该分片已经是全局的。在这种情况下，Elasticsearch不需要构建全局序数映射，并且使用全局序数不会产生额外的开销。请注意，出于性能方面的考虑，您只应强制合并一个索引，以后再也不会写入该索引

filedata

简介：
text类型的字段使用一种叫做fielddata的查询时内存数据结构。当字段被排序，聚合或者通过脚本访问时这种数据结构会被创建。它是通过从磁盘读取每个段的整个反向索引来构建的，然后存存储在java的堆内存中

PUT my_index/_mapping
{
  "properties": {
    "my_field": { //您指定的映射my_field应该包括该字段的现有映射以及fielddata参数
      "type":     "text",
      "fielddata": true
    }
  }
}

字段说明

fileddata默认是不开启的，Fielddata可能会消耗大量的堆空间，尤其是在加载高基数文本字段时。一旦fielddata已加载到堆中，它将在该段的生命周期内保留
此外，加载fielddata是一个昂贵的过程，可能会导致用户遇到延迟命中。这就是默认情况下禁用fielddata的原因。如果尝试对文本字段进行排序，聚合或脚本访问，将出现异常

//减少加载到内存中的字词数量
PUT my_index
{
  "mappings": {
    "properties": {
      "tag": {
        "type": "text",
        "fielddata": true,
        "fielddata_frequency_filter": {
          "min": 0.001, //转化成百分比是：1%
          "max": 0.1, //转化成百分比是：10%
          "min_segment_size": 500 //只有这个 segment 里的文档数量超过 500 个，而且含有该字段的文档数量占该 segment 里的文档数量比例超过 10% 时，才加载这个 segment 的 fielddata
        }
      }
    }
  }
}

内存加载字段说明

该术语可以表示为绝对数字（当数字大于1.0时）或百分比（例如0.01 是 1%和1.0 是 100%）

format

简介：
时间格式说明

PUT my_index
{
  "mappings": {
    "properties": {
      "date": {
        "type":   "date",
        "format": "yyyy-MM-dd"
      }
    }
  }
}

支持自定义日期格式
https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html

内置格式

下表列出了所有支持的默认ISO格式：

epoch_millis
格式，表示自该纪元以来的毫秒数。请注意，此时间戳受Java Long.MIN_VALUE和 的限制Long.MAX_VALUE

epoch_second
自该时期以来的秒数的格式化程序。请注意，此时间戳受Java的限制，Long.MIN_VALUE并Long.
MAX_VALUE除以1000（毫秒数）

date_optional_time 要么 strict_date_optional_time
通用ISO日期时间解析器，其中日期是必填项，时间是可选的

basic_date
完整日期的基本格式，为四位数的年份，两位数的月份和月份的两位数yyyyMMdd

basic_date_time
一个基本的格式化程序，它结合了一个基本的日期和时间，并用T： 分隔yyyyMMdd'T'HHmmss.SSSZ

basic_date_time_no_millis
一个基本格式化程序，它结合了不带毫秒的基本日期和时间，并用T：分隔yyyyMMdd'T'HHmmssZ

basic_ordinal_date
一种完整的顺序日期格式，采用四位数年份和三位DAYOFYEAR： yyyyDDD

basic_ordinal_date_time
一种全序的日期和时间，采用四位数年份和三位DAYOFYEAR格式：yyyyDDD'T'HHmmss.SSSZ

basic_ordinal_date_time_no_millis
格式化程序，用于使用四位数的年份和三位数的dayOfYear：完整的序号日期和时间（不含毫秒）yyyyDDD'T'HHmmssZ

basic_time
基本格式器，用于表示一天的两位数小时，两位的小时数分钟，两位的分钟数秒，三位的毫秒数和时区偏移量： HHmmss.SSSZ

basic_time_no_millis
一个基本的格式化程序，用于表示一天的两位数小时，两位的小时数分钟，两位的分钟数和时区偏移量：HHmmssZ

basic_t_time
一个基本的格式化为一天中的两位数字小时，小时的两位数分钟，分钟的两位数第二，三位数米利斯和时区关闭的前缀集Ť：'T'HHmmss.SSSZ

basic_t_time_no_millis
在一天中的两位数小时的基本格式，小时的两位数分钟，分钟的两位数第二和时区偏移由前缀Ť： 'T'HHmmssZ

basic_week_date 要么 strict_basic_week_date
完整日期的基本格式设置，例如：四位数字的周年，一周的两位数字的周和一周的一位数字xxxx'W'wwe

basic_week_date_time 要么 strict_basic_week_date_time
一个基本的格式，结合了基本weekyear日期和时间，分离由Ť：xxxx'W'wwe'T'HHmmss.SSSZ

basic_week_date_time_no_millis 要么 strict_basic_week_date_time_no_millis
一个基本的格式，结合了基本weekyear日期和时间，而不米利斯，分离由Ť：xxxx'W'wwe'T'HHmmssZ

date 要么 strict_date
格式化日期的完整日期，如四位数的年份，两位数的月份和月份的两位数的日期：yyyy-MM-dd

date_hour 要么 strict_date_hour
结合了完整日期和一天中两位数小时的格式化程序： yyyy-MM-dd'T'HH

date_hour_minute 要么 strict_date_hour_minute
结合了完整日期，一天中两位数的小时和小时中两位数的分钟的格式化程序：yyyy-MM-dd'T'HH:mm

date_hour_minute_second 要么 strict_date_hour_minute_second
格式化程序，它结合了完整的日期，一天中的两位数小时，小时的两位数分钟和分钟的两位数秒：yyyy-MM-dd'T'HH:mm:ss

date_hour_minute_second_fraction 要么 strict_date_hour_minute_second_fraction
格式化程序，它结合了完整的日期，一天中的两位数小时，小时的两位数分钟，分钟的两位数秒和三分之一秒yyyy-MM-dd'T'HH:mm:ss.SSS

date_hour_minute_second_millis 要么 strict_date_hour_minute_second_millis
格式化程序，它结合了完整的日期，一天中的两位数小时，小时的两位数分钟，分钟的两位数秒和三分之一秒yyyy-MM-dd'T'HH:mm:ss.SSS

date_time 要么 strict_date_time
结合了完整日期和时间（由T： 分隔）的格式化程序yyyy-MM-dd'T'HH:mm:ss.SSSZZ

date_time_no_millis 要么 strict_date_time_no_millis
格式化器，结合了充分的日期和时间，而不米利斯，分离由Ť：yyyy-MM-dd'T'HH:mm:ssZZ

hour 要么 strict_hour
一天中两位数小时的格式化程序： HH

hour_minute 要么 strict_hour_minute
每天两位数小时和每小时两位数分钟的格式化程序： HH:mm

hour_minute_second 要么 strict_hour_minute_second
格式化程序，用于一天中的两位数小时，小时的两位数分钟和分钟的两位数秒：HH:mm:ss

hour_minute_second_fraction 要么 strict_hour_minute_second_fraction
格式，用于一天中的两位数小时，小时的两位数分钟，分钟的两位数秒和秒的三位数HH:mm:ss.SSS

hour_minute_second_millis 要么 strict_hour_minute_second_millis
格式，用于一天中的两位数小时，小时的两位数分钟，分钟的两位数秒和秒的三位数HH:mm:ss.SSS

ordinal_date 要么 strict_ordinal_date
一种完整的顺序日期格式，采用四位数年份和三位DAYOFYEAR： yyyy-DDD

ordinal_date_time 要么 strict_ordinal_date_time
一种全序的日期和时间，采用四位数年份和三位DAYOFYEAR格式：yyyy-DDD'T'HH:mm:ss.SSSZZ

ordinal_date_time_no_millis 要么 strict_ordinal_date_time_no_millis
格式化程序，用于使用四位数的年份和三位数的dayOfYear：完整的序号日期和时间（不含毫秒）yyyy-DDD'T'HH:mm:ssZZ

time 要么 strict_time
格式化程序，用于表示一天的两位小时，两位的小时分钟，两位的秒分钟，三位数的秒和时区偏移量：HH:mm:ss.SSSZZ

time_no_millis 要么 strict_time_no_millis
格式，用于表示一天的两位小时，两位的小时分钟，两位的分钟分钟和时区偏移量：HH:mm:ssZZ

t_time 要么 strict_t_time
格式，用于一天的两位小时，两位的小时分钟，两位的秒分钟，三位的秒分数和以T：为前缀的时区偏移量'T'HH:mm:ss.SSSZZ

t_time_no_millis 要么 strict_t_time_no_millis
一种用于一天中的两位数字小时格式化，小时的两位数分钟，分钟的两位数第二和时区偏移由前缀Ť：'T'HH:mm:ssZZ

week_date 要么 strict_week_date
格式为完整日期的格式，为四位数字的周年，两位数字的周年和一位数字的周日：xxxx-'W'ww-e

week_date_time 要么 strict_week_date_time
格式化器，结合了充分weekyear日期和时间，分离由 Ť：xxxx-'W'ww-e'T'HH:mm:ss.SSSZZ

week_date_time_no_millis 要么 strict_week_date_time_no_millis
格式化器，结合了充分weekyear日期和时间，而不米利斯，分离由Ť：xxxx-'W'ww-e'T'HH:mm:ssZZ

weekyear 要么 strict_weekyear
一周四位数的格式化程序：xxxx

weekyear_week 要么 strict_weekyear_week
一周的四位数和一周的两位数的格式化程序： xxxx-'W'ww

weekyear_week_day 要么 strict_weekyear_week_day
四位数字的周年，两位数字的周年和一位数字的格式器：xxxx-'W'ww-e

year 要么 strict_year
四位数年份的格式化程序：yyyy

year_month 要么 strict_year_month
年份的四位数和年份的两位数的格式化程序：yyyy-MM

year_month_day 要么 strict_year_month_day
四位数年，两位数年月和两位数月日的格式化程序：yyyy-MM-dd

ignore_above

简介：
长于ignore_above设置的字符串、数组将不会被索引或存储

PUT my_index
{
  "mappings": {
    "properties": {
      "message": {
        "type": "keyword",
        "ignore_above": 20 //该字段将忽略任何超过20个字符的字符串
      }
    }
  }
}

PUT my_index/_doc/1 
{
  "message": "Syntax error"
}

PUT my_index/_doc/2 
{
  "message": "Syntax error with some long stacktrace" //该文档将被索引，但不对该message字段建立索引
}

GET my_index/_search //搜索返回两个文档，但是术语聚合中仅存在第一个文档
{
  "aggs": {
    "messages": {
      "terms": {
        "field": "message"
      }
    }
  }
}

字段说明

对于字符串数组，ignore_above将分别应用于每个数组元素，并且字符串元素的长度大于ignore_above不会被索引或存储的字符串元素

ignore_malformed

简介：
数据异常忽略

PUT my_index
{
  "mappings": {
    "properties": {
      "number_one": {
        "type": "integer",
        "ignore_malformed": true
      },
      "number_two": {
        "type": "integer"
      }
    }
  }
}

PUT my_index/_doc/1
{
  "text":       "Some text value",
  "number_one": "foo"  //该文档将为该text字段建立索引，但不对该number_one字段建立索引
}

PUT my_index/_doc/2
{
  "text":       "Some text value",
  "number_two": "foo" /该文档将被拒绝，因为number_two不允许格式错误的值
}

默认情况下，尝试将错误的数据类型索引到字段中会引发异常，并拒绝整个文档。ignore_malformed如果将参数设置为true，则可以忽略异常。格式错误的字段未编制索引，但文档中的其他字段已正常处理

支持类型
**Numeric **
long, integer, short, byte, double, float, half_float, scaled_float

Date
date

Date nanoseconds
date_nanos

Geo-point
geo_point for lat/lon points

Geo-shape
geo_shape for complex shapes like polygons

IP
ip for IPv4 and IPv6 addresses

//忽略异常全局设置
PUT my_index
{
  "settings": {
    "index.mapping.ignore_malformed": true //该number_one字段继承索引级设置
  },
  "mappings": {
    "properties": {
      "number_one": { /该number_one字段继承索引级设置
        "type": "byte"
      },
      "number_two": {
        "type": "integer",
        "ignore_malformed": false //该number_two字段将覆盖索引级别设置以关闭ignore_malformed
      }
    }
  }
}

字段说明

格式错误的字段在ignore_malformed 打开索引时将被静默忽略，建议保留包含格式错误字段的文档数，否则对该字段的查询将变得毫无意义
可以通过使用exist或term查询特殊 _ignored字段来轻松检查有多少文档的字段格式错误
不支持3种类型Nested datatype、Object datatype、Range datatypes
也不能设置ignore_malformed用来忽略提交给错误数据类型字段的JSON对象，如果将JSON对象提交到不支持的字段，则不管ignore_malformed设置如何，Elasticsearch都会返回错误并拒绝整个文档

index

简介：
该index选项控制是否对字段值建立索引。它接受true 或false，默认为true。未索引的字段不可查询

index_options

简介：
字段添加到反向索引内，以便提高检索与高亮的速度

PUT my_index
{
  "mappings": {
    "properties": {
      "text": {
        "type": "text",
        "index_options": "offsets"
      }
    }
  }
}

PUT my_index/_doc/1
{
  "text": "Quick brown fox"
}

GET my_index/_search
{
  "query": {
    "match": {
      "text": "brown fox"
    }
  },
  "highlight": {
    "fields": {
      "text": {} //text默认情况下，由于offsets已索引，该字段将使用过帐进行突出显示
    }
  }
}

字段参数说明

docs

仅文档编号被索引

freqs

文档编号和术语频率被索引。术语频率用于对重复术语进行评分，使其高于单个术语

positions

索引文档编号，术语频率和术语位置（或顺序）。位置可用于接近或短语查询

offsets

为文档编号，术语频率，位置以及开始和结束字符偏移（将术语映射回原始字符串）建立索引。统一荧光笔使用偏移来加速突出显示

注意：
数字字段不再支持该index_options参数
https://www.elastic.co/guide/en/elasticsearch/reference/current/number.html

index_phrases

如果启用，则将两个词的单词组合（带状疱疹）索引到单独的字段中。这使得精确的短语查询（无延迟）可以更有效地运行，但要以较大的索引为代价。请注意，这在不删除停用词的情况下效果最佳，因为包含停用词的短语将不会使用子字段，并且会退回到标准短语查询中。接受true或false（默认）

index_prefixes

简介：
字段前缀索引

PUT my_index
{
  "mappings": {
    "properties": {
      "full_name": {
        "type": "text",
        "index_prefixes": {
          "min_chars" : 1,
          "max_chars" : 10
        }
      }
    }
  }
}

参数说明

min_chars要索引的最小前缀长度。必须大于0，并且默认为2，该值包含在内
max_chars要索引的最大前缀长度。必须小于20，并且默认为5，该值包含在内

fields

简介：
字段映射

PUT my_index
{
  "mappings": {
    "properties": {
      "city": {
        "type": "text",
        "fields": {
          "raw": { //该city.raw字段是该字段的keyword版本city
            "type":  "keyword"
          }
        }
      }
    }
  }
}

PUT my_index/_doc/1
{
  "city": "New York"
}

PUT my_index/_doc/2
{
  "city": "York"
}

GET my_index/_search
{
  "query": {
    "match": {
      "city": "york"  //该city字段可用于全文搜索
    }
  },
  "sort": {
    "city.raw": "asc" //该city.raw字段可用于排序和汇总
  },
  "aggs": {
    "Cities": {
      "terms": {
        "field": "city.raw" //该city.raw字段可用于排序和汇总
      }
    }
  }
}

字段说明

一个string 字段可以映射为text用于全文搜索的字段，也可以映射为keyword用于排序或聚合的字段
可通过put APIs进行字段修改

//多字段分析器
PUT my_index
{
  "mappings": {
    "properties": {
      "text": { //该text字段使用standard分析仪
        "type": "text",
        "fields": {
          "english": { //该text.english字段使用english分析仪
            "type":     "text",
            "analyzer": "english"
          }
        }
      }
    }
  }
}

PUT my_index/_doc/1
{ "text": "quick brown fox" } //为两个文档建立索引，一个带有fox，另一个带有foxes

PUT my_index/_doc/2
{ "text": "quick brown foxes" } //为两个文档建立索引，一个带有fox，另一个带有foxes

GET my_index/_search
{
  "query": {
    "multi_match": {
      "query": "quick brown foxes",
      "fields": [ //同时查询text和text.english字段，并合并分数
        "text",
        "text.english"
      ],
      "type": "most_fields" //同时查询text和text.english字段，并合并分数
    }
  }
}

该text字段包含fox第一个文档和foxes第二个文档中的术语。该text.english字段包含fox两个文档，因为foxes源于fox。

查询字符串也由分析standard仪的text 领域，并通过english分析仪的text.english领域。词干字段允许查询foxes以匹配还包含的文档fox。这使我们可以匹配尽可能多的文档。通过查询未阻塞的text字段，我们提高了foxes精确匹配的文档的相关性得分

norms

简介：
类似于doc_values数据结构，可通过PUT API进行修改

PUT my_index/_mapping
{
  "properties": {
    "title": {
      "type": "text",
      "norms": false
    }
  }
}

字段说明

尽管对于评分很有用，但规范也需要大量磁盘（通常对于索引中每个字段，每个文档一个字节的顺序，即使对于没有此特定字段的文档也是如此）
如果您不需要在特定字段上评分，则应禁用该字段上的规范。特别是对于仅用于过滤或聚合的字段就是这种情况

null_value

简介：
null值不能被索引或搜索。当字段设置null为时（或空数组或null值数组），将其视为该字段没有值

PUT my_index
{
  "mappings": {
    "properties": {
      "status_code": {
        "type":       "keyword",
        "null_value": "NULL" //将显式null值替换为NULL
      }
    }
  }
}

PUT my_index/_doc/1
{
  "status_code": null
}

PUT my_index/_doc/2
{
  "status_code": [] //空数组不包含显式数组null，因此不会被替换null_value
}

GET my_index/_search
{
  "query": {
    "term": {
      "status_code": "NULL" //查询NULL退货凭证1，但不查询凭证2
    }
  }
}

字段说明

空值不能在_source结构中所修改

position_increment_gap

简介：
多字段位置相邻度查询

PUT my_index/_doc/1
{
    "names": [ "John Abraham", "Lincoln Smith"]
}

GET my_index/_search
{
    "query": {
        "match_phrase": {
            "names": {
                "query": "Abraham Lincoln" //此词组查询与我们完全期望的文档不匹配
            }
        }
    }
}

GET my_index/_search
{
    "query": {
        "match_phrase": {
            "names": {
                "query": "Abraham Lincoln",
                "slop": 101 //这句话查询匹配我们的文件，即使Abraham和Lincoln 在单独的字符串，因为slop> position_increment_gap
            }
        }
    }
}

PUT my_index
{
  "mappings": {
    "properties": {
      "names": {
        "type": "text",
        "position_increment_gap": 0 //下一个数组元素中的第一项与前一个数组元素中的最后一项相距0个项
      }
    }
  }
}

PUT my_index/_doc/1
{
    "names": [ "John Abraham", "Lincoln Smith"]
}

GET my_index/_search
{
    "query": {
        "match_phrase": {
            "names": "Abraham Lincoln" //短语查询匹配我们的文档，这很奇怪，但是它是我们在映射中要求的
        }
    }
}

字段说明

当为具有多个值的文本字段建立索引时，将在值之间添加“伪”间隙，以防止大多数短语查询在值之间进行匹配。间隙的大小使用配置position_increment_gap，默认为 100

properties

简介：
类型映射

PUT my_index
{
  "mappings": {
    "properties": { //顶级映射定义中的属性
      "manager": {
        "properties": { //manager对象字段下的属性
          "age":  { "type": "integer" },
          "name": { "type": "text"  }
        }
      },
      "employees": {
        "type": "nested",
        "properties": { //employees嵌套字段下的属性
          "age":  { "type": "integer" },
          "name": { "type": "text"  }
        }
      }
    }
  }
}

PUT my_index/_doc/1 //与上述映射相对应的示例文档
{
  "region": "US",
  "manager": {
    "name": "Alice White",
    "age": 30
  },
  "employees": [
    {
      "name": "John Smith",
      "age": 34
    },
    {
      "name": "Peter Brown",
      "age": 26
    }
  ]
}

//点符号使用
GET my_index/_search
{
  "query": {
    "match": {
      "manager.name": "Alice White"
    }
  },
  "aggs": {
    "Employees": {
      "nested": {
        "path": "employees"
      },
      "aggs": {
        "Employee Ages": {
          "histogram": {
            "field": "employees.age",
            "interval": 5
          }
        }
      }
    }
  }
}
//内部字段可以在查询，聚合等中使用点符号来引用
//必须指定内部字段的完整路径

字段说明

对于properties相同索引中相同名称的字段，允许该设置具有不同的设置。可以使用PUT映射API将新属性添加到现有字段

来源：CSDN

作者：Sam_D002

链接：https://blog.csdn.net/weixin_39662805/article/details/103795151

标签

路由聚合

内存映射