映射定义了文档及其字段的存储和索引方式。可以使用映射进行如下定义：

指定哪些字符串字段作为全文搜索字段。
确定哪些字段包含数字、日期或地理位置信息。
决定是否将文档中所有字段的值索引到 _all 字段。
设定日期值的格式。
制定规则以控制动态添加字段的映射。

Field datatypes

Binary datatype

接受二进制值作为 Base64 编码的字符串。该字段默认不存储且不可被搜索：

PUT my_index
{
    "mappings": {
        "_doc": {
            "properties": { "name": { "type": "text" },
                            "blob": { "type": "binary" }
            }
        }
    }
}

PUT my_index/_doc/1
{
    "name": "Some binary blob",
    "blob": "U29tZSBiaW5hcnkgYmxvYg=="
}

curl -X PUT "localhost:9200/my_index?pretty" -H 'Content-Type: application/json' -d' {
    "mappings": {
        "_doc": {
            "properties": { "name": { "type": "text" },
                            "blob": { "type": "binary" }
            }
        }
    }
}'

{
  "acknowledged" : true,
  "shards_acknowledged" : true,
  "index" : "my_index"
}

参数说明

binary 字段接收以下参数：

doc_values：

该字段指定是否需要以列式存储的方式保存在磁盘上，以便后续用于排序、聚合或脚本处理。可以设置为 false（默认）或 true。
store：

该字段确定是否应该独立于 _source 字段进行存储和检索。可以设置为 false（默认）或 true。

Boolean datatype

布尔字段接受 true 和 false 值，也可以接受被解释为 true 或 false 的字符。

PUT my_index
{
    "mappings": {
        "_doc": {
            "properties": {
                "is_published": { "type": "boolean" }
            }
        }
    }
}

POST my_index/_doc/1
{
    "is_published": "true"
}

GET my_index/_search
{
    "query": {
        "term": { "is_published": true }
    }
}

curl -X PUT "localhost:9200/my_index?pretty" -H 'Content-Type: application/json' -d'{
    "mappings": {
        "_doc": {
            "properties": {
                "is_published": { "type": "boolean" }
            }
        }
    }
}'

{
  "acknowledged" : true,
  "shards_acknowledged" : true,
  "index" : "my_index"
}

参数说明

boolean 字段接受以下参数：

boost：Mapping 字段查询时间提升。接受浮点数，默认为 1.0。
doc_value：该字段是否应该以列跨步的方式存储在磁盘上，以便以后可以用于排序、聚合或脚本。接受 true（默认）和 false。
index：该字段应该是可搜索的吗？接受 true（默认）和 false。
null_value：接受上面列出的任何 true 或 false 值。该值将替换任何显式空值。默认为 null，这意味着该字段被视为缺失。
store：字段值是否应与 _source 字段分开存储和检索。接受 true（默认）和 false。

Date datatype

Scope 中的日期可以是：

包含格式化日期的字符串，例如 "2015-01-01" 或 "2015/01/01 12:10:30"。一个长数，表示自时代以来的毫秒数。一个整数，表示自时代以来的秒数。在内部，日期被转换为 UTC（如果指定了时区）并存储为一个长数，表示自时代以来的毫秒数。

可以自定义日期格式，但如果未指定格式，则使用默认格式：

"strict_date_optional_time||epoch_millis" 这意味着它将接受带有可选时间戳的日期，这些时间戳符合 strict_date_optional_time 或 milliseconds-since-the-epoch 支持的格式。

PUT my_index
{
    "mappings": {
        "_doc": {
            "properties": {
              "date": { "type": "date" }
            }
        }
    }
}

PUT my_index/_doc/1
{ "date": "2015-01-01" }

PUT my_index/_doc/2
{ "date": "2015-01-01T12:10:30Z" }

PUT my_index/_doc/3
{ "date": 1420070400001 }

GET my_index/_search
{
  "sort": { "date": "asc"}
}

curl -X PUT "localhost:9200/my_index?pretty" -H 'Content-Type: application/json' -d' {
    "mappings": {
        "_doc": {
            "properties": {
                "date": { "type": "date" }
            }
        }
    }
}'

{
  "acknowledged" : true,
  "shards_acknowledged" : true,
  "index" : "my_index"
}

Multiple date formats

