使用 asyncio 与 Elasticsearch

elasticsearch 包支持使用 asyncio 和 aiohttp 的 async/await。您可以直接安装 aiohttp 或使用 [async] 额外内容

$ python -m pip install elasticsearch aiohttp

# - OR -

$ python -m pip install elasticsearch[async]

异步入门

安装后，所有异步 API 端点都可通过 AsyncElasticsearch 使用，使用方法与其他 API 相同，只是多了一个 await

import asyncio
from elasticsearch import AsyncElasticsearch

client = AsyncElasticsearch()

async def main():
    resp = await client.search(
        index="documents",
        body={"query": {"match_all": {}}},
        size=20,
    )
    print(resp)

loop = asyncio.get_event_loop()
loop.run_until_complete(main())

同步客户端下可用的所有 API 在异步客户端下也可用。

ASGI 应用程序和 Elastic APM

ASGI (异步服务器网关接口) 是一种为 Python Web 应用程序提供服务的新方法，它利用异步 I/O 来实现更好的性能。一些 ASGI 框架的示例包括 FastAPI、Django 3.0+ 和 Starlette。如果您正在使用这些框架中的一个以及 Elasticsearch，那么您应该使用 AsyncElasticsearch 以避免使用同步网络调用阻塞事件循环，从而获得最佳性能。

Elastic APM 还支持对异步 Elasticsearch 查询进行跟踪，就像对同步查询一样。有关如何使用流行的 ASGI 框架 FastAPI 和 APM 跟踪配置 AsyncElasticsearch 的示例，请查看 examples/fastapi-apm 目录中的预构建示例。

常见问题解答

初始化 `AsyncElasticsearch` 时出现 ValueError？

如果您在尝试使用 AsyncElasticsearch 时收到 ValueError: You must have 'aiohttp' installed to use AiohttpHttpNode，则应确保您的环境中已安装 aiohttp（使用 $ python -m pip freeze | grep aiohttp 检查）。否则，异步支持将不可用。

`elasticsearch-async` 包怎么样？

以前，asyncio 是通过 elasticsearch-async 包单独支持的。elasticsearch-async 包已在 v7.8 及更高版本中被 elasticsearch 包提供的 AsyncElasticsearch 取代。

收到“未关闭的客户端会话/连接器”警告？

此警告是由 aiohttp 在打开的 HTTP 连接被垃圾回收时创建的。您通常会在关闭应用程序时遇到这种情况。要解决此问题，请确保在 AsyncElasticsearch 实例被垃圾回收之前调用 close()。

例如，如果使用 FastAPI，它可能看起来像这样

import os
from contextlib import asynccontextmanager

from fastapi import FastAPI
from elasticsearch import AsyncElasticsearch

ELASTICSEARCH_URL = os.environ["ELASTICSEARCH_URL"]
client = None

@asynccontextmanager
async def lifespan(app: FastAPI):
    global client
    client = AsyncElasticsearch(ELASTICSEARCH_URL)
    yield
    await client.close()

app = FastAPI(lifespan=lifespan)

@app.get("/")
async def main():
    return await client.info()

您可以通过将此示例保存到 main.py 并执行 ELASTICSEARCH_URL=http://localhost:9200 uvicorn main:app 来运行此示例。

异步助手

所有助手的异步变体都可以在 elasticsearch.helpers 中找到，并且都以 async_* 为前缀。您会注意到这些 API 与同步助手文档中的 API 相同。

所有接受迭代器或生成器的异步助手也接受异步迭代器和异步生成器。

批量和流式批量

async elasticsearch.helpers.async_bulk(client, actions, stats_only=False, ignore_status=(), *args, **kwargs)

bulk() API 的助手，它提供了一个更人性化的界面 - 它使用操作的迭代器，并将它们以块的形式发送到 Elasticsearch。它返回一个包含摘要信息的元组 - 成功执行的操作数量，以及错误列表或错误数量（如果 stats_only 设置为 True）。请注意，默认情况下，当我们遇到错误时，我们会引发 BulkIndexError，因此像 stats_only 这样的选项仅在 raise_on_error 设置为 False 时适用。

当收集错误时，原始文档数据将包含在错误字典中，这会导致内存使用量过高。如果您需要处理大量数据并希望忽略/收集错误，请考虑使用 async_streaming_bulk() 助手，它只会返回错误，而不会将它们存储在内存中。

参数:

client (AsyncElasticsearch) – AsyncElasticsearch 的实例，用于使用

actions (Iterable[bytes | str | Dict[str, Any]] | AsyncIterable[bytes | str | Dict[str, Any]]) – 包含操作的迭代器

stats_only (bool) – 如果为 True，则仅报告成功/失败操作的数量，而不是仅报告成功操作的数量和错误响应列表

ignore_status (int | Collection[int]) – 您要忽略的 HTTP 状态代码列表

client

actions

stats_only

ignore_status

args (Any)

kwargs (Any)

返回类型:

元组[整数, 整数 | 列表[任何]]

任何额外的关键字参数将被传递给 async_streaming_bulk()，它用于执行操作，有关更多接受的参数，请参见 async_streaming_bulk()。
import asyncio
from elasticsearch import AsyncElasticsearch
from elasticsearch.helpers import async_bulk

client = AsyncElasticsearch()

async def gendata():
    mywords = ['foo', 'bar', 'baz']
    for word in mywords:
        yield {
            "_index": "mywords",
            "doc": {"word": word},
        }

async def main():
    await async_bulk(client, gendata())

loop = asyncio.get_event_loop()
loop.run_until_complete(main())
异步 elasticsearch.helpers.async_streaming_bulk(client, actions, chunk_size=500, max_chunk_bytes=104857600, raise_on_error=True, expand_action_callback=<function expand_action>, raise_on_exception=True, max_retries=0, initial_backoff=2, max_backoff=600, yield_ok=True, ignore_status=(), *args, **kwargs)

流式批量操作从传入的可迭代对象中消费操作，并为每个操作生成结果。对于非流式用例，请使用 async_bulk()，它是一个围绕流式批量的包装器，在整个输入被消费并发送后返回有关批量操作的摘要信息。

如果您指定 max_retries，它还会重试任何被拒绝并返回 429 状态码的文档。为此，它将等待（**通过调用 asyncio.sleep**）initial_backoff 秒，然后，对于同一块的每次后续拒绝，每次等待两倍的时间，直到 max_backoff 秒。

参数:

client (AsyncElasticsearch) – AsyncElasticsearch 的实例，用于使用

actions (可迭代[字节 | 字符串 | 字典[字符串, 任何]] | 异步可迭代[字节 | 字符串 | 字典[字符串, 任何]]) – 包含要执行的操作的可迭代对象或异步可迭代对象

chunk_size (整数) – 发送到 es 的一个块中的文档数量（默认：500）

max_chunk_bytes (整数) – 请求的最大字节大小（默认：100MB）

raise_on_error (布尔值) – 当发生错误时，引发包含错误（作为 .errors）的 BulkIndexError。默认情况下，我们引发异常。

raise_on_exception (布尔值) – 如果为 False，则不传播来自对 bulk 的调用的异常，只报告失败的项目。

expand_action_callback (可调用[[字节 | 字符串 | 字典[字符串, 任何]], 元组[字典[字符串, 任何], 无 | 字节 | 字典[字符串, 任何]]]) – 对传入的每个操作执行的回调，应返回一个元组，其中包含操作行和数据行（如果数据行应省略，则为无）。

max_retries (整数) – 当收到 429 时，文档将被重试的最大次数，设置为 0（默认）表示对 429 不进行重试

initial_backoff (浮点数) – 我们在第一次重试之前应该等待的秒数。任何后续重试将是 initial_backoff * 2**retry_number 的幂

max_backoff (浮点数) – 重试将等待的最大秒数

yield_ok (布尔值) – 如果设置为 False，将跳过输出中的成功文档

ignore_status (int | Collection[int]) – 您要忽略的 HTTP 状态代码列表

client

actions

chunk_size

max_chunk_bytes

raise_on_error

expand_action_callback

raise_on_exception

max_retries

initial_backoff

max_backoff

yield_ok

ignore_status

args (Any)

kwargs (Any)

返回类型:

异步可迭代[元组[布尔值, 字典[字符串, 任何]]]
import asyncio
from elasticsearch import AsyncElasticsearch
from elasticsearch.helpers import async_streaming_bulk

client = AsyncElasticsearch()

async def gendata():
    mywords = ['foo', 'bar', 'baz']
    for word in mywords:
        yield {
            "_index": "mywords",
            "word": word,
        }

async def main():
    async for ok, result in async_streaming_bulk(client, gendata()):
        action, result = result.popitem()
        if not ok:
            print("failed to %s document %s" % ())

loop = asyncio.get_event_loop()
loop.run_until_complete(main())

扫描

异步 elasticsearch.helpers.async_scan(client, query=None, scroll='5m', raise_on_error=True, preserve_order=False, size=1000, request_timeout=None, clear_scroll=True, scroll_kwargs=None, **kwargs)
在 scroll() api 之上的简单抽象 - 一个简单的迭代器，它生成由底层滚动请求返回的所有命中结果。

默认情况下，扫描不会以任何预先确定的顺序返回结果。为了在滚动时使返回的文档具有标准顺序（按分数或显式排序定义），请使用 preserve_order=True。这可能是一个昂贵的操作，并且会抵消使用 scan 的性能优势。

参数:

client (AsyncElasticsearch) – AsyncElasticsearch 的实例，用于使用

query (任何 | 无) – search() api 的主体

scroll (字符串) – 指定应为滚动搜索维护索引的一致视图的时间长度

raise_on_error (bool) – 如果遇到错误（某些分片无法执行），则引发异常 (ScanError)。默认情况下，我们会引发异常。

preserve_order (bool) – 不要将 search_type 设置为 scan - 这将导致滚动分页并保留顺序。请注意，这可能是一项非常昂贵的操作，并且很容易导致不可预测的结果，请谨慎使用。

size (int) – 每次迭代发送的批次大小（每个分片）。

request_timeout (float | None) – 对每次调用 scan 的显式超时。

clear_scroll (bool) – 在方法完成或出错时，通过清除滚动 API 在滚动 ID 上显式调用删除，默认为 true。

scroll_kwargs (MutableMapping[str, Any] | None) – 要传递给 scroll() 的其他关键字参数。

client

query

scroll

raise_on_error

preserve_order

size

request_timeout

clear_scroll

scroll_kwargs

kwargs (Any)

返回类型:

AsyncIterable[Dict[str, Any]]

任何其他关键字参数都将传递给初始 search() 调用。
async_scan(
    client,
    query={"query": {"match": {"title": "python"}}},
    index="orders-*"
)
import asyncio
from elasticsearch import AsyncElasticsearch
from elasticsearch.helpers import async_scan

client = AsyncElasticsearch()

async def main():
    async for doc in async_scan(
        client=client,
        query={"query": {"match": {"title": "python"}}},
        index="orders-*"
    ):
        print(doc)

loop = asyncio.get_event_loop()
loop.run_until_complete(main())

重新索引

async elasticsearch.helpers.async_reindex(client, source_index, target_index, query=None, target_client=None, chunk_size=500, scroll='5m', op_type=None, scan_kwargs={}, bulk_kwargs={})

将满足给定查询的来自一个索引的所有文档重新索引到另一个索引，可能（如果指定了 target_client）在不同的集群上。如果您没有指定查询，您将重新索引所有文档。

从 2.3 开始，reindex() API 作为 Elasticsearch 本身的一部分可用。建议在可能的情况下使用 API 而不是此助手。此助手主要用于向后兼容性和需要更多灵活性的情况。

注意

此助手不传输映射，只传输数据。

参数:

client (AsyncElasticsearch) – 要使用的 AsyncElasticsearch 实例（如果指定了 target_client，则用于读取）。

source_index (str | Collection[str]) – 要从中读取文档的索引（或索引列表）。

target_index (str) – 要填充的目标集群中索引的名称。

query (Any) – search() API 的主体。

target_client (AsyncElasticsearch | None) – 可选，如果指定，将用于写入（从而启用跨集群重新索引）。

chunk_size (整数) – 发送到 es 的一个块中的文档数量（默认：500）

scroll (字符串) – 指定应为滚动搜索维护索引的一致视图的时间长度

op_type (str | None) – 显式操作类型。默认为 ‘_index’。数据流必须设置为 ‘create’。如果未指定，将自动检测 target_index 是否为数据流。

