選択したフィールドの取得（Retrieve selected fields）

検索から選択したフィールドを取得する

デフォルトでは、検索応答の各ヒットには、ドキュメント _source が含まれており、これはドキュメントをインデックスする際に提供された全体の JSON オブジェクトです。検索クエリから選択したフィールドを取得するための推奨される方法は2つあります：

• インデックスマッピングに存在するフィールドの値を抽出するために fields オプション を使用する
• インデックス時に渡された元のデータにアクセスする必要がある場合は _source オプション を使用する

これらの方法の両方を使用できますが、fields オプションが推奨されます。なぜなら、これはドキュメントデータとインデックスマッピングの両方を参照するからです。場合によっては、データを取得するための 他の方法 を使用したいかもしれません。

フィールドオプション

検索応答で特定のフィールドを取得するには、fields パラメータを使用します。インデックスマッピングを参照するため、fields パラメータは _source を直接参照するよりもいくつかの利点を提供します。具体的には、fields パラメータは：

• マッピングタイプに一致する標準化された方法で各値を返します
• マルチフィールド と フィールドエイリアス を受け入れます
• 日付と空間データタイプをフォーマットします
• ランタイムフィールドの値を取得します
• インデックス時にスクリプトによって計算されたフィールドを返します
• ルックアップランタイムフィールドを使用して関連インデックスからフィールドを返します

ignore_above](/read/elasticsearch-8-15/08fcc03dd0dd2bdc.md)、ignore_malformed、および null_value を含む他のマッピングオプションも尊重されます。

fields オプションは、Elasticsearch がそれらをインデックスする方法に一致する形で値を返します。標準フィールドの場合、これは fields オプションが _source を見て値を見つけ、その後マッピングを使用して解析およびフォーマットすることを意味します。_source で見つからない選択されたフィールドはスキップされます。

特定のフィールドを取得する

次の検索リクエストは、fields パラメータを使用して user.id フィールド、http.response. で始まるすべてのフィールド、および @timestamp フィールドの値を取得します。

オブジェクト表記を使用して、format 引数を渡して、返される日付または地理空間値のフォーマットをカスタマイズできます。

Python

resp = client.search(
   index="my-index-000001",
   query={
   "match": {
   "user.id": "kimchy"
   }
   },
   fields=[
   "user.id",
   "http.response.*",
   {
   "field": "@timestamp",
   "format": "epoch_millis"
   }
   ],
   source=False,
)
print(resp)

Ruby

response = client.search(
  index: 'my-index-000001',
  body: {
   query: {
   match: {
   'user.id' => 'kimchy'
   }
   },
   fields: [
   'user.id',
   'http.response.*',
   {
   field: '@timestamp',
   format: 'epoch_millis'
   }
   ],
   _source: false
  }
)
puts response

Js

const response = await client.search({
  index: "my-index-000001",
  query: {
   match: {
   "user.id": "kimchy",
   },
  },
  fields: [
   "user.id",
   "http.response.*",
   {
   field: "@timestamp",
   format: "epoch_millis",
   },
  ],
  _source: false,
});
console.log(response);

コンソール

POST my-index-000001/_search
{
  "query": {
   "match": {
   "user.id": "kimchy"
   }
  },
  "fields": [
   "user.id",
   "http.response.*",
   {
   "field": "@timestamp",
   "format": "epoch_millis"
   }
  ],
  "_source": false
}

デフォルトでは、_id や _index のようなドキュメントメタデータフィールドは、要求された fields オプションが * のようなワイルドカードパターンを使用している場合、返されません。ただし、フィールド名を使用して明示的に要求された場合、_id、_routing、_ignored、_index および _version メタデータフィールドを取得できます。

応答は常に配列を返す

fields 応答は常に各フィールドの値の配列を返します。_source に単一の値がある場合でも、これは Elasticsearch に専用の配列タイプがないためであり、任意のフィールドには複数の値が含まれる可能性があります。fields パラメータも、配列の値が特定の順序で返されることを保証しません。詳細については、配列 に関するマッピングドキュメントを参照してください。

