投稿
  1. 云图网首页
  2. 技术专区
  3. 大数据

Elasticsearch常用操作：映射篇

• 大数据, 开源, 研发管理, 移动开发, 编程笔记 • 阅读 47

[TOC]

其实就是es的字段类型是由es来做自动检测还是由我们自己来指定，因此会分为动态映射和静态映射。

1 动态映射

1.1 映射规则

JSON格式的数据 自动推测的字段类型
null 没有字段被添加
true or false boolean类型
浮点类型数字 float类型
数字 long类型
JSON对象 object类型
数组 由数组中第一个非空值决定
string 有可能是date类型（开启日期检测）、double或long类型、text类型、keyword类型

1.2 日期检测

默认是开启的（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
              }
            }
          }
        }
      }
    }
  }
}

2 静态映射

2.1 基本案例

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"
          }
        }
      }
    }
  }
}

2.2 dynamic属性

默认情况下，当添加一份文档时，如果出现新的字段，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
}

3 字段类型

3.1 普通字段类型

一级分类 二级分类 具体类型
核心类型 字符串类型 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。

3.1.1 string

ex 5.x之后不支持，但仍可以添加，由text或keyword替代。

3.1.2 text

用于做全文搜索的字段，其字段内容会被分词器分析，在生成倒排索引前，字符串会被分词器分成一个个的词项。

实际应用中，text多用在长文本的字段中，如article的content，显然，这样的字段用于排序和聚合都是没有太大意义的。

3.1.3 keyword

只能通过精确值搜索到，区别于text类型。

其索引的词项都是字段内容本身，因此在实际应用中，会用来比较、排序、聚合等操作。

3.1.4 数字类型

具体注意的细节问题可以考虑官方文档，一般的使用都能满足需求。

3.1.5 date

json中没有日期类型，所以默认情况es的时间的形式可以为：

  • 1."yyyy-MM-dd"或"yyyy-MM-ddTHH:mm:ssZ"
    • 也就是说"yyyy-MM-dd HH:mm:ss"需要写成："2018-10-22T23:12:22Z"的形式，其实就是加了时区；
  • 2.表示毫秒的timestamp的长整型数
  • 3.表示秒的timestamp的整型数

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中，取出显示时再处理为时间字符串。

3.1.6 boolean

设置字段类型为boolean后，可以填入的值为：true、false、"true"、"false"。

3.1.7 binary

binary类型接受base64编码的字符串。

3.1.8 array

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"
            }
          ]
        }
      }
    ]
  }
}
3.1.9 object

可以直接将一个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"}

3.1.10 nested

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个。

3.1.11 range

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位整数，毫秒计时

3.2 元字段

元字段就是描述文档本身的字段，其分类及说明如下：

元字段分类 具体属性 作用
文档属性的元字段 _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。

4 映射参数

参考：https://www.elastic.co/guide/en/elasticsearch/reference/5.6/mapping-params.html。

原创文章，作者：kepupublish，如若转载，请注明出处：https://blog.ytso.com/tech/opensource/186907.html

赞 (0)
0 0
上一篇 2021年11月4日 13:31
下一篇 2021年11月4日 13:31

相关推荐

发表回复

登录后才能评论