動的マッピング - 動的テンプレート（Dynamic templates）

動的テンプレート
- Js
動的テンプレートの検証
動的テンプレートにおけるランタイムフィールドのマッピング
match_mapping_typeとunmatch_mapping_type
マッチとアンマッチ
- Python
- Ruby
- Js
- Console
- Ruby
- Js
- Console
path_matchとpath_unmatch
- Ruby
- Js
- Console
- Ruby
- Js
- Console
- Ruby
- Js
- Console
テンプレート変数
動的テンプレートの例

動的テンプレート

動的テンプレートを使用すると、Elasticsearchがデータをマッピングする方法を、デフォルトの動的フィールドマッピングルールを超えてより細かく制御できます。動的マッピングは、dynamicパラメータをtrueまたはruntimeに設定することで有効にします。その後、動的テンプレートを使用して、マッチ条件に基づいて動的に追加されたフィールドに適用できるカスタムマッピングを定義できます：

match_mapping_typeとunmatch_mapping_typeは、Elasticsearchが検出したデータ型に対して動作します
matchとunmatchは、フィールド名に対してパターンを使用してマッチします
path_matchとpath_unmatchは、フィールドへの完全なドットパスに対して動作します
動的テンプレートがmatch_mapping_type、match、またはpath_matchを定義していない場合、どのフィールドにもマッチしません。それでも、バルクリクエストのdynamic_templatesセクションで名前でテンプレートを参照できます。

マッピング仕様で{name}と{dynamic_type} テンプレート変数をプレースホルダーとして使用します。

動的フィールドマッピングは、フィールドが具体的な値を含む場合にのみ追加されます。フィールドがnullまたは空の配列を含む場合、Elasticsearchは動的フィールドマッピングを追加しません。null_valueオプションがdynamic_templateで使用される場合、フィールドに具体的な値を持つ最初のドキュメントがインデックスされた後にのみ適用されます。

動的テンプレートは、名前付きオブジェクトの配列として指定されます：

Js

"dynamic_templates": [
   {
   "my_template_name": {
   ... match conditions ...
   "mapping": { ... }
   }
   },
   ...
  ]


	テンプレート名は任意の文字列値にできます。
	マッチ条件には、`match_mapping_type`、`match`、`match_pattern`、`unmatch`、`path_match`、`path_unmatch`のいずれかを含めることができます。
	マッチしたフィールドが使用すべきマッピング。

動的テンプレートの検証

提供されたマッピングに無効なマッピングスニペットが含まれている場合、検証エラーが返されます。検証は、インデックス時に動的テンプレートを適用する際に発生し、ほとんどの場合、動的テンプレートが更新されるときにも発生します。無効なマッピングスニペットを提供すると、特定の条件下で動的テンプレートの更新または検証が失敗する可能性があります：

match_mapping_typeが指定されていないが、テンプレートが少なくとも1つの事前定義されたマッピングタイプに対して有効な場合、マッピングスニペットは有効と見なされます。ただし、テンプレートにマッチするフィールドが異なるタイプとしてインデックスされると、インデックス時に検証エラーが返されます。たとえば、match_mapping_typeを指定しない動的テンプレートを設定することは文字列型として有効と見なされますが、動的テンプレートにマッチするフィールドがlongとしてインデックスされると、インデックス時に検証エラーが返されます。match_mapping_typeを期待されるJSON型に設定するか、マッピングスニペットで希望するtypeを設定することをお勧めします。
マッピングスニペットで{name}プレースホルダーが使用されている場合、動的テンプレートの更新時に検証はスキップされます。これは、その時点でフィールド名が不明であるためです。代わりに、テンプレートがインデックス時に適用されるときに検証が行われます。

テンプレートは順番に処理されます—最初にマッチしたテンプレートが勝ちます。マッピングの更新 APIを通じて新しい動的テンプレートを追加すると、すべての既存のテンプレートが上書きされます。これにより、動的テンプレートを初期追加後に再配置または削除することができます。

動的テンプレートにおけるランタイムフィールドのマッピング

Elasticsearchに特定のタイプの新しいフィールドをランタイムフィールドとして動的にマッピングさせたい場合は、インデックスマッピングで"dynamic":"runtime"を設定します。これらのフィールドはインデックスされず、クエリ時に_sourceから読み込まれます。

または、デフォルトの動的マッピングルールを使用し、特定のフィールドをランタイムフィールドとしてマッピングするための動的テンプレートを作成することもできます。インデックスマッピングで"dynamic":"true"を設定し、その後、特定のタイプの新しいフィールドをランタイムフィールドとしてマッピングするための動的テンプレートを作成します。

たとえば、各フィールドがip_で始まるデータがあるとします。動的マッピングルールに基づいて、Elasticsearchはstringがnumeric検出を通過する場合、floatまたはlongとしてマッピングします。ただし、新しい文字列をip型のランタイムフィールドとしてマッピングする動的テンプレートを作成できます。