応答には、各ヒットの fields セクションにフラットリストとして値が含まれます。fields パラメータは全体のオブジェクトを取得しないため、リーフフィールドのみが返されます。

コンソール-結果

{
  "hits" : {
   "total" : {
   "value" : 1,
   "relation" : "eq"
   },
   "max_score" : 1.0,
   "hits" : [
   {
   "_index" : "my-index-000001",
   "_id" : "0",
   "_score" : 1.0,
   "fields" : {
   "user.id" : [
   "kimchy"
   ],
   "@timestamp" : [
   "4098435132000"
   ],
   "http.response.bytes": [
   1070000
   ],
   "http.response.status_code": [
   200
   ]
   }
   }
   ]
  }
}

ネストされたフィールドを取得する

詳細

fields フィールドの応答は、通常のオブジェクトフィールドの応答とはわずかに異なります。通常の object フィールド内のリーフ値はフラットリストとして返されますが、nested フィールド内の値は、元のネストされた配列内の各オブジェクトの独立性を維持するためにグループ化されます。ネストされたフィールド配列内の各エントリについて、値は再びフラットリストとして返されますが、親ネストされたオブジェクト内に他の nested フィールドがある場合は、同じ手順が再度深いネストされたフィールドに対して繰り返されます。

user がネストされたフィールドである次のマッピングを考慮し、次のドキュメントをインデックスした後、user フィールドの下のすべてのフィールドを取得します：

Python

resp = client.indices.create(
   index="my-index-000001",
   mappings={
   "properties": {
   "group": {
   "type": "keyword"
   },
   "user": {
   "type": "nested",
   "properties": {
   "first": {
   "type": "keyword"
   },
   "last": {
   "type": "keyword"
   }
   }
   }
   }
   },
)
print(resp)
resp1 = client.index(
   index="my-index-000001",
   id="1",
   refresh=True,
   document={
   "group": "fans",
   "user": [
   {
   "first": "John",
   "last": "Smith"
   },
   {
   "first": "Alice",
   "last": "White"
   }
   ]
   },
)
print(resp1)
resp2 = client.search(
   index="my-index-000001",
   fields=[
   "*"
   ],
   source=False,
)
print(resp2)

Ruby

response = client.indices.create(
  index: 'my-index-000001',
  body: {
   mappings: {
   properties: {
   group: {
   type: 'keyword'
   },
   user: {
   type: 'nested',
   properties: {
   first: {
   type: 'keyword'
   },
   last: {
   type: 'keyword'
   }
   }
   }
   }
   }
  }
)
puts response
response = client.index(
  index: 'my-index-000001',
  id: 1,
  refresh: true,
  body: {
   group: 'fans',
   user: [
   {
   first: 'John',
   last: 'Smith'
   },
   {
   first: 'Alice',
   last: 'White'
   }
   ]
  }
)
puts response
response = client.search(
  index: 'my-index-000001',
  body: {
   fields: [
   '*'
   ],
   _source: false
  }
)
puts response

Js

const response = await client.indices.create({
  index: "my-index-000001",
  mappings: {
   properties: {
   group: {
   type: "keyword",
   },
   user: {
   type: "nested",
   properties: {
   first: {
   type: "keyword",
   },
   last: {
   type: "keyword",
   },
   },
   },
   },
  },
});
console.log(response);
const response1 = await client.index({
  index: "my-index-000001",
  id: 1,
  refresh: "true",
  document: {
   group: "fans",
   user: [
   {
   first: "John",
   last: "Smith",
   },
   {
   first: "Alice",
   last: "White",
   },
   ],
  },
});
console.log(response1);
const response2 = await client.search({
  index: "my-index-000001",
  fields: ["*"],
  _source: false,
});
console.log(response2);

コンソール

PUT my-index-000001
{
  "mappings": {
   "properties": {
   "group" : { "type" : "keyword" },
   "user": {
   "type": "nested",
   "properties": {
   "first" : { "type" : "keyword" },
   "last" : { "type" : "keyword" }
   }
   }
   }
  }
}
PUT my-index-000001/_doc/1?refresh=true
{
  "group" : "fans",
  "user" : [
   {
   "first" : "John",
   "last" :  "Smith"
   },
   {
   "first" : "Alice",
   "last" :  "White"
   }
  ]
}
POST my-index-000001/_search
{
  "fields": ["*"],
  "_source": false
}

