ES之Mapping

最新推荐文章于 2024-06-25 21:00:00 发布
最新推荐文章于 2024-06-25 21:00:00 发布
阅读量6.5k 收藏 7
点赞数 2
分类专栏： 技术分享 文章标签： elasticsearch lucene 全文检索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/momo539bian/article/details/121022590
版权

什么是Mapping

Mapping类似数据库中的schema的定义，作用如下

  • 定义索引中的字段的名称
  • 定义字段的数据类型，例如字符串、数字、布尔......
  • 字段，倒排索引的相关配置，（Analyzed or Not Analyzed，Analyzer）

Mapping会把JSON文档映射成Lucene所需要的扁平格式

一个Mapping属于一个索引的Type

  • 每个文档都属于一个Type
  • 一个Type有一个Mapping定义
  • 7.0开始，不需要再Mapping定义中指定type信息

字段的数据类型

简单类型

  • Text / Keyword
  • Date
  • Interger / Floating
  • Boolean
  • IPv4 & IPv6

复杂类型 - 对象和嵌套对象

  • 对象类型 / 嵌套类型

特殊类型

  • geo_point & geo_shape / percolator

什么是Dynamic Mapping

  • 在写入文档的时候，如果索引不存在，会自动创建索引
  • Dynamic Mapping的机制，使得我们无需手动定义Mappings。ElasticSearch会自动根据文档信息，推算出字段的类型
  • 当时有时候会推算的不对，例如地理位置信息
  • 当类型如果设置的不对时，会导致一些功能无法正常使用，例如Range查询
类型推断错误:
#插入数据
PUT b_test/_doc/1
{
  "startLocation": {
    "lat": 32.004287,
    "lon": 118.779369
  }
}
#查看mapping
GET b_test/_mapping
{
  "b_test" : {
    "mappings" : {
      "properties" : {
        "startLocation" : {
          "properties" : {
            "lat" : {
              "type" : "float"
            },
            "lon" : {
              "type" : "float"
            }
          }
        }
      }
    }
  }
}
 
正确做法
#先创建索引
PUT b_test
{
    "mappings": {
        "properties": {
            "location": {
                "type": "geo_point"
            }
        }
    }
}
#再插入数据
PUT b_test/_doc/1
{
  "location": {
    "lat": 32.004287,
    "lon": 118.779369
  }
}

类型的自动识别

JSON类型

ElasticSearch 类型

JSON类型

ElasticSearch 类型

字符串
  • 匹配日期格式
  • 设置数字设置为float 或者long ，该选项默认关闭
  • 设置为Text，并且增加 keyword 子字段
布尔值boolean
浮点数float
整数long
对象Object
数组由第一个非空数值的类型所决定
空值忽略

添加一个文档
// 写入文档，查看Mapping
PUT mapping_test/_doc/1
{
"firstName": "Chan",
"lastName": "Jackie",
"loginDate": "2018-07-24T10:29:48.103Z"
}// 查看Mapping 文件
GET mapping_test/_mapping
{
  "mapping_test" : {
    "mappings" : {
      "properties" : {
        "firstName" : {
          "type" : "text",
          "fields" : {
            "keyword" : {
              "type" : "keyword",
              "ignore_above" : 256
            }
          }
        },
        "lastName" : {
          "type" : "text",
          "fields" : {
            "keyword" : {
              "type" : "keyword",
              "ignore_above" : 256
            }
          }
        },
        "loginDate" : {
          "type" : "date"
        }
      }
    }
  }
}
** 我们看到这里。es 将 loginDate 字符串自动处理成了 date 类型的**
 
#删除index
DELETE mapping_test
 
# dynamic mapping 推断字段的类型
PUT mapping_test/_doc/1
{
  "uid":"123",
  "isVip": false,
  "isAdmin":"true",
  "age":19,
  "heigh":180
}
// 查看Mapping 文件
GET mapping_test/_mapping
{
  "mapping_test" : {
    "mappings" : {
      "properties" : {
        "age" : {
          "type" : "long"
        },
        "heigh" : {
          "type" : "long"
        },
        "isAdmin" : {
          "type" : "text",
          "fields" : {
            "keyword" : {
              "type" : "keyword",
              "ignore_above" : 256
            }
          }
        },
        "isVip" : {
          "type" : "boolean"
        },
        "uid" : {
          "type" : "text",
          "fields" : {
            "keyword" : {
              "type" : "keyword",
              "ignore_above" : 256
            }
          }
        }
      }
    }
  }
}