scan_kwargs (MutableMapping[str, Any]) – 要传递给 async_scan() 的其他关键字参数。

bulk_kwargs (MutableMapping[str, Any]) – 要传递给 async_bulk() 的其他关键字参数。

client

source_index

target_index

query

target_client

chunk_size

scroll

op_type

scan_kwargs

bulk_kwargs

返回类型:

元组[整数, 整数 | 列表[任何]]

API 参考

AsyncElasticsearch 的 API 与 Elasticsearch 的 API 几乎相同，区别在于每个 API 调用（如 search()）都是一个 async 函数，需要一个 await 来正确返回响应主体。

AsyncElasticsearch

注意

要引用像 .indices.create() 这样的命名空间的 Elasticsearch API，请参考同步 API 参考。这些 API 在同步和异步之间是相同的。
class elasticsearch.AsyncElasticsearch(hosts=None, *, cloud_id=None, api_key=None, basic_auth=None, bearer_auth=None, opaque_id=None, headers=<DEFAULT>, connections_per_node=<DEFAULT>, http_compress=<DEFAULT>, verify_certs=<DEFAULT>, ca_certs=<DEFAULT>, client_cert=<DEFAULT>, client_key=<DEFAULT>, ssl_assert_hostname=<DEFAULT>, ssl_assert_fingerprint=<DEFAULT>, ssl_version=<DEFAULT>, ssl_context=<DEFAULT>, ssl_show_warn=<DEFAULT>, transport_class=<class 'elastic_transport.AsyncTransport'>, request_timeout=<DEFAULT>, node_class=<DEFAULT>, node_pool_class=<DEFAULT>, randomize_nodes_in_pool=<DEFAULT>, node_selector_class=<DEFAULT>, dead_node_backoff_factor=<DEFAULT>, max_dead_node_backoff=<DEFAULT>, serializer=None, serializers=<DEFAULT>, default_mimetype='application/json', max_retries=<DEFAULT>, retry_on_status=<DEFAULT>, retry_on_timeout=<DEFAULT>, sniff_on_start=<DEFAULT>, sniff_before_requests=<DEFAULT>, sniff_on_node_failure=<DEFAULT>, sniff_timeout=<DEFAULT>, min_delay_between_sniffing=<DEFAULT>, sniffed_node_callback=None, meta_header=<DEFAULT>, timeout=<DEFAULT>, randomize_hosts=<DEFAULT>, host_info_callback=None, sniffer_timeout=<DEFAULT>, sniff_on_connection_fail=<DEFAULT>, http_auth=<DEFAULT>, maxsize=<DEFAULT>, _transport=None)
Elasticsearch 低级客户端。提供从 Python 到 Elasticsearch REST API 的直接映射。

客户端实例具有其他属性，用于更新不同命名空间中的 API，例如 async_search、indices、security 等等。
client = Elasticsearch("http://localhost:9200")

# Get Document API
client.get(index="*", id="1")

# Get Index API
client.indices.get(index="*")
传输选项可以在客户端构造函数上设置，也可以使用 options() 方法设置。
# Set 'api_key' on the constructor
client = Elasticsearch(
    "http://localhost:9200",
    api_key="api_key",
)
client.search(...)

# Set 'api_key' per request
client.options(api_key="api_key").search(...)
参数:

hosts (str | Sequence[str | Mapping[str, int] | NodeConfig] | None)

cloud_id (str | None)

api_key (str | Tuple[str, str] | None)

basic_auth (str | Tuple[str, str] | None)

bearer_auth (str | None)

opaque_id (str | None)

headers (DefaultType | Mapping[str, str])

connections_per_node (DefaultType | int)

http_compress (DefaultType | bool)

verify_certs (DefaultType | bool)

ca_certs (DefaultType | str)

client_cert (DefaultType | str)

client_key (DefaultType | str)

ssl_assert_hostname (DefaultType | str)

ssl_assert_fingerprint (DefaultType | str)

ssl_version (DefaultType | int)

ssl_context (DefaultType | Any)

ssl_show_warn (DefaultType | bool)

transport_class (Type[AsyncTransport])

request_timeout (DefaultType | None | float)

node_class (DefaultType | Type[BaseNode])

node_pool_class (DefaultType | Type[NodePool])

randomize_nodes_in_pool (DefaultType | bool)

node_selector_class (DefaultType | Type[NodeSelector])

dead_node_backoff_factor (DefaultType | float)

max_dead_node_backoff (DefaultType | float)

serializer (Serializer | None)

serializers (DefaultType | Mapping[str, Serializer])

default_mimetype (str)

max_retries (DefaultType | int)

retry_on_status (DefaultType | int | Collection[int])

retry_on_timeout (DefaultType | bool)

sniff_on_start (DefaultType | bool)

sniff_before_requests (DefaultType | bool)

sniff_on_node_failure (DefaultType | bool)

sniff_timeout (DefaultType | None | float)

min_delay_between_sniffing (DefaultType | None | float)

sniffed_node_callback (Callable[[Dict[str, Any], NodeConfig], NodeConfig | None] | None)

meta_header (DefaultType | bool)

timeout (DefaultType | None | float)

randomize_hosts (DefaultType | bool)

host_info_callback (Callable[[Dict[str, Any], Dict[str, str | int]], Dict[str, str | int] | None] | None)

sniffer_timeout (DefaultType | None | float)

sniff_on_connection_fail (DefaultType | bool)

http_auth (DefaultType | Any)

maxsize (DefaultType | int)

_transport (AsyncTransport | None)

bulk(*, operations=None, body=None, index=None, error_trace=None, filter_path=None, human=None, pipeline=None, pretty=None, refresh=None, require_alias=None, routing=None, source=None, source_excludes=None, source_includes=None, timeout=None, wait_for_active_shards=None)

允许在一个请求中执行多个索引/更新/删除操作。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/docs-bulk.html

参数:

operations (Sequence[Mapping[str, Any]] | None)

index (str | None) – 要执行批量操作的数据流、索引或索引别名的名称。

pipeline (str | None) – 要用于预处理传入文档的管道的 ID。如果索引指定了默认的摄取管道，则将值设置为 _none 将为该请求禁用默认的摄取管道。如果配置了最终管道，它将始终运行，无论此参数的值如何。

refresh (Literal['false', 'true', 'wait_for'] | bool | str | None) – 如果为 true，Elasticsearch 将刷新受影响的分片以使此操作对搜索可见，如果为 wait_for，则等待刷新以使此操作对搜索可见，如果为 false，则不执行刷新操作。有效值：true、false、wait_for。

require_alias (bool | None) – 如果为 true，则请求的操作必须针对索引别名。

routing (str | None) – 用于将操作路由到特定分片的自定义值。

source (bool | str | Sequence[str] | None) – 返回 _source 字段的 true 或 false，或要返回的字段列表。

source_excludes (str | Sequence[str] | None) – 要从响应中排除的源字段的逗号分隔列表。

source_includes (str | Sequence[str] | None) – 要包含在响应中的源字段的逗号分隔列表。

timeout (Literal[-1] | ~typing.Literal[0] | str | None) – 每个操作等待以下操作的时间段：自动索引创建、动态映射更新、等待活动分片。

wait_for_active_shards (int | Literal['all', 'index-setting'] | str | None) – 在继续操作之前必须处于活动状态的分片副本数量。设置为所有或任何正整数，直到索引中的分片总数 (number_of_replicas+1)。

body (Sequence[Mapping[str, Any]] | None)

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

返回类型:

ObjectApiResponse[Any]

clear_scroll(*, error_trace=None, filter_path=None, human=None, pretty=None, scroll_id=None, body=None)

显式清除滚动搜索上下文。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/clear-scroll-api.html

参数:

scroll_id (str | Sequence[str] | None) – 要清除的滚动 ID。要清除所有滚动 ID，请使用 _all。

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

body (Dict[str, Any] | None)

返回类型:

ObjectApiResponse[Any]

async close()

关闭传输和所有内部连接

返回类型:

None

close_point_in_time(*, id=None, error_trace=None, filter_path=None, human=None, pretty=None, body=None)

关闭时间点

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/point-in-time-api.html

参数:

id (str | None) – 时间点的 ID。

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

body (Dict[str, Any] | None)

返回类型:

ObjectApiResponse[Any]

count(*, index=None, allow_no_indices=None, analyze_wildcard=None, analyzer=None, default_operator=None, df=None, error_trace=None, expand_wildcards=None, filter_path=None, human=None, ignore_throttled=None, ignore_unavailable=None, lenient=None, min_score=None, preference=None, pretty=None, q=None, query=None, routing=None, terminate_after=None, body=None)

返回与查询匹配的文档数量。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/search-count.html

参数:

index (str | Sequence[str] | None) – 要搜索的数据流、索引和别名的逗号分隔列表。支持通配符 (*)。要搜索所有数据流和索引，请省略此参数或使用 * 或 _all。

allow_no_indices (bool | None) – 如果为 false，则如果任何通配符表达式、索引别名或 _all 值仅针对缺失或关闭的索引，则请求将返回错误。即使请求针对其他打开的索引，此行为也适用。

analyze_wildcard (bool | None) – 如果为 true，则分析通配符和前缀查询。此参数只能在指定 q 查询字符串参数时使用。

analyzer (str | None) – 用于查询字符串的分析器。此参数只能在指定 q 查询字符串参数时使用。

default_operator (Literal['and', 'or'] | str | None) – 查询字符串查询的默认运算符：AND 或 OR。此参数只能在指定 q 查询字符串参数时使用。

df (str | None) – 用作默认字段，在查询字符串中没有给出字段前缀的地方。此参数只能在指定 q 查询字符串参数时使用。

expand_wildcards (Sequence[Literal['all', 'closed', 'hidden', 'none', 'open'] | str] | ~typing.Literal['all', 'closed', 'hidden', 'none', 'open'] | str | None) – 通配符模式可以匹配的索引类型。如果请求可以定位数据流，则此参数决定通配符表达式是否匹配隐藏的数据流。支持逗号分隔的值，例如 open,hidden。

ignore_throttled (bool | None) – 如果为 true，则在冻结时忽略具体、扩展或别名索引。

ignore_unavailable (bool | None) – 如果为 false，则如果请求定位到丢失或关闭的索引，则返回错误。

lenient (bool | None) – 如果为 true，则会忽略查询字符串中基于格式的查询失败（例如，向数字字段提供文本）。

min_score (float | None) – 设置文档必须具有的最小 _score 值才能包含在结果中。

preference (str | None) – 指定应执行操作的节点或分片。默认情况下为随机。

q (str | None) – Lucene 查询字符串语法中的查询。

query (Mapping[str, Any] | None) – 使用 Query DSL 定义搜索定义。

routing (str | None) – 用于将操作路由到特定分片的自定义值。

terminate_after (int | None) – 每个分片要收集的文档的最大数量。如果查询达到此限制，Elasticsearch 会提前终止查询。Elasticsearch 在排序之前收集文档。

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

body (Dict[str, Any] | None)

返回类型:

ObjectApiResponse[Any]

create(*, index, id, document=None, body=None, error_trace=None, filter_path=None, human=None, pipeline=None, pretty=None, refresh=None, routing=None, timeout=None, version=None, version_type=None, wait_for_active_shards=None)

在索引中创建新文档。当索引中已存在具有相同 ID 的文档时，返回 409 响应。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/docs-index_.html

参数:

index (str) – 要定位的数据流或索引的名称。如果目标不存在且与具有 data_stream 定义的索引模板的名称或通配符 (*) 模式匹配，则此请求创建数据流。如果目标不存在且与数据流模板不匹配，则此请求创建索引。

id (str) – 文档的唯一标识符。

document (Mapping[str, Any] | None)

pipeline (str | None) – 要用于预处理传入文档的管道的 ID。如果索引指定了默认的摄取管道，则将值设置为 _none 将为该请求禁用默认的摄取管道。如果配置了最终管道，它将始终运行，无论此参数的值如何。

refresh (Literal['false', 'true', 'wait_for'] | bool | str | None) – 如果为 true，Elasticsearch 将刷新受影响的分片以使此操作对搜索可见，如果为 wait_for，则等待刷新以使此操作对搜索可见，如果为 false，则不执行刷新操作。有效值：true、false、wait_for。

routing (str | None) – 用于将操作路由到特定分片的自定义值。

timeout (Literal[-1] | ~typing.Literal[0] | str | None) – 请求等待以下操作的时间段：自动索引创建、动态映射更新、等待活动分片。

