› › ›

按查询删除 API

删除与指定查询匹配的文档。

resp = client.delete_by_query(
    index="my-index-000001",
    query={
        "match": {
            "user.id": "elkbee"
        }
    },
)
print(resp)

response = client.delete_by_query(
  index: 'my-index-000001',
  body: {
    query: {
      match: {
        'user.id' => 'elkbee'
      }
    }
  }
)
puts response

const response = await client.deleteByQuery({
  index: "my-index-000001",
  query: {
    match: {
      "user.id": "elkbee",
    },
  },
});
console.log(response);

POST /my-index-000001/_delete_by_query
{
  "query": {
    "match": {
      "user.id": "elkbee"
    }
  }
}

请求

编辑

POST /<目标>/_delete_by_query

先决条件

编辑

如果启用了 Elasticsearch 安全功能，您必须具有以下目标数据流、索引或别名的索引权限
- read
- delete 或 write

描述

编辑

您可以使用与搜索 API 相同的语法，在请求 URI 或请求正文中指定查询条件。

当您提交按查询删除请求时，Elasticsearch 会在开始处理请求时获取数据流或索引的快照，并使用 internal 版本控制删除匹配的文档。如果文档在获取快照和删除操作处理之间发生更改，则会导致版本冲突，并且删除操作会失败。

版本等于 0 的文档无法使用按查询删除来删除，因为 internal 版本控制不支持 0 作为有效的版本号。

在处理按查询删除请求时，Elasticsearch 会依次执行多个搜索请求以查找所有要删除的匹配文档。对每批匹配的文档执行批量删除请求。如果搜索或批量请求被拒绝，则请求会重试最多 10 次，并进行指数退避。如果达到最大重试限制，则处理停止，并且所有失败的请求都会在响应中返回。任何成功完成的删除请求仍然有效，它们不会被回滚。

您可以选择计算版本冲突，而不是停止并返回，方法是将 conflicts 设置为 proceed。请注意，如果您选择计算版本冲突，则该操作可能会尝试从源删除比 max_docs 更多的文档，直到它成功删除了 max_docs 个文档，或者它已经遍历了源查询中的每个文档。

刷新分片

编辑

指定 refresh 参数会在请求完成后刷新按查询删除涉及的所有分片。这与删除 API 的 refresh 参数不同，后者仅导致接收删除请求的分片被刷新。与删除 API 不同，它不支持 wait_for。

异步运行按查询删除

编辑

如果请求包含 wait_for_completion=false，则 Elasticsearch 会执行一些预检，启动请求，并返回一个task，您可以使用该任务取消或获取任务的状态。Elasticsearch 会在 .tasks/task/${taskId} 中将此任务记录为文档。当您完成任务后，应删除任务文档，以便 Elasticsearch 可以回收空间。

等待活动分片

编辑

wait_for_active_shards 控制在继续执行请求之前，必须有多少分片副本处于活动状态。有关详细信息，请参阅活动分片。timeout 控制每个写请求等待不可用分片变为可用的时间。这两者都与批量 API 中的工作方式完全相同。按查询删除使用滚动搜索，因此您还可以指定 scroll 参数来控制它保持搜索上下文活动的时间，例如 ?scroll=10m。默认值为 5 分钟。

限制删除请求

编辑

要控制按查询删除发出批量删除操作的速率，您可以将 requests_per_second 设置为任何正十进制数。这会在每个批次中填充等待时间以限制速率。将 requests_per_second 设置为 -1 可禁用限制。

限制使用批次之间的等待时间，以便内部滚动请求可以获得一个考虑到请求填充的超时时间。填充时间是批次大小除以 requests_per_second 与写入所花费时间之间的差值。默认情况下，批次大小为 1000，因此如果 requests_per_second 设置为 500

target_time = 1000 / 500 per second = 2 seconds
wait_time = target_time - write_time = 2 seconds - .5 seconds = 1.5 seconds