能否更改Mapping的字段类型

两种情况：

1、新增加字段

  • Dynamic 设置为true 时， 一旦有新增字段的文档写入， Mapping 也同时被更新
  • Dynamic 设置为false 时，Mapping 不会被更新，新增字段的数据无法被索引，但是信息会出现在_source 中
  • Dynamic 设置成Strict， 文档写入失败

2、对已有字段，一旦已经有数据写入，就不再支持修改字段定义

  • Lucene 实现的倒排索引，一旦生成后，就不允许修改
  • 如果希望改变字段类型，必须Reindex API， 重建索引

原因：

1、因为如果修改了字段的数据类型，会导致已被索引的属性无法被搜索，

2、但是如果是增加新的字段，就不会有这样的影响。

控制Dynamic Mappings

true

false

strict

文档可索引√√x
字段可索引√xx
Mapping被更新√xx
  • 当 dynamic 被设置为 false 的时候，存在新增字段的数据写入，该数据可以被索引。但是新增字段被丢弃
  • 当设置为 Strict 模式的时候，数据写入直接报错
#写入的文档加入新的字段，默认Mapping支持dynamic
PUT mapping_test/_doc/1
{
  "dynamicTest":"test"
}
 
#查询
GET /mapping_test/_search
{
  "version": true,
  "query": {
    "match": {
      "dynamicTest": "test"
    }
  }
}
 
#修改为dynamic false
PUT mapping_test/_mapping
{
  "dynamic": false
}
 
#新增anotherField
PUT mapping_test/_doc/10
{
  "anotherField":"test"
}
 
#查看数据
GET b_test/_doc/10
 
#该字段无法被索引，应为dynamic为false
GET /mapping_test/_search
{
  "version": true,
  "query": {
    "match": {
      "anotherField": "test"
    }
  }
}
 
#修改为dynamic strict
PUT mapping_test/_mapping
{
  "dynamic": "strict"
}
 
#写入数据出错， HTTP CODE 400
PUT mapping_test/_doc/10
{
  "lastField":"test"
}

如何显示定义一个Mapping

PUT /your_index
{
    "mappings": {
        "properties": {
            // 字段
        }
    }
}
 
#e.g.
PUT /scheduler_driver_intention_info
{
    "mappings": {
        "properties": {
            "intentionId": {
                "type": "long"
            },
            "productId": {
                "type": "long"
            },
            "driverId": {
                "type": "long"
            },
            "cooperationType": {
                "type": "integer"
            },
            "startLocation": {
                "type": "geo_point"
            },
            "truckType": {
                "type": "long"
            },
            "truckLength": {
                "type": "double"
            },
            "startCityList": {
                "type": "nested",
                "properties": {
                    "districtId": {
                        "type": "integer"
                    },
                    "districtName": {
                        "type": "keyword"
                    },
                    "cityId": {
                        "type": "integer"
                    },
                    "cityName": {
                        "type": "keyword"
                    },
                    "generalizationFlag": {
                        "type": "boolean"
                    }
                }
            },
            "endCityList": {
                "type": "nested",
                "properties": {
                    "districtId": {
                        "type": "integer"
                    },
                    "districtName": {
                        "type": "keyword"
                    },
                    "cityId": {
                        "type": "integer"
                    },
                    "cityName": {
                        "type": "keyword"
                    },
                    "generalizationFlag": {
                        "type": "boolean"
                    }
                }
            },
            "startExcludeCityList": {
                "type": "nested",
                "properties": {
                    "districtId": {
                        "type": "integer"
                    },
                    "districtName": {
                        "type": "keyword"
                    }
                }
            },
            "endExcludeCityList": {
                "type": "nested",
                "properties": {
                    "districtId": {
                        "type": "integer"
                    },
                    "districtName": {
                        "type": "keyword"
                    }
                }
            },
            "createTime": {
                "type": "long"
            },
            "createTimeStr": {
                "type": "text",
                "fields": {
                    "keyword": {
                        "type": "keyword",
                        "ignore_above": 256
                    }
                }
            },
            "updateTime": {
                "type": "long"
            },
            "updateTimeStr": {
                "type": "text",
                "fields": {
                    "keyword": {
                        "type": "keyword",
                        "ignore_above": 256
                    }
                }
            },
            "valid": {
                "type": "boolean"
            }
        }
    }
}
 