version (int | None) – 用于并发控制的显式版本号。指定的版本必须与文档的当前版本匹配，请求才能成功。

version_type (Literal['external', 'external_gte', 'force', 'internal'] | str | None) – 特定版本类型：external、external_gte。

wait_for_active_shards (int | Literal['all', 'index-setting'] | str | None) – 在继续操作之前必须处于活动状态的分片副本数量。设置为 all 或任何正整数，直到索引中的分片总数 (number_of_replicas+1)。

body (Mapping[str, Any] | None)

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

返回类型:

ObjectApiResponse[Any]

delete(*, index, id, error_trace=None, filter_path=None, human=None, if_primary_term=None, if_seq_no=None, pretty=None, refresh=None, routing=None, timeout=None, version=None, version_type=None, wait_for_active_shards=None)

从索引中删除文档。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/docs-delete.html

参数:

index (str) – 目标索引的名称。

id (str) – 文档的唯一标识符。

if_primary_term (int | None) – 仅在文档具有此主项时执行操作。

if_seq_no (int | None) – 仅在文档具有此序列号时执行操作。

refresh (Literal['false', 'true', 'wait_for'] | bool | str | None) – 如果为 true，Elasticsearch 将刷新受影响的分片以使此操作对搜索可见，如果为 wait_for，则等待刷新以使此操作对搜索可见，如果为 false，则不执行刷新操作。有效值：true、false、wait_for。

routing (str | None) – 用于将操作路由到特定分片的自定义值。

timeout (Literal[-1] | ~typing.Literal[0] | str | None) – 等待活动分片的时间段。

version (int | None) – 用于并发控制的显式版本号。指定的版本必须与文档的当前版本匹配，请求才能成功。

version_type (Literal['external', 'external_gte', 'force', 'internal'] | str | None) – 特定版本类型：external、external_gte。

wait_for_active_shards (int | Literal['all', 'index-setting'] | str | None) – 在继续操作之前必须处于活动状态的分片副本数量。设置为 all 或任何正整数，直到索引中的分片总数 (number_of_replicas+1)。

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

返回类型:

ObjectApiResponse[Any]

delete_by_query(*, index, allow_no_indices=None, analyze_wildcard=None, analyzer=None, conflicts=None, default_operator=None, df=None, error_trace=None, expand_wildcards=None, filter_path=None, from_=None, human=None, ignore_unavailable=None, lenient=None, max_docs=None, preference=None, pretty=None, q=None, query=None, refresh=None, request_cache=None, requests_per_second=None, routing=None, scroll=None, scroll_size=None, search_timeout=None, search_type=None, slice=None, slices=None, sort=None, stats=None, terminate_after=None, timeout=None, version=None, wait_for_active_shards=None, wait_for_completion=None, body=None)

删除与提供的查询匹配的文档。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/docs-delete-by-query.html

参数:

index (str | Sequence[str]) – 要搜索的数据流、索引和别名的逗号分隔列表。支持通配符 (*)。要搜索所有数据流或索引，请省略此参数或使用 * 或 _all。

allow_no_indices (bool | None) – 如果为 false，则如果任何通配符表达式、索引别名或 _all 值仅针对缺失或关闭的索引，则请求将返回错误。即使请求针对其他打开的索引，此行为也适用。例如，如果索引以 foo 开头，但没有索引以 bar 开头，则针对 foo*,bar* 的请求将返回错误。

analyze_wildcard (bool | None) – 如果为 true，则分析通配符和前缀查询。

analyzer (str | None) – 用于查询字符串的分析器。

conflicts (Literal['abort', 'proceed'] | str | None) – 如果按查询删除遇到版本冲突时该怎么办：abort 或 proceed。

default_operator (Literal['and', 'or'] | str | None) – 查询字符串查询的默认运算符：AND 或 OR。

df (str | None) – 用作默认值的字段，在查询字符串中没有字段前缀。

expand_wildcards (Sequence[Literal['all', 'closed', 'hidden', 'none', 'open'] | str] | ~typing.Literal['all', 'closed', 'hidden', 'none', 'open'] | str | None) – 通配符模式可以匹配的索引类型。如果请求可以针对数据流，则此参数确定通配符表达式是否匹配隐藏的数据流。支持逗号分隔的值，例如 open,hidden。有效值为：all、open、closed、hidden、none。

from – 起始偏移量（默认值：0）

ignore_unavailable (bool | None) – 如果为 false，则如果请求定位到丢失或关闭的索引，则返回错误。

lenient (bool | None) – 如果为 true，则会忽略查询字符串中基于格式的查询失败（例如，向数字字段提供文本）。

max_docs (int | None) – 要删除的文档的最大数量。

preference (str | None) – 指定应执行操作的节点或分片。默认情况下为随机。

q (str | None) – Lucene 查询字符串语法中的查询。

query (Mapping[str, Any] | None) – 使用查询 DSL 指定要删除的文档。

refresh (bool | None) – 如果为 true，则 Elasticsearch 在请求完成后刷新参与按查询删除的所有分片。

request_cache (bool | None) – 如果为 true，则此请求将使用请求缓存。默认为索引级别设置。

requests_per_second (float | None) – 此请求的节流，以每秒子请求数表示。

routing (str | None) – 用于将操作路由到特定分片的自定义值。

scroll (Literal[-1] | ~typing.Literal[0] | str | None) – 保留滚动搜索上下文的期限。

scroll_size (int | None) – 为操作提供支持的滚动请求的大小。

search_timeout (Literal[-1] | ~typing.Literal[0] | str | None) – 每个搜索请求的显式超时。默认为无超时。

search_type (Literal['dfs_query_then_fetch', 'query_then_fetch'] | str | None) – 搜索操作的类型。可用选项：query_then_fetch、dfs_query_then_fetch。

slice (Mapping[str, Any] | None) – 使用提供的切片 ID 和切片总数手动切片请求。

slices (int | Literal['auto'] | str | None) – 此任务应划分的切片数量。

sort (Sequence[str] | None) – <field>:<direction> 对的逗号分隔列表。

stats (Sequence[str] | None) – 用于日志记录和统计目的的请求的特定 tag。

terminate_after (int | None) – 每个分片要收集的文档的最大数量。如果查询达到此限制，Elasticsearch 将提前终止查询。Elasticsearch 在排序之前收集文档。谨慎使用。Elasticsearch 将此参数应用于处理请求的每个分片。如果可能，让 Elasticsearch 自动执行提前终止。避免为针对跨多个数据层级具有支持索引的数据流的请求指定此参数。

timeout (Literal[-1] | ~typing.Literal[0] | str | None) – 每个删除请求等待活动分片的期限。

version (bool | None) – 如果为 true，则将文档版本作为命中的一部分返回。

wait_for_active_shards (int | Literal['all', 'index-setting'] | str | None) – 在继续操作之前必须处于活动状态的分片副本数量。设置为所有或任何正整数，直到索引中的分片总数 (number_of_replicas+1)。

wait_for_completion (bool | None) – 如果为 true，则请求将阻塞，直到操作完成。

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

from_ (int | None)

human (bool | None)

pretty (bool | None)

body (Dict[str, Any] | None)

返回类型:

ObjectApiResponse[Any]

delete_by_query_rethrottle(*, task_id, error_trace=None, filter_path=None, human=None, pretty=None, requests_per_second=None)

更改特定 Delete By Query 操作的每秒请求数。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/docs-delete-by-query.html

参数:

task_id (int | str) – 任务的 ID。

requests_per_second (float | None) – 此请求的节流，以每秒子请求数表示。

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

返回类型:

ObjectApiResponse[Any]

delete_script(*, id, error_trace=None, filter_path=None, human=None, master_timeout=None, pretty=None, timeout=None)

删除脚本。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/modules-scripting.html

参数:

id (str) – 存储的脚本或搜索模板的标识符。

master_timeout (Literal[-1] | ~typing.Literal[0] | str | None) – 等待连接到主节点的时间段。如果在超时时间到期之前没有收到响应，则请求失败并返回错误。

timeout (Literal[-1] | ~typing.Literal[0] | str | None) – 等待响应的时间段。如果在超时时间到期之前没有收到响应，则请求失败并返回错误。

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

返回类型:

ObjectApiResponse[Any]

exists(*, index, id, error_trace=None, filter_path=None, human=None, preference=None, pretty=None, realtime=None, refresh=None, routing=None, source=None, source_excludes=None, source_includes=None, stored_fields=None, version=None, version_type=None)

返回有关文档是否存在于索引中的信息。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/docs-get.html

参数:

index (str) – 数据流、索引和别名的逗号分隔列表。支持通配符 (*).

id (str) – 文档的标识符。

preference (str | None) – 指定应执行操作的节点或分片。默认情况下为随机。

realtime (bool | None) – 如果为 true，则请求是实时的，而不是近实时的。

refresh (bool | None) – 如果为 true，则 Elasticsearch 在请求完成后刷新参与按查询删除的所有分片。

routing (str | None) – 针对指定的初级分片。

source (bool | str | Sequence[str] | None) – 返回 _source 字段的 true 或 false，或要返回的字段列表。

source_excludes (str | Sequence[str] | None) – 要在响应中排除的源字段的逗号分隔列表。

source_includes (str | Sequence[str] | None) – 要包含在响应中的源字段的逗号分隔列表。

stored_fields (str | Sequence[str] | None) – 要作为命中的一部分返回的存储字段列表。如果未指定任何字段，则响应中不包含任何存储字段。如果指定此字段，则 _source 参数默认为 false。

version (int | None) – 用于并发控制的显式版本号。指定的版本必须与文档的当前版本匹配，请求才能成功。

version_type (Literal['external', 'external_gte', 'force', 'internal'] | str | None) – 特定版本类型：external、external_gte。

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

返回类型:

HeadApiResponse

exists_source(*, index, id, error_trace=None, filter_path=None, human=None, preference=None, pretty=None, realtime=None, refresh=None, routing=None, source=None, source_excludes=None, source_includes=None, version=None, version_type=None)

返回有关文档源是否存在于索引中的信息。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/docs-get.html

参数:

index (str) – 数据流、索引和别名的逗号分隔列表。支持通配符 (*).

id (str) – 文档的标识符。

preference (str | None) – 指定应执行操作的节点或分片。默认情况下为随机。

realtime (bool | None) – 如果为 true，则请求是实时的，而不是近实时的。

refresh (bool | None) – 如果为 true，则 Elasticsearch 在请求完成后刷新参与按查询删除的所有分片。

routing (str | None) – 针对指定的初级分片。

source (bool | str | Sequence[str] | None) – 返回 _source 字段的 true 或 false，或要返回的字段列表。

source_excludes (str | Sequence[str] | None) – 要在响应中排除的源字段的逗号分隔列表。

source_includes (str | Sequence[str] | None) – 要包含在响应中的源字段的逗号分隔列表。

version (int | None) – 用于并发控制的显式版本号。指定的版本必须与文档的当前版本匹配，请求才能成功。

version_type (Literal['external', 'external_gte', 'force', 'internal'] | str | None) – 特定版本类型：external、external_gte。

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

返回类型:

HeadApiResponse

explain(*, index, id, analyze_wildcard=None, analyzer=None, default_operator=None, df=None, error_trace=None, filter_path=None, human=None, lenient=None, preference=None, pretty=None, q=None, query=None, routing=None, source=None, source_excludes=None, source_includes=None, stored_fields=None, body=None)

返回有关特定文档匹配（或不匹配）查询的原因的信息。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/search-explain.html

参数:

index (str) – 用于限制请求的索引名称。此参数只能提供单个索引名称。

id (str) – 定义文档 ID。

analyze_wildcard (bool | None) – 如果为 true，则分析通配符和前缀查询。

analyzer (str | None) – 用于查询字符串的分析器。此参数只能在指定 q 查询字符串参数时使用。

default_operator (Literal['and', 'or'] | str | None) – 查询字符串查询的默认运算符：AND 或 OR。

df (str | None) – 用作默认值的字段，在查询字符串中没有字段前缀。

lenient (bool | None) – 如果为 true，则会忽略查询字符串中基于格式的查询失败（例如，向数字字段提供文本）。

preference (str | None) – 指定应执行操作的节点或分片。默认情况下为随机。

q (str | None) – Lucene 查询字符串语法中的查询。

query (Mapping[str, Any] | None) – 使用 Query DSL 定义搜索定义。

routing (str | None) – 用于将操作路由到特定分片的自定义值。

source (bool | str | Sequence[str] | None) – True 或 false 表示是否返回 _source 字段，或返回字段列表。