次のリクエストは、strings_as_ipという名前の動的テンプレートを定義します。Elasticsearchがip*パターンにマッチする新しいstringフィールドを検出すると、それらのフィールドはip型のランタイムフィールドとしてマッピングされます。ipフィールドは動的にマッピングされないため、このテンプレートは"dynamic":"true"または"dynamic":"runtime"のいずれかで使用できます。

Python

resp = client.indices.create(
   index="my-index-000001",
   mappings={
   "dynamic_templates": [
   {
   "strings_as_ip": {
   "match_mapping_type": "string",
   "match": "ip*",
   "runtime": {
   "type": "ip"
   }
   }
   }
   ]
   },
)
print(resp)

Ruby

response = client.indices.create(
  index: 'my-index-000001',
  body: {
   mappings: {
   dynamic_templates: [
   {
   strings_as_ip: {
   match_mapping_type: 'string',
   match: 'ip*',
   runtime: {
   type: 'ip'
   }
   }
   }
   ]
   }
  }
)
puts response

Js

const response = await client.indices.create({
  index: "my-index-000001",
  mappings: {
   dynamic_templates: [
   {
   strings_as_ip: {
   match_mapping_type: "string",
   match: "ip*",
   runtime: {
   type: "ip",
   },
   },
   },
   ],
  },
});
console.log(response);

Console

PUT my-index-000001/
{
  "mappings": {
   "dynamic_templates": [
   {
   "strings_as_ip": {
   "match_mapping_type": "string",
   "match": "ip*",
   "runtime": {
   "type": "ip"
   }
   }
   }
   ]
  }
}

この例を参照して、動的テンプレートを使用してstringフィールドをインデックスフィールドまたはランタイムフィールドとしてマッピングする方法を確認してください。

match_mapping_typeとunmatch_mapping_type