由于批次是作为单个 _bulk 请求发出的，因此较大的批次大小会导致 Elasticsearch 创建许多请求并在开始下一组之前等待。这是一种“突发”而不是“平稳”的情况。

切片

编辑

按查询删除支持切片滚动以并行化删除过程。这可以提高效率并提供一种将请求分解为较小部分的便捷方法。

将 slices 设置为 auto 会为大多数数据流和索引选择一个合理的数字。如果您正在手动切片或以其他方式调整自动切片，请记住

当 slices 的数量等于索引或支持索引中的分片数量时，查询性能最高效。如果该数字很大（例如，500），则选择一个较小的数字，因为太多的 slices 会损害性能。将 slices 设置得高于分片数量通常不会提高效率，并且会增加开销。
删除性能随着切片数量的增加，在可用资源上线性扩展。

查询或删除性能是否在运行时占主导地位取决于正在重新索引的文档和集群资源。

路径参数

编辑

<目标>: (可选，字符串) 要搜索的数据流、索引和别名的逗号分隔列表。支持通配符 (*)。要搜索所有数据流或索引，请省略此参数或使用 * 或 `_all`。

查询参数

编辑

allow_no_indices

(可选，布尔值) 如果为 false，则如果任何通配符表达式、索引别名或 _all 值仅以丢失或关闭的索引为目标，则请求会返回错误。即使请求以其他打开的索引为目标，此行为也适用。例如，如果索引以 foo 开头，但没有索引以 bar 开头，则以 foo*,bar* 为目标的请求会返回错误。

默认为 true。

analyzer

(可选，字符串) 用于查询字符串的分析器。

仅当指定 q 查询字符串参数时，才能使用此参数。

analyze_wildcard

(可选，布尔值) 如果为 true，则会分析通配符和前缀查询。默认为 false。

仅当指定 q 查询字符串参数时，才能使用此参数。

conflicts

(可选，字符串) 如果按查询删除遇到版本冲突，则执行的操作：abort 或 proceed。默认为 abort。

default_operator

(可选，字符串) 查询字符串查询的默认运算符：AND 或 OR。默认为 OR。

仅当指定 q 查询字符串参数时，才能使用此参数。

df

(可选，字符串) 用作默认值（在查询字符串中未给出字段前缀时）的字段。

仅当指定 q 查询字符串参数时，才能使用此参数。

expand_wildcards

(可选，字符串) 通配符模式可以匹配的索引类型。如果请求可以以数据流为目标，则此参数确定通配符表达式是否匹配隐藏的数据流。支持逗号分隔的值，例如 open,hidden。有效值为

all: 匹配任何数据流或索引，包括隐藏的数据流或索引。
open: 匹配打开的、非隐藏的索引。也匹配任何非隐藏的数据流。
closed: 匹配关闭的、非隐藏的索引。也匹配任何非隐藏的数据流。数据流无法关闭。
hidden: 匹配隐藏的数据流和隐藏的索引。必须与 open、closed 或两者组合使用。
none: 不接受通配符模式。

默认为 open。

ignore_unavailable

(可选，布尔值) 如果为 false，则如果请求以丢失或关闭的索引为目标，则会返回错误。默认为 false。

lenient

(可选，布尔值) 如果为 true，则会忽略查询字符串中基于格式的查询失败（例如，为数字字段提供文本）。默认为 false。

仅当指定 q 查询字符串参数时，才能使用此参数。

max_docs

(可选，整数) 要处理的最大文档数。默认为所有文档。当设置为小于或等于 scroll_size 的值时，将不会使用滚动来检索操作的结果。

preference

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

q

(可选，字符串) 以 Lucene 查询字符串语法表示的查询。

request_cache

(可选，布尔值) 如果为 true，则此请求使用请求缓存。默认为索引级设置。

refresh

(可选，布尔值) 如果为 true，则 Elasticsearch 会在请求完成后刷新按查询删除涉及的所有分片。默认为 false。

requests_per_second