応答は first と last 名をグループ化し、フラットリストとして返すのではなく、

コンソール-結果

{
  "took": 2,
  "timed_out": false,
  "_shards": {
   "total": 1,
   "successful": 1,
   "skipped": 0,
   "failed": 0
  },
  "hits": {
   "total": {
   "value": 1,
   "relation": "eq"
   },
   "max_score": 1.0,
   "hits": [{
   "_index": "my-index-000001",
   "_id": "1",
   "_score": 1.0,
   "fields": {
   "group" : ["fans"],
   "user": [{
   "first": ["John"],
   "last": ["Smith"]
   },
   {
   "first": ["Alice"],
   "last": ["White"]
   }
   ]
   }
   }]
  }
}

ネストされたフィールドは、そのネストされたパスによってグループ化され、取得するために使用されるパターンに関係なく、たとえば、前の例から user.first フィールドのみをクエリする場合：

Python

resp = client.search(
   index="my-index-000001",
   fields=[
   "user.first"
   ],
   source=False,
)
print(resp)

Ruby

response = client.search(
  index: 'my-index-000001',
  body: {
   fields: [
   'user.first'
   ],
   _source: false
  }
)
puts response

Js

const response = await client.search({
  index: "my-index-000001",
  fields: ["user.first"],
  _source: false,
});
console.log(response);

コンソール

POST my-index-000001/_search
{
  "fields": ["user.first"],
  "_source": false
}

応答はユーザーのファーストネームのみを返しますが、ネストされた user 配列の構造は維持されます：

コンソール-結果

{
  "took": 2,
  "timed_out": false,
  "_shards": {
   "total": 1,
   "successful": 1,
   "skipped": 0,
   "failed": 0
  },
  "hits": {
   "total": {
   "value": 1,
   "relation": "eq"
   },
   "max_score": 1.0,
   "hits": [{
   "_index": "my-index-000001",
   "_id": "1",
   "_score": 1.0,
   "fields": {
   "user": [{
   "first": ["John"]
   },
   {
   "first": ["Alice"]
   }
   ]
   }
   }]
  }
}

ただし、fields パターンがネストされた user フィールドを直接ターゲットにすると、値は返されません。なぜなら、パターンがリーフフィールドと一致しないからです。

マッピングされていないフィールドを取得する

詳細

デフォルトでは、fields パラメータはマッピングされたフィールドの値のみを返します。ただし、Elasticsearch は、_source を false に設定したり、enabled: false を持つオブジェクトフィールドを使用したりして、マッピングされていないフィールドを _source に保存することを許可します。これらのオプションは、オブジェクトコンテンツの解析とインデックスを無効にします。

_source からのオブジェクト内のマッピングされていないフィールドを取得するには、include_unmapped オプションを fields セクションで使用します：

Python

resp = client.indices.create(
   index="my-index-000001",
   mappings={
   "enabled": False
   },
)
print(resp)
resp1 = client.index(
   index="my-index-000001",
   id="1",
   refresh=True,
   document={
   "user_id": "kimchy",
   "session_data": {
   "object": {
   "some_field": "some_value"
   }
   }
   },
)
print(resp1)
resp2 = client.search(
   index="my-index-000001",
   fields=[
   "user_id",
   {
   "field": "session_data.object.*",
   "include_unmapped": True
   }
   ],
   source=False,
)
print(resp2)

Ruby

response = client.indices.create(
  index: 'my-index-000001',
  body: {
   mappings: {
   enabled: false
   }
  }
)
puts response
response = client.index(
  index: 'my-index-000001',
  id: 1,
  refresh: true,
  body: {
   user_id: 'kimchy',
   session_data: {
   object: {
   some_field: 'some_value'
   }
   }
  }
)
puts response
response = client.search(
  index: 'my-index-000001',
  body: {
   fields: [
   'user_id',
   {
   field: 'session_data.object.*',
   include_unmapped: true
   }
   ],
   _source: false
  }
)
puts response