#索引新增字段
PUT your_index/_mapping
{
  "properties": {
    "aaa": {
      "type": "text"
    }
  }
}

为了减少输入工作量，减少出错概率，可以依照以下步骤

  • 创建一个临时的index，写入一些样本数据
  • 通过访问Mapping API获取该临时文件的动态Mapping定义
  • 修改后，使用该配置创建你的索引
  • 删除临时索引

为了减少输入工作量，减少出错概率，可以依照以下步骤

  • 创建一个临时的index，写入一些样本数据
  • 通过访问Mapping API获取该临时文件的动态Mapping定义
  • 修改后，使用该配置创建你的索引
  • 删除临时索引

控制当前字段是否被索引

Index - 控制当前字段是否被索引，默认为true，如果设置成false，该字段不可被搜索

# 设置index为false
PUT b_test
{
  "mappings": {
    "properties": {
      "firstName":{
        "type": "text"
      },
      "lastName":{
        "type": "text"
      },
      "mobile":{
        "type": "text",
        "index": false
      }
    }
  }
}
 
PUT /b_test/_doc/1
{
  "firstName": "zhang",
  "lastName": "san",
  "mobile": "123"
}
 
#报错
GET /b_test/_search
{
  "query": {
    "match": {
      "mobile": "123"
    }
  }
}

Index Options

1、四种不同的级别的Index Options 设置，可以控制倒排索引记录的内容

  • docs - 记录 doc id
  • freqs - 记录 doc id 和 term frequencies
  • positions - 记录 doc id 和 term frequencies / term position
  • offsets - doc id / term frequencies / term position /character offects

2、Text 类型默认记录 positions，其他默认为 docs
3、记录内容越多，占用存储空间越大

# 显示的创建Mapping
PUT b_test
{
  "mappings": {
    "properties": {
      "name":{
        "type": "text"
      },
      "address":{
        "type": "text"
      },
      "phone_num":{
        "type": "text",
        "index": false
      },
      "bio":{
        "type": "text",
        "index_options": "offsets"
      }
    }
  }
}

null_value

  • 需要对null 值进行搜索
  • 只有 KeyWord类型支持设定 null_Value
# 显示的创建Mapping
PUT b_test
{
  "mappings": {
    "properties": {
      "firstName":{
        "type": "text"
      },
      "lastName":{
        "type": "text"
      },
      "mobile":{
        "type": "keyword",
        "null_value": "NULL"
      }
    }
  }
}
 
PUT /b_test/_doc/1
{
  "firstName": "zhang",
  "lastName": "san",
  "mobile": null
}
# 查询 注意NULL为大写
GET b_test/_search?q=mobile:NULL
GET b_test/_search
{
  "query": {
    "match": {
      "mobile": "NULL"
    }
  }
}

copy_to设置

  • _all 在 7 中被 copy_to 所替代
  • 满意一些特定的搜索要求
  • copy_to 将字段的数值拷贝到 目标字段， 实现类似 _all 的作用
  • copy_to 的目标字段不出现在 _source 中
# 显示的创建Mapping
PUT b_test
{
  "mappings": {
    "properties": {
      "firstName":{
        "type": "text",
        "copy_to": "fullName"
      },
      "lastName":{
        "type": "text",
        "copy_to": "fullName"
      }
    }
  }
}
 
PUT /b_test/_doc/1
{
  "firstName": "zhang",
  "lastName": "san"
}
# 查询
GET b_test/_search?q=fullName:(zhang san)

数组类型

ES中不提供专门的数组类型，但是任何字段，都可以包含多个相同类型的数值

PUT b_test/_doc/1
{
  "firstName": "Chan",
  "lastName": "zhangsan"
}
 
PUT b_test/_doc/2
{
  "firstName": "Chan",
  "lastName": ["zhangsan","lisi"]
}
 
# 查询
GET /b_test/_search
{
  "query": {
    "term": {
      "lastName.keyword": "zhangsan"
    }
  }
}

对象类型和嵌套对象（Nested Object）

关系数据库的范式设计

1NF - 消除非主属性对键的部分函数依赖

