ドキュメントAPI - クエリによる削除（Delete by query）

Delete by query API
Request
Prerequisites
Description
- Refreshing shards
- Slicing
Query parameters
Request body
Response body
- Console-Result
Examples
Get the status of a delete by query operation

Delete by query API

指定されたクエリに一致するドキュメントを削除します。

Python

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

Ruby

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

Js

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

Console

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

Request

POST /<target>/_delete_by_query

Prerequisites

Elasticsearchのセキュリティ機能が有効になっている場合、ターゲットデータストリーム、インデックス、またはエイリアスに対して次のインデックス権限を持っている必要があります：
- read
- delete または write

Description

リクエストURIまたはリクエストボディで、Search APIと同じ構文を使用してクエリ基準を指定できます。

クエリによる削除リクエストを送信すると、Elasticsearchはリクエストの処理を開始する際にデータストリームまたはインデックスのスナップショットを取得し、internalバージョニングを使用して一致するドキュメントを削除します。スナップショットが取得されてから削除操作が処理されるまでにドキュメントが変更されると、バージョンの競合が発生し、削除操作は失敗します。

バージョンが0のドキュメントは、internalバージョニングが0を有効なバージョン番号としてサポートしていないため、クエリによる削除で削除できません。

クエリによる削除リクエストを処理する際、Elasticsearchは一致するすべてのドキュメントを削除するために複数の検索リクエストを順次実行します。一致するドキュメントの各バッチに対してバルク削除リクエストが実行されます。検索またはバルクリクエストが拒否された場合、リクエストは最大10回まで再試行され、指数バックオフが適用されます。最大再試行制限に達すると、処理は停止し、すべての失敗したリクエストが応答に返されます。成功裏に完了した削除リクエストはそのまま残り、ロールバックされることはありません。

バージョンの競合をカウントすることを選択することもでき、conflictsをproceedに設定することで、処理を停止して返す代わりにカウントします。バージョンの競合をカウントすることを選択した場合、操作はmax_docsからmax_docsドキュメントを正常に削除するまで、ソースからmax_docsドキュメントを削除しようとする可能性があります。

Refreshing shards