source_excludes (str | Sequence[str] | None) – 要从响应中排除的源字段的逗号分隔列表。

source_includes (str | Sequence[str] | None) – 要包含在响应中的源字段的逗号分隔列表。

stored_fields (str | Sequence[str] | None) – 逗号分隔的存储字段列表，将在响应中返回。

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

body (Dict[str, Any] | None)

返回类型:

ObjectApiResponse[Any]

field_caps(*, index=None, allow_no_indices=None, error_trace=None, expand_wildcards=None, fields=None, filter_path=None, filters=None, human=None, ignore_unavailable=None, include_empty_fields=None, include_unmapped=None, index_filter=None, pretty=None, runtime_mappings=None, types=None, body=None)

返回有关多个索引中字段功能的信息。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/search-field-caps.html

参数:

index (str | Sequence[str] | None) – 逗号分隔的数据流、索引和别名列表，用于限制请求。支持通配符 (*)。要定位所有数据流和索引，请省略此参数或使用 * 或 _all。

allow_no_indices (bool | None) – 如果为 false，则如果任何通配符表达式、索引别名或 _all 值仅针对缺少的或关闭的索引，则请求将返回错误。即使请求针对其他打开的索引，此行为也适用。例如，如果索引以 foo 开头，但没有索引以 bar 开头，则针对 foo*,bar* 的请求将返回错误。

expand_wildcards (Sequence[Literal['all', 'closed', 'hidden', 'none', 'open'] | str] | ~typing.Literal['all', 'closed', 'hidden', 'none', 'open'] | str | None) – 通配符模式可以匹配的索引类型。如果请求可以定位数据流，则此参数决定通配符表达式是否匹配隐藏的数据流。支持逗号分隔的值，例如 open,hidden。

fields (str | Sequence[str] | None) – 要检索功能的字段列表。支持通配符 (*) 表达式。

filters (str | None) – 一组可选的过滤器：可以包括 +metadata,-metadata,-nested,-multifield,-parent

ignore_unavailable (bool | None) – 如果为 true，则响应中不包含缺少的或关闭的索引。

include_empty_fields (bool | None) – 如果为 false，则响应中不包含空字段。

include_unmapped (bool | None) – 如果为 true，则响应中将包含未映射的字段。

index_filter (Mapping[str, Any] | None) – 如果提供的查询重写为在每个分片上匹配 none，则允许过滤索引。

runtime_mappings (Mapping[str, Mapping[str, Any]] | None) – 在请求中定义临时运行时字段，类似于在搜索请求中执行的方式。这些字段仅作为查询的一部分存在，并优先于在索引映射中定义的具有相同名称的字段。

types (Sequence[str] | None) – 仅返回列表中包含其中一种类型的字段的结果

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

body (Dict[str, Any] | None)

返回类型:

ObjectApiResponse[Any]

get(*, index, id, error_trace=None, filter_path=None, force_synthetic_source=None, human=None, preference=None, pretty=None, realtime=None, refresh=None, routing=None, source=None, source_excludes=None, source_includes=None, stored_fields=None, version=None, version_type=None)

返回一个文档。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/docs-get.html

参数:

index (str) – 包含文档的索引名称。

id (str) – 文档的唯一标识符。

force_synthetic_source (bool | None) – 此请求是否强制使用合成 _source？使用此选项测试映射是否支持合成 _source，并了解最坏情况下的性能。启用此选项的获取操作将比在索引中启用合成 _source 慢。

preference (str | None) – 指定应执行操作的节点或分片。默认情况下为随机。

realtime (bool | None) – 如果为 true，则请求是实时的，而不是近实时的。

refresh (bool | None) – 如果为真，Elasticsearch 将刷新受影响的分片，使此操作对搜索可见。如果为假，则不刷新。

routing (str | None) – 针对指定的初级分片。

source (bool | str | Sequence[str] | None) – 返回 _source 字段，值为真或假，或要返回的字段列表。

source_excludes (str | Sequence[str] | None) – 要在响应中排除的源字段的逗号分隔列表。

source_includes (str | Sequence[str] | None) – 要包含在响应中的源字段的逗号分隔列表。

stored_fields (str | Sequence[str] | None) – 要作为命中的一部分返回的存储字段列表。如果未指定任何字段，则响应中不包含任何存储字段。如果指定此字段，则 _source 参数默认为 false。

version (int | None) – 用于并发控制的显式版本号。指定的版本必须与文档的当前版本匹配，请求才能成功。

version_type (Literal['external', 'external_gte', 'force', 'internal'] | str | None) – 特定的版本类型：internal、external、external_gte。

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

返回类型:

ObjectApiResponse[Any]

get_script(*, id, error_trace=None, filter_path=None, human=None, master_timeout=None, pretty=None)

返回一个脚本。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/modules-scripting.html

参数:

id (str) – 存储的脚本或搜索模板的标识符。

master_timeout (Literal[-1] | ~typing.Literal[0] | str | None) – 指定连接到主节点的超时时间

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

返回类型:

ObjectApiResponse[Any]

get_script_context(*, error_trace=None, filter_path=None, human=None, pretty=None)

返回所有脚本上下文。

https://elastic.ac.cn/guide/en/elasticsearch/painless/8.14/painless-contexts.html

参数:

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

返回类型:

ObjectApiResponse[Any]

get_script_languages(*, error_trace=None, filter_path=None, human=None, pretty=None)

返回可用的脚本类型、语言和上下文

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/modules-scripting.html

参数:

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

返回类型:

ObjectApiResponse[Any]

get_source(*, index, id, error_trace=None, filter_path=None, human=None, preference=None, pretty=None, realtime=None, refresh=None, routing=None, source=None, source_excludes=None, source_includes=None, stored_fields=None, version=None, version_type=None)

返回文档的源代码。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/docs-get.html

参数:

index (str) – 包含文档的索引名称。

id (str) – 文档的唯一标识符。

preference (str | None) – 指定应执行操作的节点或分片。默认情况下为随机。

realtime (bool | None) – 布尔值) 如果为真，则请求为实时请求，而不是近实时请求。

refresh (bool | None) – 如果为真，Elasticsearch 将刷新受影响的分片，使此操作对搜索可见。如果为假，则不刷新。

routing (str | None) – 针对指定的初级分片。

source (bool | str | Sequence[str] | None) – 返回 _source 字段，值为真或假，或要返回的字段列表。

source_excludes (str | Sequence[str] | None) – 要在响应中排除的源字段的逗号分隔列表。

source_includes (str | Sequence[str] | None) – 要包含在响应中的源字段的逗号分隔列表。

stored_fields (str | Sequence[str] | None)

version (int | None) – 用于并发控制的显式版本号。指定的版本必须与文档的当前版本匹配，请求才能成功。

version_type (Literal['external', 'external_gte', 'force', 'internal'] | str | None) – 特定的版本类型：internal、external、external_gte。

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

返回类型:

ObjectApiResponse[Any]

health_report(*, feature=None, error_trace=None, filter_path=None, human=None, pretty=None, size=None, timeout=None, verbose=None)

返回集群的健康状况。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/health-api.html

参数:

feature (str | Sequence[str] | None) – 集群的特性，由顶级健康报告 API 返回。

size (int | None) – 限制健康报告 API 返回的受影响资源数量。

timeout (Literal[-1] | ~typing.Literal[0] | str | None) – 显式操作超时。

verbose (bool | None) – 选择更多关于系统健康的信息。

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

返回类型:

ObjectApiResponse[Any]

index(*, index, document=None, body=None, id=None, error_trace=None, filter_path=None, human=None, if_primary_term=None, if_seq_no=None, op_type=None, pipeline=None, pretty=None, refresh=None, require_alias=None, routing=None, timeout=None, version=None, version_type=None, wait_for_active_shards=None)

在索引中创建或更新文档。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/docs-index_.html

参数:

index (str) – 要目标的数据流或索引的名称。

document (Mapping[str, Any] | None)

id (str | None) – 文档的唯一标识符。

if_primary_term (int | None) – 仅在文档具有此主项时执行操作。

if_seq_no (int | None) – 仅在文档具有此序列号时执行操作。

op_type (Literal['create', 'index'] | str | None) – 设置为 create 仅在文档不存在时索引文档（如果不存在则放入）。如果具有指定 _id 的文档已存在，则索引操作将失败。与使用 <index>/_create 端点相同。有效值：index、create。如果指定了文档 ID，则默认为 index。否则，默认为 create。

pipeline (str | None) – 要用于预处理传入文档的管道的 ID。如果索引指定了默认的摄取管道，则将值设置为 _none 将为该请求禁用默认的摄取管道。如果配置了最终管道，它将始终运行，无论此参数的值如何。

refresh (Literal['false', 'true', 'wait_for'] | bool | str | None) – 如果为 true，Elasticsearch 将刷新受影响的分片以使此操作对搜索可见，如果为 wait_for，则等待刷新以使此操作对搜索可见，如果为 false，则不执行刷新操作。有效值：true、false、wait_for。

require_alias (bool | None) – 如果为 true，则目标必须是索引别名。

routing (str | None) – 用于将操作路由到特定分片的自定义值。

timeout (Literal[-1] | ~typing.Literal[0] | str | None) – 请求等待以下操作的时间段：自动索引创建、动态映射更新、等待活动分片。

version (int | None) – 用于并发控制的显式版本号。指定的版本必须与文档的当前版本匹配，请求才能成功。

version_type (Literal['external', 'external_gte', 'force', 'internal'] | str | None) – 特定版本类型：external、external_gte。

wait_for_active_shards (int | Literal['all', 'index-setting'] | str | None) – 在继续操作之前必须处于活动状态的分片副本数量。设置为所有或任何正整数，直到索引中的分片总数 (number_of_replicas+1)。

body (Mapping[str, Any] | None)

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

返回类型:

ObjectApiResponse[Any]

info(*, error_trace=None, filter_path=None, human=None, pretty=None)

返回有关集群的基本信息。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/index.html

参数:

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

返回类型:

ObjectApiResponse[Any]

knn_search(*, index, knn=None, docvalue_fields=None, error_trace=None, fields=None, filter=None, filter_path=None, human=None, pretty=None, routing=None, source=None, stored_fields=None, body=None)

执行 kNN 搜索。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/search-search.html

参数:

index (str | Sequence[str]) – 要搜索的索引名称的逗号分隔列表；使用 _all 或对所有索引执行操作

knn (Mapping[str, Any] | None) – 要执行的 kNN 查询

docvalue_fields (Sequence[Mapping[str, Any]] | None) – 该请求返回与响应的 hits.fields 属性中这些模式匹配的字段名称的文档值。接受通配符 (*) 模式。

fields (str | Sequence[str] | None) – 该请求返回与响应的 hits.fields 属性中这些模式匹配的字段名称的值。接受通配符 (*) 模式。

filter (Mapping[str, Any] | Sequence[Mapping[str, Any]] | None) – 查询以过滤可以匹配的文档。kNN 搜索将返回也匹配此过滤器的最顶部的 k 个文档。该值可以是单个查询或查询列表。如果未提供 filter，则允许所有文档匹配。

routing (str | None) – 逗号分隔的特定路由值的列表

source (bool | Mapping[str, Any] | None) – 指示为匹配的文档返回哪些源字段。这些字段在搜索响应的 hits._source 属性中返回。

stored_fields (str | Sequence[str] | None) – 要作为命中结果的一部分返回的存储字段列表。如果未指定任何字段，则响应中不包含任何存储字段。如果指定了此字段，则_source参数默认为false。您可以传递_source: true以在搜索响应中返回源字段和存储字段。

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

body (Dict[str, Any] | None)

返回类型:

ObjectApiResponse[Any]

mget(*, index=None, docs=None, error_trace=None, filter_path=None, force_synthetic_source=None, human=None, ids=None, preference=None, pretty=None, realtime=None, refresh=None, routing=None, source=None, source_excludes=None, source_includes=None, stored_fields=None, body=None)

允许在一个请求中获取多个文档。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/docs-multi-get.html

参数:

index (str | None) – 当指定了ids或当docs数组中的文档未指定索引时，要从中检索文档的索引名称。

docs (Sequence[Mapping[str, Any]] | None) – 您要检索的文档。如果请求 URI 中未指定索引，则需要此参数。

force_synthetic_source (bool | None) – 此请求是否强制使用合成 _source？使用此选项测试映射是否支持合成 _source，并了解最坏情况下的性能。启用此选项的获取操作将比在索引中启用合成 _source 慢。