(可选，整数) 此请求的每秒子请求的限制。默认为 -1（无限制）。

routing

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

scroll

(可选，时间值) 保留用于滚动的搜索上下文的时间段。请参阅滚动搜索结果。

scroll_size

(可选，整数) 为操作提供支持的滚动请求的大小。默认为 1000。

search_type

(可选，字符串) 搜索操作的类型。可用选项

query_then_fetch
dfs_query_then_fetch

search_timeout

(可选，时间单位) 每个搜索请求的显式超时。默认为无超时。

slices

(可选，整数) 此任务应划分成的切片数。默认为 1，表示任务未划分成子任务。

sort

(可选，字符串) : 对的逗号分隔列表。

stats

(可选，字符串) 用于日志记录和统计目的的请求的特定 tag。

terminate_after

(可选，整数) 每个分片要收集的最大文档数。如果查询达到此限制，则 Elasticsearch 会提前终止查询。Elasticsearch 会在排序之前收集文档。

请谨慎使用。Elasticsearch 将此参数应用于处理请求的每个分片。如果可能，请让 Elasticsearch 自动执行提前终止。对于跨多个数据层具有后备索引的数据流的请求，请避免指定此参数。

timeout

（可选，时间单位）每个删除请求等待活动分片的时间段。默认为 1m（一分钟）。

version

（可选，布尔值）如果为 true，则返回文档版本作为命中的一部分。

wait_for_active_shards

（可选，字符串）在继续操作之前必须处于活动状态的每个分片的副本数。设置为 all 或任何非负整数，最大为索引中每个分片的副本总数 (number_of_replicas+1)。默认为 1，表示仅等待每个主分片处于活动状态。

请参阅活动分片。

请求正文

编辑

query: （可选，查询对象）使用查询 DSL 指定要删除的文档。

响应正文

编辑

JSON 响应如下所示

{
  "took" : 147,
  "timed_out": false,
  "total": 119,
  "deleted": 119,
  "batches": 1,
  "version_conflicts": 0,
  "noops": 0,
  "retries": {
    "bulk": 0,
    "search": 0
  },
  "throttled_millis": 0,
  "requests_per_second": -1.0,
  "throttled_until_millis": 0,
  "failures" : [ ]
}

took: 从整个操作开始到结束的毫秒数。
timed_out: 如果在按查询删除执行期间执行的任何请求超时，则此标志设置为 true。
total: 成功处理的文档数。
deleted: 成功删除的文档数。
batches: 按查询删除操作拉回的滚动响应数。
version_conflicts: 按查询删除操作遇到的版本冲突数。
noops: 对于按查询删除操作，此字段始终等于零。它的存在只是为了使按查询删除、按查询更新和重新索引 API 返回具有相同结构的响应。
retries: 按查询删除操作尝试的重试次数。bulk 是重试的批量操作数，而 search 是重试的搜索操作数。
throttled_millis: 为符合 requests_per_second，请求休眠的毫秒数。
requests_per_second: 在按查询删除期间有效执行的每秒请求数。
throttled_until_millis: 在 _delete_by_query 响应中，此字段应始终等于零。它仅在使用任务 API 时才有意义，该 API 指示为了符合 requests_per_second，节流请求将在何时（以自纪元以来的毫秒为单位）再次执行。
failures: 如果在该过程中出现任何不可恢复的错误，则显示失败数组。如果此数组为非空，则表示该请求因这些失败而中止。按查询删除操作是使用批处理实现的，任何失败都会导致整个过程中止，但当前批处理中的所有失败都会被收集到数组中。您可以使用 conflicts 选项来防止重新索引因版本冲突而中止。

示例

编辑

从 my-index-000001 数据流或索引中删除所有文档

resp = client.delete_by_query(
    index="my-index-000001",
    conflicts="proceed",
    query={
        "match_all": {}
    },
)
print(resp)

response = client.delete_by_query(
  index: 'my-index-000001',
  conflicts: 'proceed',
  body: {
    query: {
      match_all: {}
    }
  }
)
puts response