2NF - 消除非主属性对键的传递函数依赖

3NF - 消除主属性对键的传递函数依赖

BCNF - 主属性不依赖于主属性

  • 范式化设计（Normalization）的主要目标时”减少不必要的更新“
  • 副作用：一个完全范式化设计的数据库会经常面临”查询缓慢“的问题（数据库越范式化，就需要Jion越多的表）
  • 范式化节省了存储空间，但是存储空间却越来越便宜
  • 范式化简化了更新，但是数据”读“取操作可能更多

Denormalization

  • 反范式化设计
    • 数据“Flattening”,不使用关联关系，而是在文档中保存冗余的数据拷贝
  • 优点：无需处理Joins操作，数据读取性能好
    • Elasticsearch 通过压缩_source字段，减少磁盘空间的开销
  • 缺点：不适合在数据频繁修改的场景
    • 一条数据（用户名）的改动，可能会引起很多数据的更新

ES中处理关联关系

  • 关系型数据库，一般会考虑 Normalize 数据；在Elasticsearch，往往考虑 Denormalize 数据
    • Denormalize 的好处：读的速度变快、无需表连接、无需行锁
  • Elasticsearch 并不擅长处理关联关系，我们一般采用以下四种方法处理关联
    • 对象类型
    • 嵌套对象（Nested Object）
    • 父子关联关系（Parent 、Child）
    • 应用端关联

对象类型：

PUT /blog
{
  "mappings": {
    "properties": {
      "content": {
        "type": "text"
      },
      "time": {
        "type": "date"
      },
      "user": {
        "properties": {
          "city": {
            "type": "text"
          },
          "userid": {
            "type": "long"
          },
          "username": {
            "type": "keyword"
          }
        }
      }
    }
  }
}
 
# 插入一条 Blog 信息
PUT blog/_doc/1
{
  "content":"I like Elasticsearch",
  "time":"2021-10-19T00:00:00",
  "user":{
    "userid":1,
    "username":"Jack",
    "city":"Shanghai"
  }
}
 
# 查询 Blog 信息
POST blog/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "content": "Elasticsearch"
          }
        },
        {
          "match": {
            "user.username": "Jack"
          }
        }
      ]
    }
  }
}

对象数组类型：

# 电影的Mapping信息
PUT my_movies
{
      "mappings" : {
      "properties" : {
        "actors" : {
          "properties" : {
            "first_name" : {
              "type" : "keyword"
            },
            "last_name" : {
              "type" : "keyword"
            }
          }
        },
        "title" : {
          "type" : "text",
          "fields" : {
            "keyword" : {
              "type" : "keyword",
              "ignore_above" : 256
            }
          }
        }
      }
    }
}
 
# 写入一条电影信息
POST my_movies/_doc/1
{
  "title":"Speed",
  "actors":[
    {
      "first_name":"Keanu",
      "last_name":"Reeves"
    },
 
    {
      "first_name":"Dennis",
      "last_name":"Hopper"
    }
 
  ]
}
# 查询电影信息
POST my_movies/_search
{
  "query": {
    "bool": {
      "must": [
        {"match": {"actors.first_name": "Keanu"}},
        {"match": {"actors.last_name": "Hopper"}}
      ]
    }
  }
}

问题：为什么会搜索到不需要的结果？

  • 储存时，内部对象的边界没有在考虑在内，JSON格式被处理成扁平键值对的结构
  • 当对多个字段进行查询时，导致了意外的搜索结果
  • 可以用 Nested Data Type 解决这个问题

Nested Data Type

  • Nested 数据类型：允许对象数组中的对象呗独立索引
  • 使用 Nested 和 Properties 关键词，将所有 actors 索引到对个分隔的文档
  • 在内部，Nested 文档会被保存在两个 Lucene 文档中，查询时做join处理

PUT my_movies
{
      "mappings" : {
      "properties" : {
        "actors" : {
          "type": "nested",
          "properties" : {
            "first_name" : {"type" : "keyword"},
            "last_name" : {"type" : "keyword"}
          }},
        "title" : {
          "type" : "text",
          "fields" : {"keyword":{"type":"keyword","ignore_above":256}}
        }
      }
    }
}
 