ids (str | Sequence[str] | None) – 您要检索的文档的 ID。当请求 URI 中指定了索引时允许使用。

preference (str | None) – 指定应执行操作的节点或分片。默认情况下为随机。

realtime (bool | None) – 如果为 true，则请求是实时的，而不是近实时的。

refresh (bool | None) – 如果为true，则请求在检索文档之前刷新相关分片。

routing (str | None) – 用于将操作路由到特定分片的自定义值。

source (bool | str | Sequence[str] | None) – True 或 false 表示是否返回 _source 字段，或返回字段列表。

source_excludes (str | Sequence[str] | None) – 要从响应中排除的源字段的逗号分隔列表。您也可以使用此参数从_source_includes查询参数中指定的子集中排除字段。

source_includes (str | Sequence[str] | None) – 要包含在响应中的源字段的逗号分隔列表。如果指定了此参数，则仅返回这些源字段。您可以使用_source_excludes查询参数从该子集中排除字段。如果_source参数为false，则忽略此参数。

stored_fields (str | Sequence[str] | None) – 如果为true，则检索存储在索引中的文档字段，而不是文档_source。

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

body (Dict[str, Any] | None)

返回类型:

ObjectApiResponse[Any]

msearch(*, searches=None, body=None, index=None, allow_no_indices=None, ccs_minimize_roundtrips=None, error_trace=None, expand_wildcards=None, filter_path=None, human=None, ignore_throttled=None, ignore_unavailable=None, max_concurrent_searches=None, max_concurrent_shard_requests=None, pre_filter_shard_size=None, pretty=None, rest_total_hits_as_int=None, routing=None, search_type=None, typed_keys=None)

允许在一个请求中执行多个搜索操作。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/search-multi-search.html

参数:

searches (Sequence[Mapping[str, Any]] | None)

index (str | Sequence[str] | None) – 要搜索的数据流、索引和索引别名的逗号分隔列表。

allow_no_indices (bool | None) – 如果为 false，则如果任何通配符表达式、索引别名或 _all 值仅针对缺少的或关闭的索引，则请求将返回错误。即使请求针对其他打开的索引，此行为也适用。例如，如果索引以 foo 开头，但没有索引以 bar 开头，则针对 foo*,bar* 的请求将返回错误。

ccs_minimize_roundtrips (bool | None) – 如果为 true，则对于跨集群搜索请求，协调节点和远程集群之间的网络往返次数将降至最低。

expand_wildcards (Sequence[Literal['all', 'closed', 'hidden', 'none', 'open'] | str] | ~typing.Literal['all', 'closed', 'hidden', 'none', 'open'] | str | None) – 通配符表达式可以匹配的索引类型。如果请求可以针对数据流，则此参数确定通配符表达式是否匹配隐藏的数据流。

ignore_throttled (bool | None) – 如果为 true，则在冻结时忽略具体、扩展或别名索引。

ignore_unavailable (bool | None) – 如果为 true，则响应中不包含缺少的或关闭的索引。

max_concurrent_searches (int | None) – 多搜索 API 可以执行的并发搜索的最大数量。

max_concurrent_shard_requests (int | None) – 每个子搜索请求在每个节点上执行的并发分片请求的最大数量。

pre_filter_shard_size (int | None) – 定义一个阈值，如果搜索请求扩展到的分片数量超过该阈值，则强制执行预过滤往返以根据查询重写预过滤搜索分片。如果例如分片无法根据其重写方法匹配任何文档（例如，如果日期过滤器是匹配的必需条件，但分片边界和查询是不相交的），则此过滤往返可以显着限制分片数量。

rest_total_hits_as_int (bool | None) – 如果为真，则在响应中将 hits.total 返回为整数。默认为 false，它返回一个对象。

routing (str | None) – 用于将搜索操作路由到特定分片的自定义路由值。

search_type (Literal['dfs_query_then_fetch', 'query_then_fetch'] | str | None) – 指示在对返回的文档进行评分时是否应使用全局词项和文档频率。

typed_keys (bool | None) – 指定在响应中是否应在其各自类型之前添加聚合和建议器名称。

body (Sequence[Mapping[str, Any]] | None)

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

返回类型:

ObjectApiResponse[Any]

msearch_template(*, search_templates=None, body=None, index=None, ccs_minimize_roundtrips=None, error_trace=None, filter_path=None, human=None, max_concurrent_searches=None, pretty=None, rest_total_hits_as_int=None, search_type=None, typed_keys=None)

允许在一个请求中执行多个搜索模板操作。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/search-multi-search.html

参数:

search_templates (Sequence[Mapping[str, Any]] | None)

index (str | Sequence[str] | None) – 要搜索的数据流、索引和别名的逗号分隔列表。支持通配符 (*)。要搜索所有数据流和索引，请省略此参数或使用 *。

ccs_minimize_roundtrips (bool | None) – 如果为 true，则会为跨集群搜索请求最小化网络往返次数。

max_concurrent_searches (int | None) – API 可以运行的并发搜索的最大数量。

rest_total_hits_as_int (bool | None) – 如果为 true，则响应将返回 hits.total 作为整数。如果为 false，则它将返回 hits.total 作为对象。

search_type (Literal['dfs_query_then_fetch', 'query_then_fetch'] | str | None) – 搜索操作的类型。可用选项：query_then_fetch、dfs_query_then_fetch。

typed_keys (bool | None) – 如果为 true，则响应将使用其各自类型为聚合和建议器名称添加前缀。

body (Sequence[Mapping[str, Any]] | None)

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

返回类型:

ObjectApiResponse[Any]

mtermvectors(*, index=None, docs=None, error_trace=None, field_statistics=None, fields=None, filter_path=None, human=None, ids=None, offsets=None, payloads=None, positions=None, preference=None, pretty=None, realtime=None, routing=None, term_statistics=None, version=None, version_type=None, body=None)

在一个请求中返回多个词项向量。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/docs-multi-termvectors.html

参数:

index (str | None) – 包含文档的索引名称。

docs (Sequence[Mapping[str, Any]] | None) – 现有或人工文档的数组。

field_statistics (bool | None) – 如果为 true，则响应将包含文档计数、文档频率总和以及总词项频率总和。

fields (str | Sequence[str] | None) – 要包含在统计信息中的字段的逗号分隔列表或通配符表达式。用作默认列表，除非在 completion_fields 或 fielddata_fields 参数中提供了特定字段列表。

ids (Sequence[str] | None) – 如果它们在同一个索引中，则使用简化语法通过其 ID 指定文档。

offsets (bool | None) – 如果为 true，则响应将包含词项偏移量。

payloads (bool | None) – 如果为 true，则响应将包含词项有效负载。

positions (bool | None) – 如果为 true，则响应将包含词项位置。

preference (str | None) – 指定应执行操作的节点或分片。默认情况下为随机。

realtime (bool | None) – 如果为 true，则请求是实时的，而不是近实时的。

routing (str | None) – 用于将操作路由到特定分片的自定义值。

term_statistics (bool | None) – 如果为 true，则响应将包含词项频率和文档频率。

version (int | None) – 如果为 true，则将文档版本作为命中的一部分返回。

version_type (Literal['external', 'external_gte', 'force', 'internal'] | str | None) – 特定的版本类型。

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

body (Dict[str, Any] | None)

返回类型:

ObjectApiResponse[Any]

open_point_in_time(*, index, keep_alive, error_trace=None, expand_wildcards=None, filter_path=None, human=None, ignore_unavailable=None, preference=None, pretty=None, routing=None)

打开一个时间点，可以在后续搜索中使用

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/point-in-time-api.html

参数:

index (str | Sequence[str]) – 要打开时间点的索引名称的逗号分隔列表；使用 _all 或空字符串对所有索引执行操作

keep_alive (Literal[-1] | ~typing.Literal[0] | str) – 扩展相应时间点的生存时间。

expand_wildcards (Sequence[Literal['all', 'closed', 'hidden', 'none', 'open'] | str] | ~typing.Literal['all', 'closed', 'hidden', 'none', 'open'] | str | None) – 通配符模式可以匹配的索引类型。如果请求可以针对数据流，则此参数确定通配符表达式是否匹配隐藏的数据流。支持逗号分隔的值，例如 open,hidden。有效值为：all、open、closed、hidden、none。

ignore_unavailable (bool | None) – 如果为 false，则如果请求定位到丢失或关闭的索引，则返回错误。

preference (str | None) – 指定应执行操作的节点或分片。默认情况下为随机。

routing (str | None) – 用于将操作路由到特定分片的自定义值。

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

返回类型:

ObjectApiResponse[Any]

ping(*, error_trace=None, filter_path=None, human=None, pretty=None)

如果从 info() API 返回成功响应，则返回 True，否则返回 False。此 API 调用可能会在传输层（由于连接错误或超时）或非 2XX HTTP 响应（由于身份验证或授权问题）失败。

如果您想了解请求失败的原因，您应该使用 info() API。

https://elastic.ac.cn/guide/en/elasticsearch/reference/current/index.html

参数:

error_trace (bool | None)

filter_path (List[str] | str | None)

human (bool | None)

pretty (bool | None)

返回类型:

bool

put_script(*, id, script=None, context=None, error_trace=None, filter_path=None, human=None, master_timeout=None, pretty=None, timeout=None, body=None)

创建或更新脚本。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/modules-scripting.html

参数:

id (str) – 存储脚本或搜索模板的标识符。在集群中必须唯一。

script (Mapping[str, Any] | None) – 包含脚本或搜索模板、其参数及其语言。

context (str | None) – 脚本或搜索模板应该运行的上下文。为了防止错误，API 会立即在此上下文中编译脚本或模板。

master_timeout (Literal[-1] | ~typing.Literal[0] | str | None) – 等待连接到主节点的时间段。如果在超时时间到期之前没有收到响应，则请求失败并返回错误。

timeout (Literal[-1] | ~typing.Literal[0] | str | None) – 等待响应的时间段。如果在超时时间到期之前没有收到响应，则请求失败并返回错误。

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

body (Dict[str, Any] | None)

返回类型:

ObjectApiResponse[Any]

rank_eval(*, requests=None, index=None, allow_no_indices=None, error_trace=None, expand_wildcards=None, filter_path=None, human=None, ignore_unavailable=None, metric=None, pretty=None, search_type=None, body=None)

允许评估一组典型搜索查询的排名搜索结果的质量

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/search-rank-eval.html

参数:

requests (Sequence[Mapping[str, Any]] | None) – 一组典型的搜索请求，以及它们提供的评分。

index (str | Sequence[str] | None) – 用于限制请求的数据流、索引和索引别名的逗号分隔列表。支持通配符 (*) 表达式。要定位集群中的所有数据流和索引，请省略此参数或使用 _all 或 *。

allow_no_indices (bool | None) – 如果为 false，则如果任何通配符表达式、索引别名或 _all 值仅针对缺失或关闭的索引，则请求将返回错误。即使请求针对其他打开的索引，此行为也适用。例如，如果索引以 foo 开头，但没有索引以 bar 开头，则针对 foo*,bar* 的请求将返回错误。

expand_wildcards (Sequence[Literal['all', 'closed', 'hidden', 'none', 'open'] | str] | ~typing.Literal['all', 'closed', 'hidden', 'none', 'open'] | str | None) – 是否将通配符表达式扩展到打开、关闭或两者兼有的具体索引。

ignore_unavailable (bool | None) – 如果为 true，则响应中不包含缺少的或关闭的索引。

metric (Mapping[str, Any] | None) – 要计算的评估指标的定义。

search_type (str | None) – 搜索操作类型

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

body (Dict[str, Any] | None)

返回类型:

ObjectApiResponse[Any]

reindex(*, dest=None, source=None, conflicts=None, error_trace=None, filter_path=None, human=None, max_docs=None, pretty=None, refresh=None, requests_per_second=None, require_alias=None, script=None, scroll=None, size=None, slices=None, timeout=None, wait_for_active_shards=None, wait_for_completion=None, body=None)

允许将文档从一个索引复制到另一个索引，可以选择通过查询过滤源文档，更改目标索引设置，或从远程集群获取文档。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/docs-reindex.html

参数:

dest (Mapping[str, Any] | None) – 您要复制到的目标。

source (Mapping[str, Any] | None) – 您要复制的源。

conflicts (Literal['abort', 'proceed'] | str | None) – 设置为继续以继续重新索引，即使存在冲突。

max_docs (int | None) – 要重新索引的最大文档数。

refresh (bool | None) – 如果为 true，则请求刷新受影响的分片以使此操作对搜索可见。

