元数据字段

桶聚合总是返回一个名为 doc_count 的字段，显示每个桶中聚合和分区的文档数量。doc_count 的值的计算非常简单。对于每个桶中收集的每个文档，doc_count 都会增加1。

虽然这种简单的方法在计算单个文档的聚合时是有效的，但它无法准确表示存储预聚合数据的文档（例如 histogram 或 aggregate_metric_double 字段），因为一个摘要字段可能代表多个文档。

为了在使用预聚合数据时正确计算文档数量，我们引入了一个名为 _doc_count 的元数据字段类型。_doc_count 必须始终是一个表示单个汇总字段中聚合文档数量的正整数。

当字段 _doc_count 被添加到文档中时，所有桶聚合将尊重其值并根据该字段的值增加桶 doc_count。如果文档不包含任何 _doc_count 字段，则默认隐含 _doc_count = 1。

PUT my_index
{
  "mappings" : {
    "properties" : {
      "my_histogram" : {
        "type" : "histogram"
      },
      "my_text" : {
        "type" : "keyword"
      }
    }
  }
}

PUT my_index/_doc/1
{
  "my_text" : "histogram_1",
  "my_histogram" : {
      "values" : [0.1, 0.2, 0.3, 0.4, 0.5],
      "counts" : [3, 7, 23, 12, 6]
   },
  "_doc_count": 45 
}

PUT my_index/_doc/2
{
  "my_text" : "histogram_2",
  "my_histogram" : {
      "values" : [0.1, 0.25, 0.35, 0.4, 0.45, 0.5],
      "counts" : [8, 17, 8, 7, 6, 2]
   },
  "_doc_count": 62 
}

GET /_search
{
    "aggs" : {
        "histogram_titles" : {
            "terms" : { "field" : "my_text" }
        }
    }
}

{
    ...
    "aggregations" : {
        "histogram_titles" : {
            "doc_count_error_upper_bound": 0,
            "sum_other_doc_count": 0,
            "buckets" : [
                {
                    "key" : "histogram_2",
                    "doc_count" : 62
                },
                {
                    "key" : "histogram_1",
                    "doc_count" : 45
                }
            ]
        }
    }
}

_field_names 字段用于索引文档中包含除 null 以外的任何值的每个字段的名称。该字段曾被 exists 查询用来查找具有或不具有特定字段的任何非 null 值的文档。

现在，_field_names 字段仅索引那些已禁用 doc_values 和 norms 的字段的名称。对于启用了 doc_values 或 norm 的字段，exists 查询仍然可用，但不会使用 _field_names 字段。

_ignored 字段索引并存储了文档中被忽略的每个字段的名称，当文档被索引时，这些字段被忽略。例如，当字段格式错误并且 ignore_malformed 被启用时，或者当 keyword 字段的值超过了其可选的 ignore_above 设置时，或者当达到 index.mapping.total_fields.limit 并且 index.mapping.total_fields.ignore_dynamic_beyond_limit 设置为 true 时。

此字段可以通过 term、 terms 和 exists 查询进行搜索，并且作为搜索结果的一部分返回。

例如，以下查询匹配所有具有一个或多个被忽略字段的文档：

GET _search
{
  "query": {
    "exists": {
      "field": "_ignored"
    }
  }
}

同样，下面的查询会找到所有在索引时被忽略的@timestamp字段的文档：

GET _search
{
  "query": {
    "term": {
      "_ignored": "@timestamp"
    }
  }
}

自8.15.0版本起，_ignored 字段也支持聚合操作。 例如，以下查询可以找到所有被忽略的字段：

GET _search
{
  "aggs": {
    "ignored_fields": {
      "terms": {
         "field": "_ignored"
      }
    }
  }
}

每个文档都有一个唯一的_id，该ID被索引，因此可以使用GET API或ids查询来查找文档。_id可以在索引时分配，或者由Elasticsearch生成一个唯一的_id。此字段在映射中不可配置。