可以通过用 || 分隔来指定多种格式作为分隔符。将依次尝试每种格式，直到找到匹配的格式。

PUT my_index
{
    "mappings": {
        "_doc": {
            "properties": {
                "date": { "type":   "date",
                          "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis" }
            }
        }
    }
}

参数说明

date 字段接受以下参数：

boost：Mapping 字段查询时间提升。接受浮点数，默认为 1.0。
doc_values：表示该字段是否应该以列跨步的方式存储在磁盘上，以便以后可以用于排序、聚合或脚本。接受 true（默认）或 false。
format：可以解析的日期格式。默认为 strict_date_optional_time||epoch_millis。
locale：解析自月份以来的日期时使用的语言环境在所有语言中都没有相同的名称和/或缩写。默认为 ROOT 语言环境，
index：表示该字段应该是可搜索的吗。接受 true（默认）或 false。
null_value：接受配置格式之一的日期值作为替换任何显式空值的字段。默认为 null，这意味着该字段被视为缺失。
store：字段值是否应与 _source 字段分开存储和检索。接受 true（默认）或 false。

IP datatype

PUT my_index
{
  "mappings": {
    "_doc": {
      "properties": {
        "ip_addr": {
          "type": "ip"
        }
      }
    }
  }
}

PUT my_index/_doc/1
{
  "ip_addr": "192.168.1.1"
}

GET my_index/_search
{
  "query": {
    "term": {
      "ip_addr": "192.168.0.0/16"
    }
  }
}

transwarp@transwarp-ThinkPad-T14-Gen-1:~/mygit1/shiva/build/bin$ curl -X PUT "localhost:9200/my_index?pretty" -H 'Content-Type: application/json' -d'
{
  "mappings": {
    "_doc": {
      "properties": {
        "ip_addr": {
          "type": "ip"
        }
      }
    }
  }
}'

{
  "acknowledged" : true,
  "shards_acknowledged" : true,
  "index" : "my_index"
}

参数说明

ip 字段接受以下参数：

boost：Mapping 字段查询时间提升。接受浮点数，默认为 1.0。
doc_values：该字段是否应该以列跨步的方式存储在磁盘上，以便以后可以用于排序、聚合或脚本.接受 true（默认）或 false。
index：该字段应该是可搜索的吗？接受 true（默认）或 false。
null_value：接受配置格式之一的日期值作为替换任何显式空值的字段。默认为 null，这意味着该字段被视为缺失。
store：字段值是否应与 _source 字段分开存储和检索。接受 true（默认）或 false。

Keyword datatype

用于索引结构化内容的字段，例如电子邮件地址、主机名、状态代码、邮政编码或标签。

它们通常用于过滤（查找所有发布状态的博客文章）、排序和聚合。关键字字段只能按其精确值进行搜索。

如果您需要索引全文内容，例如电子邮件正文或产品描述，您可能应该使用文本字段。

以下是关键字字段的示例：

PUT my_index
{
  "mappings": {
    "_doc": {
      "properties": {
        "tags": {
          "type":  "keyword"
        }
      }
    }
  }
}

curl -X PUT "localhost:9200/my_index?pretty" -H 'Content-Type: application/json' -d'{
   "mappings": {
     "_doc": {
       "properties": {
         "tags": {
           "type":  "keyword"
         }
       }
     }
   }
}'

{
  "acknowledged" : true,
  "shards_acknowledged" : true,
  "index" : "my_index"
}

参数说明

boost：mapping 字段查询时间提升。接受浮点数，默认为 1.0。
doc_values：表示该字段是否应该以列跨步的方式存储在磁盘上，以便以后可以用于排序、聚合或脚本。接受 true（默认）或 false。
fields：多字段允许为不同目的以多种方式索引相同的字符串值，例如一个用于搜索的字段和一个用于排序和聚合的多字段。
ignore_above：不要索引任何长于该值的字符串。默认为 2147483647，以便接受所有值。但是请注意，默认动态映射规则会创建一个子关键字字段，通过设置 ignore_above: 256 来覆盖此默认值。
index：该字段应该是可搜索的吗？接受 true（默认）或 false。
index_options：出于评分目的，应将哪些信息存储在索引中。默认为 docs，但也可以设置为 freqs 以在计算分数时考虑词频。
null_value：接受替换任何显式空值的字符串值。默认为 null，这意味着该字段被视为缺失。
store: 字段值是否应与 _source 字段分开存储和检索。接受 true（默认）或 false。