### Running delete by query asynchronously
リクエストに`````wait_for_completion=false`````が含まれている場合、Elasticsearchは一部の事前チェックを実行し、リクエストを開始し、タスクのキャンセルまたはステータスを取得するために使用できる[`````task`````](/read/elasticsearch-8-15/4819d08b09fe89d8.md)を返します。Elasticsearchはこのタスクの記録を`````.tasks/task/${taskId}`````にドキュメントとして作成します。タスクが完了したら、Elasticsearchがスペースを回収できるようにタスクドキュメントを削除する必要があります。
### Waiting for active shards
`````wait_for_active_shards`````は、リクエストを進める前にアクティブでなければならないシャードのコピーの数を制御します。詳細については[Active shards](9a3777dee7ec0d3c.md#index-wait-for-active-shards)を参照してください。`````timeout`````は、各書き込みリクエストが利用できないシャードが利用可能になるまで待機する時間を制御します。両方とも、[Bulk API](/read/elasticsearch-8-15/7cc0d7a47de34557.md)での動作とまったく同じです。クエリによる削除はスクロール検索を使用するため、`````scroll`````パラメータを指定して検索コンテキストを生かしておく時間を制御することもできます。たとえば、`````?scroll=10m`````です。デフォルトは5分です。
### Throttling delete requests
クエリによる削除が削除操作のバッチを発行する速度を制御するには、`````requests_per_second`````を任意の正の小数に設定できます。これにより、各バッチに待機時間が追加され、速度が制御されます。`````requests_per_second`````を`````-1`````に設定すると、スロットリングが無効になります。  
スロットリングは、バッチ間に待機時間を使用して、内部スクロールリクエストにリクエストのパディングを考慮したタイムアウトを与えます。パディング時間は、バッチサイズを`````requests_per_second`````で割った値と、書き込みにかかった時間の差です。デフォルトのバッチサイズは`````1000`````であり、`````requests_per_second`````が`````500`````に設定されている場合：
#### Txt
``````txt
target_time = 1000 / 500 per second = 2 seconds
wait_time = target_time - write_time = 2 seconds - .5 seconds = 1.5 seconds
`

バッチが単一の_bulkリクエストとして発行されるため、大きなバッチサイズはElasticsearchが多くのリクエストを作成し、次のセットを開始する前に待機する原因となります。これは「バースト」ではなく「スムーズ」です。

Slicing

クエリによる削除は、削除プロセスを並列化するためにsliced scrollをサポートしています。これにより、効率が向上し、リクエストを小さな部分に分割する便利な方法が提供されます。


-  クエリパフォーマンスは、`````slices`````の数がインデックスまたはバックインデックスのシャードの数と等しいときに最も効率的です。その数が大きい場合（たとえば、500）、パフォーマンスを損なうため、より低い数を選択してください。`````slices`````をシャードの数よりも高く設定することは、一般的に効率を改善せず、オーバーヘッドを追加します。  
-  削除パフォーマンスは、スライスの数に応じて利用可能なリソース全体で線形にスケールします。  
クエリまたは削除パフォーマンスがランタイムを支配するかどうかは、再インデックスされるドキュメントとクラスターリソースによって異なります。
## Path parameters
-   `````<target>

(オプション、文字列) 検索するデータストリーム、インデックス、およびエイリアスのカンマ区切りリスト。ワイルドカードをサポートしています（*）。すべてのデータストリームまたはインデックスを検索するには、このパラメータを省略するか、* or `_allを使用します。

Query parameters

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 search resultsを参照してください。
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（1分）です。
version
(オプション、ブール値) trueの場合、ヒットの一部としてドキュメントバージョンを返します。
wait_for_active_shards
(オプション、文字列) 操作を進める前にアクティブでなければならないシャードのコピーの数。allまたはインデックスの総シャード数（number_of_replicas+1）までの任意の正の整数に設定します。デフォルト：1、プライマリシャード。
Active shardsを参照してください。

Request body

query
(オプション、クエリオブジェクト) Query DSLを使用して削除するドキュメントを指定します。

Response body

JSON応答は次のようになります：

Console-Result

{
  "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応答では常にゼロに等しいはずです。これは、Task APIを使用している場合にのみ意味を持ち、スロットルされたリクエストが次に実行される時間（エポックからのミリ秒）を示します。requests_per_secondに従うために。
failures
プロセス中に回復不可能なエラーが発生した場合の失敗の配列。これが非空の場合、リクエストはそれらの失敗のために中止されました。クエリによる削除はバッチを使用して実装されており、いずれかの失敗が発生すると、全体のプロセスが中止されますが、現在のバッチ内のすべての失敗が配列に収集されます。conflictsオプションを使用して、バージョンの競合で再インデックスが中止されるのを防ぐことができます。

Examples


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

Ruby

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

Js

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

Console

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

複数のデータストリームまたはインデックスからドキュメントを削除します：

Python

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

Ruby

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

Js

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

Console

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

特定のルーティング値に制限してクエリによる削除操作を行います：

Python

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

Ruby

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

Js

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

Console

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

デフォルトでは_delete_by_queryは1000のスクロールバッチを使用します。scroll_size URLパラメータでバッチサイズを変更できます：

Python

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

Ruby

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

Js

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

Console

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

ユニークな属性を使用してドキュメントを削除します：

Python

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

Ruby

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

Js

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

Console

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

Slice manually

スライスIDとスライスの総数を指定して、クエリによる削除を手動でスライスします：

Python

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)

Ruby

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

Js

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);

Console

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

これが機能することを確認できます：

Python

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)

Ruby

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

Js

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);

Console

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

これにより、次のような妥当なtotalが得られます：

Console-Result

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

Use automatic slicing

クエリによる削除を自動的に並列化することもできます。これは、sliced scrollを使用して_idでスライスします。使用するスライスの数を指定するにはslicesを使用します：

Python

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

Ruby

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

Js

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

Console

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

これが機能することを確認できます：

Python

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

Ruby

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

Js

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);

Console

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

これにより、次のような妥当なtotalが得られます：

Console-Result

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


`````slices`````を`````_delete_by_query`````に追加すると、上記のセクションで使用される手動プロセスが自動化され、サブリクエストが作成されます。これにはいくつかの特異性があります：  
-  これらのリクエストは[Tasks APIs](/read/elasticsearch-8-15/4819d08b09fe89d8.md)で確認できます。これらのサブリクエストは、`````slices`````を持つリクエストのタスクの「子」タスクです。  
-  `````slices`````を持つリクエストのタスクのステータスを取得すると、完了したスライスのステータスのみが含まれます。  
-  これらのサブリクエストは、キャンセルや再スロットリングなどのために個別にアドレス指定できます。  
-  `````slices`````でリクエストを再スロットリングすると、未完了のサブリクエストが比例的に再スロットリングされます。  
-  `````slices`````でリクエストをキャンセルすると、各サブリクエストがキャンセルされます。  
-  `````slices`````の性質上、各サブリクエストはソースデータストリームまたはインデックスのスナップショットをわずかに異なるものとして取得しますが、これらはすべてほぼ同時に取得されます。
#### Change throttling for a request
`````requests_per_second`````の値は、`````_rethrottle````` APIを使用して実行中のクエリによる削除で変更できます。クエリを高速化する再スロットリングは即座に効果を発揮しますが、クエリを遅くする再スロットリングは、スクロールタイムアウトを防ぐために現在のバッチの完了後に効果を発揮します。
#### Php
``````php
$params = [
   'task_id' => 'r1A2WoRbTwKZ516z6NEs5A:36619',
];
$response = $client->deleteByQueryRethrottle($params);
`

Python

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

Ruby

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

Go

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

Js

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

Console

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

タスクAPIを使用してタスクIDを取得します。requests_per_secondを任意の正の小数値に設定するか、-1を設定してスロットリングを無効にします。

Get the status of a delete by query operation

タスクAPIを使用して、クエリによる削除操作のステータスを取得します：

Php

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

Python

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

Ruby

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

Go

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

Js

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

Console

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

応答は次のようになります：

Console-Result

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

このオブジェクトには実際のステータスが含まれています。これは、重要なtotalフィールドの追加を伴う応答JSONと同じです。 totalは、再インデックスが実行することを期待する操作の合計数です。updated、created、およびdeletedフィールドを追加することで進捗を推定できます。リクエストは、これらの合計がtotalフィールドに等しくなると完了します。


	このオブジェクトには実際のステータスが含まれています。これは、重要な`total`フィールドの追加を伴う応答JSONと同じです。 `total`は、再インデックスが実行することを期待する操作の合計数です。`updated`、`created`、および`deleted`フィールドを追加することで進捗を推定できます。リクエストは、これらの合計が`total`フィールドに等しくなると完了します。

タスクIDを使用して、タスクを直接検索できます：

Php

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

Python

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

Ruby

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

Go

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

Js

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

Console

GET /_tasks/r1A2WoRbTwKZ516z6NEs5A:36619

このAPIの利点は、wait_for_completion=falseと統合されて、完了したタスクのステータスを透過的に返すことです。タスクが完了し、wait_for_completion=falseが設定されている場合、resultsまたはerrorフィールドが返されます。この機能のコストは、wait_for_completion=falseが.tasks/task/${taskId}で作成するドキュメントです。このドキュメントを削除するのはあなたの責任です。

Cancel a delete by query operation

クエリによる削除は、タスクキャンセルAPIを使用してキャンセルできます：

Php

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

Python

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

Ruby

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

Go

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

Js

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

Console

POST _tasks/r1A2WoRbTwKZ516z6NEs5A:36619/_cancel

タスクIDはタスクAPIを使用して見つけることができます。

キャンセルは迅速に行われるべきですが、数秒かかる場合があります。上記のタスクステータスAPIは、タスクがキャンセルされたことを確認し、自身を終了するまで、クエリによる削除タスクをリストし続けます。