在诸如 term、terms、match 和 query_string 的查询中，_id 字段的值是可访问的。

# Example documents
PUT my-index-000001/_doc/1
{
  "text": "Document with ID 1"
}

PUT my-index-000001/_doc/2?refresh=true
{
  "text": "Document with ID 2"
}

GET my-index-000001/_search
{
  "query": {
    "terms": {
      "_id": [ "1", "2" ] 
    }
  }
}

_id 字段在聚合、排序和脚本中受到限制。 如果需要对 _id 字段进行排序或聚合，建议将 _id 字段的内容复制到另一个启用了 doc_values 的字段中。

在跨多个索引执行查询时，有时希望添加仅与某些索引的文档相关的查询子句。 _index 字段允许匹配文档所索引到的索引。 它的值可以在某些查询和聚合中访问，并且在排序或脚本编写时也可以使用：

PUT index_1/_doc/1
{
  "text": "Document in index 1"
}

PUT index_2/_doc/2?refresh=true
{
  "text": "Document in index 2"
}

GET index_1,index_2/_search
{
  "query": {
    "terms": {
      "_index": ["index_1", "index_2"] 
    }
  },
  "aggs": {
    "indices": {
      "terms": {
        "field": "_index", 
        "size": 10
      }
    }
  },
  "sort": [
    {
      "_index": { 
        "order": "asc"
      }
    }
  ],
  "script_fields": {
    "index_name": {
      "script": {
        "lang": "painless",
        "source": "doc['_index']" 
      }
    }
  }
}

_index 字段实际上是暴露出来的——它不会作为真实字段添加到 Lucene 索引中。这意味着你可以在 term 或 terms 查询（或任何重写为 term 查询的查询，例如 match、query_string 或 simple_query_string 查询）中使用 _index 字段，以及 prefix 和 wildcard 查询。然而，它不支持 regexp 和 fuzzy 查询。

对_index字段的查询除了具体的索引名称外，还接受索引别名。

映射类型可以具有与其关联的自定义元数据。这些元数据完全不由Elasticsearch使用，但可以用于存储特定于应用程序的元数据，例如文档所属的类：

PUT my-index-000001
{
  "mappings": {
    "_meta": { 
      "class": "MyApp::User",
      "version": {
        "min": "1.0",
        "max": "1.3"
      }
    }
  }
}

可以使用更新映射 API 在现有类型上更新 _meta 字段：

PUT my-index-000001/_mapping
{
  "_meta": {
    "class": "MyApp2::User3",
    "version": {
      "min": "1.3",
      "max": "1.5"
    }
  }
}

文档通过以下公式路由到索引中的特定分片：

routing_factor = num_routing_shards / num_primary_shards
shard_num = (hash(_routing) % num_routing_shards) / routing_factor

num_routing_shards 是索引设置 index.number_of_routing_shards 的值。num_primary_shards 是索引设置 index.number_of_shards 的值。

默认的 _routing 值是文档的 _id。 可以通过为每个文档指定自定义的 routing 值来实现自定义路由模式。例如：

PUT my-index-000001/_doc/1?routing=user1&refresh=true 
{
  "title": "This is a document"
}

GET my-index-000001/_doc/1?routing=user1 

在查询中可以访问_routing字段的值：

GET my-index-000001/_search
{
  "query": {
    "terms": {
      "_routing": [ "user1" ] 
    }
  }
}

GET my-index-000001/_search?routing=user1,user2 
{
  "query": {
    "match": {
      "title": "document"
    }
  }
}

PUT my-index-000002
{
  "mappings": {
    "_routing": {
      "required": true 
    }
  }
}

PUT my-index-000002/_doc/1 
{
  "text": "No routing value provided"
}

routing_value = hash(_routing) + hash(_id) % routing_partition_size
shard_num = (routing_value % num_routing_shards) / routing_factor