Numeric datatype

支持以下数字类型：

long：一个有符号的 64 位整数，最小值为 -263，最大值为 263-1。
integer：一个带符号的 32 位整数，最小值为 -231，最大值为 231-1。
short：一个带符号的 16 位整数，最小值为 -32,768，最大值为 32,767。
byte：一个有符号的 8 位整数，最小值为 -128，最大值为 127。
double：双精度 64 位 IEEE 754 浮点数，限制为有限值。
float：单精度 32 位 IEEE 754 浮点数，限制为有限值。

PUT my_index
{
  "mappings": {
    "_doc": {
      "properties": {
        "number_of_bytes": {
          "type": "integer"
        },
        "time_in_seconds": {
          "type": "float"
        },
        "price": {
          "type": "scaled_float",
          "scaling_factor": 100
        }
      }
    }
  }
}

curl -X PUT "localhost:9200/my_index?pretty" -H 'Content-Type: application/json' -d' {
   "mappings": {
     "_doc": {
       "properties": {
         "number_of_bytes": {
           "type": "integer"
         },
         "time_in_seconds": {
           "type": "float"
         },
         "price": {
           "type": "byte"
         }
       }
     }
   }
}'

{
  "acknowledged" : true,
  "shards_acknowledged" : true,
  "index" : "my_index"
}
----

参数说明

numeric 字段可以接收以下参数：

boost：Mapping 字段查询时间提升。接受浮点数，默认为 1.0。
doc_values：该字段是否应该以列跨步的方式存储在磁盘上，以便以后可以用于排序、聚合或脚本？接受 true（默认）或 false。
index：该字段应该是可搜索的吗？接受 true（默认）或 false。
null_value：接受替换任何显式空值的字符串值。默认为 null，这意味着该字段被视为缺失。
store：字段值是否应与 _source 字段分开存储和检索。接受 true（默认）或false。

Text datatype

用于索引全文值的字段，例如电子邮件正文或产品描述。对这些字段进行分析，也就是说，它们在被索引之前通过 analyzer 将字符串转换为单个词项的列表。分析过程允许在每个全文字段中搜索单个单词。文本字段不用于排序，也很少用于聚合（尽管重要的文本聚合是一个明显的例外）。

下面是一个文本字段的映射示例：

PUT my_index
{
  "mappings": {
    "_doc": {
      "properties": {
        "full_name": {
          "type":  "text"
        }
      }
    }
  }
}

curl -X PUT "localhost:9200/my_index?pretty" -H 'Content-Type: application/json' -d' {
   "mappings": {
     "_doc": {
       "properties": {
         "full_name": {
           "type":  "text"
         }
       }
     }
   }
 }'

{
  "acknowledged" : true,
  "shards_acknowledged" : true,
  "index" : "my_index"
}

参数说明

对于 text 字段，可以接收以下参数：

analyzer：在索引时间和搜索时间都应该用于分析的字符串字段的 analyzer（除非被 search_analyzer 覆盖）。
boost：Mapping 字段查询时间提升。接受浮点数，默认为 1.0。
doc_values：表示该字段是否应该以列跨步的方式存储在磁盘上，以便以后可以用于排序、聚合或脚本。接受 true（默认）或 false。
fields：多字段允许为不同目的以多种方式索引相同的字符串值，例如一个用于搜索的字段和一个用于排序和聚合的多字段。
index：表示该字段应该是可搜索的吗。

接受 true（默认）或 false。

index_options：出于评分目的，应将哪些信息存储在索引中。默认为 docs，但也可以设置为 freqs 以在计算分数时考虑词频。
null_value：接受替换任何显式空值的字符串值。默认为 null，这意味着该字段被视为缺失。
store：字段值是否应与 _source 字段分开存储和检索。接受 true（默认）或 false。

Mapping parameters

analyzer

被分析的字符串字段的值通过 analyzer 传递，以将字符串转换为词元。例如，字符串 "The quick Brown Foxes"。根据使用的 analyzer ，可能会被分析为：quick、brown、foxes。这使得可以在大块文本中有效地搜索单个单词。

