当前位置：首页 > article >正文

ElasticSearch7.x入门教程之索引数据类型和映射（四）

article 2024/11/25 11:00:51

文章目录

前言
一、基本数据类型
二、数据类型映射
- 1.动态映射
- 2.静态映射
总结

前言

本来想直接记录工作当中索引查询相关的操作，但是似乎如果不先记录索引数据类型的话，还真不好操作。好多查询都是根据数据类型来的，所以先简单介绍哈ES索引中相关的数据类型。

一、基本数据类型

这里只是记录我在工作当中常用的数据类型，并不是ES7.x中全部的数据类型，更多数据类型，可以查看官网说明。
官网地址：https://www.elastic.co/guide/en/elasticsearch/reference/7.9/mapping-types.html

1、字符串类

string：这是一个已经过期的字符串类型。在 es5 之前，用这个来描述字符串，现在的话，它已经被 text 和 keyword 替代了。
text：如果一个字段是要被全文检索的，比如说博客内容、新闻内容、产品描述，那么可以使用 text。用了 text 之后，字段内容会被分析，在生成倒排索引之前，字符串会被分词器分成一个个词项。text 类型的字段不用于排序，很少用于聚合。这种字符串也被称为 analyzed 字段。
keyword：这种类型适用于结构化的字段，例如标签、email 地址、手机号码等等，这种类型的字段可以用作过滤、排序、聚合等。这种字符串也称之为 not-analyzed 字段。

2、数字类型
在这里插入图片描述

1、在满足需求的情况下，优先使用范围小的字段。字段长度越短，索引和搜索的效率越高。
2、浮点数，优先考虑使用 scaled_float。

例如：
scaled_float 类型：

PUT product
{
  "mappings": {
    "properties": {
      "name":{
        "type": "text"
      },
      "price":{
        "type": "scaled_float",
        "scaling_factor": 100
      }
    }
  }
}

3、日期类型
由于 JSON 中没有日期类型，所以 es 中的日期类型形式就比较多样：

2020-11-11 或者 2020-11-11 11:11:11
一个从 1970.1.1 零点到现在的一个秒数或者毫秒数。

es 内部将时间转为 UTC，然后将时间按照 millseconds-since-the-epoch 的长整型来存储。

自定义日期类型：

PUT product
{
  "mappings": {
    "properties": {
      "date":{
        "type": "date"
      }
    }
  }
}

这个能够解析出来的时间格式比较多。

PUT product/_doc/1
{
  "date":"2020-11-11"
}

PUT product/_doc/2
{
  "date":"2020-11-11T11:11:11Z"
}


PUT product/_doc/3
{
  "date":"1604672099958"
}

上面三个文档中的日期都可以被解析，内部存储的是毫秒计时的长整型数。

4、布尔类型（boolean）
JSON 中的 “true”、“false”、true、false 都可以。

5、二进制类型（binary）
二进制接受的是 base64 编码的字符串，默认不存储，也不可搜索。

6、范围类型

integer_range
float_range
long_range
double_range
date_range
ip_range

定义的时候，指定范围类型即可：

PUT product
{
  "mappings": {
    "properties": {
      "date":{
        "type": "date"
      },
      "price":{
        "type":"float_range"
      }
    }
  }
}

插入文档的时候，需要指定范围的界限：

PUT product
{
  "mappings": {
    "properties": {
      "date":{
        "type": "date"
      },
      "price":{
        "type":"float_range"
      }
    }
  }
}

指定范围的时，可以使用 gt、gte、lt、lte。

7、数组类型
es 中没有专门的数组类型。默认情况下，任何字段都可以有一个或者多个值。需要注意的是，数组中的元素必须是同一种类型。

添加数组是，数组中的第一个元素决定了整个数组的类型。

8、对象类型（object）
由于 JSON 本身具有层级关系，所以文档包含内部对象。内部对象中，还可以再包含内部对象。

PUT product/_doc/2
{
  "date":"2020-11-11T11:11:11Z",
  "ext_info":{
    "address":"China"
  }
}

9、嵌套类型（nested）

nested 是 object 中的一个特例。

如果使用 object 类型，假如有如下一个文档：

{
  "user":[
	    {
	      "first":"Zhang",
	      "last":"san"
	    },
	    {
	      "first":"Li",
	      "last":"si"
	    }
    ]
}

由于 Lucene 没有内部对象的概念，所以 es 会将对象层次扁平化，将一个对象转为字段名和值构成的简单列表。即上面的文档，最终存储形式如下：

{
"user.first":["Zhang","Li"],
"user.last":["san","si"]
}