Js

const response = await client.indices.create({
  index: "my-index-000001",
  mappings: {
   enabled: false,
  },
});
console.log(response);
const response1 = await client.index({
  index: "my-index-000001",
  id: 1,
  refresh: "true",
  document: {
   user_id: "kimchy",
   session_data: {
   object: {
   some_field: "some_value",
   },
   },
  },
});
console.log(response1);
const response2 = await client.search({
  index: "my-index-000001",
  fields: [
   "user_id",
   {
   field: "session_data.object.*",
   include_unmapped: true,
   },
  ],
  _source: false,
});
console.log(response2);

コンソール

PUT my-index-000001
{
  "mappings": {
   "enabled": false
  }
}
PUT my-index-000001/_doc/1?refresh=true
{
  "user_id": "kimchy",
  "session_data": {
   "object": {
   "some_field": "some_value"
   }
   }
}
POST my-index-000001/_search
{
  "fields": [
   "user_id",
   {
   "field": "session_data.object.*",
   "include_unmapped" : true
   }
  ],
  "_source": false
}

応答には、session_data.object.* パスの下にフィールド結果が含まれます。フィールドがマッピングされていなくても。user_id フィールドもマッピングされていませんが、include_unmapped がそのフィールドパターンに対して true に設定されていないため、応答には含まれません。

コンソール-結果

{
  "took" : 2,
  "timed_out" : false,
  "_shards" : {
   "total" : 1,
   "successful" : 1,
   "skipped" : 0,
   "failed" : 0
  },
  "hits" : {
   "total" : {
   "value" : 1,
   "relation" : "eq"
   },
   "max_score" : 1.0,
   "hits" : [
   {
   "_index" : "my-index-000001",
   "_id" : "1",
   "_score" : 1.0,
   "fields" : {
   "session_data.object.some_field": [
   "some_value"
   ]
   }
   }
   ]
  }
}

無視されたフィールド値

詳細

fields セクションの応答は、インデックス時に有効だった値のみを返します。検索リクエストが、形式が不正または大きすぎるために無視されたフィールドの値を要求する場合、これらの値は ignored_field_values セクションに別途返されます。

この例では、無視され、インデックスに追加されなかった値を持つドキュメントをインデックスします。したがって、検索結果に別途表示されます：

Python

resp = client.indices.create(
   index="my-index-000001",
   mappings={
   "properties": {
   "my-small": {
   "type": "keyword",
   "ignore_above": 2
   },
   "my-large": {
   "type": "keyword"
   }
   }
   },
)
print(resp)
resp1 = client.index(
   index="my-index-000001",
   id="1",
   refresh=True,
   document={
   "my-small": [
   "ok",
   "bad"
   ],
   "my-large": "ok content"
   },
)
print(resp1)
resp2 = client.search(
   index="my-index-000001",
   fields=[
   "my-*"
   ],
   source=False,
)
print(resp2)

Ruby

response = client.indices.create(
  index: 'my-index-000001',
  body: {
   mappings: {
   properties: {
   "my-small": {
   type: 'keyword',
   ignore_above: 2
   },
   "my-large": {
   type: 'keyword'
   }
   }
   }
  }
)
puts response
response = client.index(
  index: 'my-index-000001',
  id: 1,
  refresh: true,
  body: {
   "my-small": [
   'ok',
   'bad'
   ],
   "my-large": 'ok content'
  }
)
puts response
response = client.search(
  index: 'my-index-000001',
  body: {
   fields: [
   'my-*'
   ],
   _source: false
  }
)
puts response

Js

const response = await client.indices.create({
  index: "my-index-000001",
  mappings: {
   properties: {
   "my-small": {
   type: "keyword",
   ignore_above: 2,
   },
   "my-large": {
   type: "keyword",
   },
   },
  },
});
console.log(response);
const response1 = await client.index({
  index: "my-index-000001",
  id: 1,
  refresh: "true",
  document: {
   "my-small": ["ok", "bad"],
   "my-large": "ok content",
  },
});
console.log(response1);
const response2 = await client.search({
  index: "my-index-000001",
  fields: ["my-*"],
  _source: false,
});
console.log(response2);