const response = await client.deleteByQuery({
  index: "my-index-000001",
  conflicts: "proceed",
  query: {
    match_all: {},
  },
});
console.log(response);

POST my-index-000001/_delete_by_query?conflicts=proceed
{
  "query": {
    "match_all": {}
  }
}

从多个数据流或索引中删除文档

resp = client.delete_by_query(
    index="my-index-000001,my-index-000002",
    query={
        "match_all": {}
    },
)
print(resp)

response = client.delete_by_query(
  index: 'my-index-000001,my-index-000002',
  body: {
    query: {
      match_all: {}
    }
  }
)
puts response

const response = await client.deleteByQuery({
  index: "my-index-000001,my-index-000002",
  query: {
    match_all: {},
  },
});
console.log(response);

POST /my-index-000001,my-index-000002/_delete_by_query
{
  "query": {
    "match_all": {}
  }
}

将按查询删除操作限制为特定路由值的分片

resp = client.delete_by_query(
    index="my-index-000001",
    routing="1",
    query={
        "range": {
            "age": {
                "gte": 10
            }
        }
    },
)
print(resp)

response = client.delete_by_query(
  index: 'my-index-000001',
  routing: 1,
  body: {
    query: {
      range: {
        age: {
          gte: 10
        }
      }
    }
  }
)
puts response

const response = await client.deleteByQuery({
  index: "my-index-000001",
  routing: 1,
  query: {
    range: {
      age: {
        gte: 10,
      },
    },
  },
});
console.log(response);

POST my-index-000001/_delete_by_query?routing=1
{
  "query": {
    "range" : {
        "age" : {
           "gte" : 10
        }
    }
  }
}

默认情况下，_delete_by_query 使用 1000 个滚动的批次。您可以使用 scroll_size URL 参数更改批次大小

resp = client.delete_by_query(
    index="my-index-000001",
    scroll_size="5000",
    query={
        "term": {
            "user.id": "kimchy"
        }
    },
)
print(resp)

response = client.delete_by_query(
  index: 'my-index-000001',
  scroll_size: 5000,
  body: {
    query: {
      term: {
        'user.id' => 'kimchy'
      }
    }
  }
)
puts response

const response = await client.deleteByQuery({
  index: "my-index-000001",
  scroll_size: 5000,
  query: {
    term: {
      "user.id": "kimchy",
    },
  },
});
console.log(response);

POST my-index-000001/_delete_by_query?scroll_size=5000
{
  "query": {
    "term": {
      "user.id": "kimchy"
    }
  }
}

使用唯一属性删除文档

resp = client.delete_by_query(
    index="my-index-000001",
    query={
        "term": {
            "user.id": "kimchy"
        }
    },
    max_docs=1,
)
print(resp)

response = client.delete_by_query(
  index: 'my-index-000001',
  body: {
    query: {
      term: {
        'user.id' => 'kimchy'
      }
    },
    max_docs: 1
  }
)
puts response

const response = await client.deleteByQuery({
  index: "my-index-000001",
  query: {
    term: {
      "user.id": "kimchy",
    },
  },
  max_docs: 1,
});
console.log(response);

POST my-index-000001/_delete_by_query
{
  "query": {
    "term": {
      "user.id": "kimchy"
    }
  },
  "max_docs": 1
}

手动切片

编辑

通过提供切片 ID 和切片总数手动切片按查询删除

resp = client.delete_by_query(
    index="my-index-000001",
    slice={
        "id": 0,
        "max": 2
    },
    query={
        "range": {
            "http.response.bytes": {
                "lt": 2000000
            }
        }
    },
)
print(resp)

resp1 = client.delete_by_query(
    index="my-index-000001",
    slice={
        "id": 1,
        "max": 2
    },
    query={
        "range": {
            "http.response.bytes": {
                "lt": 2000000
            }
        }
    },
)
print(resp1)