扁平化之后，用户名之间的关系没了。这样会导致如果搜索 Zhang si 这个人，会搜索到。

此时可以 nested 类型来解决问题，nested 对象类型可以保持数组中每个对象的独立性。nested 类型将数组中的每一饿对象作为独立隐藏文档来索引，这样每一个嵌套对象都可以独立被索引。

{
	{
	"user.first":"Zhang",
	"user.last":"san"
	},{
	"user.first":"Li",
	"user.last":"si"
	}
}

优点：文档存储在一起，读取性能高。
缺点：更新父或者子文档时需要更新更个文档。

10、地理类型

使用场景：

查找某一个范围内的地理位置
通过地理位置或者相对中心点的距离来聚合文档
把距离整个到文档的评分中
通过距离对文档进行排序

有如下几个类型：

geo_point：geo_point 就是一个坐标点

定义方式如下：

PUT people
{
  "mappings": {
    "properties": {
      "location":{
        "type": "geo_point"
      }
    }
  }
}

创建时指定字段类型，存储的时候，有四种方式：

PUT people/_doc/1
{
  "location":{
    "lat": 34.27,
    "lon": 108.94
  }
}

PUT people/_doc/2
{
  "location":"34.27,108.94"
}

PUT people/_doc/3
{
  "location":"uzbrgzfxuzup"
}

PUT people/_doc/4
{
  "location":[108.94,34.27]
}

注意，使用数组描述，先经度后纬度。
地址位置转 geo_hash：http://www.csxgame.top/#/

geo_shape
该类型是多种地理空间类型的集合体，如下：

指定 geo_shape 类型：

PUT people
{
  "mappings": {
    "properties": {
      "location":{
        "type": "geo_shape"
      }
    }
  }
}

添加文档时需要指定具体的类型：

PUT people/_doc/1
{
  "location":{
    "type":"point",
    "coordinates": [108.94,34.27]
  }
}

如果是 linestring，如下：

PUT people/_doc/2
{
  "location":{
    "type":"linestring",
    "coordinates": [[108.94,34.27],[100,33]]
  }
}

11、 特殊类型 —> IP

存储 IP 地址，类型是 ip：

PUT blog
{
  "mappings": {
    "properties": {
      "address":{
        "type": "ip"
      }
    }
  }
}

添加文档：

PUT blog/_doc/1
{
  "address":"192.168.91.1"
}

搜索文档：

GET blog/_search
{
  "query": {
    "term": {
      "address": "192.168.0.0/16"
    }
  }
}

12、 特殊类型 —> token_count

用于统计字符串分词后的词项个数。

PUT blog
{
  "mappings": {
    "properties": {
      "title":{
        "type": "text",
        "fields": {
          "length":{
            "type":"token_count",
            "analyzer":"standard"
          }
        }
      }
    }
  }
}

相当于新增了 title.length 字段用来统计分词后词项的个数。

添加文档：

PUT blog/_doc/1
{
  "title":"zhang san"
}

可以通过 token_count 去查询：

GET blog/_search
{
  "query": {
    "term": {
      "title.length": 2
    }
  }
}

二、数据类型映射

数据类型映射就是 Mapping，它用来定义一个文档以及文档所包含的字段该如何被存储和索引。所以，它其实有点类似于关系型数据库中表的定义。

分为动态映射与静态映射。

1.动态映射

顾名思义，就是自动创建出来的映射。es 根据存入的文档，自动分析出来文档中字段的类型以及存储方式，这种就是动态映射。
举一个简单例子，新建一个索引，然后查看索引信息：

# 创建一个文章索引
PUT essay
# 查看索引
GET /essay
{
  "essay" : {
    "aliases" : { },
    "mappings" : { },
    "settings" : {
      "index" : {
        "creation_date" : "1732458477134",
        "number_of_shards" : "1",
        "number_of_replicas" : "1",
        "uuid" : "K6c2XK-MQZOyD4_uvrDWYQ",
        "version" : {
          "created" : "7090399"
        },
        "provided_name" : "essay"
      }
    }
  }
}

在创建好的索引信息中，可以看到，mappings 为空，这个 mappings 中保存的就是映射信息。

现在我们向索引中添加一个文档，如下：

POST /essay/_doc
{
  "title":"鲁迅有约",
  "date":"2024-11-12"
}

文档添加成功后，就会自动生成 Mappings：

GET /essay
{
  "essay" : {
    "mappings" : {
      "properties" : {
        "date" : {
          "type" : "date"
        },
        "title" : {
          "type" : "text",
          "fields" : {
            "keyword" : {
              "type" : "keyword",
              "ignore_above" : 256
            }
          }
        }
      }
    }
  }
}