此分析过程不仅需要在索引时进行，而且还需要在查询时进行：查询字符串需要通过相同（或类似）的 analyzer，以便它尝试查找的词项与那些词项具有相同的格式存在于索引中。

Scope 附带了许多预定义的 analyzer，无需进一步配置即可使用。它还附带了许多字符过滤器、标记器和标记过滤器，它们可以组合起来为每个索引配置自定义 analyzer。

可以按查询、按字段或按索引指定 analyzer。

PUT /my_index
{
  "mappings": {
    "_doc": {
      "properties": {
        "text": {
          "type": "text",
          "fields": {
            "english": {
              "type":     "text",
              "analyzer": "english"
            }
          }
        }
      }
    }
  }
}

GET my_index/_analyze
{
  "field": "text",
  "text": "The quick Brown Foxes."
}

GET my_index/_analyze
{
  "field": "text.english",
  "text": "The quick Brown Foxes."
}

curl -XPUT "localhost:9200/my_index?pretty" -H 'Content-Type: application/json' -d'{
   "mappings": {
     "_doc": {
       "properties": {
         "text": {
           "type": "text",
           "fields": {
             "english": {
               "type":     "text",
               "analyzer": "english"
             }
           }
         }
       }
     }
   }
}'

{
  "acknowledged" : true,
  "shards_acknowledged" : true,
  "index" : "my_index"
}

copy_to

copy_to 参数可以将多个字段的值复制到一个组字段中，然后可以将其作为单个字段进行查询。例如，可以将 first_name 和 last_name 字段复制到 full_name 字段，如下所示：

PUT my_index
{
  "mappings": {
    "_doc": {
      "properties": {
        "first_name": {
          "type": "text",
          "copy_to": "full_name"
        },
        "last_name": {
          "type": "text",
          "copy_to": "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": {
        "query": "John Smith",
        "operator": "and"
      }
    }
  }
}

curl -XPUT "localhost:9200/my_index?pretty" -H 'Content-Type: application/json' -d' {
"mappings": {
     "_doc": {
       "properties": {
         "first_name": {
           "type": "text",
           "copy_to": "full_name"
         },
         "last_name": {
           "type": "text",
           "copy_to": "full_name"
         },
         "full_name": {
           "type": "text"
         }
       }
     }
   }
}'

{
  "acknowledged" : true,
  "shards_acknowledged" : true,
  "index" : "my_index"
}

doc_values

默认情况下，大多数字段都已编入索引，这使得它们可搜索。倒排索引允许查询在唯一排序的词项列表中查找搜索词项，并从中立即访问包含该词项的文档列表。

排序、聚合和访问脚本中的字段值需要不同的数据访问模式。需要能够查找文档并找到它在字段中的词项，而不是查找词项和查找文档。

文档值是在文档索引时构建的磁盘数据结构。它们存储与 _source 相同的值，但以面向列的方式存储，这对于排序和聚合更有效。几乎所有字段类型都支持 doc_values。

所有支持 doc_values 的字段都默认启用它们。如果确定不需要对字段进行排序或聚合，或从脚本访问字段值，则可以禁用 doc_values 以节省磁盘空间：

PUT my_index
{
  "mappings": {
    "_doc": {
      "properties": {
        "status_code": {
          "type":       "keyword"
        },
        "session_id": {
          "type":       "keyword",
          "doc_values": false
        }
      }
    }
  }
}

curl -X PUT "localhost:9200/my_index?pretty" -H 'Content-Type: application/json' -d' {
   "mappings": {
     "_doc": {
       "properties": {
         "status_code": {
           "type":       "keyword"
         },
         "session_id": {
           "type":       "keyword",
           "doc_values": false
         }
       }
     }
   }
}'

{
  "acknowledged" : true,
  "shards_acknowledged" : true,
  "index" : "my_index"
}

format

在 JSON 文档中，日期表示为字符串。Scope 使用一组预配置的格式来识别这些字符串并将其解析为一个 long 值，该值表示 UTC 中的毫秒数。

除了内置格式之外，还可以使用熟悉的 "yyyy/MM/dd" 语法指定自定义格式：

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

curl -X PUT "localhost:9200/my_index?pretty" -H 'Content-Type: application/json' -d'{
   "mappings": {
     "_doc": {
       "properties": {
         "date": {
           "type":   "date",
           "format": "yyyy-MM-dd"
         }
       }
     }
   }
}'