response = client.delete_by_query(
  index: 'my-index-000001',
  body: {
    slice: {
      id: 0,
      max: 2
    },
    query: {
      range: {
        'http.response.bytes' => {
          lt: 2_000_000
        }
      }
    }
  }
)
puts response

response = client.delete_by_query(
  index: 'my-index-000001',
  body: {
    slice: {
      id: 1,
      max: 2
    },
    query: {
      range: {
        'http.response.bytes' => {
          lt: 2_000_000
        }
      }
    }
  }
)
puts response

const response = await client.deleteByQuery({
  index: "my-index-000001",
  slice: {
    id: 0,
    max: 2,
  },
  query: {
    range: {
      "http.response.bytes": {
        lt: 2000000,
      },
    },
  },
});
console.log(response);

const response1 = await client.deleteByQuery({
  index: "my-index-000001",
  slice: {
    id: 1,
    max: 2,
  },
  query: {
    range: {
      "http.response.bytes": {
        lt: 2000000,
      },
    },
  },
});
console.log(response1);

POST my-index-000001/_delete_by_query
{
  "slice": {
    "id": 0,
    "max": 2
  },
  "query": {
    "range": {
      "http.response.bytes": {
        "lt": 2000000
      }
    }
  }
}
POST my-index-000001/_delete_by_query
{
  "slice": {
    "id": 1,
    "max": 2
  },
  "query": {
    "range": {
      "http.response.bytes": {
        "lt": 2000000
      }
    }
  }
}

您可以使用以下方法验证是否有效

resp = client.indices.refresh()
print(resp)

resp1 = client.search(
    index="my-index-000001",
    size="0",
    filter_path="hits.total",
    query={
        "range": {
            "http.response.bytes": {
                "lt": 2000000
            }
        }
    },
)
print(resp1)

response = client.indices.refresh
puts response

response = client.search(
  index: 'my-index-000001',
  size: 0,
  filter_path: 'hits.total',
  body: {
    query: {
      range: {
        'http.response.bytes' => {
          lt: 2_000_000
        }
      }
    }
  }
)
puts response

const response = await client.indices.refresh();
console.log(response);

const response1 = await client.search({
  index: "my-index-000001",
  size: 0,
  filter_path: "hits.total",
  query: {
    range: {
      "http.response.bytes": {
        lt: 2000000,
      },
    },
  },
});
console.log(response1);

GET _refresh
POST my-index-000001/_search?size=0&filter_path=hits.total
{
  "query": {
    "range": {
      "http.response.bytes": {
        "lt": 2000000
      }
    }
  }
}

这会产生一个合理的 total，如下所示

{
  "hits": {
    "total" : {
        "value": 0,
        "relation": "eq"
    }
  }
}

使用自动切片

编辑

您还可以让按查询删除使用切片滚动自动并行化，以在 _id 上进行切片。使用 slices 指定要使用的切片数

resp = client.delete_by_query(
    index="my-index-000001",
    refresh=True,
    slices="5",
    query={
        "range": {
            "http.response.bytes": {
                "lt": 2000000
            }
        }
    },
)
print(resp)

response = client.delete_by_query(
  index: 'my-index-000001',
  refresh: true,
  slices: 5,
  body: {
    query: {
      range: {
        'http.response.bytes' => {
          lt: 2_000_000
        }
      }
    }
  }
)
puts response

const response = await client.deleteByQuery({
  index: "my-index-000001",
  refresh: "true",
  slices: 5,
  query: {
    range: {
      "http.response.bytes": {
        lt: 2000000,
      },
    },
  },
});
console.log(response);

POST my-index-000001/_delete_by_query?refresh&slices=5
{
  "query": {
    "range": {
      "http.response.bytes": {
        "lt": 2000000
      }
    }
  }
}

您还可以使用以下方法验证是否有效

resp = client.search(
    index="my-index-000001",
    size="0",
    filter_path="hits.total",
    query={
        "range": {
            "http.response.bytes": {
                "lt": 2000000
            }
        }
    },
)
print(resp)

