Извлечение выбранных полей из результатов поиска

По умолчанию каждый результат поиска включает поле _source, которое представляет собой весь JSON-объект, предоставленный при индексировании документа. Рекомендуется использовать два метода для извлечения выбранных полей из запроса поиска:

Вы можете использовать оба этих метода, но параметр fields предпочтительнее, так как он учитывает как данные документа, так и схемы индекса. В некоторых случаях вам может понадобиться использовать другие методы извлечения данных.

Для извлечения определенных полей в ответе поиска используйте параметр fields. Поскольку он обращается к схемам индекса, этот параметр предоставляет несколько преимуществ по сравнению с прямым использованием _source. В частности, параметр fields:

Учитываются и другие параметры схемы, включая ignore_above, ignore_malformed и null_value.

Параметр fields возвращает значения так, как Elasticsearch их индексирует. Для стандартных полей это означает, что параметр fields ищет значения в _source, затем анализирует и форматирует их с помощью схемы. Выбранные поля, которые не найдены в _source, пропускаются.

Следующий запрос поиска использует параметр fields для извлечения значений поля user.id, всех полей, начинающихся с http.response., и поля @timestamp.

Используя нотацию объектов, вы можете передать аргумент format для настройки формата возвращаемых дат или геопространственных значений.

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)

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

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
}

Ответ 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
          ]
        }
      }
    ]
  }
}

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)

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

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
}

{
  "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"]
          }
        ]
      }
    }]
  }
}

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

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

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
}

{
  "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"]
          }
        ]
      }
    }]
  }
}

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)

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

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
}

{
  "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"
          ]
        }
      }
    ]
  }
}

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)

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

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
}

{
  "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. Исходный документ не включается в ответ.

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

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

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

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

Чтобы вернуть только подмножество полей источника, укажите шаблон с подстановкой (*) в параметре _source. Следующий запрос API поиска возвращает исходный код только для поля obj и его свойств.

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

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

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 и их свойств.

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

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

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"
    }
  }
}

Для более точного управления вы можете указать объект, содержащий массивы шаблонов includes и excludes в параметре _source.

Если указано свойство includes, будут возвращены только поля источника, соответствующие одному из его шаблонов. Вы можете исключить поля из этого подмножества, используя свойство excludes.

Если свойство includes не указано, возвращается весь исходный документ источника, за исключением полей, соответствующих шаблону в свойстве excludes.

Следующий запрос API поиска возвращает исходный код только для полей obj1 и obj2 и их свойств, исключая любые вложенные поля description.

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

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

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"
    }
  }
}

Исходный код документа _source хранится как одно поле в Lucene. Эта структура означает, что весь объект _source должен быть загружен и распарсен, даже если вам требуется только часть из него. Чтобы избежать этого ограничения, вы можете попробовать другие варианты загрузки полей:

Elasticsearch всегда пытается загрузить значения из _source. Это поведение имеет те же последствия, что и фильтрация источника, где Elasticsearch необходимо загрузить и разобрать весь _source, чтобы получить только одно поле.

Вы можете использовать параметр docvalue_fields, чтобы вернуть значения документов для одного или нескольких полей в ответ на поиск.

Значения документов хранят те же значения, что и _source, но в структуре на диске, основанной на столбцах, оптимизированной для сортировки и агрегаций. Поскольку каждое поле хранится отдельно, Elasticsearch считывает только запрошенные значения поля и может избежать загрузки всего документа _source.

Значения документов хранятся по умолчанию для поддерживаемых полей. Однако значения документов не поддерживаются для полей text или text_annotated.

Следующий запрос поиска использует параметр docvalue_fields, чтобы получить значения документов для поля user.id, всех полей, начинающихся с http.response., и поля @timestamp:

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)

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

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" 
    }
  ]
}

Также возможно хранить значения отдельных полей, используя параметр отображения store. Вы можете использовать параметр stored_fields, чтобы включить эти сохранённые значения в ответ на поиск.

Позволяет выборочно загружать определенные хранящиеся поля для каждого документа, представленного результатом поиска.

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

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

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 для каждого результата, например:

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

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

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. Если указано поле объекта, оно будет проигнорировано.

Чтобы полностью отключить сохранённые поля (и поля метаданных), используйте: _none_:

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

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

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

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

Вы можете использовать параметр script_fields для получения вычисления скрипта (на основе разных полей) для каждого совпадения. Например:

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)

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

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']. Вот пример:

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

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

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, приведет к загрузке терминов для этого поля в память (кеширование), что ускорит выполнение, но увеличит потребление памяти. Также, обозначение doc[...] позволяет только простым значениям полей (вы не можете вернуть JSON-объект) и имеет смысл только для неанализируемых или однословных полей. Однако, использование doc по-прежнему является рекомендуемым способом доступа к значениям из документа, если это возможно, потому что _source необходимо загружать и парсить каждый раз, когда он используется. Использование _source очень медленное.