コンソール

PUT my-index-000001
{
  "mappings": {
   "properties": {
   "my-small" : { "type" : "keyword", "ignore_above": 2 },
   "my-large" : { "type" : "keyword" }
   }
  }
}
PUT my-index-000001/_doc/1?refresh=true
{
  "my-small": ["ok", "bad"],
  "my-large": "ok content"
}
POST my-index-000001/_search
{
  "fields": ["my-*"],
  "_source": false
}

応答には、ignored_field_values パスの下に無視されたフィールド値が含まれます。これらの値はドキュメントの元の JSON ソースから取得され、未加工であり、成功裏にインデックスされたフィールドとは異なり、フォーマットされたり処理されたりすることはありません。fields セクションで返されます。

コンソール-結果

{
  "took" : 2,
  "timed_out" : false,
  "_shards" : {
   "total" : 1,
   "successful" : 1,
   "skipped" : 0,
   "failed" : 0
  },
  "hits" : {
   "total" : {
   "value" : 1,
   "relation" : "eq"
   },
   "max_score" : 1.0,
   "hits" : [
   {
   "_index" : "my-index-000001",
   "_id" : "1",
   "_score" : 1.0,
   "_ignored" : [ "my-small"],
   "fields" : {
   "my-large": [
   "ok content"
   ],
   "my-small": [
   "ok"
   ]
   },
   "ignored_field_values" : {
   "my-small": [
   "bad"
   ]
   }
   }
   ]
  }
}

ソースオプション

_source パラメータを使用して、返されるソースのフィールドを選択できます。これは ソースフィルタリング と呼ばれます。

次の検索 API リクエストは、_source リクエストボディパラメータを false に設定します。ドキュメントソースは応答に含まれません。

Python

resp = client.search(
   source=False,
   query={
   "match": {
   "user.id": "kimchy"
   }
   },
)
print(resp)

Ruby

response = client.search(
  body: {
   _source: false,
   query: {
   match: {
   'user.id' => 'kimchy'
   }
   }
  }
)
puts response

Js

const response = await client.search({
  _source: false,
  query: {
   match: {
   "user.id": "kimchy",
   },
  },
});
console.log(response);

コンソール

GET /_search
{
  "_source": false,
  "query": {
   "match": {
   "user.id": "kimchy"
   }
  }
}

ソースフィールドのサブセットのみを返すには、* パラメータにワイルドカード (*) パターンを指定します。次の検索 API リクエストは、obj フィールドとそのプロパティのソースを返します。

Python

resp = client.search(
   source="obj.*",
   query={
   "match": {
   "user.id": "kimchy"
   }
   },
)
print(resp)

Ruby

response = client.search(
  body: {
   _source: 'obj.*',
   query: {
   match: {
   'user.id' => 'kimchy'
   }
   }
  }
)
puts response

Js

const response = await client.search({
  _source: "obj.*",
  query: {
   match: {
   "user.id": "kimchy",
   },
  },
});
console.log(response);

コンソール

GET /_search
{
  "_source": "obj.*",
  "query": {
   "match": {
   "user.id": "kimchy"
   }
  }
}

_source フィールドにワイルドカードパターンの配列を指定することもできます。次の検索 API リクエストは、obj1 および obj2 フィールドとそのプロパティのソースを返します。

Python

resp = client.search(
   source=[
   "obj1.*",
   "obj2.*"
   ],
   query={
   "match": {
   "user.id": "kimchy"
   }
   },
)
print(resp)

Ruby

response = client.search(
  body: {
   _source: [
   'obj1.*',
   'obj2.*'
   ],
   query: {
   match: {
   'user.id' => 'kimchy'
   }
   }
  }
)
puts response

Js

const response = await client.search({
  _source: ["obj1.*", "obj2.*"],
  query: {
   match: {
   "user.id": "kimchy",
   },
  },
});
console.log(response);