requests_per_second (float | None) – 此请求的节流，以每秒子请求数表示。默认为无节流。

require_alias (bool | None) – 如果为 true，则目标必须是索引别名。

script (Mapping[str, Any] | None) – 在重新索引时运行以更新文档源或元数据的脚本。

scroll (Literal[-1] | ~typing.Literal[0] | str | None) – 指定应为滚动搜索维护索引一致视图的时间长度。

size (int | None)

slices (int | Literal['auto'] | str | None) – 此任务应划分的切片数。默认为 1 个切片，这意味着任务不会被切分成子任务。

timeout (Literal[-1] | ~typing.Literal[0] | str | None) – 每个索引等待自动索引创建、动态映射更新和等待活动分片的时间段。

wait_for_active_shards (int | Literal['all', 'index-setting'] | str | None) – 在继续操作之前必须处于活动状态的分片副本数量。设置为 all 或任何正整数，直到索引中的分片总数 (number_of_replicas+1)。

wait_for_completion (bool | None) – 如果为 true，则请求将阻塞，直到操作完成。

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

body (Dict[str, Any] | None)

返回类型:

ObjectApiResponse[Any]

reindex_rethrottle(*, task_id, error_trace=None, filter_path=None, human=None, pretty=None, requests_per_second=None)

更改特定重新索引操作的每秒请求数。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/docs-reindex.html

参数:

task_id (str) – 任务的标识符。

requests_per_second (float | None) – 此请求的节流，以每秒子请求数表示。

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

返回类型:

ObjectApiResponse[Any]

render_search_template(*, id=None, error_trace=None, file=None, filter_path=None, human=None, params=None, pretty=None, source=None, body=None)

允许使用 Mustache 语言预渲染搜索定义。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/render-search-template-api.html

参数:

id (str | None) – 要渲染的搜索模板的 ID。如果未指定 source，则需要此参数或 id 请求正文参数。

file (str | None)

params (Mapping[str, Any] | None) – 用于替换模板中 Mustache 变量的键值对。键是变量名。值是变量值。

source (str | None) – 内联搜索模板。支持与搜索 API 的请求正文相同的参数。这些参数也支持 Mustache 变量。如果未指定 id 或 <templated-id>，则需要此参数。

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

body (Dict[str, Any] | None)

返回类型:

ObjectApiResponse[Any]

scripts_painless_execute(*, context=None, context_setup=None, error_trace=None, filter_path=None, human=None, pretty=None, script=None, body=None)

允许执行任意脚本并返回结果

https://elastic.ac.cn/guide/en/elasticsearch/painless/8.14/painless-execute-api.html

参数:

context (str | None) – 脚本应在其中运行的上下文。

context_setup (Mapping[str, Any] | None) – context 的附加参数。

script (Mapping[str, Any] | None) – 要执行的 Painless 脚本。

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

body (Dict[str, Any] | None)

返回类型:

ObjectApiResponse[Any]

scroll(*, scroll_id=None, error_trace=None, filter_path=None, human=None, pretty=None, rest_total_hits_as_int=None, scroll=None, body=None)

允许从单个搜索请求中检索大量结果。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/search-request-body.html#request-body-search-scroll

参数:

scroll_id (str | None) – 搜索的滚动 ID。

rest_total_hits_as_int (bool | None) – 如果为真，API 响应的 hit.total 属性将作为整数返回。如果为假，API 响应的 hit.total 属性将作为对象返回。

scroll (Literal[-1] | ~typing.Literal[0] | str | None) – 保留滚动搜索上下文的期限。

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

body (Dict[str, Any] | None)

返回类型:

ObjectApiResponse[Any]

search(*, index=None, aggregations=None, aggs=None, allow_no_indices=None, allow_partial_search_results=None, analyze_wildcard=None, analyzer=None, batched_reduce_size=None, ccs_minimize_roundtrips=None, collapse=None, default_operator=None, df=None, docvalue_fields=None, error_trace=None, expand_wildcards=None, explain=None, ext=None, fields=None, filter_path=None, force_synthetic_source=None, from_=None, highlight=None, human=None, ignore_throttled=None, ignore_unavailable=None, indices_boost=None, knn=None, lenient=None, max_concurrent_shard_requests=None, min_compatible_shard_node=None, min_score=None, pit=None, post_filter=None, pre_filter_shard_size=None, preference=None, pretty=None, profile=None, q=None, query=None, rank=None, request_cache=None, rescore=None, rest_total_hits_as_int=None, retriever=None, routing=None, runtime_mappings=None, script_fields=None, scroll=None, search_after=None, search_type=None, seq_no_primary_term=None, size=None, slice=None, sort=None, source=None, source_excludes=None, source_includes=None, stats=None, stored_fields=None, suggest=None, suggest_field=None, suggest_mode=None, suggest_size=None, suggest_text=None, terminate_after=None, timeout=None, track_scores=None, track_total_hits=None, typed_keys=None, version=None, body=None)

返回与查询匹配的结果。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/search-search.html

参数:

index (str | Sequence[str] | None) – 要搜索的数据流、索引和别名的逗号分隔列表。支持通配符 (*)。要搜索所有数据流和索引，请省略此参数或使用 * 或 _all。

聚合 (Mapping[str, Mapping[str, Any]] | None) – 定义作为搜索请求的一部分运行的聚合。

aggs (Mapping[str, Mapping[str, Any]] | None) – 定义作为搜索请求的一部分运行的聚合。

allow_no_indices (bool | None) – 如果为 false，则如果任何通配符表达式、索引别名或 _all 值仅针对缺失或关闭的索引，则请求将返回错误。即使请求针对其他打开的索引，此行为也适用。例如，如果索引以 foo 开头，但没有索引以 bar 开头，则针对 foo*,bar* 的请求将返回错误。

allow_partial_search_results (bool | None) – 如果为真，则在存在分片请求超时或分片故障时返回部分结果。如果为假，则返回错误，没有部分结果。

analyze_wildcard (bool | None) – 如果为真，则分析通配符和前缀查询。此参数只能在指定 q 查询字符串参数时使用。

analyzer (str | None) – 用于查询字符串的分析器。此参数只能在指定 q 查询字符串参数时使用。

batched_reduce_size (int | None) – 在协调节点上一次应减少的分片结果数量。如果请求中潜在的分片数量可能很大，则应使用此值作为保护机制来减少每个搜索请求的内存开销。

ccs_minimize_roundtrips (bool | None) – 如果为真，则在执行跨集群搜索 (CCS) 请求时，将最大程度地减少协调节点与远程集群之间的网络往返次数。

collapse (Mapping[str, Any] | None) – 将搜索结果折叠到指定字段的值。

default_operator (Literal['and', 'or'] | str | None) – 查询字符串查询的默认运算符：AND 或 OR。此参数只能在指定 q 查询字符串参数时使用。

df (str | None) – 用作默认字段，在查询字符串中没有给出字段前缀的地方。此参数只能在指定 q 查询字符串参数时使用。

docvalue_fields (Sequence[Mapping[str, Any]] | None) – 通配符 (*) 模式的数组。请求在响应的 hits.fields 属性中返回与这些模式匹配的字段名称的文档值。

expand_wildcards (Sequence[Literal['all', 'closed', 'hidden', 'none', 'open'] | str] | ~typing.Literal['all', 'closed', 'hidden', 'none', 'open'] | str | None) – 通配符模式可以匹配的索引类型。如果请求可以定位数据流，则此参数决定通配符表达式是否匹配隐藏的数据流。支持逗号分隔的值，例如 open,hidden。

explain (bool | None) – 如果为真，则返回有关作为命中的一部分的评分计算的详细信息。

ext (Mapping[str, Any] | None) – 由 Elasticsearch 插件定义的搜索扩展的配置。

fields (Sequence[Mapping[str, Any]] | None) – 通配符 (*) 模式的数组。请求在响应的 hits.fields 属性中返回与这些模式匹配的字段名称的值。

force_synthetic_source (bool | None) – 此请求是否强制使用合成 _source？使用此选项测试映射是否支持合成 _source，并了解最坏情况下的性能。启用此选项的获取操作将比在索引中启用合成 _source 慢。

from – 起始文档偏移量。需要是非负数。默认情况下，您无法使用 from 和 size 参数翻页超过 10,000 个命中。要翻页更多命中，请使用 search_after 参数。

highlight (Mapping[str, Any] | None) – 指定用于从搜索结果中的一个或多个字段检索突出显示的片段的突出显示器。

ignore_throttled (bool | None) – 如果为 true，则在冻结时将忽略具体、扩展或别名索引。

ignore_unavailable (bool | None) – 如果为 false，则如果请求定位到丢失或关闭的索引，则返回错误。

indices_boost (Sequence[Mapping[str, float]] | None) – 提升来自指定索引的文档的 _score。

knn (Mapping[str, Any] | Sequence[Mapping[str, Any]] | None) – 定义要运行的近似 kNN 搜索。

lenient (bool | None) – 如果为 true，则会忽略查询字符串中基于格式的查询失败（例如，向数字字段提供文本）。此参数只能在指定 q 查询字符串参数时使用。

max_concurrent_shard_requests (int | None) – 定义此搜索并发执行的每个节点的并发分片请求数。应使用此值来限制搜索对集群的影响，以限制并发分片请求的数量。

min_compatible_shard_node (str | None) – 可以处理请求的节点的最低版本。任何处理节点的版本低于此版本都将导致请求失败。

min_score (float | None) – 匹配文档的最小 _score。_score 较低的文档不包含在搜索结果中。

pit (Mapping[str, Any] | None) – 将搜索限制为某个时间点 (PIT)。如果您提供 PIT，则不能在请求路径中指定 <index>。

post_filter (Mapping[str, Any] | None) – 使用 post_filter 参数过滤搜索结果。在计算聚合后过滤搜索命中。后置过滤器对聚合结果没有影响。

pre_filter_shard_size (int | None) – 定义一个阈值，如果搜索请求扩展到的分片数量超过阈值，则强制执行预过滤往返以根据查询重写预过滤搜索分片。如果例如分片无法根据其重写方法匹配任何文档（如果日期过滤器是必需的匹配项，但分片边界和查询是不相交的），则此过滤往返可以显着限制分片数量。如果满足以下任何条件，则在未指定的情况下执行预过滤阶段：请求的目标超过 128 个分片；请求的目标是一个或多个只读索引；查询的主要排序目标是索引字段。

preference (str | None) – 用于搜索的节点和分片。默认情况下，Elasticsearch 使用自适应副本选择从合格的节点和分片中选择，并考虑分配感知。有效值为：_only_local 仅在本地节点上的分片上运行搜索；_local 尽可能在本地节点上的分片上运行搜索，或者如果不行，则使用默认方法选择分片；_only_nodes:<node-id>,<node-id> 仅在指定节点 ID 上运行搜索，其中，如果在多个选定节点上存在合适的分片，则使用默认方法使用这些节点上的分片，或者如果所有指定节点都不可用，则使用默认方法从任何可用节点选择分片；_prefer_nodes:<node-id>,<node-id> 尽可能在指定节点 ID 上运行搜索，或者如果不行，则使用默认方法选择分片；_shards:<shard>,<shard> 仅在指定分片上运行搜索；<custom-string>（任何不以 _ 开头的字符串）将具有相同 <custom-string> 的搜索路由到相同分片，并按相同顺序。

profile (bool | None) – 设置为 true 以返回有关搜索请求中各个组件执行的详细计时信息。注意：这是一个调试工具，会给搜索执行带来很大的开销。

q (str | None) – 使用查询参数搜索的 Lucene 查询字符串语法中的查询。查询参数搜索不支持完整的 Elasticsearch 查询 DSL，但对于测试很有用。

query (Mapping[str, Any] | None) – 使用 Query DSL 定义搜索定义。

rank (Mapping[str, Any] | None) – 定义要使用的 Reciprocal Rank Fusion (RRF)。

request_cache (bool | None) – 如果为 true，则为 size 为 0 的请求启用搜索结果的缓存。默认为索引级别设置。

rescore (Mapping[str, Any] | Sequence[Mapping[str, Any]] | None) – 可用于通过重新排序 query 和 post_filter 阶段返回的前 (例如 100 - 500) 个文档来提高精度。

rest_total_hits_as_int (bool | None) – 指示 hits.total 应该在 rest 搜索响应中呈现为整数还是对象。