{
  "acknowledged" : true,
  "shards_acknowledged" : true,
  "index" : "my_index"
}

以下大多数格式都有严格的配套格式，例如，像 5/11/1 这样的日期将被视为无效，需要将其重写为 2005/11/01 才能被日期解析器接受。

要使用它们，您需要在日期格式的名称前面加上 strict_，例如 strict_date_optional_time 而不是 date_optional_time。

这些严格的日期格式在动态映射日期字段时特别有用，以确保不会意外地将不相关的字符串映射为日期。

下面列出了支持的所有默认 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 为前缀的时区偏移的基本格式化程序：'T’HHmmss.SSSZ。
basic_t_time_no_millis：一个基本的格式化程序，用于一天中的两位数小时、小时的两位数分钟、分钟的两位数秒以及以 T 为前缀的时区偏移量：'T’HHmmssZ。
basic_week_date 或 strict_basic_week_date：完整日期的基本格式化程序，如四位数的周年、两位数的周年和一位数的星期：xxxx’W’wwe。
basic_week_date_time 或 strict_basic_week_date_time：一个基本的格式化程序，它结合了基本的星期日期和时间，用 T 分隔：xxxx’W’wwe’T’HHmmss.SSSZ。
basic_week_date_time_no_millis 或 strict_basic_week_date_time_no_millis：一个基本的格式化程序，它结合了基本的星期日期和时间，没有毫秒，用 T 分隔：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：一个格式化程序，它结合了完整的日期和时间，没有毫秒，用 T 分隔：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 为前缀的时区偏移量的格式化程序：'T’HH:mm:ssZZ。
week_date 或 strict_week_date：将完整日期格式化为四位数的周年、两位数的周数和一位数的周数：xxxx-'W’ww-e。
week_date_time 或 strict_week_date_time：一个组合了完整的星期日期和时间的格式化程序，用 T 分隔：xxxx-'W’ww-e’T’HH:mm:ss.SSSZZ。
week_date_time_no_millis 或 strict_week_date_time_no_millis：一个格式化程序，它结合了一个完整的星期日期和时间，没有毫秒，用 T 分隔：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 设置的字符串将不会被索引或存储。对于字符串数组，ignore_above 将分别应用于每个数组元素，并且长度超过 ignore_above 的字符串元素将不会被索引或存储。

PUT my_index
{
  "mappings": {
    "_doc": {
      "properties": {
        "message": {
          "type": "keyword",
          "ignore_above": 20
        }
      }
    }
  }
}

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

PUT my_index/_doc/2
{
  "message": "Syntax error with some long stacktrace"
}

GET _search
{
  "aggs": {
    "messages": {
      "terms": {
        "field": "message"
      }
    }
  }
}

curl -X PUT "localhost:9200/my_index?pretty" -H 'Content-Type: application/json' -d'{
   "mappings": {
     "_doc": {
       "properties": {
         "message": {
           "type": "keyword",
           "ignore_above": 20
         }
       }
     }
   }
}'

{
  "acknowledged" : true,
  "shards_acknowledged" : true,
  "index" : "my_index"
}

index

index 选项控制字段值是否被索引。它接受 true 或 false，默认为 true。未编入索引的字段不可查询。

fields

出于不同目的以不同方式索引同一字段通常很有用。这就是多领域的目的。例如，text 字段可以映射为全文搜索的文本字段，以及排序的 keyword 字段：