コンソール

GET /_search
{
  "_source": [ "obj1.*", "obj2.*" ],
  "query": {
   "match": {
   "user.id": "kimchy"
   }
  }
}

より細かい制御を行うには、_source パラメータに includes および excludes パターンの配列を含むオブジェクトを指定できます。

includes プロパティが指定されている場合、そのパターンのいずれかに一致するソースフィールドのみが返されます。このサブセットからフィールドを除外するには、excludes プロパティを使用できます。

includes プロパティが指定されていない場合、excludes プロパティに一致するパターンのフィールドを除外して、ドキュメントソース全体が返されます。

次の検索 API リクエストは、obj1 および obj2 フィールドとそのプロパティのソースを返し、子 description フィールドは除外します。

Python

resp = client.search(
   source={
   "includes": [
   "obj1.*",
   "obj2.*"
   ],
   "excludes": [
   "*.description"
   ]
   },
   query={
   "term": {
   "user.id": "kimchy"
   }
   },
)
print(resp)

Ruby

response = client.search(
  body: {
   _source: {
   includes: [
   'obj1.*',
   'obj2.*'
   ],
   excludes: [
   '*.description'
   ]
   },
   query: {
   term: {
   'user.id' => 'kimchy'
   }
   }
  }
)
puts response

Js

const response = await client.search({
  _source: {
   includes: ["obj1.*", "obj2.*"],
   excludes: ["*.description"],
  },
  query: {
   term: {
   "user.id": "kimchy",
   },
  },
});
console.log(response);

コンソール

GET /_search
{
  "_source": {
   "includes": [ "obj1.*", "obj2.*" ],
   "excludes": [ "*.description" ]
  },
  "query": {
   "term": {
   "user.id": "kimchy"
   }
  }
}

データを取得する他の方法

fields を使用する方が通常は良い

これらのオプションは通常必要ありません。fields オプションを使用する方が通常は良い選択です。ストレージされた docvalue_fields を強制的に読み込む必要がある場合を除きます。

ドキュメントの _source は、Lucene に単一のフィールドとして保存されます。この構造により、_source オブジェクト全体を読み込んで解析する必要があります。たとえその一部だけを要求している場合でも。この制限を回避するために、フィールドを読み込むための他のオプションを試すことができます：

• 選択したフィールドの値を取得するために docvalue_fields パラメータを使用します。これは、キーワードや日付など、doc 値をサポートする比較的小さな数のフィールドを返す場合に良い選択です。
• 特定のストレージされたフィールドの値を取得するために stored_fields パラメータを使用します（store マッピングオプションを使用するフィールド）。

Elasticsearch は常に _source から値を読み込もうとします。この動作は、Elasticsearch が単一のフィールドを取得するために _source 全体を読み込んで解析する必要があるというソースフィルタリングの同じ影響を持ちます。

ドキュメント値フィールド

docvalue_fields パラメータを使用して、検索応答の1つまたは複数のフィールドの ドキュメント値 を返すことができます。

ドキュメント値は、_source と同じ値を保存しますが、ソートや集計に最適化されたディスク上の列ベースの構造で保存されます。各フィールドは別々に保存されるため、Elasticsearch は要求されたフィールド値のみを読み込み、ドキュメント _source 全体を読み込むのを避けることができます。

ドキュメント値は、デフォルトでサポートされているフィールドに保存されます。ただし、text または text_annotated フィールドにはドキュメント値はサポートされていません。

次の検索リクエストは、docvalue_fields パラメータを使用して、user.id フィールド、http.response. で始まるすべてのフィールド、および @timestamp フィールドのドキュメント値を取得します：

Python

resp = client.search(
   index="my-index-000001",
   query={
   "match": {
   "user.id": "kimchy"
   }
   },
   docvalue_fields=[
   "user.id",
   "http.response.*",
   {
   "field": "date",
   "format": "epoch_millis"
   }
   ],
)
print(resp)

Ruby