retriever (Mapping[str, Any] | None) – 检索器是描述从搜索返回的顶级文档的规范。检索器替换搜索 API 的其他元素，这些元素也返回顶级文档，例如查询和 knn。

routing (str | None) – 用于将操作路由到特定分片的自定义值。

runtime_mappings (Mapping[str, Mapping[str, Any]] | None) – 在搜索请求中定义一个或多个运行时字段。这些字段优先于具有相同名称的映射字段。

script_fields (Mapping[str, Mapping[str, Any]] | None) – 为每个命中检索脚本评估 (基于不同的字段)。

scroll (Literal[-1] | ~typing.Literal[0] | str | None) – 用于保留搜索上下文以进行滚动的周期。请参阅滚动搜索结果。默认情况下，此值不能超过 1d (24 小时)。您可以使用 search.max_keep_alive 集群级设置更改此限制。

search_after (Sequence[None | bool | float | int | str | Any] | None) – 用于使用上一页的排序值集检索下一页命中。

search_type (Literal['dfs_query_then_fetch', 'query_then_fetch'] | str | None) – 如何为相关性评分计算分布式词频。

seq_no_primary_term (bool | None) – 如果为 true，则返回每个命中的最后修改的序列号和主项。

size (int | None) – 要返回的命中数。默认情况下，您无法使用 from 和 size 参数浏览超过 10,000 个命中。要浏览更多命中，请使用 search_after 参数。

slice (Mapping[str, Any] | None) – 可用于将滚动搜索拆分为多个可以独立使用的切片。

sort (Sequence[str | Mapping[str, Any]] | str | Mapping[str, Any] | None) – <field>:<direction> 对的逗号分隔列表。

source (bool | Mapping[str, Any] | None) – 指示为匹配的文档返回哪些源字段。这些字段在搜索响应的 hits._source 属性中返回。

source_excludes (str | Sequence[str] | None) – 要从响应中排除的源字段的逗号分隔列表。您也可以使用此参数从 _source_includes 查询参数中指定的子集中排除字段。如果 _source 参数为 false，则忽略此参数。

source_includes (str | Sequence[str] | None) – 要包含在响应中的源字段的逗号分隔列表。如果指定了此参数，则仅返回这些源字段。您可以使用_source_excludes查询参数从该子集中排除字段。如果_source参数为false，则忽略此参数。

stats (Sequence[str] | None) – 与搜索关联的统计组。每个组都为其关联的搜索维护一个统计聚合。您可以使用索引统计 API 检索这些统计信息。

stored_fields (str | Sequence[str] | None) – 作为命中的一部分返回的存储字段列表。如果未指定任何字段，则响应中不包含任何存储字段。如果指定了此字段，则 _source 参数默认为 false。您可以传递 _source: true 以在搜索响应中返回源字段和存储字段。

suggest (Mapping[str, Any] | None) – 定义一个建议器，它根据提供的文本提供类似的术语。

suggest_field (str | None) – 指定要用于建议的字段。

suggest_mode (Literal['always', 'missing', 'popular'] | str | None) – 指定建议模式。此参数只能在指定了 suggest_field 和 suggest_text 查询字符串参数时使用。

suggest_size (int | None) – 要返回的建议数。此参数只能在指定了 suggest_field 和 suggest_text 查询字符串参数时使用。

suggest_text (str | None) – 应返回建议的源文本。此参数只能在指定了 suggest_field 和 suggest_text 查询字符串参数时使用。

terminate_after (int | None) – 每个分片要收集的文档最大数量。如果查询达到此限制，Elasticsearch 会提前终止查询。Elasticsearch 会在排序之前收集文档。谨慎使用。Elasticsearch 将此参数应用于处理请求的每个分片。如果可能，让 Elasticsearch 自动执行提前终止。避免为针对跨多个数据层级跨越多个索引的数据流的请求指定此参数。如果设置为 0 (默认)，则查询不会提前终止。

timeout (str | None) – 指定等待每个分片响应的时间段。如果在超时到期之前没有收到响应，则请求失败并返回错误。默认为无超时。

track_scores (bool | None) – 如果为 true，则计算并返回文档分数，即使分数不用于排序。

track_total_hits (bool | int | None) – 用于准确计算查询匹配的命中数。如果为 true，则会以牺牲部分性能为代价返回确切的命中数。如果为 false，则响应不包含与查询匹配的总命中数。

typed_keys (bool | None) – 如果为 true，则聚合和建议器名称将在响应中以其各自的类型为前缀。

version (bool | None) – 如果为 true，则将文档版本作为命中的一部分返回。

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

from_ (int | None)

human (bool | None)

pretty (bool | None)

body (Dict[str, Any] | None)

返回类型:

ObjectApiResponse[Any]

search_mvt(*, index, field, zoom, x, y, aggs=None, buffer=None, error_trace=None, exact_bounds=None, extent=None, fields=None, filter_path=None, grid_agg=None, grid_precision=None, grid_type=None, human=None, pretty=None, query=None, runtime_mappings=None, size=None, sort=None, track_total_hits=None, with_labels=None, body=None)

搜索矢量瓦片以获取地理空间值。将结果作为二进制 Mapbox 矢量瓦片返回。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/search-vector-tile-api.html

参数:

index (str | Sequence[str]) – 要搜索的数据流、索引或别名的逗号分隔列表

field (str) – 包含要返回的地理空间数据的字段

zoom (int) – 要搜索的矢量瓦片的缩放级别

x (int) – 要搜索的矢量瓦片的 X 坐标

y (int) – 要搜索的矢量瓦片的 Y 坐标

aggs (Mapping[str, Mapping[str, Any]] | None) – geotile_grid 的子聚合。支持以下聚合类型： - avg - cardinality - max - min - sum

buffer (int | None) – 瓦片外部剪裁缓冲区的尺寸（以像素为单位）。这使渲染器能够避免几何体延伸到瓦片范围之外而产生的轮廓伪影。

exact_bounds (bool | None) – 如果为 false，则元层的功能是瓦片的边界框。如果为 true，则元层的功能是 geo_bounds 聚合产生的边界框。聚合在与 wrap_longitude 设置为 false 的 <zoom>/<x>/<y> 瓦片相交的 <field> 值上运行。生成的边界框可能大于矢量瓦片。

extent (int | None) – 瓦片一侧的尺寸（以像素为单位）。矢量瓦片是正方形，具有相等的边。

fields (str | Sequence[str] | None) – 要在 hits 层中返回的字段。支持通配符 (*)。此参数不支持具有数组值的字段。具有数组值的字段可能会返回不一致的结果。

grid_agg (Literal['geohex', 'geotile'] | str | None) – 用于为 field 创建网格的聚合。

grid_precision (int | None) – 通过 aggs 层提供的额外缩放级别。例如，如果 <zoom> 为 7 且 grid_precision 为 8，则可以放大到级别 15。接受 0-8。如果为 0，则结果不包含 aggs 层。

grid_type (Literal['centroid', 'grid', 'point'] | str | None) – 确定 aggs 层中要素的几何类型。在 aggs 层中，每个要素代表一个 geotile_grid 单元格。如果为 'grid'，则每个要素是单元格边界框的多边形。如果为 'point'，则每个要素是单元格质心的点。

query (Mapping[str, Any] | None) – 用于过滤搜索文档的查询 DSL。

runtime_mappings (Mapping[str, Mapping[str, Any]] | None) – 在搜索请求中定义一个或多个运行时字段。这些字段优先于具有相同名称的映射字段。

size (int | None) – 要在 hits 层中返回的要素最大数量。接受 0-10000。如果为 0，则结果不包含 hits 层。

sort (Sequence[str | Mapping[str, Any]] | str | Mapping[str, Any] | None) – 对 hits 层中的要素进行排序。默认情况下，API 会为每个要素计算一个边界框。它根据此框的对角线长度对要素进行排序，从最长到最短。

track_total_hits (bool | int | None) – 用于准确计算查询匹配的命中数。如果为 true，则会以牺牲部分性能为代价返回确切的命中数。如果为 false，则响应不包含与查询匹配的总命中数。

with_labels (bool | None) – 如果为 true，则 hits 和 aggs 层将包含代表原始要素的建议标签位置的额外点要素。

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

body (Dict[str, Any] | None)

返回类型:

BinaryApiResponse

search_shards(*, index=None, allow_no_indices=None, error_trace=None, expand_wildcards=None, filter_path=None, human=None, ignore_unavailable=None, local=None, preference=None, pretty=None, routing=None)

返回搜索请求将要执行的索引和分片的信息。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/search-shards.html

参数:

index (str | Sequence[str] | None) – 返回搜索请求将要执行的索引和分片。

allow_no_indices (bool | None) – 如果为 false，则如果任何通配符表达式、索引别名或 _all 值仅针对缺失或关闭的索引，则请求将返回错误。即使请求针对其他打开的索引，此行为也适用。例如，如果索引以 foo 开头，但没有索引以 bar 开头，则针对 foo*,bar* 的请求将返回错误。

expand_wildcards (Sequence[Literal['all', 'closed', 'hidden', 'none', 'open'] | str] | ~typing.Literal['all', 'closed', 'hidden', 'none', 'open'] | str | None) – 通配符模式可以匹配的索引类型。如果请求可以针对数据流，则此参数确定通配符表达式是否匹配隐藏的数据流。支持逗号分隔的值，例如 open,hidden。有效值为：all、open、closed、hidden、none。

ignore_unavailable (bool | None) – 如果为 false，则如果请求定位到丢失或关闭的索引，则返回错误。

local (bool | None) – 如果为 true，则请求仅从本地节点检索信息。

preference (str | None) – 指定应执行操作的节点或分片。默认情况下为随机。

routing (str | None) – 用于将操作路由到特定分片的自定义值。

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

返回类型:

ObjectApiResponse[Any]

search_template(*, index=None, allow_no_indices=None, ccs_minimize_roundtrips=None, error_trace=None, expand_wildcards=None, explain=None, filter_path=None, human=None, id=None, ignore_throttled=None, ignore_unavailable=None, params=None, preference=None, pretty=None, profile=None, rest_total_hits_as_int=None, routing=None, scroll=None, search_type=None, source=None, typed_keys=None, body=None)

允许使用 Mustache 语言预渲染搜索定义。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/search-template.html

参数:

index (str | Sequence[str] | None) – 要搜索的数据流、索引和别名的逗号分隔列表。支持通配符 (*)。

allow_no_indices (bool | None) – 如果为 false，则如果任何通配符表达式、索引别名或 _all 值仅针对缺失或关闭的索引，则请求将返回错误。即使请求针对其他打开的索引，此行为也适用。例如，如果索引以 foo 开头，但没有索引以 bar 开头，则针对 foo*,bar* 的请求将返回错误。

ccs_minimize_roundtrips (bool | None) – 如果为 true，则会为跨集群搜索请求最小化网络往返次数。

expand_wildcards (Sequence[Literal['all', 'closed', 'hidden', 'none', 'open'] | str] | ~typing.Literal['all', 'closed', 'hidden', 'none', 'open'] | str | None) – 通配符模式可以匹配的索引类型。如果请求可以针对数据流，则此参数确定通配符表达式是否匹配隐藏的数据流。支持逗号分隔的值，例如 open,hidden。有效值为：all、open、closed、hidden、none。

explain (bool | None) – 如果为 true，则返回有关每个命中项的评分计算的详细信息。

id (str | None) – 要使用的搜索模板的 ID。如果没有指定源，则此参数是必需的。

ignore_throttled (bool | None) – 如果为 true，则在被节流时，指定的确切、扩展或别名索引不会包含在响应中。

ignore_unavailable (bool | None) – 如果为 false，则如果请求定位到丢失或关闭的索引，则返回错误。

params (Mapping[str, Any] | None) – 用于替换模板中 Mustache 变量的键值对。键是变量名。值是变量值。

preference (str | None) – 指定应执行操作的节点或分片。默认情况下为随机。

profile (bool | None) – 如果为 true，则对查询执行进行分析。

rest_total_hits_as_int (bool | None) – 如果为 true，则 hits.total 在响应中将呈现为整数。

routing (str | None) – 用于将操作路由到特定分片的自定义值。

scroll (Literal[-1] | ~typing.Literal[0] | str | None) – 指定应为滚动搜索维护索引一致视图的时间长度。

search_type (Literal['dfs_query_then_fetch', 'query_then_fetch'] | str | None) – 搜索操作的类型。

source (str | None) – 内联搜索模板。支持与搜索 API 的请求主体相同的参数。还支持 Mustache 变量。如果没有指定 id，则此参数是必需的。