PUT my_index
{
  "mappings": {
    "_doc": {
      "properties": {
        "city": {
          "type": "text",
          "fields": {
            "raw": {
              "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"
    }
  },
  "sort": {
    "city.raw": "asc"
  }
}

curl -X PUT "localhost:9200/my_index?pretty" -H 'Content-Type: application/json' -d' {
   "mappings": {
     "_doc": {
       "properties": {
         "city": {
           "type": "text",
           "fields": {
             "raw": {
               "type":  "keyword"
             }
           }
         }
       }
     }
   }
}'

{
  "acknowledged" : true,
  "shards_acknowledged" : true,
  "index" : "my_index"
}

position_increment_gap

分析的文本字段会考虑词项位置，以便能够支持邻近或短语查询。当索引具有多个值的文本字段时，值之间会添加一个“假”间隙，以防止大多数短语查询在值之间匹配。此间隙的大小使用 position_increment_gap 配置，默认为 100。

PUT my_index
{
  "mappings": {
    "_doc": {
      "properties": {
        "names": {
          "type": "text",
          "position_increment_gap": 0
        }
      }
    }
  }
}

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

GET my_index/_search
{
    "query": {
        "match_phrase": {
            "names": "Abraham Lincoln"
        }
    }
}

curl -XPUT "localhost:9200/my_index?pretty" -H 'Content-Type: application/json' -d' {
   "mappings": {
     "_doc": {
       "properties": {
         "names": {
           "type": "text",
           "position_increment_gap": 0
         }
       }
     }
   }
}'

{
  "acknowledged" : true,
  "shards_acknowledged" : true,
  "index" : "my_index"
}

search_analyzer

通常，在索引时和搜索时应该应用相同的 analyzer，以确保查询中的词项与倒排索引中的词项格式相同。

但是，有时需要在搜索时使用不同的 analyzer，例如在使用 edge_ngram 标记器进行自动完成时。

默认情况下，查询将使用字段 mapping 中定义的 analyzer，但这可以用 search_analyzer 设置覆盖：

PUT my_index
{
  "settings": {
    "analysis": {
      "filter": {
        "autocomplete_filter": {
          "type": "edge_ngram",
          "min_gram": 1,
          "max_gram": 20
        }
      },
      "analyzer": {
        "autocomplete": {
          "type": "custom",
          "tokenizer": "standard",
          "filter": [
            "lowercase",
            "autocomplete_filter"
          ]
        }
      }
    }
  },
  "mappings": {
    "_doc": {
      "properties": {
        "text": {
          "type": "text",
          "analyzer": "autocomplete",
          "search_analyzer": "standard"
        }
      }
    }
  }
}

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

GET my_index/_search
{
  "query": {
    "match": {
      "text": {
        "query": "Quick Br",
        "operator": "and"
      }
    }
  }
}

curl -X PUT "localhost:9200/my_index?pretty" -H 'Content-Type: application/json' -d' {
   "settings": {
     "analysis": {
       "filter": {
         "autocomplete_filter": {
           "type": "edge_ngram",
           "min_gram": 1,
           "max_gram": 20
         }
       },
       "analyzer": {
         "autocomplete": {
           "type": "custom",
           "tokenizer": "standard",
           "filter": [
             "lowercase",
             "autocomplete_filter"
           ]
         }
       }
     }
   },
   "mappings": {
     "_doc": {
       "properties": {
         "text": {
           "type": "text",
           "analyzer": "autocomplete",
           "search_analyzer": "standard"
         }
       }
     }
   }
}'

{
  "acknowledged" : true,
  "shards_acknowledged" : true,
  "index" : "my_index"
}

store

默认情况下，对字段值进行索引以使其可搜索，但不会存储它们。这意味着可以查询该字段，但无法检索原始字段值。

通常这无关紧要。字段值已经是默认存储的 _source 字段的一部分。如果您只想检索单个字段或几个字段的值，而不是整个 _source，则可以通过源过滤来实现。

在某些情况下，存储字段是有意义的。例如，如果有一个包含标题、日期和非常大的内容字段的文档，只想检索标题和日期，而不必从大的 _source 字段中提取这些字段：

PUT my_index
{
  "mappings": {
    "_doc": {
      "properties": {
        "title": {
          "type": "text",
          "store": true
        },
        "date": {
          "type": "date",
          "store": true
        },
        "content": {
          "type": "text"
        }
      }
    }
  }
}

PUT my_index/_doc/1
{
  "title":   "Some short title",
  "date":    "2015-01-01",
  "content": "A very long content field..."
}

GET my_index/_search
{
  "stored_fields": [ "title", "date" ]
}

curl -X PUT "localhost:9200/my_index?pretty" -H 'Content-Type: application/json' -d' {
   "mappings": {
     "_doc": {
       "properties": {
         "title": {
           "type": "text",
           "store": true
         },
         "date": {
           "type": "date",
           "store": true
         },
         "content": {
           "type": "text"
         }
       }
     }
   }
}'

{
  "acknowledged" : true,
  "shards_acknowledged" : true,
  "index" : "my_index"
}