# 写入一条电影信息
POST my_movies/_doc/1
{
  "title":"Speed",
  "actors":[
    {
      "first_name":"Keanu",
      "last_name":"Reeves"
    },
 
    {
      "first_name":"Dennis",
      "last_name":"Hopper"
    }
 
  ]
}
# Nested 查询
POST my_movies/_search
{
  "query": {
    "bool": {
      "must": [
        {"match": {"title": "Speed"}},
        {
          "nested": {
            "path": "actors",
            "query": {
              "bool": {
                "must": [
                  {"match": {
                    "actors.first_name": "Keanu"
                  }},
                  {"match": {
                    "actors.last_name": "Hopper"
                  }}
                ]
              }
            }
          }
        }
      ]
    }
  }
}

倒排索引

倒排索引，是适合用于进行搜索的

倒排索引的结构

（1）包含这个关键词的document list
（2）包含这个关键词的所有document的数量：IDF（inverse document frequency）
（3）这个关键词在每个document中出现的次数：TF（term frequency）
（4）这个关键词在这个document中的次序
（5）每个document的长度：length norm
（6）包含这个关键词的所有document的平均长度

word doc1 doc2

dog     *       *
hello    *
you      *

倒排索引不可变的好处

（1）不需要锁，提升并发能力，避免锁的问题
（2）数据不变，一直保存在os cache中，只要cache内存足够
（3）filter cache一直驻留在内存，因为数据不变
（4）可以压缩，节省cpu和io开销

倒排索引不可变的坏处：每次都要重新构建整个索引

注意事项

1、在ES5.x里，一定要注意数值类型是否需要做范围查询，看似数值，但其实只用于Term或者Terms这类精确匹配的，应该定义为keyword类型。典型的例子就是索引web日志时常见的HTTP Status code。

2、如果RangeQuery的结果集很大，并且还需要和其他结果集更小的查询条件做AND的，应该升级到ES5.4+，该版本在底层引入的indexOrDocValuesQuery，可以极大提升该场景下RangeQuery的查询速度。

3、reindex重建索引

一个field的设置是不能被修改的，如果要修改一个Field或者primary shard那么应该重新按照新的mapping，建立一个index，然后将数据批量查询出来，重新用bulk api写入index中批量查询的时候，建议采用scroll api，并且采用多线程并发的方式来reindex数据，每次scoll就查询指定日期的一段数据，交给一个线程即可。

如果说旧索引的名字，是old_index，新索引的名字是new_index，终端java应用，已经在使用old_index在操作了，难道还要去停止java应用，修改使用的index为new_index，才重新启动java应用吗？这个过程中，就会导致java应用停机，可用性降低，所以给java应用一个别名，这个别名是指向旧索引的，java应用先用index alias来操作，此时实际指向的是旧的my_index

①PUT /{my_index}/_alias/{alias_index}

②新建一个index，调整其mapping

③使用scroll api将数据批量查询出来

GET /my_index/_search?scroll=1m
{
"query": {
"match_all": {}
},
"sort": ["_doc"],
"size": 1
}

④采用bulk api将scoll查出来的一批数据，批量写入新索引

POST /_bulk
{ "index": { "_index": "my_index_new", "_type": "my_type", "_id": "2" }}
{ "content": "xxx" }

⑤反复循环，查询一批又一批的数据出来，采取bulk api将每一批数据批量写入新索引

⑥将alias_index切换到my_index_new上去，java应用会直接通过index别名使用新的索引中的数据，java应用程序不需要停机，零提交，高可用

POST /_aliases
{
"actions": [
{ "remove": { "index": "my_index", "alias": "alias_index" }},
{ "add": { "index": "my_index_new", "alias": "alias_index" }}
]
}

相关文档

官网文档
Mapping | Elasticsearch Guide [7.5] | Elastic

一文搞懂 Elasticsearch 之 Mapping
一文搞懂 Elasticsearch 之 Mapping - 云+社区 - 腾讯云

理解 Percolator 数据类型及 Percolate 查询
Elasticsearch：理解 Percolator 数据类型及 Percolate 查询-阿里云开发者社区

使用 ignore_above 限制字符串长度
Elasticsearch 7 : 使用 ignore_above 限制字符串长度 - 乐天笔记