The _source 字段包含在索引时传递的原始 JSON 文档主体。_source 字段本身未被索引（因此不可搜索），但它被存储以便在执行 fetch 请求时返回，例如 get 或 search。

如果磁盘使用对你很重要，那么请考虑以下选项：

PUT idx
{
  "settings": {
    "index": {
      "mapping": {
        "source": {
          "mode": "synthetic"
        }
      }
    }
  }
}

PUT idx/_doc/1
{
  "foo": [
    {
      "bar": 1
    },
    {
      "bar": 2
    }
  ]
}

{
  "foo": {
    "bar": [1, 2]
  }
}

PUT idx/_doc/1
{
  "foo": [
    {
      "bar": 1
    },
    {
      "baz": 2
    }
  ]
}

{
  "foo": {
    "bar": 1,
    "baz": 2
  }
}

PUT idx/_doc/1
{
  "foo.bar.baz": 1
}

{
  "foo": {
    "bar": {
      "baz": 1
    }
  }
}

"script": { "source": """  emit(params._source['foo.bar.baz'])  """ }

"script": { "source": """  emit(params._source['foo']['bar']['baz'])  """ }

"script": { "source": """  emit(params._source.foo.bar.baz)  """ }

"script": { "source": """  emit(field('foo.bar.baz').get(null))   """ }
"script": { "source": """  emit($('foo.bar.baz', null))   """ }

PUT idx_keep
{
  "settings": {
    "index": {
      "mapping": {
        "source": {
          "mode": "synthetic"
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "path": {
        "type": "object",
        "synthetic_source_keep": "all"
      },
      "ids": {
        "type": "integer",
        "synthetic_source_keep": "arrays"
      }
    }
  }
}

PUT idx_keep/_doc/1
{
  "path": {
    "to": [
      { "foo": [3, 2, 1] },
      { "foo": [30, 20, 10] }
    ],
    "bar": "baz"
  },
  "ids": [ 200, 100, 300, 100 ]
}

{
  "path": {
    "to": [
      { "foo": [3, 2, 1] },
      { "foo": [30, 20, 10] }
    ],
    "bar": "baz"
  },
  "ids": [ 200, 100, 300, 100 ]
}

PUT my-index-000001
{
  "mappings": {
    "_source": {
      "enabled": false
    }
  }
}

PUT logs
{
  "mappings": {
    "_source": {
      "includes": [
        "*.count",
        "meta.*"
      ],
      "excludes": [
        "meta.description",
        "meta.other.*"
      ]
    }
  }
}

PUT logs/_doc/1
{
  "requests": {
    "count": 10,
    "foo": "bar" 
  },
  "meta": {
    "name": "Some metric",
    "description": "Some metric description", 
    "other": {
      "foo": "one", 
      "baz": "two" 
    }
  }
}

GET logs/_search
{
  "query": {
    "match": {
      "meta.other.foo": "one" 
    }
  }
}

在跨多个索引执行查询时，有时希望针对位于给定数据层节点上的索引（data_hot、data_warm、data_cold 或 data_frozen）。 _tier 字段允许匹配文档所索引到的索引的 tier_preference 设置。 首选值在某些查询中是可访问的：

PUT index_1/_doc/1
{
  "text": "Document in index 1"
}

PUT index_2/_doc/2?refresh=true
{
  "text": "Document in index 2"
}

GET index_1,index_2/_search
{
  "query": {
    "terms": {
      "_tier": ["data_hot", "data_warm"] 
    }
  }
}

通常，查询会使用terms查询来列出感兴趣的层级，但您可以在任何重写为term查询的查询中使用_tier字段，例如match、query_string、term、terms或simple_query_string查询，以及prefix和wildcard查询。然而，它不支持regexp和fuzzy查询。

索引的 tier_preference 设置是一个以逗号分隔的层级名称列表，按优先顺序排列，即托管索引的首选层级首先列出，后面可能跟随许多备用选项。查询匹配仅考虑第一个优先级（列表的第一个值）。