response = client.search(
  index: 'my-index-000001',
  body: {
   query: {
   match: {
   'user.id' => 'kimchy'
   }
   },
   docvalue_fields: [
   'user.id',
   'http.response.*',
   {
   field: 'date',
   format: 'epoch_millis'
   }
   ]
  }
)
puts response

Js

const response = await client.search({
  index: "my-index-000001",
  query: {
   match: {
   "user.id": "kimchy",
   },
  },
  docvalue_fields: [
   "user.id",
   "http.response.*",
   {
   field: "date",
   format: "epoch_millis",
   },
  ],
});
console.log(response);

コンソール

GET my-index-000001/_search
{
  "query": {
   "match": {
   "user.id": "kimchy"
   }
  },
  "docvalue_fields": [
   "user.id",
   "http.response.*",
   {
   "field": "date",
   "format": "epoch_millis"
   }
  ]
}

docvalue_fields パラメータを使用してネストされたオブジェクトのドキュメント値を取得することはできません。ネストされたオブジェクトを指定すると、検索はそのフィールドに対して空の配列 ([ ]) を返します。ネストされたフィールドにアクセスするには、inner_hits パラメータの docvalue_fields プロパティを使用する必要があります。

ストレージフィールド

個々のフィールドの値を store マッピングオプションを使用して保存することも可能です。stored_fields パラメータを使用して、これらの保存された値を検索応答に含めることができます。

stored_fields パラメータは、マッピングで明示的に保存されているとマークされたフィールド用であり、デフォルトではオフになっており、一般的には推奨されません。代わりに、返される元のソースドキュメントのサブセットを選択するために ソースフィルタリング を使用してください。

検索ヒットによって表される各ドキュメントの特定の保存されたフィールドを選択的に読み込むことを許可します。

Python

resp = client.search(
   stored_fields=[
   "user",
   "postDate"
   ],
   query={
   "term": {
   "user": "kimchy"
   }
   },
)
print(resp)

Ruby

response = client.search(
  body: {
   stored_fields: [
   'user',
   'postDate'
   ],
   query: {
   term: {
   user: 'kimchy'
   }
   }
  }
)
puts response

Js

const response = await client.search({
  stored_fields: ["user", "postDate"],
  query: {
   term: {
   user: "kimchy",
   },
  },
});
console.log(response);

コンソール

GET /_search
{
  "stored_fields" : ["user", "postDate"],
  "query" : {
   "term" : { "user" : "kimchy" }
  }
}

* を使用してドキュメントからすべての保存されたフィールドを読み込むことができます。

空の配列は、各ヒットの _id および _type のみを返すことになります。たとえば：

Python

resp = client.search(
   stored_fields=[],
   query={
   "term": {
   "user": "kimchy"
   }
   },
)
print(resp)

Ruby

response = client.search(
  body: {
   stored_fields: [],
   query: {
   term: {
   user: 'kimchy'
   }
   }
  }
)
puts response

Js

const response = await client.search({
  stored_fields: [],
  query: {
   term: {
   user: "kimchy",
   },
  },
});
console.log(response);

コンソール

GET /_search
{
  "stored_fields" : [],
  "query" : {
   "term" : { "user" : "kimchy" }
  }
}

要求されたフィールドが保存されていない場合（store マッピングが false に設定されている場合）、それらは無視されます。

ドキュメント自体から取得された保存されたフィールド値は常に配列として返されます。対照的に、_routing のようなメタデータフィールドは、決して配列として返されません。

また、stored_fields オプションを介して返されるのはリーフフィールドのみです。オブジェクトフィールドが指定されている場合、それは無視されます。

stored_fields 自体はネストされたオブジェクトのフィールドを読み込むために使用できません。フィールドがそのパスにネストされたオブジェクトを含む場合、その保存されたフィールドに対してデータは返されません。ネストされたフィールドにアクセスするには、stored_fields ブロック内で使用する必要があります。

保存されたフィールドを無効にする

保存されたフィールド（およびメタデータフィールド）を完全に無効にするには、_none_ を使用します：

Python

resp = client.search(
   stored_fields="_none_",
   query={
   "term": {
   "user": "kimchy"
   }
   },
)
print(resp)