typed_keys (bool | None) – 如果为 true，则响应将使用其各自类型为聚合和建议器名称添加前缀。

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

body (Dict[str, Any] | None)

返回类型:

ObjectApiResponse[Any]

terms_enum(*, index, field=None, case_insensitive=None, error_trace=None, filter_path=None, human=None, index_filter=None, pretty=None, search_after=None, size=None, string=None, timeout=None, body=None)

terms enum API 可用于发现索引中以提供的字符串开头的术语。它专为自动完成场景中使用的低延迟查找而设计。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/search-terms-enum.html

参数:

index (str) – 要搜索的数据流、索引和索引别名的逗号分隔列表。支持通配符 (*) 表达式。

field (str | None) – 要匹配索引术语开头的字符串。如果未提供，则会考虑字段中的所有术语。

case_insensitive (bool | None) – 如果为 true，则提供的搜索字符串将与索引术语匹配，不区分大小写。

index_filter (Mapping[str, Any] | None) – 允许在提供的查询重写为 match_none 时过滤索引分片。

search_after (str | None)

size (int | None) – 要返回的匹配术语数量。

string (str | None) – 索引中应返回术语的字符串。如果将一个请求的最后一个结果作为后续请求的 search_after 参数传递，则允许进行某种形式的分页。

timeout (Literal[-1] | ~typing.Literal[0] | str | None) – 收集结果所花费的最大时间长度。默认为“1s”（一秒）。如果超时，则响应中的 complete 标志设置为 false，结果可能是部分的或为空的。

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

body (Dict[str, Any] | None)

返回类型:

ObjectApiResponse[Any]

termvectors(*, index, id=None, doc=None, error_trace=None, field_statistics=None, fields=None, filter=None, filter_path=None, human=None, offsets=None, payloads=None, per_field_analyzer=None, positions=None, preference=None, pretty=None, realtime=None, routing=None, term_statistics=None, version=None, version_type=None, body=None)

返回特定文档字段中术语的信息和统计数据。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/docs-termvectors.html

参数:

index (str) – 包含文档的索引名称。

id (str | None) – 文档的唯一标识符。

doc (Mapping[str, Any] | None) – 您想要检索术语向量的一个人工文档（索引中不存在的文档）。

field_statistics (bool | None) – 如果为 true，则响应将包含文档计数、文档频率总和以及总词项频率总和。

fields (str | Sequence[str] | None) – 要包含在统计信息中的字段的逗号分隔列表或通配符表达式。用作默认列表，除非在 completion_fields 或 fielddata_fields 参数中提供了特定字段列表。

filter (Mapping[str, Any] | None) – 根据术语的 tf-idf 分数过滤术语。

offsets (bool | None) – 如果为 true，则响应将包含词项偏移量。

payloads (bool | None) – 如果为 true，则响应将包含词项有效负载。

per_field_analyzer (Mapping[str, str] | None) – 覆盖默认的每个字段分析器。

positions (bool | None) – 如果为 true，则响应将包含词项位置。

preference (str | None) – 指定应执行操作的节点或分片。默认情况下为随机。

realtime (bool | None) – 如果为 true，则请求是实时的，而不是近实时的。

routing (str | None) – 用于将操作路由到特定分片的自定义值。

term_statistics (bool | None) – 如果为 true，则响应将包含术语频率和文档频率。

version (int | None) – 如果为 true，则将文档版本作为命中的一部分返回。

version_type (Literal['external', 'external_gte', 'force', 'internal'] | str | None) – 特定的版本类型。

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

body (Dict[str, Any] | None)

返回类型:

ObjectApiResponse[Any]

update(*, index, id, detect_noop=None, doc=None, doc_as_upsert=None, error_trace=None, filter_path=None, human=None, if_primary_term=None, if_seq_no=None, lang=None, pretty=None, refresh=None, require_alias=None, retry_on_conflict=None, routing=None, script=None, scripted_upsert=None, source=None, source_excludes=None, source_includes=None, timeout=None, upsert=None, wait_for_active_shards=None, body=None)

使用脚本或部分文档更新文档。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/docs-update.html

参数:

index (str) – 索引的名称

id (str) – 文档 ID

detect_noop (bool | None) – 设置为 false 以禁用将响应中的 ‘result’ 设置为 ‘noop’（如果文档没有发生更改）。

doc (Mapping[str, Any] | None) – 对现有文档的局部更新。

doc_as_upsert (bool | None) – 设置为 true 以使用 ‘doc’ 的内容作为 ‘upsert’ 的值

if_primary_term (int | None) – 仅在文档具有此主项时执行操作。

if_seq_no (int | None) – 仅在文档具有此序列号时执行操作。

lang (str | None) – 脚本语言。

refresh (Literal['false', 'true', 'wait_for'] | bool | str | None) – 如果为 ‘true’，Elasticsearch 将刷新受影响的分片以使此操作对搜索可见，如果为 ‘wait_for’，则等待刷新以使此操作对搜索可见，如果为 ‘false’，则不执行刷新操作。

require_alias (bool | None) – 如果为 true，则目标必须是索引别名。

retry_on_conflict (int | None) – 指定发生冲突时应重试操作的次数。

routing (str | None) – 用于将操作路由到特定分片的自定义值。

script (Mapping[str, Any] | None) – 要执行以更新文档的脚本。

scripted_upsert (bool | None) – 设置为 true 以执行脚本，无论文档是否存在。

source (bool | Mapping[str, Any] | None) – 设置为 false 以禁用源检索。您还可以指定要检索的字段的逗号分隔列表。

source_excludes (str | Sequence[str] | None) – 指定要排除的源字段。

source_includes (str | Sequence[str] | None) – 指定要检索的源字段。

timeout (Literal[-1] | ~typing.Literal[0] | str | None) – 等待动态映射更新和活动分片的超时时间。这保证 Elasticsearch 在失败之前至少等待超时时间。实际等待时间可能会更长，尤其是在发生多次等待时。

upsert (Mapping[str, Any] | None) – 如果文档不存在，则将“upsert”的内容插入为新文档。如果文档存在，则执行“script”。

wait_for_active_shards (int | Literal['all', 'index-setting'] | str | None) – 在继续执行操作之前必须处于活动状态的分片副本数量。设置为“all”或任何正整数，直到索引中的分片总数（number_of_replicas+1）。默认为 1，表示主分片。

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

body (Dict[str, Any] | None)

返回类型:

ObjectApiResponse[Any]

update_by_query(*, index, allow_no_indices=None, analyze_wildcard=None, analyzer=None, conflicts=None, default_operator=None, df=None, error_trace=None, expand_wildcards=None, filter_path=None, from_=None, human=None, ignore_unavailable=None, lenient=None, max_docs=None, pipeline=None, preference=None, pretty=None, query=None, refresh=None, request_cache=None, requests_per_second=None, routing=None, script=None, scroll=None, scroll_size=None, search_timeout=None, search_type=None, slice=None, slices=None, sort=None, stats=None, terminate_after=None, timeout=None, version=None, version_type=None, wait_for_active_shards=None, wait_for_completion=None, body=None)

更新与指定查询匹配的文档。如果未指定查询，则对索引中的每个文档执行更新，而不会更改源，例如为了获取映射更改。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/docs-update-by-query.html

参数:

index (str | Sequence[str]) – 要搜索的数据流、索引和别名的逗号分隔列表。支持通配符 (*)。要搜索所有数据流或索引，请省略此参数或使用 * 或 _all。

allow_no_indices (bool | None) – 如果为 false，则如果任何通配符表达式、索引别名或 _all 值仅针对缺失或关闭的索引，则请求将返回错误。即使请求针对其他打开的索引，此行为也适用。例如，如果索引以 foo 开头，但没有索引以 bar 开头，则针对 foo*,bar* 的请求将返回错误。

analyze_wildcard (bool | None) – 如果为 true，则分析通配符和前缀查询。

analyzer (str | None) – 用于查询字符串的分析器。

conflicts (Literal['abort', 'proceed'] | str | None) – 如果更新查询遇到版本冲突，该怎么办：abort 或 proceed。

default_operator (Literal['and', 'or'] | str | None) – 查询字符串查询的默认运算符：AND 或 OR。

df (str | None) – 用作默认值的字段，在查询字符串中没有字段前缀。

expand_wildcards (Sequence[Literal['all', 'closed', 'hidden', 'none', 'open'] | str] | ~typing.Literal['all', 'closed', 'hidden', 'none', 'open'] | str | None) – 通配符模式可以匹配的索引类型。如果请求可以针对数据流，则此参数确定通配符表达式是否匹配隐藏的数据流。支持逗号分隔的值，例如 open,hidden。有效值为：all、open、closed、hidden、none。

from – 起始偏移量（默认值：0）

ignore_unavailable (bool | None) – 如果为 false，则如果请求定位到丢失或关闭的索引，则返回错误。

lenient (bool | None) – 如果为 true，则会忽略查询字符串中基于格式的查询失败（例如，向数字字段提供文本）。

max_docs (int | None) – 要更新的文档的最大数量。

pipeline (str | None) – 要用于预处理传入文档的管道的 ID。如果索引指定了默认的摄取管道，则将值设置为 _none 将为该请求禁用默认的摄取管道。如果配置了最终管道，它将始终运行，无论此参数的值如何。

preference (str | None) – 指定应执行操作的节点或分片。默认情况下为随机。

query (Mapping[str, Any] | None) – 使用查询 DSL 指定要更新的文档。

refresh (bool | None) – 如果为 true，Elasticsearch 会刷新受影响的分片，以使操作对搜索可见。

request_cache (bool | None) – 如果为 true，则此请求使用请求缓存。

requests_per_second (float | None) – 此请求的节流，以每秒子请求数表示。

routing (str | None) – 用于将操作路由到特定分片的自定义值。

script (Mapping[str, Any] | None) – 在更新时运行的脚本，用于更新文档源或元数据。

scroll (Literal[-1] | ~typing.Literal[0] | str | None) – 保留滚动搜索上下文的期限。

scroll_size (int | None) – 为操作提供支持的滚动请求的大小。

search_timeout (Literal[-1] | ~typing.Literal[0] | str | None) – 每个搜索请求的显式超时时间。

search_type (Literal['dfs_query_then_fetch', 'query_then_fetch'] | str | None) – 搜索操作的类型。可用选项：query_then_fetch、dfs_query_then_fetch。

slice (Mapping[str, Any] | None) – 使用提供的切片 ID 和切片总数手动切片请求。

slices (int | Literal['auto'] | str | None) – 此任务应划分的切片数量。

sort (Sequence[str] | None) – <field>:<direction> 对的逗号分隔列表。

stats (Sequence[str] | None) – 用于日志记录和统计目的的请求的特定 tag。

terminate_after (int | None) – 每个分片要收集的文档的最大数量。如果查询达到此限制，Elasticsearch 将提前终止查询。Elasticsearch 在排序之前收集文档。谨慎使用。Elasticsearch 将此参数应用于处理请求的每个分片。如果可能，让 Elasticsearch 自动执行提前终止。避免为针对跨多个数据层级具有支持索引的数据流的请求指定此参数。

timeout (Literal[-1] | ~typing.Literal[0] | str | None) – 每个更新请求等待以下操作的时间段：动态映射更新，等待活动分片。

version (bool | None) – 如果为 true，则将文档版本作为命中的一部分返回。

version_type (bool | None) – 文档是否应该在命中时增加版本号（内部）或不增加（重新索引）

wait_for_active_shards (int | Literal['all', 'index-setting'] | str | None) – 在继续操作之前必须处于活动状态的分片副本数量。设置为 all 或任何正整数，直到索引中的分片总数 (number_of_replicas+1)。

wait_for_completion (bool | None) – 如果为 true，则请求将阻塞，直到操作完成。

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

from_ (int | None)

human (bool | None)

pretty (bool | None)

body (Dict[str, Any] | None)

返回类型:

ObjectApiResponse[Any]

update_by_query_rethrottle(*, task_id, error_trace=None, filter_path=None, human=None, pretty=None, requests_per_second=None)

更改特定更新查询操作的每秒请求数。

https://elastic.ac.cn/guide/en/elasticsearch/reference/8.14/docs-update-by-query.html

参数:

task_id (str) – 任务的 ID。

requests_per_second (float | None) – 此请求的节流，以每秒子请求数表示。

error_trace (bool | None)

filter_path (str | Sequence[str] | None)

human (bool | None)

pretty (bool | None)

返回类型:

ObjectApiResponse[Any]