› › ›

多文档获取 (mget) API

通过 ID 检索多个 JSON 文档。

resp = client.mget(
    docs=[
        {
            "_index": "my-index-000001",
            "_id": "1"
        },
        {
            "_index": "my-index-000001",
            "_id": "2"
        }
    ],
)
print(resp)

response = client.mget(
  body: {
    docs: [
      {
        _index: 'my-index-000001',
        _id: '1'
      },
      {
        _index: 'my-index-000001',
        _id: '2'
      }
    ]
  }
)
puts response

const response = await client.mget({
  docs: [
    {
      _index: "my-index-000001",
      _id: "1",
    },
    {
      _index: "my-index-000001",
      _id: "2",
    },
  ],
});
console.log(response);

GET /_mget
{
  "docs": [
    {
      "_index": "my-index-000001",
      "_id": "1"
    },
    {
      "_index": "my-index-000001",
      "_id": "2"
    }
  ]
}

请求

编辑

GET /_mget

GET /<索引>/_mget

先决条件

编辑

如果启用了 Elasticsearch 安全功能，您必须拥有目标索引或索引别名的 read 索引权限。

描述

编辑

您可以使用 mget 从一个或多个索引中检索多个文档。如果在请求 URI 中指定索引，则只需在请求正文中指定文档 ID。

安全

编辑

请参阅基于 URL 的访问控制。

部分响应

编辑

为了确保快速响应，如果一个或多个分片失败，多文档获取 API 将返回部分结果。有关更多信息，请参阅分片失败。

路径参数

编辑

<index>: （可选，字符串）当指定 ids 时，或当 docs 数组中的文档未指定索引时，从中检索文档的索引名称。

查询参数

编辑

preference

（可选，字符串）指定应在其上执行操作的节点或分片。默认为随机。

realtime

（可选，布尔值）如果为 true，则请求是实时的，而不是近实时的。默认为 true。请参阅实时。

refresh

（可选，布尔值）如果为 true，则请求会在检索文档之前刷新相关分片。默认为 false。

routing

（可选，字符串）用于将操作路由到特定分片的自定义值。

stored_fields

（可选，字符串）要包含在响应中的 存储字段 的逗号分隔列表。

_source

（可选，字符串）返回或不返回 _source 字段，或者返回的字段列表，值为 true 或 false。

_source_excludes

（可选，字符串）要从响应中排除的源字段的逗号分隔列表。

您还可以使用此参数从 _source_includes 查询参数中指定的子集中排除字段。

如果 _source 参数为 false，则忽略此参数。

_source_includes

（可选，字符串）要包含在响应中的源字段的逗号分隔列表。

如果指定此参数，则仅返回这些源字段。您可以使用 _source_excludes 查询参数从此子集中排除字段。

如果 _source 参数为 false，则忽略此参数。

请求正文

编辑

docs

（可选，数组）要检索的文档。如果未在请求 URI 中指定索引，则为必需项。您可以为每个文档指定以下属性

_id

（必需，字符串）唯一的文档 ID。

_index

（可选，字符串）包含文档的索引。如果未在请求 URI 中指定索引，则为必需项。

routing

（可选，字符串）文档所在的的主分片的键。如果在索引期间使用了路由，则为必需项。

_source

（可选，布尔值）如果为 false，则排除所有 _source 字段。默认为 true。

source_include: （可选，数组）要从 _source 字段中提取并返回的字段。
source_exclude: （可选，数组）要从返回的 _source 字段中排除的字段。

_stored_fields

（可选，数组）要检索的存储字段。

ids

（可选，数组）要检索的文档的 ID。当在请求 URI 中指定索引时允许使用。

响应正文

编辑

响应包括一个 docs 数组，其中包含按请求中指定的顺序排列的文档。返回的文档结构类似于 get API 返回的结构。如果获取特定文档失败，则错误将包含在文档的位置中。

示例

编辑

通过 ID 获取文档

编辑

如果在请求 URI 中指定索引，则请求正文中只需要文档 ID

resp = client.mget(
    index="my-index-000001",
    docs=[
        {
            "_id": "1"
        },
        {
            "_id": "2"
        }
    ],
)
print(resp)

response = client.mget(
  index: 'my-index-000001',
  body: {
    docs: [
      {
        _id: '1'
      },
      {
        _id: '2'
      }
    ]
  }
)
puts response

const response = await client.mget({
  index: "my-index-000001",
  docs: [
    {
      _id: "1",
    },
    {
      _id: "2",
    },
  ],
});
console.log(response);

GET /my-index-000001/_mget
{
  "docs": [
    {
      "_id": "1"
    },
    {
      "_id": "2"
    }
  ]
}

您可以使用 ids 元素来简化请求

resp = client.mget(
    index="my-index-000001",
    ids=[
        "1",
        "2"
    ],
)
print(resp)

response = client.mget(
  index: 'my-index-000001',
  body: {
    ids: [
      '1',
      '2'
    ]
  }
)
puts response

const response = await client.mget({
  index: "my-index-000001",
  ids: ["1", "2"],
});
console.log(response);

GET /my-index-000001/_mget
{
  "ids" : ["1", "2"]
}

筛选源字段

编辑

默认情况下，为每个文档返回 _source 字段（如果已存储）。使用 _source 和 _source_include 或 source_exclude 属性来筛选为特定文档返回的字段。您可以在请求 URI 中包含 _source、_source_includes 和 _source_excludes 查询参数，以指定在没有每个文档指令时使用的默认值。

例如，以下请求将文档 1 的 _source 设置为 false，以完全排除源，从文档 2 中检索 field3 和 field4，并从文档 3 中检索 user 字段，但筛选掉 user.location 字段。