JSONは`````long`````と`````integer`````、または`````double`````と`````float`````を区別しないため、解析された浮動小数点数は`````double````` JSONデータ型と見なされ、解析された`````integer`````数は`````long`````と見なされます。  
動的マッピングでは、Elasticsearchは常に広いデータ型を選択します。唯一の例外は`````float`````で、これは`````double`````よりも少ないストレージスペースを必要とし、ほとんどのアプリケーションに対して十分な精度を持っています。ランタイムフィールドは`````float`````をサポートしていないため、`````"dynamic":"runtime"`````は`````double`````を使用します。  
Elasticsearchは次のデータ型を自動的に検出します：  
|     |     |     |
| --- | --- | --- |
|  | **Elasticsearchデータ型** |
| **JSONデータ型** | **`````"dynamic":"true"`````** | **`````"dynamic":"runtime"`````** |
| `````null````` | フィールドが追加されていません | フィールドが追加されていません |
| `````true`````または`````false````` | `````boolean````` | `````boolean````` |
| `````double````` | `````float````` | `````double````` |
| `````long````` | `````long````` | `````long````` |
| `````object````` | `````object````` | フィールドが追加されていません |
| `````array````` | 配列内の最初の非`````null`````値に依存 | 配列内の最初の非`````null`````値に依存 |
| `````string`````が[日付検出](56049773a26d4fae.md#date-detection "Date detection")を通過する | `````date````` | `````date````` |
| `````string`````が[数値検出](56049773a26d4fae.md#numeric-detection "Numeric detection")を通過する | `````float`````または`````long````` | `````double`````または`````long````` |
| `````string`````が`````date`````検出または`````numeric`````検出を通過しない | `````text`````と`````.keyword`````サブフィールドを持つ | `````keyword````` |
`````match_mapping_type`````または`````unmatch_mapping_type`````パラメータに対して、単一のデータ型またはデータ型のリストを指定できます。`````*`````パラメータにワイルドカードを使用して、すべてのデータ型をマッチさせることもできます。  
たとえば、すべての整数フィールドを`````integer`````としてマッピングし、すべての`````string`````フィールドを`````text`````および`````keyword`````の両方としてマッピングしたい場合、次のテンプレートを使用できます：
#### Python
``````python
resp = client.indices.create(
   index="my-index-000001",
   mappings={
   "dynamic_templates": [
   {
   "numeric_counts": {
   "match_mapping_type": [
   "long",
   "double"
   ],
   "match": "count",
   "mapping": {
   "type": "{dynamic_type}",
   "index": False
   }
   }
   },
   {
   "integers": {
   "match_mapping_type": "long",
   "mapping": {
   "type": "integer"
   }
   }
   },
   {
   "strings": {
   "match_mapping_type": "string",
   "mapping": {
   "type": "text",
   "fields": {
   "raw": {
   "type": "keyword",
   "ignore_above": 256
   }
   }
   }
   }
   },
   {
   "non_objects_keyword": {
   "match_mapping_type": "*",
   "unmatch_mapping_type": "object",
   "mapping": {
   "type": "keyword"
   }
   }
   }
   ]
   },
)
print(resp)
resp1 = client.index(
   index="my-index-000001",
   id="1",
   document={
   "my_integer": 5,
   "my_string": "Some string",
   "my_boolean": "false",
   "field": {
   "count": 4
   }
   },
)
print(resp1)
`

Ruby

response = client.indices.create(
  index: 'my-index-000001',
  body: {
   mappings: {
   dynamic_templates: [
   {
   numeric_counts: {
   match_mapping_type: [
   'long',
   'double'
   ],
   match: 'count',
   mapping: {
   type: '{dynamic_type}',
   index: false
   }
   }
   },
   {
   integers: {
   match_mapping_type: 'long',
   mapping: {
   type: 'integer'
   }
   }
   },
   {
   strings: {
   match_mapping_type: 'string',
   mapping: {
   type: 'text',
   fields: {
   raw: {
   type: 'keyword',
   ignore_above: 256
   }
   }
   }
   }
   },
   {
   non_objects_keyword: {
   match_mapping_type: '*',
   unmatch_mapping_type: 'object',
   mapping: {
   type: 'keyword'
   }
   }
   }
   ]
   }
  }
)
puts response
response = client.index(
  index: 'my-index-000001',
  id: 1,
  body: {
   my_integer: 5,
   my_string: 'Some string',
   my_boolean: 'false',
   field: {
   count: 4
   }
  }
)
puts response

Js

const response = await client.indices.create({
  index: "my-index-000001",
  mappings: {
   dynamic_templates: [
   {
   numeric_counts: {
   match_mapping_type: ["long", "double"],
   match: "count",
   mapping: {
   type: "{dynamic_type}",
   index: false,
   },
   },
   },
   {
   integers: {
   match_mapping_type: "long",
   mapping: {
   type: "integer",
   },
   },
   },
   {
   strings: {
   match_mapping_type: "string",
   mapping: {
   type: "text",
   fields: {
   raw: {
   type: "keyword",
   ignore_above: 256,
   },
   },
   },
   },
   },
   {
   non_objects_keyword: {
   match_mapping_type: "*",
   unmatch_mapping_type: "object",
   mapping: {
   type: "keyword",
   },
   },
   },
   ],
  },
});
console.log(response);
const response1 = await client.index({
  index: "my-index-000001",
  id: 1,
  document: {
   my_integer: 5,
   my_string: "Some string",
   my_boolean: "false",
   field: {
   count: 4,
   },
  },
});
console.log(response1);

Console

PUT my-index-000001
{
  "mappings": {
   "dynamic_templates": [
   {
   "numeric_counts": {
   "match_mapping_type": ["long", "double"],
   "match": "count",
   "mapping": {
   "type": "{dynamic_type}",
   "index": false
   }
   }
   },
   {
   "integers": {
   "match_mapping_type": "long",
   "mapping": {
   "type": "integer"
   }
   }
   },
   {
   "strings": {
   "match_mapping_type": "string",
   "mapping": {
   "type": "text",
   "fields": {
   "raw": {
   "type":  "keyword",
   "ignore_above": 256
   }
   }
   }
   }
   },
   {
   "non_objects_keyword": {
   "match_mapping_type": "*",
   "unmatch_mapping_type": "object",
   "mapping": {
   "type": "keyword"
   }
   }
   }
   ]
  }
}
PUT my-index-000001/_doc/1
{
  "my_integer": 5,
  "my_string": "Some string",
  "my_boolean": "false",
  "field": {"count": 4}
}


	`my_integer`フィールドは`integer`としてマッピングされます。
	`my_string`フィールドは`text`としてマッピングされ、`keyword` マルチフィールドを持ちます。
	`my_boolean`フィールドは`keyword`としてマッピングされます。
	`field.count`フィールドは`long`としてマッピングされます。

マッチとアンマッチ


`````match_pattern`````パラメータは、フィールド名に対して単純なワイルドカードの代わりに完全なJava正規表現マッチングをサポートするために`````match`````パラメータの動作を調整します。たとえば：
#### Js
``````js
"match_pattern": "regex",
  "match": "^profit_\d+$"
`

次の例は、stringフィールドの名前がlong_で始まるすべてのフィールド（_textで終わるものを除く）をマッチさせ、longフィールドとしてマッピングします：

Python

resp = client.indices.create(
   index="my-index-000001",
   mappings={
   "dynamic_templates": [
   {
   "longs_as_strings": {
   "match_mapping_type": "string",
   "match": "long_*",
   "unmatch": "*_text",
   "mapping": {
   "type": "long"
   }
   }
   }
   ]
   },
)
print(resp)
resp1 = client.index(
   index="my-index-000001",
   id="1",
   document={
   "long_num": "5",
   "long_text": "foo"
   },
)
print(resp1)

Ruby

response = client.indices.create(
  index: 'my-index-000001',
  body: {
   mappings: {
   dynamic_templates: [
   {
   longs_as_strings: {
   match_mapping_type: 'string',
   match: 'long_*',
   unmatch: '*_text',
   mapping: {
   type: 'long'
   }
   }
   }
   ]
   }
  }
)
puts response
response = client.index(
  index: 'my-index-000001',
  id: 1,
  body: {
   long_num: '5',
   long_text: 'foo'
  }
)
puts response

Js

const response = await client.indices.create({
  index: "my-index-000001",
  mappings: {
   dynamic_templates: [
   {
   longs_as_strings: {
   match_mapping_type: "string",
   match: "long_*",
   unmatch: "*_text",
   mapping: {
   type: "long",
   },
   },
   },
   ],
  },
});
console.log(response);
const response1 = await client.index({
  index: "my-index-000001",
  id: 1,
  document: {
   long_num: "5",
   long_text: "foo",
  },
});
console.log(response1);

Console

PUT my-index-000001
{
  "mappings": {
   "dynamic_templates": [
   {
   "longs_as_strings": {
   "match_mapping_type": "string",
   "match":   "long_*",
   "unmatch": "*_text",
   "mapping": {
   "type": "long"
   }
   }
   }
   ]
  }
}
PUT my-index-000001/_doc/1
{
  "long_num": "5",
  "long_text": "foo"
}


	`long_num`フィールドは`long`としてマッピングされます。
	`long_text`フィールドはデフォルトの`string`マッピングを使用します。


次の例は、`````ip_`````で始まるか`````_ip`````で終わるすべてのフィールドをマッチさせ、`````one`````で始まるか`````two`````で終わるフィールドを除外し、`````ip`````フィールドとしてマッピングします：
#### Python
``````python
resp = client.indices.create(
   index="my-index-000001",
   mappings={
   "dynamic_templates": [
   {
   "ip_fields": {
   "match": [
   "ip_*",
   "*_ip"
   ],
   "unmatch": [
   "one*",
   "*two"
   ],
   "mapping": {
   "type": "ip"
   }
   }
   }
   ]
   },
)
print(resp)
resp1 = client.index(
   index="my-index",
   id="1",
   document={
   "one_ip": "will not match",
   "ip_two": "will not match",
   "three_ip": "12.12.12.12",
   "ip_four": "13.13.13.13"
   },
)
print(resp1)
`

Ruby

response = client.indices.create(
  index: 'my-index-000001',
  body: {
   mappings: {
   dynamic_templates: [
   {
   ip_fields: {
   match: [
   'ip_*',
   '*_ip'
   ],
   unmatch: [
   'one*',
   '*two'
   ],
   mapping: {
   type: 'ip'
   }
   }
   }
   ]
   }
  }
)
puts response
response = client.index(
  index: 'my-index',
  id: 1,
  body: {
   one_ip: 'will not match',
   ip_two: 'will not match',
   three_ip: '12.12.12.12',
   ip_four: '13.13.13.13'
  }
)
puts response

Js

const response = await client.indices.create({
  index: "my-index-000001",
  mappings: {
   dynamic_templates: [
   {
   ip_fields: {
   match: ["ip_*", "*_ip"],
   unmatch: ["one*", "*two"],
   mapping: {
   type: "ip",
   },
   },
   },
   ],
  },
});
console.log(response);
const response1 = await client.index({
  index: "my-index",
  id: 1,
  document: {
   one_ip: "will not match",
   ip_two: "will not match",
   three_ip: "12.12.12.12",
   ip_four: "13.13.13.13",
  },
});
console.log(response1);

Console

PUT my-index-000001
{
  "mappings": {
   "dynamic_templates": [
   {
   "ip_fields": {
   "match":   ["ip_*", "*_ip"],
   "unmatch": ["one*", "*two"],
   "mapping": {
   "type": "ip"
   }
   }
   }
   ]
  }
}
PUT my-index/_doc/1
{
  "one_ip":   "will not match",
  "ip_two":   "will not match",
  "three_ip": "12.12.12.12",
  "ip_four":  "13.13.13.13"
}


	`one_ip`フィールドはマッチしないため、`text`のデフォルトマッピングを使用します。
	`ip_two`フィールドはマッチしないため、`text`のデフォルトマッピングを使用します。
	`three_ip`フィールドは`ip`型としてマッピングされます。
	`ip_four`フィールドは`ip`型としてマッピングされます。

path_matchとpath_unmatch


この例では、`````name`````オブジェクト内のフィールドの値をトップレベルの`````full_name`````フィールドにコピーしますが、`````middle`````フィールドは除外されます：
#### Python
``````python
resp = client.indices.create(
   index="my-index-000001",
   mappings={
   "dynamic_templates": [
   {
   "full_name": {
   "path_match": "name.*",
   "path_unmatch": "*.middle",
   "mapping": {
   "type": "text",
   "copy_to": "full_name"
   }
   }
   }
   ]
   },
)
print(resp)
resp1 = client.index(
   index="my-index-000001",
   id="1",
   document={
   "name": {
   "first": "John",
   "middle": "Winston",
   "last": "Lennon"
   }
   },
)
print(resp1)
`

Ruby

response = client.indices.create(
  index: 'my-index-000001',
  body: {
   mappings: {
   dynamic_templates: [
   {
   full_name: {
   path_match: 'name.*',
   path_unmatch: '*.middle',
   mapping: {
   type: 'text',
   copy_to: 'full_name'
   }
   }
   }
   ]
   }
  }
)
puts response
response = client.index(
  index: 'my-index-000001',
  id: 1,
  body: {
   name: {
   first: 'John',
   middle: 'Winston',
   last: 'Lennon'
   }
  }
)
puts response

Js

const response = await client.indices.create({
  index: "my-index-000001",
  mappings: {
   dynamic_templates: [
   {
   full_name: {
   path_match: "name.*",
   path_unmatch: "*.middle",
   mapping: {
   type: "text",
   copy_to: "full_name",
   },
   },
   },
   ],
  },
});
console.log(response);
const response1 = await client.index({
  index: "my-index-000001",
  id: 1,
  document: {
   name: {
   first: "John",
   middle: "Winston",
   last: "Lennon",
   },
  },
});
console.log(response1);

Console

PUT my-index-000001
{
  "mappings": {
   "dynamic_templates": [
   {
   "full_name": {
   "path_match":   "name.*",
   "path_unmatch": "*.middle",
   "mapping": {
   "type":       "text",
   "copy_to":    "full_name"
   }
   }
   }
   ]
  }
}
PUT my-index-000001/_doc/1
{
  "name": {
   "first":  "John",
   "middle": "Winston",
   "last":   "Lennon"
  }
}

次の例では、path_matchとpath_unmatchの両方にパターンの配列を使用します。


#### Python
``````python
resp = client.indices.create(
   index="my-index-000001",
   mappings={
   "dynamic_templates": [
   {
   "full_name": {
   "path_match": [
   "name.*",
   "user.name.*"
   ],
   "path_unmatch": [
   "*.middle",
   "*.midinitial"
   ],
   "mapping": {
   "type": "text",
   "copy_to": "full_name"
   }
   }
   }
   ]
   },
)
print(resp)
resp1 = client.index(
   index="my-index-000001",
   id="1",
   document={
   "name": {
   "first": "John",
   "middle": "Winston",
   "last": "Lennon"
   }
   },
)
print(resp1)
resp2 = client.index(
   index="my-index-000001",
   id="2",
   document={
   "user": {
   "name": {
   "first": "Jane",
   "midinitial": "M",
   "last": "Salazar"
   }
   }
   },
)
print(resp2)
`

Ruby

response = client.indices.create(
  index: 'my-index-000001',
  body: {
   mappings: {
   dynamic_templates: [
   {
   full_name: {
   path_match: [
   'name.*',
   'user.name.*'
   ],
   path_unmatch: [
   '*.middle',
   '*.midinitial'
   ],
   mapping: {
   type: 'text',
   copy_to: 'full_name'
   }
   }
   }
   ]
   }
  }
)
puts response
response = client.index(
  index: 'my-index-000001',
  id: 1,
  body: {
   name: {
   first: 'John',
   middle: 'Winston',
   last: 'Lennon'
   }
  }
)
puts response
response = client.index(
  index: 'my-index-000001',
  id: 2,
  body: {
   user: {
   name: {
   first: 'Jane',
   midinitial: 'M',
   last: 'Salazar'
   }
   }
  }
)
puts response

Js

const response = await client.indices.create({
  index: "my-index-000001",
  mappings: {
   dynamic_templates: [
   {
   full_name: {
   path_match: ["name.*", "user.name.*"],
   path_unmatch: ["*.middle", "*.midinitial"],
   mapping: {
   type: "text",
   copy_to: "full_name",
   },
   },
   },
   ],
  },
});
console.log(response);
const response1 = await client.index({
  index: "my-index-000001",
  id: 1,
  document: {
   name: {
   first: "John",
   middle: "Winston",
   last: "Lennon",
   },
  },
});
console.log(response1);
const response2 = await client.index({
  index: "my-index-000001",
  id: 2,
  document: {
   user: {
   name: {
   first: "Jane",
   midinitial: "M",
   last: "Salazar",
   },
   },
  },
});
console.log(response2);

Console

PUT my-index-000001
{
  "mappings": {
   "dynamic_templates": [
   {
   "full_name": {
   "path_match":   ["name.*", "user.name.*"],
   "path_unmatch": ["*.middle", "*.midinitial"],
   "mapping": {
   "type":       "text",
   "copy_to":    "full_name"
   }
   }
   }
   ]
  }
}
PUT my-index-000001/_doc/1
{
  "name": {
   "first":  "John",
   "middle": "Winston",
   "last":   "Lennon"
  }
}
PUT my-index-000001/_doc/2
{
  "user": {
   "name": {
   "first":      "Jane",
   "midinitial": "M",
   "last":       "Salazar"
   }
  }
}


#### Python
``````python
resp = client.index(
   index="my-index-000001",
   id="2",
   document={
   "name": {
   "first": "Paul",
   "last": "McCartney",
   "title": {
   "value": "Sir",
   "category": "order of chivalry"
   }
   }
   },
)
print(resp)
`

Ruby

response = client.index(
  index: 'my-index-000001',
  id: 2,
  body: {
   name: {
   first: 'Paul',
   last: 'McCartney',
   title: {
   value: 'Sir',
   category: 'order of chivalry'
   }
   }
  }
)
puts response

Js

const response = await client.index({
  index: "my-index-000001",
  id: 2,
  document: {
   name: {
   first: "Paul",
   last: "McCartney",
   title: {
   value: "Sir",
   category: "order of chivalry",
   },
   },
  },
});
console.log(response);

Console

PUT my-index-000001/_doc/2
{
  "name": {
   "first":  "Paul",
   "last":   "McCartney",
   "title": {
   "value": "Sir",
   "category": "order of chivalry"
   }
  }
}

テンプレート変数


#### Python
``````python
resp = client.indices.create(
   index="my-index-000001",
   mappings={
   "dynamic_templates": [
   {
   "named_analyzers": {
   "match_mapping_type": "string",
   "match": "*",
   "mapping": {
   "type": "text",
   "analyzer": "{name}"
   }
   }
   },
   {
   "no_doc_values": {
   "match_mapping_type": "*",
   "mapping": {
   "type": "{dynamic_type}",
   "doc_values": False
   }
   }
   }
   ]
   },
)
print(resp)
resp1 = client.index(
   index="my-index-000001",
   id="1",
   document={
   "english": "Some English text",
   "count": 5
   },
)
print(resp1)
`

Ruby

response = client.indices.create(
  index: 'my-index-000001',
  body: {
   mappings: {
   dynamic_templates: [
   {
   named_analyzers: {
   match_mapping_type: 'string',
   match: '*',
   mapping: {
   type: 'text',
   analyzer: '{name}'
   }
   }
   },
   {
   no_doc_values: {
   match_mapping_type: '*',
   mapping: {
   type: '{dynamic_type}',
   doc_values: false
   }
   }
   }
   ]
   }
  }
)
puts response
response = client.index(
  index: 'my-index-000001',
  id: 1,
  body: {
   english: 'Some English text',
   count: 5
  }
)
puts response

Js

const response = await client.indices.create({
  index: "my-index-000001",
  mappings: {
   dynamic_templates: [
   {
   named_analyzers: {
   match_mapping_type: "string",
   match: "*",
   mapping: {
   type: "text",
   analyzer: "{name}",
   },
   },
   },
   {
   no_doc_values: {
   match_mapping_type: "*",
   mapping: {
   type: "{dynamic_type}",
   doc_values: false,
   },
   },
   },
   ],
  },
});
console.log(response);
const response1 = await client.index({
  index: "my-index-000001",
  id: 1,
  document: {
   english: "Some English text",
   count: 5,
  },
});
console.log(response1);

Console

PUT my-index-000001
{
  "mappings": {
   "dynamic_templates": [
   {
   "named_analyzers": {
   "match_mapping_type": "string",
   "match": "*",
   "mapping": {
   "type": "text",
   "analyzer": "{name}"
   }
   }
   },
   {
   "no_doc_values": {
   "match_mapping_type":"*",
   "mapping": {
   "type": "{dynamic_type}",
   "doc_values": false
   }
   }
   }
   ]
  }
}
PUT my-index-000001/_doc/1
{
  "english": "Some English text",
  "count":   5
}


	`english`フィールドは`string`フィールドとして`english`アナライザーを使用してマッピングされます。
	`count`フィールドは`long`フィールドとして`doc_values`が無効になっています。

動的テンプレートの例

ここに、潜在的に有用な動的テンプレートのいくつかの例があります：

構造化検索


#### Python
``````python
resp = client.indices.create(
   index="my-index-000001",
   mappings={
   "dynamic_templates": [
   {
   "strings_as_keywords": {
   "match_mapping_type": "string",
   "mapping": {
   "type": "keyword"
   }
   }
   }
   ]
   },
)
print(resp)
`

Ruby

response = client.indices.create(
  index: 'my-index-000001',
  body: {
   mappings: {
   dynamic_templates: [
   {
   strings_as_keywords: {
   match_mapping_type: 'string',
   mapping: {
   type: 'keyword'
   }
   }
   }
   ]
   }
  }
)
puts response

Js

const response = await client.indices.create({
  index: "my-index-000001",
  mappings: {
   dynamic_templates: [
   {
   strings_as_keywords: {
   match_mapping_type: "string",
   mapping: {
   type: "keyword",
   },
   },
   },
   ],
  },
});
console.log(response);

Console

PUT my-index-000001
{
  "mappings": {
   "dynamic_templates": [
   {
   "strings_as_keywords": {
   "match_mapping_type": "string",
   "mapping": {
   "type": "keyword"
   }
   }
   }
   ]
  }
}

文字列のためのテキストのみのマッピング

前の例とは対照的に、文字列フィールドの全文検索にのみ関心があり、集計、ソート、または正確な検索を実行する予定がない場合、Elasticsearchに文字列をtextとしてマッピングするように指示できます：

Python

resp = client.indices.create(
   index="my-index-000001",
   mappings={
   "dynamic_templates": [
   {
   "strings_as_text": {
   "match_mapping_type": "string",
   "mapping": {
   "type": "text"
   }
   }
   }
   ]
   },
)
print(resp)

Ruby

response = client.indices.create(
  index: 'my-index-000001',
  body: {
   mappings: {
   dynamic_templates: [
   {
   strings_as_text: {
   match_mapping_type: 'string',
   mapping: {
   type: 'text'
   }
   }
   }
   ]
   }
  }
)
puts response

Js

const response = await client.indices.create({
  index: "my-index-000001",
  mappings: {
   dynamic_templates: [
   {
   strings_as_text: {
   match_mapping_type: "string",
   mapping: {
   type: "text",
   },
   },
   },
   ],
  },
});
console.log(response);

Console

PUT my-index-000001
{
  "mappings": {
   "dynamic_templates": [
   {
   "strings_as_text": {
   "match_mapping_type": "string",
   "mapping": {
   "type": "text"
   }
   }
   }
   ]
  }
}

また、動的テンプレートを作成して、文字列フィールドをマッピングのランタイムセクションでkeywordフィールドとしてマッピングすることもできます。Elasticsearchがstring型の新しいフィールドを検出すると、それらのフィールドはkeyword型のランタイムフィールドとして作成されます。


たとえば、次のリクエストは、`````string`````フィールドを`````keyword`````型のランタイムフィールドとしてマッピングするための動的テンプレートを作成します。`````runtime`````定義は空ですが、新しい`````string`````フィールドは、Elasticsearchがマッピングにフィールドタイプを追加するために使用する[動的マッピングルール](56049773a26d4fae.md#dynamic-field-mapping-types)に基づいて`````keyword`````ランタイムフィールドとしてマッピングされます。日付検出または数値検出を通過しない`````string`````は、自動的に`````keyword`````としてマッピングされます：
#### Python
``````python
resp = client.indices.create(
   index="my-index-000001",
   mappings={
   "dynamic_templates": [
   {
   "strings_as_keywords": {
   "match_mapping_type": "string",
   "runtime": {}
   }
   }
   ]
   },
)
print(resp)
`

Ruby

response = client.indices.create(
  index: 'my-index-000001',
  body: {
   mappings: {
   dynamic_templates: [
   {
   strings_as_keywords: {
   match_mapping_type: 'string',
   runtime: {}
   }
   }
   ]
   }
  }
)
puts response

Js

const response = await client.indices.create({
  index: "my-index-000001",
  mappings: {
   dynamic_templates: [
   {
   strings_as_keywords: {
   match_mapping_type: "string",
   runtime: {},
   },
   },
   ],
  },
});
console.log(response);

Console

PUT my-index-000001
{
  "mappings": {
   "dynamic_templates": [
   {
   "strings_as_keywords": {
   "match_mapping_type": "string",
   "runtime": {}
   }
   }
   ]
  }
}

単純なドキュメントをインデックスします：

Python

resp = client.index(
   index="my-index-000001",
   id="1",
   document={
   "english": "Some English text",
   "count": 5
   },
)
print(resp)

Ruby

response = client.index(
  index: 'my-index-000001',
  id: 1,
  body: {
   english: 'Some English text',
   count: 5
  }
)
puts response

Js

const response = await client.index({
  index: "my-index-000001",
  id: 1,
  document: {
   english: "Some English text",
   count: 5,
  },
});
console.log(response);

Console

PUT my-index-000001/_doc/1
{
  "english": "Some English text",
  "count":   5
}

マッピングを表示すると、englishフィールドがkeyword型のランタイムフィールドであることがわかります：

Python

resp = client.indices.get_mapping(
   index="my-index-000001",
)
print(resp)

Ruby

response = client.indices.get_mapping(
  index: 'my-index-000001'
)
puts response

Js

const response = await client.indices.getMapping({
  index: "my-index-000001",
});
console.log(response);

Console

GET my-index-000001/_mapping

Console-Result

{
  "my-index-000001" : {
   "mappings" : {
   "dynamic_templates" : [
   {
   "strings_as_keywords" : {
   "match_mapping_type" : "string",
   "runtime" : { }
   }
   }
   ],
   "runtime" : {
   "english" : {
   "type" : "keyword"
   }
   },
   "properties" : {
   "count" : {
   "type" : "long"
   }
   }
   }
  }
}

無効なノルム

ノルムはインデックス時のスコアリング要因です。スコアリングに関心がない場合、たとえばスコアでドキュメントをソートしない場合、これらのスコアリング要因のストレージをインデックスで無効にして、スペースを節約できます。

Python

resp = client.indices.create(
   index="my-index-000001",
   mappings={
   "dynamic_templates": [
   {
   "strings_as_keywords": {
   "match_mapping_type": "string",
   "mapping": {
   "type": "text",
   "norms": False,
   "fields": {
   "keyword": {
   "type": "keyword",
   "ignore_above": 256
   }
   }
   }
   }
   }
   ]
   },
)
print(resp)

Ruby

response = client.indices.create(
  index: 'my-index-000001',
  body: {
   mappings: {
   dynamic_templates: [
   {
   strings_as_keywords: {
   match_mapping_type: 'string',
   mapping: {
   type: 'text',
   norms: false,
   fields: {
   keyword: {
   type: 'keyword',
   ignore_above: 256
   }
   }
   }
   }
   }
   ]
   }
  }
)
puts response

Js

const response = await client.indices.create({
  index: "my-index-000001",
  mappings: {
   dynamic_templates: [
   {
   strings_as_keywords: {
   match_mapping_type: "string",
   mapping: {
   type: "text",
   norms: false,
   fields: {
   keyword: {
   type: "keyword",
   ignore_above: 256,
   },
   },
   },
   },
   },
   ],
  },
});
console.log(response);

Console

PUT my-index-000001
{
  "mappings": {
   "dynamic_templates": [
   {
   "strings_as_keywords": {
   "match_mapping_type": "string",
   "mapping": {
   "type": "text",
   "norms": false,
   "fields": {
   "keyword": {
   "type": "keyword",
   "ignore_above": 256
   }
   }
   }
   }
   }
   ]
  }
}

このテンプレートにおけるサブkeywordフィールドは、動的マッピングのデフォルトルールと一貫性を持たせるために表示されます。もちろん、正確な検索や集計をこのフィールドで行う必要がない場合は、前のセクションで説明したように削除できます。

時系列

Elasticsearchで時系列分析を行う場合、集計することが多いがフィルタリングは決して行わない多くの数値フィールドを持つことが一般的です。その場合、ディスクスペースを節約し、インデックス速度を向上させるために、これらのフィールドのインデックスを無効にすることができます：

Python

resp = client.indices.create(
   index="my-index-000001",
   mappings={
   "dynamic_templates": [
   {
   "unindexed_longs": {
   "match_mapping_type": "long",
   "mapping": {
   "type": "long",
   "index": False
   }
   }
   },
   {
   "unindexed_doubles": {
   "match_mapping_type": "double",
   "mapping": {
   "type": "float",
   "index": False
   }
   }
   }
   ]
   },
)
print(resp)

Ruby

response = client.indices.create(
  index: 'my-index-000001',
  body: {
   mappings: {
   dynamic_templates: [
   {
   unindexed_longs: {
   match_mapping_type: 'long',
   mapping: {
   type: 'long',
   index: false
   }
   }
   },
   {
   unindexed_doubles: {
   match_mapping_type: 'double',
   mapping: {
   type: 'float',
   index: false
   }
   }
   }
   ]
   }
  }
)
puts response

Js

const response = await client.indices.create({
  index: "my-index-000001",
  mappings: {
   dynamic_templates: [
   {
   unindexed_longs: {
   match_mapping_type: "long",
   mapping: {
   type: "long",
   index: false,
   },
   },
   },
   {
   unindexed_doubles: {
   match_mapping_type: "double",
   mapping: {
   type: "float",
   index: false,
   },
   },
   },
   ],
  },
});
console.log(response);

Console

PUT my-index-000001
{
  "mappings": {
   "dynamic_templates": [
   {
   "unindexed_longs": {
   "match_mapping_type": "long",
   "mapping": {
   "type": "long",
   "index": false
   }
   }
   },
   {
   "unindexed_doubles": {
   "match_mapping_type": "double",
   "mapping": {
   "type": "float",
   "index": false
   }
   }
   }
   ]
  }
}


	デフォルトの動的マッピングルールと同様に、ダブルはフロートとしてマッピングされ、通常は十分に正確ですが、ディスクスペースの半分を必要とします。