Dynamic mapping

动态映射功能在索引文档之前不必创建索引、定义类型等信息，在索引的同时会自动完成索引、类型、映射的创建。当文档中出现一个新的字段时，会利用动态映射来确定该字段的数据类型，并自动为其添加映射。

你可以通过设置dynamic参数来控制这种行为，它接受以下几种选项：

true：默认值。动态添加字段
false：新检测到的字段将被忽略。这些字段将不会被索引，因此将无法搜索，但仍将出现在返回点击的源字段中。这些字段不会添加到映射中，必须显式添加新字段。
strict：如果碰到陌生字段，抛出异常

动态字段映射启用时，适用如下规则确定字段应该具有哪种数据类型：

表 3. 动态映射规定数据类型
JSON 数据类型	Scope 数据类型
null	No field is added
true or false	boolean field
floating point number	float field
integer	long field
object	object field
array	Depends on the first non-null value in the array
string	Either a date field (if the value passes date detection), a double or long field (if the value passes numeric detection) or a text field, with a keyword sub-field.

# 创建 dynamic mapping
PUT /my_index
{
    "mappings": { "dynamic": "strict",
    "properties": { "title": { "type": "text" },
                    "address": { "type": "object", "dynamic": "true" }
    }
}

# 插入数据进行测试
PUT /my_index/_doc/1
{
    "title": "my article",
    "content": "this is my article",
    "address": { "province": "guangdong",
                 "city": "guangzhou" }
}

返回结果如下，由于 content 为新增字段，结果会抛出异常。

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

date_detection

默认会按照一定格式识别 date，比如 yyyy-MM-dd。但是如果某个 field 先过来一个 2017-01-01 的值，就会被自动映射成 date，后面如果再来一个 "hello world" 之类的值，就会报错。可以手动关闭某个 type 的 date_detection，如果有需要，自己手动指定某个 field 为 date 类型。

# 关闭自动映射的 date_detection
PUT /my_index
{
"mappings": {
"date_detection": false,
"properties": {
"title": {
"type": "text"
},
"address": {
"type": "object",
"dynamic": "true"
}
}
}
}

# 插入数据进行测试
PUT /my_index/_doc/1
{
"title": "my article",
"content": "this is my article",
"address": {
"province": "guangdong",
"city": "guangzhou"
},
"post_date": "2019-09-10"
}

GET /my_index/_mapping

返回结果如下，字段都成功新增。同时由于关闭了 date_detection，post_date 字段类型是 text 类型不是 date 类型。

{
  "my_index" : {
    "mappings" : {
      "date_detection" : false,
      "properties" : {
        "address" : {
          "dynamic" : "true",
          "properties" : {
            "city" : {
              "type" : "text",
              "fields" : {
                "keyword" : {
                  "type" : "keyword",
                  "ignore_above" : 256
                }
              }
            },
            "province" : {
              "type" : "text",
              "fields" : {
                "keyword" : {
                  "type" : "keyword",
                  "ignore_above" : 256
                }
              }
            }
          }
        },
        "content" : {
          "type" : "text",
          "fields" : {
            "keyword" : {
              "type" : "keyword",
              "ignore_above" : 256
            }
          }
        },
        "post_date" : {
          "type" : "text",
          "fields" : {
            "keyword" : {
              "type" : "keyword",
              "ignore_above" : 256
            }
          }
        },
        "title" : {
          "type" : "text"
        }
      }
    }
  }
}

numeric_detection

虽然 JSON 支持浮点和整数数据类型，但某些应用程序或语言有时可能需要将数字识别为字符串。通常的解决方案是显式地映射这些字段，但是可以启用数字检测（默认情况下禁用）来自动完成这些操作。

# 开启自动映射的 numeric_detection
PUT my_index
{
"mappings": {
"numeric_detection": true
}
}

# 插入数据进行测试
PUT my_index/_doc/1
{
"my_float": "1.0",
"my_integer": "1"
}

GET my_index/_mapping

返回结果如下，所有数字均识别为了字符串

{
  "my_index" : {
    "mappings" : {
      "numeric_detection" : true,
      "properties" : {
        "my_float" : {
          "type" : "float"
        },
        "my_integer" : {
          "type" : "long"
        }
      }
    }
  }
}