Ruby

response = client.search(
  body: {
   stored_fields: '_none_',
   query: {
   term: {
   user: 'kimchy'
   }
   }
  }
)
puts response

Js

const response = await client.search({
  stored_fields: "_none_",
  query: {
   term: {
   user: "kimchy",
   },
  },
});
console.log(response);

コンソール

GET /_search
{
  "stored_fields": "_none_",
  "query" : {
   "term" : { "user" : "kimchy" }
  }
}

_source および version パラメータは、_none_ が使用されている場合は有効にできません。

スクリプトフィールド

script_fields パラメータを使用して、各ヒットの スクリプト評価 を取得できます。たとえば：

Python

resp = client.search(
   query={
   "match_all": {}
   },
   script_fields={
   "test1": {
   "script": {
   "lang": "painless",
   "source": "doc['price'].value * 2"
   }
   },
   "test2": {
   "script": {
   "lang": "painless",
   "source": "doc['price'].value * params.factor",
   "params": {
   "factor": 2
   }
   }
   }
   },
)
print(resp)

Ruby

response = client.search(
  body: {
   query: {
   match_all: {}
   },
   script_fields: {
   "test1": {
   script: {
   lang: 'painless',
   source: "doc['price'].value * 2"
   }
   },
   "test2": {
   script: {
   lang: 'painless',
   source: "doc['price'].value * params.factor",
   params: {
   factor: 2
   }
   }
   }
   }
  }
)
puts response

Js

const response = await client.search({
  query: {
   match_all: {},
  },
  script_fields: {
   test1: {
   script: {
   lang: "painless",
   source: "doc['price'].value * 2",
   },
   },
   test2: {
   script: {
   lang: "painless",
   source: "doc['price'].value * params.factor",
   params: {
   factor: 2,
   },
   },
   },
  },
});
console.log(response);

コンソール

GET /_search
{
  "query": {
   "match_all": {}
  },
  "script_fields": {
   "test1": {
   "script": {
   "lang": "painless",
   "source": "doc['price'].value * 2"
   }
   },
   "test2": {
   "script": {
   "lang": "painless",
   "source": "doc['price'].value * params.factor",
   "params": {
   "factor": 2.0
   }
   }
   }
  }
}

スクリプトフィールドは、保存されていないフィールド（上記の price の場合）で機能し、カスタム値を返すことを許可します（スクリプトの評価値）。

スクリプトフィールドは、実際の _source ドキュメントにアクセスし、params['_source'] を使用してそこから返される特定の要素を抽出することもできます。以下はその例です：

Python

resp = client.search(
   query={
   "match_all": {}
   },
   script_fields={
   "test1": {
   "script": "params['_source']['message']"
   }
   },
)
print(resp)

Ruby

response = client.search(
  body: {
   query: {
   match_all: {}
   },
   script_fields: {
   "test1": {
   script: "params['_source']['message']"
   }
   }
  }
)
puts response

Js

const response = await client.search({
  query: {
   match_all: {},
  },
  script_fields: {
   test1: {
   script: "params['_source']['message']",
   },
  },
});
console.log(response);

コンソール

GET /_search
{
  "query": {
   "match_all": {}
  },
  "script_fields": {
   "test1": {
   "script": "params['_source']['message']"
   }
  }
}

ここでの _source キーワードに注意して、json のようなモデルをナビゲートします。

doc['my_field'].value と params['_source']['my_field'] の違いを理解することが重要です。最初のものは、ドキュメントキーワードを使用して、そのフィールドの用語がメモリに読み込まれる（キャッシュされる）ため、実行が速くなりますが、メモリ消費が増加します。また、doc[...] 表記は、単純な値フィールドのみを許可し（json オブジェクトを返すことはできません）、分析されていないか単一の用語に基づくフィールドにのみ意味があります。ただし、doc を使用することは、可能であれば、ドキュメントから値にアクセスするための推奨方法です。_source は、使用されるたびに読み込まれ、解析されなければならないためです。_source を使用するのは非常に遅いです。