可以看到，date 字段的类型为 date，title 的类型有两个，text 和 keyword。

默认情况下，文档中如果新增了字段，mappings 中也会自动新增进来。

有的时候，如果希望新增字段时，能够抛出异常来提醒开发者，这个可以通过 mappings 中 dynamic 属性来配置。

dynamic 属性有三种取值：

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

具体配置方式如下，创建索引时指定 mappings（这其实就是静态映射）：

PUT essay1
{
  "mappings": {
    "dynamic":"strict",
    "properties": {
      "title":{
        "type": "text"
      },
      "age":{
        "type":"long"
      }
    }
  }
}

然后向 blog 中索引中添加数据：

POST /essay1/_doc
{
  "title":"鲁迅有约",
  "age": 12,
  "date":"2024-11-12"
}

在添加的文档中，多出了一个 date 字段，而该字段没有预定义，所以这个添加操作就回报错：

{
  "error" : {
    "root_cause" : [
      {
        "type" : "strict_dynamic_mapping_exception",
        "reason" : "mapping set to strict, dynamic introduction of [date] within [_doc] is not allowed"
      }
    ],
    "type" : "strict_dynamic_mapping_exception",
    "reason" : "mapping set to strict, dynamic introduction of [date] within [_doc] is not allowed"
  },
  "status" : 400
}

动态映射还有一个日期检测的问题。

例如新建一个索引，然后添加一个含有日期的文档，如下：

PUT /essay2/_doc/1
{
  "remark":"2024-11-12"
}

添加成功后，remark 字段会被推断是一个日期类型。

GET /essay2/_mapping
# 结果如下：
{
  "essay2" : {
    "mappings" : {
      "properties" : {
        "remark" : {
          "type" : "date"
        }
      }
    }
  }
}

此时，remark 字段就无法存储其他类型了。

PUT /essay2/_doc/2
{
  "remark":"你好啊"
}
# 此时报错如下：
{
  "error" : {
    "root_cause" : [
      {
        "type" : "mapper_parsing_exception",
        "reason" : "failed to parse field [remark] of type [date] in document with id '2'. Preview of field's value: '你好啊'"
      }
    ],
    "type" : "mapper_parsing_exception",
    "reason" : "failed to parse field [remark] of type [date] in document with id '2'. Preview of field's value: '你好啊'",
    "caused_by" : {
      "type" : "illegal_argument_exception",
      "reason" : "failed to parse date field [你好啊] with format [strict_date_optional_time||epoch_millis]",
      "caused_by" : {
        "type" : "date_time_parse_exception",
        "reason" : "date_time_parse_exception: Failed to parse with all enclosed parsers"
      }
    }
  },
  "status" : 400
}

要解决这个问题，可以使用静态映射，即在索引定义时，将 remark 指定为 text 类型。也可以关闭日期检测。

PUT essay3
{
  "mappings": {
    "date_detection": false
  }
}

此时日期类型就回当成文本来处理。

最后附加一个类型推断表：

JSON中的数据	自动推断出来的数据类型	说明（Java中没有指定字段类型的情况）
null	没有字段被添加	-
true/false	boolean	-
浮点数字（float、double、BigDecimal）	float	包括Java中的BigDecimal
整数数字（long、integer、short、byte）	long
日期类型（date、LocalDateTime）	long	包括Java中的LocalDateTime等系列
数组	数组中第一个非空值来决定	-
string	text/keyword/date/double/long等都有可能	-

2.静态映射

静态映射就是在新建索引的时候，指定每个字段的类型。

方式一
一般来说，我们在kibana中新建索引的时候可以指定类型，比如：

PUT /building_info
{
  "mappings": {
    "properties": {
       "address" : {
          "type" : "text"
        },
        "city_code" : {
          "type" : "keyword"
        },
        "county" : {
          "type" : "keyword"
        },
        "create_time" : {
          "type" : "date"
        }
    }
  }
}

方式二
就是我们在继承Java代码的时候，在Java中去创建，这个后面专门出一篇文章来记录。
例如：

@Document(indexName = "building_info", shards = 3, replicas = 1)
public class BuildingInfo implements Serializable {

    private static final long serialVersionUID = 1L;

    @Id
    private Long id;

    @Field(type = FieldType.Text)
    private String name;

    @Field(type = FieldType.Text)
    private String address;

    @Field(value = "create_time", type = FieldType.Date)
    private Date createTime;
    
    @Field(type = FieldType.Keyword)
    private Integer floor;
    
}