resp = client.mget(
    docs=[
        {
            "_index": "test",
            "_id": "1",
            "_source": False
        },
        {
            "_index": "test",
            "_id": "2",
            "_source": [
                "field3",
                "field4"
            ]
        },
        {
            "_index": "test",
            "_id": "3",
            "_source": {
                "include": [
                    "user"
                ],
                "exclude": [
                    "user.location"
                ]
            }
        }
    ],
)
print(resp)

response = client.mget(
  body: {
    docs: [
      {
        _index: 'test',
        _id: '1',
        _source: false
      },
      {
        _index: 'test',
        _id: '2',
        _source: [
          'field3',
          'field4'
        ]
      },
      {
        _index: 'test',
        _id: '3',
        _source: {
          include: [
            'user'
          ],
          exclude: [
            'user.location'
          ]
        }
      }
    ]
  }
)
puts response

const response = await client.mget({
  docs: [
    {
      _index: "test",
      _id: "1",
      _source: false,
    },
    {
      _index: "test",
      _id: "2",
      _source: ["field3", "field4"],
    },
    {
      _index: "test",
      _id: "3",
      _source: {
        include: ["user"],
        exclude: ["user.location"],
      },
    },
  ],
});
console.log(response);

GET /_mget
{
  "docs": [
    {
      "_index": "test",
      "_id": "1",
      "_source": false
    },
    {
      "_index": "test",
      "_id": "2",
      "_source": [ "field3", "field4" ]
    },
    {
      "_index": "test",
      "_id": "3",
      "_source": {
        "include": [ "user" ],
        "exclude": [ "user.location" ]
      }
    }
  ]
}

获取存储字段

编辑

使用 stored_fields 属性来指定要检索的存储字段集。任何请求的未存储字段都将被忽略。您可以在请求 URI 中包含 stored_fields 查询参数，以指定在没有每个文档指令时使用的默认值。

例如，以下请求从文档 1 中检索 field1 和 field2，并从文档 2 中检索 field3 和 field4

resp = client.mget(
    docs=[
        {
            "_index": "test",
            "_id": "1",
            "stored_fields": [
                "field1",
                "field2"
            ]
        },
        {
            "_index": "test",
            "_id": "2",
            "stored_fields": [
                "field3",
                "field4"
            ]
        }
    ],
)
print(resp)

response = client.mget(
  body: {
    docs: [
      {
        _index: 'test',
        _id: '1',
        stored_fields: [
          'field1',
          'field2'
        ]
      },
      {
        _index: 'test',
        _id: '2',
        stored_fields: [
          'field3',
          'field4'
        ]
      }
    ]
  }
)
puts response

const response = await client.mget({
  docs: [
    {
      _index: "test",
      _id: "1",
      stored_fields: ["field1", "field2"],
    },
    {
      _index: "test",
      _id: "2",
      stored_fields: ["field3", "field4"],
    },
  ],
});
console.log(response);

GET /_mget
{
  "docs": [
    {
      "_index": "test",
      "_id": "1",
      "stored_fields": [ "field1", "field2" ]
    },
    {
      "_index": "test",
      "_id": "2",
      "stored_fields": [ "field3", "field4" ]
    }
  ]
}

以下请求默认从所有文档中检索 field1 和 field2。这些默认字段将为文档 1 返回，但被覆盖为返回文档 2 的 field3 和 field4。

resp = client.mget(
    index="test",
    stored_fields="field1,field2",
    docs=[
        {
            "_id": "1"
        },
        {
            "_id": "2",
            "stored_fields": [
                "field3",
                "field4"
            ]
        }
    ],
)
print(resp)

response = client.mget(
  index: 'test',
  stored_fields: 'field1,field2',
  body: {
    docs: [
      {
        _id: '1'
      },
      {
        _id: '2',
        stored_fields: [
          'field3',
          'field4'
        ]
      }
    ]
  }
)
puts response

const response = await client.mget({
  index: "test",
  stored_fields: "field1,field2",
  docs: [
    {
      _id: "1",
    },
    {
      _id: "2",
      stored_fields: ["field3", "field4"],
    },
  ],
});
console.log(response);

GET /test/_mget?stored_fields=field1,field2
{
  "docs": [
    {
      "_id": "1"
    },
    {
      "_id": "2",
      "stored_fields": [ "field3", "field4" ]
    }
  ]
}

指定文档路由

编辑

如果在索引期间使用了路由，则需要指定路由值来检索文档。例如，以下请求从与路由键 key1 对应的分片中获取 test/_doc/2，并从与路由键 key2 对应的分片中获取 test/_doc/1。

resp = client.mget(
    routing="key1",
    docs=[
        {
            "_index": "test",
            "_id": "1",
            "routing": "key2"
        },
        {
            "_index": "test",
            "_id": "2"
        }
    ],
)
print(resp)

response = client.mget(
  routing: 'key1',
  body: {
    docs: [
      {
        _index: 'test',
        _id: '1',
        routing: 'key2'
      },
      {
        _index: 'test',
        _id: '2'
      }
    ]
  }
)
puts response

const response = await client.mget({
  routing: "key1",
  docs: [
    {
      _index: "test",
      _id: "1",
      routing: "key2",
    },
    {
      _index: "test",
      _id: "2",
    },
  ],
});
console.log(response);

GET /_mget?routing=key1
{
  "docs": [
    {
      "_index": "test",
      "_id": "1",
      "routing": "key2"
    },
    {
      "_index": "test",
      "_id": "2"
    }
  ]
}

« 按查询更新 API 批量 API »