539bian
关注
专栏目录
ES 基本使用《四》--索引mapping
let it go的博客
10-20 3941
1. mapping 为了能够将时间域视为时间，数字域视为数字，字符串域视为全文或精确值字符串， Elasticsearch 需要知道每个域中数据的类型。这个信息包含在映射中。索引中每个文档都有 类型 。每种类型都有它自己的 映射 ，或者 模式定义。映射定义了类型中的域，每个域的数据类型，以及Elasticsearch如何处理这些域。映射也用于配置与类型有关的元数据。 索引mapping：
Elasticsearch之mapping
北漂码农有话说
09-04 264
Elasticsearch之mapping 这是es系列的第四篇文章了，阅读前三篇有助于小伙伴们理解本篇文章。 1、Elasticsearch总览 2、Elasticsearch安装 3、Elasticsearch上手 回顾 上一篇文章和小伙伴们简单聊了一下关于es的基本操作，包括检查集群状态、创建索引、添加文档、删除索引等。那么本篇我们就再继续完善我们的学习。 首先我们先来来，补充一些上篇文章中遗漏的知识点。 上篇文章我们讨论了如何查询索引，用如下_cat的api实现的： curl -X&nbs
【ElasticSearch-基础篇】Mapping结构
qq_42890164的博客
01-08 2449
【ElasticSearch-基础篇】Mapping结构
深入解析Elasticsearch 8.4.1：Mapping与字段类型实战指南
最新发布
qq_41934990的博客
06-25 1331
在Elasticsearch中，Mapping定义了索引中每个字段的类型、属性以及设置。Mapping的作用是告诉Elasticsearch如何索引文档中的字段，包括如何分析字段值以及如何存储它们。分词即使将文本拆分成单独的单次或词项的过程分词是搜索引擎在建立索引和执行查询时的关键步骤，将文本拆分成单词，并构建倒排索引，可以实现更好的搜索和检索效果。分词规则是指如何将文本进行拆分的规则和算法。elasticsearch使用一些列的分词器（analyzer）和标记器(tokenizer)来处理文本内容。
elasticsearch中的mapping简介
热门推荐
lvhong84的专栏
04-17 7万+
最近项目准备用到elasticsearch， 首先需要搞清楚elasticsearch的一些概念，在网上发现这篇文章不错，以通俗易懂的语言讲明白了mapping的概念。 默认mapping elasticsearch(以下简称ES)是没有模式(schema)的，当我们执行以下命令： curl -XPUT http://localhost:9200/test/item/1 -d '{"name":"zach", "description": "A Pretty cool guy."}' ES能非常聪明的识
ES mapping 详解
赵英超的博客
10-12 3万+
1 mapping type 映射（mapping） 映射是定义一个文档以及其所包含的字段如何被存储和索引的方法。 例如，用映射来定义以下内容： 哪些 string 类型的 field 应当被当成当成 full-text 字段 哪些字段应该是数值类型、日期类型或者是地理位置信息 日期类型字段的格式是怎么样的 是否文档的所有字段都需要被索引到 _all 字段 动态增加的 field ...
Es之mapping
一个菜鸡的博客
01-03 4223
关系型数据库中两个数据表示是独立的，即使他们里面有相同名称的列也不影响使用， 但 ES 中不是这样的。elasticsearch 是基于 Lucene 开发的搜索引擎，而 ES 中不同 type下名称相同的 filed 最终在 Lucene 中的处理方式是一样的。
ES入门八：Mapping的详细讲解
一只小星星
03-05 3941
前面我们提到最好不要用Dynamic Mapping来生成Mapping，但是如果Mapping拥有的字段非常多的时候，自定义Mapping是非常痛苦的并且容易出错。那有没有办法减轻一下我们的工作量哪？我们可以把JSON对象直接写入，利用Dynamic Mapping的特性帮我们生成一个初步可用的Mapping，然后我们修改这个 Mapping来直到满足我们的需求。创建临时索引，并写入业务数据获取这个临时索引的Mapping根据业务场景，完善这个Mapping。如对某些字段定义的分词器等。
Elasticsearch 之 Mapping
jifeng3321的专栏
05-22 272
Elasticsearch 之 Mapping 什么是mapping Mapping 用来定义存储结构及索引过程，类似关系型数据中的schema 定义 定义索引中的字段名称 定义字段的数据类型 定义字段、倒排索引的相关配置 Mapping-Type mapping对应索引中的一个Type 一个type有一个mapping定义 ES 7.0 开始，不需要在Mapping 定义中指定type信息，type默认为_doc 字段的数据类型 创建索引 # 执行以下语句创建一个索引
ElasticSearch之Mapping设置
pizicai007的博客
02-13 685
ElasticSearch 中的 Mapping 类似与数据库中的表结构定义。Mapping 中的字段类型一旦设定后，禁止直接修改，原因是Lucene 实现的倒排索引生成后不允许修改，如果非要更改，只能重新建立索引，然后做 reindex 操作。Mapping 主要作用如下： 定义 Index 下的字段名； 定义字段的类型，如数值型，字符串型，布尔型； 定义倒排索引相关的配置，如是否索引，记...
（四）elasticsearch之mapping详解和数据类型
qq_37891300的博客
08-22 1059
elasticsearch之mapping详解和数据类型 一、mapping介绍 类似数据库中的表结构定义，主要作用如下： 定义 index 下的字段名（Field name） 定义字段的类型，比如 数值型，字符串型，布尔型等 定义倒排索引的相关配置，比如是的索引、是否记录position 等 二、常用mapping 相关api 1、获取索引 mapping 请求：GET XXX-INDE...
一文搞懂 Elasticsearch 之 Mapping
武培轩
03-18 512
这篇文章主要介绍 Mapping、Dynamic Mapping 以及 ElasticSearch 是如何自动判断字段的类型，同时介绍 Mapping 的相关参数设置。 首先来看下什么是 Mapping： 什么是 Mapping？ 在一篇文章带你搞定 ElasticSearch 术语中，我们讲到了 Mapping 类似于数据库中的表结构定义 schema，它有以下几个作用： 定义索引中的字段的名...
Elasticsearch---映射
相信自己有能力，那么你就真的会有！
08-31 382
平凡的脚步也可以走完伟大的行程。
ES的mapping配置详解
liuerchong的博客
03-25 8028
mapping的基本格式 { "mappings":{ "_doc":{ "_all":{ "enabled":false #默认情况，ElasticSarch自动使用_all所有的文档的域都会被加到_all中进行索引。可以使用"_all" : {"enabled":false} 开关禁用它。如果某个域不希望被加到_all中，可以使用"include_in_all":false关闭 },
ES:什么是mapping
标题
09-27 3192
自动或手动为index中的type建立的一种数据结构和相关配置，简称为mapping dynamic mapping，自动为我们建立index，创建type，以及type对应的mapping，mapping中包含了每个field对应的数据类型，以及如何分词等设置 GET /website/_mapping/article { "website&am
ES中mapping讲解
Xlucas的博客
11-08 6758
注意：以下都是基于ES6操作的 准备数据 PUT /web/info/1 { "post_date": "2018-11-01", "title": "the first info", "content": "the first info in this web", "author_id": "xlucas" } PUT /web
ES maping 学习笔记
tianjinsong的专栏
12-04 8379
一Filed type(字段类型) 1. 核心数据类型： String datatype string Numeric datatypes long, integer, short, byte, double, float Date datatype date 默认format："strict_date_optional_time||epoch_millis"是或的关系 strict...
es put mapping
weixin_34209406的博客
08-15 1259
fd dg public Map<String, Map<String, String>> javaBeanToMapping(Object instance, List<String> textMappingList, Map<String, String> nestedMappingMap) { Field field;...
Elasticsearch es Mapping
05-26
Elasticsearch Mapping 是指索引（index）中的字段映射（mapping），它定义了文档中每个字段的数据类型和如何存储数据。Mapping 是 Elasticsearch 中非常重要的概念，因为它定义了如何解析和索引文档。 在 Elasticsearch 中，Mapping 分为两种类型：静态 Mapping 和动态 Mapping。 静态 Mapping 是在创建索引时定义的，它指定了所有字段的数据类型和属性。一旦创建了索引，静态 Mapping 就不能再更改。如果想要更改 Mapping，就需要重新创建索引，这会导致数据丢失。 动态 Mapping 是在索引文档时自动创建的，它会根据文档中的字段自动推断数据类型和属性。如果 Elasticsearch 发现一个新的字段，它会自动将其添加到 Mapping 中，并根据字段的数据类型进行设置。 Mapping 有助于优化搜索性能和提高搜索准确性。正确定义 Mapping 可以使 Elasticsearch 更好地理解文档中的数据，从而更好地执行搜索操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值