response = client.search(
  index: 'my-index-000001',
  size: 0,
  filter_path: 'hits.total',
  body: {
    query: {
      range: {
        'http.response.bytes' => {
          lt: 2_000_000
        }
      }
    }
  }
)
puts response

const response = await client.search({
  index: "my-index-000001",
  size: 0,
  filter_path: "hits.total",
  query: {
    range: {
      "http.response.bytes": {
        lt: 2000000,
      },
    },
  },
});
console.log(response);

POST my-index-000001/_search?size=0&filter_path=hits.total
{
  "query": {
    "range": {
      "http.response.bytes": {
        "lt": 2000000
      }
    }
  }
}

这会产生一个合理的 total，如下所示

{
  "hits": {
    "total" : {
        "value": 0,
        "relation": "eq"
    }
  }
}

将 slices 设置为 auto 将让 Elasticsearch 选择要使用的切片数。此设置将每个分片使用一个切片，直到达到某个限制。如果有多个源数据流或索引，它将根据具有最少分片数的索引或后备索引选择切片数。

将 slices 添加到 _delete_by_query 只会自动执行上面部分中使用的手动过程，创建子请求，这意味着它有一些怪癖

您可以在任务 API 中看到这些请求。这些子请求是带有 slices 的请求的任务的“子”任务。
获取带有 slices 的请求的任务状态仅包含已完成切片的状态。
这些子请求可以单独寻址，用于取消和重新限制等操作。
重新限制带有 slices 的请求将按比例重新限制未完成的子请求。
取消带有 slices 的请求将取消每个子请求。
由于 slices 的性质，每个子请求不会获得文档的完全均匀的部分。所有文档都将被寻址，但某些切片可能比其他切片大。预计较大的切片具有更均匀的分布。
在带有 slices 的请求上，requests_per_second 和 max_docs 等参数会按比例分配给每个子请求。结合上面关于分布不均匀的点，您应该得出结论：将 max_docs 与 slices 一起使用可能不会导致删除恰好 max_docs 个文档。
每个子请求都会获得源数据流或索引的略有不同的快照，尽管这些快照都是在大约同一时间拍摄的。

更改请求的节流

编辑

可以使用 _rethrottle API 更改正在运行的按查询删除操作的 requests_per_second 值。加速查询的重新限制会立即生效，但减慢查询的重新限制会在完成当前批处理后生效，以防止滚动超时。

$params = [
    'task_id' => 'r1A2WoRbTwKZ516z6NEs5A:36619',
];
$response = $client->deleteByQueryRethrottle($params);

resp = client.delete_by_query_rethrottle(
    task_id="r1A2WoRbTwKZ516z6NEs5A:36619",
    requests_per_second="-1",
)
print(resp)

response = client.delete_by_query_rethrottle(
  task_id: 'r1A2WoRbTwKZ516z6NEs5A:36619',
  requests_per_second: -1
)
puts response

res, err := es.DeleteByQueryRethrottle(
	"r1A2WoRbTwKZ516z6NEs5A:36619",
	esapi.IntPtr(-1),
)
fmt.Println(res, err)

const response = await client.deleteByQueryRethrottle({
  task_id: "r1A2WoRbTwKZ516z6NEs5A:36619",
  requests_per_second: "-1",
});
console.log(response);

POST _delete_by_query/r1A2WoRbTwKZ516z6NEs5A:36619/_rethrottle?requests_per_second=-1

使用任务 API 获取任务 ID。将 requests_per_second 设置为任何正十进制值或 -1 以禁用节流。

获取按查询删除操作的状态

编辑

使用任务 API 获取按查询删除操作的状态

$response = $client->tasks()->list();

resp = client.tasks.list(
    detailed=True,
    actions="*/delete/byquery",
)
print(resp)

response = client.tasks.list(
  detailed: true,
  actions: '*/delete/byquery'
)
puts response

