您好，登录后才能下订单哦！
密码登录
登录注册
点击 登录注册 即表示同意《亿速云用户服务条款》
[TOC]
其实就是es的字段类型是由es来做自动检测还是由我们自己来指定，因此会分为动态映射和静态映射。
| JSON格式的数据 | 自动推测的字段类型 |
|---|---|
| null | 没有字段被添加 |
| true or false | boolean类型 |
| 浮点类型数字 | float类型 |
| 数字 | long类型 |
| JSON对象 | object类型 |
| 数组 | 由数组中第一个非空值决定 |
| string | 有可能是date类型（开启日期检测）、double或long类型、text类型、keyword类型 |
默认是开启的（es5.4），测试案例如下：
PUT myblog
GET myblog/_mapping
PUT myblog/article/1
{
"id":1,
"postdate":"2018-10-27"
}
GET myblog/_mapping
{
"myblog": {
"mappings": {
"article": {
"properties": {
"id": {
"type": "long"
},
"postdate": {
"type": "date"
}
}
}
}
}
}关闭日期检测后，则不会检测为日期，如下：
PUT myblog
{
"mappings": {
"article": {
"date_detection": false
}
}
}
GET myblog/_mapping
PUT myblog/article/1
{
"id":1,
"postdate":"2018-10-27"
}
GET myblog/_mapping
{
"myblog": {
"mappings": {
"article": {
"date_detection": false,
"properties": {
"id": {
"type": "long"
},
"postdate": {
"type": "text",
"fields": {
"keyword": {
"type": "keyword",
"ignore_above": 256
}
}
}
}
}
}
}
}PUT myblog
{
"mappings": {
"article": {
"properties": {
"id":{"type": "long"},
"title":{"type": "text"},
"postdate":{"type": "date"}
}
}
}
}
GET myblog/_mapping
PUT myblog/article/1
{
"id":1,
"title":"elasticsearch is wonderful!",
"postdate":"2018-10-27"
}
GET myblog/_mapping
{
"myblog": {
"mappings": {
"article": {
"properties": {
"id": {
"type": "long"
},
"postdate": {
"type": "date"
},
"title": {
"type": "text"
}
}
}
}
}
}默认情况下，当添加一份文档时，如果出现新的字段，es也会添加进去，不过这个是可以进行控制的，通过dynamic来进行设置：
| dynamic值 | 说明 |
|---|---|
| true | 默认值为true，自动添加字段 |
| false | 忽略新的字段 |
| strict | 严格模式，发现新的字段抛出异常 |
PUT myblog
{
"mappings": {
"article": {
"dynamic":"strict",
"properties": {
"id":{"type": "long"},
"title":{"type": "text"},
"postdate":{"type": "date"}
}
}
}
}
GET myblog/_mapping
PUT myblog/article/1
{
"id":1,
"title":"elasticsearch is wonderful!",
"content":"a long text",
"postdate":"2018-10-27"
}
{
"error": {
"root_cause": [
{
"type": "strict_dynamic_mapping_exception",
"reason": "mapping set to strict, dynamic introduction of [content] within [article] is not allowed"
}
],
"type": "strict_dynamic_mapping_exception",
"reason": "mapping set to strict, dynamic introduction of [content] within [article] is not allowed"
},
"status": 400
}| 一级分类 | 二级分类 | 具体类型 |
|---|---|---|
| 核心类型 | 字符串类型 | string、text、keyword |
| 数字类型 | long、intger、short、byte、double、float、half_float、scaled_float | |
| 日期类型 | date | |
| 布尔类型 | boolean | |
| 二进制类型 | binary | |
| 范围类型 | range | |
| 复合类型 | 数组类型 | array |
| 对象类型 | object | |
| 嵌套类型 | nested | |
| 地理类型 | 地理坐标 | geo_point |
| 地理图形 | geo_shape | |
| 特殊类型 | IP类型 | ip |
| 范围类型 | completion | |
| 令牌计数类型 | token_count | |
| 附件类型 | attachment | |
| 抽取类型 | percolator |
下面只会列出一些在个人工作中常用的，详细的可以参考官方文档：https://www.elastic.co/guide/en/elasticsearch/reference/5.6/mapping.html。
ex 5.x之后不支持，但仍可以添加，由text或keyword替代。
用于做全文搜索的字段，其字段内容会被分词器分析，在生成倒排索引前，字符串会被分词器分成一个个的词项。
实际应用中，text多用在长文本的字段中，如article的content，显然，这样的字段用于排序和聚合都是没有太大意义的。
只能通过精确值搜索到，区别于text类型。
其索引的词项都是字段内容本身，因此在实际应用中，会用来比较、排序、聚合等操作。
具体注意的细节问题可以考虑官方文档，一般的使用都能满足需求。
json中没有日期类型，所以默认情况es的时间的形式可以为：
es内部存储的是毫秒计时的长整型数。
当然上面只是默认情况下的，在设置字段的类型时，我们也可以设置自己定义的时间格式：
PUT myblog
{
"mappings": {
"article": {
"properties": {
"postdate":{
"type": "date",
"format": "yyyy-MM-dd HH:mm:ss"
}
}
}
}
}format也可以指定多个日期格式，使用"||"分隔开：
"format": "yyyy-MM-dd HH:mm:ss||yyyy/MM/dd HH:mm:ss"之后就可以写入定义的时间格式的数据了：
PUT myblog/article/1
{
"postdate":"2017-09-23 23:12:22"
}在我的工作场景中，如果需要存入的为时间，很多时候会先把其处理为毫秒值的timestamp，然后再存入es中，取出显示时再处理为时间字符串。
设置字段类型为boolean后，可以填入的值为：true、false、"true"、"false"。
binary类型接受base64编码的字符串。
es没有专用的数组类型，默认情况下任何字段都可以包含一个或者多个值，但是一个数组中的值必须是同一种类型。动态添加数据时，数组的第一个值的类型决定整个数组的类型（其实也就是这个字段的类型），混合数组是不支持的。数组可以包含null值，空数组[]会被当作missing field对待。另外在文档中使用array类型不需要提前做任何配置，默认支持。
比如添加下面一个数组的字段数据：
DELETE my_index
PUT my_index/my_type/1
{
"lists":[
{
"name":"xpleaf",
"job":"es"
}
]
}其实际上该字段的类型就会被动态映射为text：
GET my_index/my_type/_mapping
{
"my_index": {
"mappings": {
"my_type": {
"properties": {
"lists": {
"properties": {
"job": {
"type": "text",
"fields": {
"keyword": {
"type": "keyword",
"ignore_above": 256
}
}
},
"name": {
"type": "text",
"fields": {
"keyword": {
"type": "keyword",
"ignore_above": 256
}
}
}
}
}
}
}
}
}
}直接搜索也是支持的：
GET my_index/my_type/_search
{
"query": {
"term": {
"lists.name": {
"value": "xpleaf"
}
}
}
}返回结果：
{
"took": 0,
"timed_out": false,
"_shards": {
"total": 5,
"successful": 5,
"failed": 0
},
"hits": {
"total": 1,
"max_score": 0.2876821,
"hits": [
{
"_index": "my_index",
"_type": "my_type",
"_id": "1",
"_score": 0.2876821,
"_source": {
"lists": [
{
"name": "xpleaf",
"job": "es"
}
]
}
}
]
}
}可以直接将一个json对象写入es中，如下：
DELETE my_index
PUT my_index/my_type/1
{
"object":{
"name":"xpleaf",
"job":"es"
}
}其实际上该字段的类型就会被动态映射为text：
{
"my_index": {
"mappings": {
"my_type": {
"properties": {
"object": {
"properties": {
"job": {
"type": "text",
"fields": {
"keyword": {
"type": "keyword",
"ignore_above": 256
}
}
},
"name": {
"type": "text",
"fields": {
"keyword": {
"type": "keyword",
"ignore_above": 256
}
}
}
}
}
}
}
}
}
}直接搜索也是可以的：
GET my_index/my_type/_search
{
"query": {
"term": {
"object.name": {
"value": "xpleaf"
}
}
}
}返回结果：
{
"took": 0,
"timed_out": false,
"_shards": {
"total": 5,
"successful": 5,
"failed": 0
},
"hits": {
"total": 1,
"max_score": 0.2876821,
"hits": [
{
"_index": "my_index",
"_type": "my_type",
"_id": "1",
"_score": 0.2876821,
"_source": {
"object": {
"name": "xpleaf",
"job": "es"
}
}
}
]
}
}object对象，实际上在es内部会被扁平化处理，如上面的，在es中实际为：
{"object.name":"xpleaf", "object.job":"es"}
nested类型是object类型中的一个特例，可以让对象数组独立索引和查询。Lucene没有内部对象的概念，所以es将对象层次扁平化，转化成字段名字和值构成的简单列表。
虽然是object类型中的一个特例，但是其字段的type是固定的，也就是nested，这是与object的最大不同。
那么为什么要使用nested类型呢，使用object不就可以了吗？这里贴一下官方提供的一个例子来进行说明（https://www.elastic.co/guide/en/elasticsearch/reference/5.6/nested.html）：
Arrays of inner object fields do not work the way you may expect. Lucene has no concept of inner objects, so Elasticsearch flattens object hierarchies into a simple list of field names and values. For instance, the following document:
PUT my_index/my_type/1
{
"group" : "fans",
"user" : [
{
"first" : "John",
"last" : "Smith"
},
{
"first" : "Alice",
"last" : "White"
}
]
}would be transformed internally into a document that looks more like this:
{
"group" : "fans",
"user.first" : [ "alice", "john" ],
"user.last" : [ "smith", "white" ]
}The user.first and user.last fields are flattened into multi-value fields, and the association between alice and white is lost. This document would incorrectly match a query for alice AND smith:
GET my_index/_search
{
"query": {
"bool": {
"must": [
{ "match": { "user.first": "Alice" }},
{ "match": { "user.last": "Smith" }}
]
}
}
}上面是直接使用object而导致的问题，也就是说实际上进行上面的搜索时，该文档是不应该被匹配出来的，但是确匹配出来了。使用nested对象类型就可以保持数组中每个对象的独立性，nested类型将数组中每个对象作为独立隐藏文档来索引，这意味着每个嵌套对象都可以独立被搜索。
If you need to index arrays of objects and to maintain the independence of each object in the array, you should use the nested datatype instead of the object datatype. Internally, nested objects index each object in the array as a separate hidden document, meaning that each nested object can be queried independently of the others, with the nested query:
PUT my_index
{
"mappings": {
"my_type": {
"properties": {
"user": {
"type": "nested"
}
}
}
}
}
PUT my_index/my_type/1
{
"group" : "fans",
"user" : [
{
"first" : "John",
"last" : "Smith"
},
{
"first" : "Alice",
"last" : "White"
}
]
}
GET my_index/_search
{
"query": {
"nested": {
"path": "user",
"query": {
"bool": {
"must": [
{ "match": { "user.first": "Alice" }},
{ "match": { "user.last": "Smith" }}
]
}
}
}
}
}
GET my_index/_search
{
"query": {
"nested": {
"path": "user",
"query": {
"bool": {
"must": [
{ "match": { "user.first": "Alice" }},
{ "match": { "user.last": "White" }}
]
}
},
"inner_hits": {
"highlight": {
"fields": {
"user.first": {}
}
}
}
}
}
}索引一个包含100个nested字段的文档实际上就是索引101个文档，每个嵌套文档都作为一个独立文档来索引。为了防止过度定义嵌套字段的数量，每个索引可以定义的嵌套字段被限制在50个。
range类型及其取值范围如下：
| 类型 | 范围 |
|---|---|
| integer_range | -2^31~2^31-1 |
| float_range | 32-bit IEEE 754 |
| long_range | -2^63~2^63-1 |
| double_range | 64-bit IEEE 754 |
| date_range | 64位整数，毫秒计时 |
元字段就是描述文档本身的字段，其分类及说明如下：
| 元字段分类 | 具体属性 | 作用 |
|---|---|---|
| 文档属性的元字段 | _index | 文档所属索引 |
| _uid | 包含_type和_id的复合字段(取值为{type}#{id}) |
|
| _type | 文档的类型 | |
| _id | 文档的id | |
| 源文档的元字段 | _source | 文档的原始JSON字符串 |
| _size | _source字段的大小 | |
| _all | 包含索引全部字段的超级字段 | |
| _field_names | 文档中包含非空值的所有字段 | |
| 路由的元字段 | _parent | 指定文档间的父子关系 |
| _routing | 将文档路由到特定分片的自定义路由值 | |
| 自定义元字段 | _meta | 用于自定义元数据 |
各个字段的详细说明，可以参考：https://www.elastic.co/guide/en/elasticsearch/reference/5.6/mapping-fields.html。
参考：https://www.elastic.co/guide/en/elasticsearch/reference/5.6/mapping-params.html。
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。