res, err := es.Tasks.List(
	es.Tasks.List.WithActions("*/delete/byquery"),
	es.Tasks.List.WithDetailed(true),
)
fmt.Println(res, err)

const response = await client.tasks.list({
  detailed: "true",
  actions: "*/delete/byquery",
});
console.log(response);

GET _tasks?detailed=true&actions=*/delete/byquery

响应如下所示

{
  "nodes" : {
    "r1A2WoRbTwKZ516z6NEs5A" : {
      "name" : "r1A2WoR",
      "transport_address" : "127.0.0.1:9300",
      "host" : "127.0.0.1",
      "ip" : "127.0.0.1:9300",
      "attributes" : {
        "testattr" : "test",
        "portsfile" : "true"
      },
      "tasks" : {
        "r1A2WoRbTwKZ516z6NEs5A:36619" : {
          "node" : "r1A2WoRbTwKZ516z6NEs5A",
          "id" : 36619,
          "type" : "transport",
          "action" : "indices:data/write/delete/byquery",
          "status" : {    
            "total" : 6154,
            "updated" : 0,
            "created" : 0,
            "deleted" : 3500,
            "batches" : 36,
            "version_conflicts" : 0,
            "noops" : 0,
            "retries": 0,
            "throttled_millis": 0
          },
          "description" : ""
        }
      }
    }
  }
}

此对象包含实际状态。它与响应 JSON 类似，但增加了重要的 total 字段。total 是重新索引期望执行的操作总数。您可以通过添加 updated、created 和 deleted 字段来估计进度。当它们的总和等于 total 字段时，请求将完成。

使用任务 ID，您可以直接查找任务

$params = [
    'task_id' => 'r1A2WoRbTwKZ516z6NEs5A:36619',
];
$response = $client->tasks()->get($params);

resp = client.tasks.get(
    task_id="r1A2WoRbTwKZ516z6NEs5A:36619",
)
print(resp)

response = client.tasks.get(
  task_id: 'r1A2WoRbTwKZ516z6NEs5A:36619'
)
puts response

res, err := es.Tasks.Get(
	"r1A2WoRbTwKZ516z6NEs5A:36619",
)
fmt.Println(res, err)

const response = await client.tasks.get({
  task_id: "r1A2WoRbTwKZ516z6NEs5A:36619",
});
console.log(response);

GET /_tasks/r1A2WoRbTwKZ516z6NEs5A:36619

此 API 的优点是它与 wait_for_completion=false 集成，以透明地返回已完成任务的状态。如果任务已完成，并且在其上设置了 wait_for_completion=false，则它将返回 results 或 error 字段。此功能的代价是 wait_for_completion=false 在 .tasks/task/${taskId} 创建的文档。由您来删除该文档。

取消按查询删除操作

编辑

可以使用任务取消 API 取消任何按查询删除操作

$params = [
    'task_id' => 'r1A2WoRbTwKZ516z6NEs5A:36619',
];
$response = $client->tasks()->cancel($params);

resp = client.tasks.cancel(
    task_id="r1A2WoRbTwKZ516z6NEs5A:36619",
)
print(resp)

response = client.tasks.cancel(
  task_id: 'r1A2WoRbTwKZ516z6NEs5A:36619'
)
puts response

res, err := es.Tasks.Cancel(
	es.Tasks.Cancel.WithTaskID("r1A2WoRbTwKZ516z6NEs5A:36619"),
)
fmt.Println(res, err)

const response = await client.tasks.cancel({
  task_id: "r1A2WoRbTwKZ516z6NEs5A:36619",
});
console.log(response);

POST _tasks/r1A2WoRbTwKZ516z6NEs5A:36619/_cancel

可以使用任务 API 找到任务 ID。

取消应该很快发生，但可能需要几秒钟。上面的任务状态 API 将继续列出按查询删除任务，直到此任务检查它是否已取消并自行终止。

« 删除 API 更新 API »