パーコレート（Percolate）

パーコレートクエリ

percolate クエリは、インデックスに保存されたクエリと一致させるために使用できます。 percolate クエリ自体には、保存されたクエリと一致させるために使用されるドキュメントが含まれています。

サンプル使用法

簡単な例を提供するために、このドキュメントでは、my-index-000001 インデックスをパーコレートクエリとドキュメントの両方に使用します。この設定は、登録されたパーコレートクエリが少数の場合にうまく機能します。より多くの使用がある場合は、クエリとドキュメントを別々のインデックスに保存することをお勧めします。詳細については、内部の動作を参照してください。

2つのフィールドを持つインデックスを作成します:

Python

resp = client.indices.create(
   index="my-index-000001",
   mappings={
   "properties": {
   "message": {
   "type": "text"
   },
   "query": {
   "type": "percolator"
   }
   }
   },
)
print(resp)

Ruby

response = client.indices.create(
  index: 'my-index-000001',
  body: {
   mappings: {
   properties: {
   message: {
   type: 'text'
   },
   query: {
   type: 'percolator'
   }
   }
   }
  }
)
puts response

Js

const response = await client.indices.create({
  index: "my-index-000001",
  mappings: {
   properties: {
   message: {
   type: "text",
   },
   query: {
   type: "percolator",
   },
   },
  },
});
console.log(response);

コンソール

PUT /my-index-000001
{
  "mappings": {
   "properties": {
   "message": {
   "type": "text"
   },
   "query": {
   "type": "percolator"
   }
   }
  }
}

message フィールドは、percolator クエリで定義されたドキュメントを一時インデックスにインデックス化する前に前処理するために使用されるフィールドです。

query フィールドは、クエリドキュメントのインデックス化に使用されます。これは、実際の Elasticsearch クエリを表す JSON オブジェクトを保持します。query フィールドは、パーコレータフィールドタイプを使用するように構成されています。このフィールドタイプは、クエリ DSL を理解し、percolate クエリで定義されたドキュメントと一致させるために後で使用できるようにクエリを保存します。

パーコレータにクエリを登録します:

Python

resp = client.index(
   index="my-index-000001",
   id="1",
   refresh=True,
   document={
   "query": {
   "match": {
   "message": "bonsai tree"
   }
   }
   },
)
print(resp)

Ruby

response = client.index(
  index: 'my-index-000001',
  id: 1,
  refresh: true,
  body: {
   query: {
   match: {
   message: 'bonsai tree'
   }
   }
  }
)
puts response

Js

const response = await client.index({
  index: "my-index-000001",
  id: 1,
  refresh: "true",
  document: {
   query: {
   match: {
   message: "bonsai tree",
   },
   },
  },
});
console.log(response);

コンソール

PUT /my-index-000001/_doc/1?refresh
{
  "query": {
   "match": {
   "message": "bonsai tree"
   }
  }
}

登録されたパーコレータクエリにドキュメントを一致させます:

Python

resp = client.search(
   index="my-index-000001",
   query={
   "percolate": {
   "field": "query",
   "document": {
   "message": "A new bonsai tree in the office"
   }
   }
   },
)
print(resp)

Js

const response = await client.search({
  index: "my-index-000001",
  query: {
   percolate: {
   field: "query",
   document: {
   message: "A new bonsai tree in the office",
   },
   },
  },
});
console.log(response);

コンソール

GET /my-index-000001/_search
{
  "query": {
   "percolate": {
   "field": "query",
   "document": {
   "message": "A new bonsai tree in the office"
   }
   }
  }
}

上記のリクエストは、次のレスポンスを生成します:

コンソール-結果

{
  "took": 13,
  "timed_out": false,
  "_shards": {
   "total": 1,
   "successful": 1,
   "skipped" : 0,
   "failed": 0
  },
  "hits": {
   "total" : {
   "value": 1,
   "relation": "eq"
   },
   "max_score": 0.26152915,
   "hits": [
   {
   "_index": "my-index-000001",
   "_id": "1",
   "_score": 0.26152915,
   "_source": {
   "query": {
   "match": {
   "message": "bonsai tree"
   }
   }
   },
   "fields" : {
   "_percolator_document_slot" : [0]
   }
   }
   ]
  }
}

パラメータ

ドキュメントをパーコレートする際に必要なパラメータは次のとおりです:

パーコレートされるドキュメントのソースを指定する代わりに、すでに保存されたドキュメントからソースを取得することもできます。percolate クエリは、そのドキュメントを取得するために内部的に get リクエストを実行します。

その場合、document パラメータは次のパラメータに置き換えることができます:


| | |
| —- | —- |
| index | ドキュメントが存在するインデックス。これは必須のパラメータです。 |
| type | 取得するドキュメントのタイプ。このパラメータは非推奨で、Elasticsearch 8.0 で削除されます。 |
| id | 取得するドキュメントの ID。これは必須のパラメータです。 |
| routing | オプションで、パーコレートするドキュメントを取得するために使用されるルーティング。 |
| preference | オプションで、パーコレートするドキュメントを取得するために使用される優先度。 |
| version | オプションで、取得されるドキュメントの期待されるバージョン。 |

フィルターコンテキストでのパーコレート

スコアに興味がない場合は、bool クエリのフィルター句または constant_score クエリ内にパーコレータクエリをラップすることで、より良いパフォーマンスが期待できます。

Python

resp = client.search(
   index="my-index-000001",
   query={
   "constant_score": {
   "filter": {
   "percolate": {
   "field": "query",
   "document": {
   "message": "A new bonsai tree in the office"
   }
   }
   }
   }
   },
)
print(resp)

Js

const response = await client.search({
  index: "my-index-000001",
  query: {
   constant_score: {
   filter: {
   percolate: {
   field: "query",
   document: {
   message: "A new bonsai tree in the office",
   },
   },
   },
   },
  },
});
console.log(response);

コンソール

GET /my-index-000001/_search
{
  "query": {
   "constant_score": {
   "filter": {
   "percolate": {
   "field": "query",
   "document": {
   "message": "A new bonsai tree in the office"
   }
   }
   }
   }
  }
}

インデックス時に、パーコレータクエリから用語が抽出され、パーコレータはしばしば抽出された用語を見てクエリが一致するかどうかを判断できます。ただし、スコアを計算するには、一致する各クエリをデシリアライズし、パーコレートされたドキュメントに対して実行する必要があり、これははるかに高価な操作です。したがって、スコアの計算が必要ない場合は、percolate クエリを constant_score クエリまたは bool クエリのフィルター句でラップする必要があります。

percolate クエリは、クエリキャッシュによってキャッシュされることはありません。

複数のドキュメントをパーコレート

percolate クエリは、インデックスされたパーコレータクエリと同時に複数のドキュメントと一致させることができます。単一のリクエストで複数のドキュメントをパーコレートすることで、クエリを複数回解析して一致させる必要がなくなるため、パフォーマンスが向上します。

各一致したパーコレータクエリと共に返される _percolator_document_slot フィールドは、複数のドキュメントを同時にパーコレートする際に重要です。これは、特定のパーコレータクエリと一致したドキュメントを示します。数字は、documents 配列内のスロットと相関しています。

Python

resp = client.search(
   index="my-index-000001",
   query={
   "percolate": {
   "field": "query",
   "documents": [
   {
   "message": "bonsai tree"
   },
   {
   "message": "new tree"
   },
   {
   "message": "the office"
   },
   {
   "message": "office tree"
   }
   ]
   }
   },
)
print(resp)

Js

const response = await client.search({
  index: "my-index-000001",
  query: {
   percolate: {
   field: "query",
   documents: [
   {
   message: "bonsai tree",
   },
   {
   message: "new tree",
   },
   {
   message: "the office",
   },
   {
   message: "office tree",
   },
   ],
   },
  },
});
console.log(response);

コンソール

GET /my-index-000001/_search
{
  "query": {
   "percolate": {
   "field": "query",
   "documents": [
   {
   "message": "bonsai tree"
   },
   {
   "message": "new tree"
   },
   {
   "message": "the office"
   },
   {
   "message": "office tree"
   }
   ]
   }
  }
}

コンソール-結果

{
  "took": 13,
  "timed_out": false,
  "_shards": {
   "total": 1,
   "successful": 1,
   "skipped" : 0,
   "failed": 0
  },
  "hits": {
   "total" : {
   "value": 1,
   "relation": "eq"
   },
   "max_score": 0.7093853,
   "hits": [
   {
   "_index": "my-index-000001",
   "_id": "1",
   "_score": 0.7093853,
   "_source": {
   "query": {
   "match": {
   "message": "bonsai tree"
   }
   }
   },
   "fields" : {
   "_percolator_document_slot" : [0, 1, 3]
   }
   }
   ]
  }
}

既存のドキュメントをパーコレート

新しくインデックスされたドキュメントをパーコレートするには、percolate クエリを使用できます。インデックスリクエストからのレスポンスに基づいて、_id およびその他のメタ情報を使用して、新しく追加されたドキュメントを即座にパーコレートできます。

例

前の例に基づいています。

パーコレートしたいドキュメントをインデックスします:

Python

resp = client.index(
   index="my-index-000001",
   id="2",
   document={
   "message": "A new bonsai tree in the office"
   },
)
print(resp)

Ruby

response = client.index(
  index: 'my-index-000001',
  id: 2,
  body: {
   message: 'A new bonsai tree in the office'
  }
)
puts response

Js

const response = await client.index({
  index: "my-index-000001",
  id: 2,
  document: {
   message: "A new bonsai tree in the office",
  },
});
console.log(response);

コンソール

PUT /my-index-000001/_doc/2
{
  "message" : "A new bonsai tree in the office"
}

インデックスレスポンス:

コンソール-結果

{
  "_index": "my-index-000001",
  "_id": "2",
  "_version": 1,
  "_shards": {
   "total": 2,
   "successful": 1,
   "failed": 0
  },
  "result": "created",
  "_seq_no" : 1,
  "_primary_term" : 1
}

既存のドキュメントをパーコレートし、インデックスレスポンスを基に新しい検索リクエストを構築します:

Python

resp = client.search(
   index="my-index-000001",
   query={
   "percolate": {
   "field": "query",
   "index": "my-index-000001",
   "id": "2",
   "version": 1
   }
   },
)
print(resp)

Js

const response = await client.search({
  index: "my-index-000001",
  query: {
   percolate: {
   field: "query",
   index: "my-index-000001",
   id: "2",
   version: 1,
   },
  },
});
console.log(response);

コンソール

GET /my-index-000001/_search
{
  "query": {
   "percolate": {
   "field": "query",
   "index": "my-index-000001",
   "id": "2",
   "version": 1
   }
  }
}

返された検索レスポンスは、前の例と同じです。

パーコレートクエリとハイライト

percolate クエリは、ハイライトに関して特別な方法で処理されます。クエリのヒットは、percolate クエリで提供されるドキュメントをハイライトするために使用されます。一方、通常のハイライトでは、検索リクエストのクエリがヒットをハイライトするために使用されます。

例

この例は、最初の例のマッピングに基づいています。

クエリを保存します:

Python

resp = client.index(
   index="my-index-000001",
   id="3",
   refresh=True,
   document={
   "query": {
   "match": {
   "message": "brown fox"
   }
   }
   },
)
print(resp)

Ruby

response = client.index(
  index: 'my-index-000001',
  id: 3,
  refresh: true,
  body: {
   query: {
   match: {
   message: 'brown fox'
   }
   }
  }
)
puts response

Js

const response = await client.index({
  index: "my-index-000001",
  id: 3,
  refresh: "true",
  document: {
   query: {
   match: {
   message: "brown fox",
   },
   },
  },
});
console.log(response);

コンソール

PUT /my-index-000001/_doc/3?refresh
{
  "query": {
   "match": {
   "message": "brown fox"
   }
  }
}

別のクエリを保存します:

Python

resp = client.index(
   index="my-index-000001",
   id="4",
   refresh=True,
   document={
   "query": {
   "match": {
   "message": "lazy dog"
   }
   }
   },
)
print(resp)

Ruby

response = client.index(
  index: 'my-index-000001',
  id: 4,
  refresh: true,
  body: {
   query: {
   match: {
   message: 'lazy dog'
   }
   }
  }
)
puts response

Js

const response = await client.index({
  index: "my-index-000001",
  id: 4,
  refresh: "true",
  document: {
   query: {
   match: {
   message: "lazy dog",
   },
   },
  },
});
console.log(response);

コンソール

PUT /my-index-000001/_doc/4?refresh
{
  "query": {
   "match": {
   "message": "lazy dog"
   }
  }
}

percolate クエリとハイライトを有効にした検索リクエストを実行します:

Python

resp = client.search(
   index="my-index-000001",
   query={
   "percolate": {
   "field": "query",
   "document": {
   "message": "The quick brown fox jumps over the lazy dog"
   }
   }
   },
   highlight={
   "fields": {
   "message": {}
   }
   },
)
print(resp)

Js

const response = await client.search({
  index: "my-index-000001",
  query: {
   percolate: {
   field: "query",
   document: {
   message: "The quick brown fox jumps over the lazy dog",
   },
   },
  },
  highlight: {
   fields: {
   message: {},
   },
  },
});
console.log(response);

コンソール

GET /my-index-000001/_search
{
  "query": {
   "percolate": {
   "field": "query",
   "document": {
   "message": "The quick brown fox jumps over the lazy dog"
   }
   }
  },
  "highlight": {
   "fields": {
   "message": {}
   }
  }
}

次のレスポンスが得られます。

コンソール-結果

{
  "took": 7,
  "timed_out": false,
  "_shards": {
   "total": 1,
   "successful": 1,
   "skipped" : 0,
   "failed": 0
  },
  "hits": {
   "total" : {
   "value": 2,
   "relation": "eq"
   },
   "max_score": 0.26152915,
   "hits": [
   {
   "_index": "my-index-000001",
   "_id": "3",
   "_score": 0.26152915,
   "_source": {
   "query": {
   "match": {
   "message": "brown fox"
   }
   }
   },
   "highlight": {
   "message": [
   "The quick <em>brown</em> <em>fox</em> jumps over the lazy dog"
   ]
   },
   "fields" : {
   "_percolator_document_slot" : [0]
   }
   },
   {
   "_index": "my-index-000001",
   "_id": "4",
   "_score": 0.26152915,
   "_source": {
   "query": {
   "match": {
   "message": "lazy dog"
   }
   }
   },
   "highlight": {
   "message": [
   "The quick brown fox jumps over the <em>lazy</em> <em>dog</em>"
   ]
   },
   "fields" : {
   "_percolator_document_slot" : [0]
   }
   }
   ]
  }
}

検索リクエストのクエリがパーコレータのヒットをハイライトするのではなく、パーコレータクエリが percolate クエリで定義されたドキュメントをハイライトしています。

以下のリクエストのように、複数のドキュメントを同時にパーコレートする場合、ハイライトレスポンスは異なります:

Python

resp = client.search(
   index="my-index-000001",
   query={
   "percolate": {
   "field": "query",
   "documents": [
   {
   "message": "bonsai tree"
   },
   {
   "message": "new tree"
   },
   {
   "message": "the office"
   },
   {
   "message": "office tree"
   }
   ]
   }
   },
   highlight={
   "fields": {
   "message": {}
   }
   },
)
print(resp)

Js

const response = await client.search({
  index: "my-index-000001",
  query: {
   percolate: {
   field: "query",
   documents: [
   {
   message: "bonsai tree",
   },
   {
   message: "new tree",
   },
   {
   message: "the office",
   },
   {
   message: "office tree",
   },
   ],
   },
  },
  highlight: {
   fields: {
   message: {},
   },
  },
});
console.log(response);

コンソール

GET /my-index-000001/_search
{
  "query": {
   "percolate": {
   "field": "query",
   "documents": [
   {
   "message": "bonsai tree"
   },
   {
   "message": "new tree"
   },
   {
   "message": "the office"
   },
   {
   "message": "office tree"
   }
   ]
   }
  },
  "highlight": {
   "fields": {
   "message": {}
   }
  }
}

少し異なるレスポンス:

コンソール-結果

{
  "took": 13,
  "timed_out": false,
  "_shards": {
   "total": 1,
   "successful": 1,
   "skipped" : 0,
   "failed": 0
  },
  "hits": {
   "total" : {
   "value": 1,
   "relation": "eq"
   },
   "max_score": 0.7093853,
   "hits": [
   {
   "_index": "my-index-000001",
   "_id": "1",
   "_score": 0.7093853,
   "_source": {
   "query": {
   "match": {
   "message": "bonsai tree"
   }
   }
   },
   "fields" : {
   "_percolator_document_slot" : [0, 1, 3]
   },
   "highlight" : {
   "0_message" : [
   "<em>bonsai</em> <em>tree</em>"
   ],
   "3_message" : [
   "office <em>tree</em>"
   ],
   "1_message" : [
   "new <em>tree</em>"
   ]
   }
   }
   ]
  }
}

パーコレータクエリ内の名前付きクエリ

保存されたパーコレータクエリが複雑なクエリであり、どのサブクエリがパーコレートされたドキュメントに一致したかを追跡したい場合は、サブクエリの \_name パラメータを使用できます。この場合、レスポンス内の各ヒットには、_percolator_document_slot フィールドと共に、各パーコレートされたドキュメントに一致した _percolator_document_slot_<slotNumber>_matched_queries フィールドが含まれます。

例えば:

Python

resp = client.index(
   index="my-index-000001",
   id="5",
   refresh=True,
   document={
   "query": {
   "bool": {
   "should": [
   {
   "match": {
   "message": {
   "query": "Japanese art",
   "_name": "query1"
   }
   }
   },
   {
   "match": {
   "message": {
   "query": "Holand culture",
   "_name": "query2"
   }
   }
   }
   ]
   }
   }
   },
)
print(resp)

Ruby

response = client.index(
  index: 'my-index-000001',
  id: 5,
  refresh: true,
  body: {
   query: {
   bool: {
   should: [
   {
   match: {
   message: {
   query: 'Japanese art',
   _name: 'query1'
   }
   }
   },
   {
   match: {
   message: {
   query: 'Holand culture',
   _name: 'query2'
   }
   }
   }
   ]
   }
   }
  }
)
puts response

Js

const response = await client.index({
  index: "my-index-000001",
  id: 5,
  refresh: "true",
  document: {
   query: {
   bool: {
   should: [
   {
   match: {
   message: {
   query: "Japanese art",
   _name: "query1",
   },
   },
   },
   {
   match: {
   message: {
   query: "Holand culture",
   _name: "query2",
   },
   },
   },
   ],
   },
   },
  },
});
console.log(response);

コンソール

PUT /my-index-000001/_doc/5?refresh
{
  "query": {
   "bool": {
   "should": [
   {
   "match": {
   "message": {
   "query": "Japanese art",
   "_name": "query1"
   }
   }
   },
   {
   "match": {
   "message": {
   "query": "Holand culture",
   "_name": "query2"
   }
   }
   }
   ]
   }
  }
}

Python

resp = client.search(
   index="my-index-000001",
   query={
   "percolate": {
   "field": "query",
   "documents": [
   {
   "message": "Japanse art"
   },
   {
   "message": "Holand culture"
   },
   {
   "message": "Japanese art and Holand culture"
   },
   {
   "message": "no-match"
   }
   ]
   }
   },
)
print(resp)

Js

const response = await client.search({
  index: "my-index-000001",
  query: {
   percolate: {
   field: "query",
   documents: [
   {
   message: "Japanse art",
   },
   {
   message: "Holand culture",
   },
   {
   message: "Japanese art and Holand culture",
   },
   {
   message: "no-match",
   },
   ],
   },
  },
});
console.log(response);

コンソール

GET /my-index-000001/_search
{
  "query": {
   "percolate": {
   "field": "query",
   "documents": [
   {
   "message": "Japanse art"
   },
   {
   "message": "Holand culture"
   },
   {
   "message": "Japanese art and Holand culture"
   },
   {
   "message": "no-match"
   }
   ]
   }
  }
}

コンソール-結果

{
  "took": 55,
  "timed_out": false,
  "_shards": {
   "total": 1,
   "successful": 1,
   "skipped" : 0,
   "failed": 0
  },
  "hits": {
   "total" : {
   "value": 1,
   "relation": "eq"
   },
   "max_score": 1.1181908,
   "hits": [
   {
   "_index": "my-index-000001",
   "_id": "5",
   "_score": 1.1181908,
   "_source": {
   "query": {
   "bool": {
   "should": [
   {
   "match": {
   "message": {
   "query": "Japanese art",
   "_name": "query1"
   }
   }
   },
   {
   "match": {
   "message": {
   "query": "Holand culture",
   "_name": "query2"
   }
   }
   }
   ]
   }
   }
   },
   "fields" : {
   "_percolator_document_slot" : [0, 1, 2],
   "_percolator_document_slot_0_matched_queries" : ["query1"],
   "_percolator_document_slot_1_matched_queries" : ["query2"],
   "_percolator_document_slot_2_matched_queries" : ["query1", "query2"]
   }
   }
   ]
  }
}

複数のパーコレートクエリを指定

単一の検索リクエストで複数の percolate クエリを指定することが可能です:

Python

resp = client.search(
   index="my-index-000001",
   query={
   "bool": {
   "should": [
   {
   "percolate": {
   "field": "query",
   "document": {
   "message": "bonsai tree"
   },
   "name": "query1"
   }
   },
   {
   "percolate": {
   "field": "query",
   "document": {
   "message": "tulip flower"
   },
   "name": "query2"
   }
   }
   ]
   }
   },
)
print(resp)

Js

const response = await client.search({
  index: "my-index-000001",
  query: {
   bool: {
   should: [
   {
   percolate: {
   field: "query",
   document: {
   message: "bonsai tree",
   },
   name: "query1",
   },
   },
   {
   percolate: {
   field: "query",
   document: {
   message: "tulip flower",
   },
   name: "query2",
   },
   },
   ],
   },
  },
});
console.log(response);

コンソール

GET /my-index-000001/_search
{
  "query": {
   "bool": {
   "should": [
   {
   "percolate": {
   "field": "query",
   "document": {
   "message": "bonsai tree"
   },
   "name": "query1"
   }
   },
   {
   "percolate": {
   "field": "query",
   "document": {
   "message": "tulip flower"
   },
   "name": "query2"
   }
   }
   ]
   }
  }
}

_percolator_document_slot フィールド名は、_name パラメータで指定されたものでサフィックスされます。それが指定されていない場合、field パラメータが使用され、これにより曖昧さが生じます。

上記の検索リクエストは、次のようなレスポンスを返します:

コンソール-結果

{
  "took": 13,
  "timed_out": false,
  "_shards": {
   "total": 1,
   "successful": 1,
   "skipped" : 0,
   "failed": 0
  },
  "hits": {
   "total" : {
   "value": 1,
   "relation": "eq"
   },
   "max_score": 0.26152915,
   "hits": [
   {
   "_index": "my-index-000001",
   "_id": "1",
   "_score": 0.26152915,
   "_source": {
   "query": {
   "match": {
   "message": "bonsai tree"
   }
   }
   },
   "fields" : {
   "_percolator_document_slot_query1" : [0]
   }
   }
   ]
  }
}

内部の動作

パーコレータフィールドタイプ](/read/elasticsearch-8-15/43c8aef30c6f9416.md) マッピングが構成されたインデックスにドキュメントをインデックスすると、ドキュメントのクエリ部分が解析され、Lucene クエリに変換され、Lucene インデックスに保存されます。クエリのバイナリ表現が保存されますが、クエリの用語も分析され、インデックスフィールドに保存されます。

検索時に、リクエストで指定されたドキュメントが Lucene ドキュメントに解析され、メモリ内の一時 Lucene インデックスに保存されます。このメモリ内インデックスは、この1つのドキュメントのみを保持でき、最適化されています。その後、メモリ内インデックスの用語に基づいて、候補のパーコレータクエリを選択する特別なクエリが構築されます。これらのクエリは、実際に一致するかどうかをメモリ内インデックスによって評価されます。

候補のパーコレータクエリの選択は、percolate クエリの実行中の重要なパフォーマンス最適化であり、メモリ内インデックスが評価する必要のある候補一致の数を大幅に減少させることができます。percolate クエリがこれを行える理由は、パーコレータクエリのインデックス時に、クエリ用語が抽出され、パーコレータクエリと共にインデックスされるからです。残念ながら、パーコレータはすべてのクエリから用語を抽出できず（例えば、wildcard または geo_shape クエリ）、その結果、特定のケースではパーコレータが選択最適化を行えないことがあります（例えば、ブールクエリの必須句にサポートされていないクエリが定義されている場合や、サポートされていないクエリがパーコレータドキュメント内の唯一のクエリである場合）。これらのクエリはパーコレータによってマークされ、次の検索を実行することで見つけることができます:

Python

resp = client.search(
   query={
   "term": {
   "query.extraction_result": "failed"
   }
   },
)
print(resp)

Ruby

response = client.search(
  body: {
   query: {
   term: {
   'query.extraction_result' => 'failed'
   }
   }
  }
)
puts response

Js

const response = await client.search({
  query: {
   term: {
   "query.extraction_result": "failed",
   },
  },
});
console.log(response);

コンソール

GET /_search
{
  "query": {
   "term" : {
   "query.extraction_result" : "failed"
   }
  }
}

上記の例は、マッピングに query フィールドが percolator タイプであることを前提としています。

パーコレートの設計を考慮すると、パーコレートクエリとパーコレートされるドキュメントに別々のインデックスを使用することが理にかなっていることが多く、例のように単一のインデックスを使用するのではなく、いくつかの利点があります:

• パーコレートクエリは、パーコレートされたドキュメントとは異なるフィールドセットを含むため、2つの別々のインデックスを使用することで、フィールドをより密に、効率的に保存できます。
• パーコレートクエリは、他のクエリと同じようにはスケールしないため、パーコレートのパフォーマンスは、プライマリシャードの数のような異なるインデックス構成を使用することで向上する可能性があります。

ノート

高コストのクエリを許可

search.allow_expensive_queries が false に設定されている場合、パーコレートクエリは実行されません。

カスタム類似性の使用

パーコレートクエリは、設定された カスタム類似性 を尊重しません。常にデフォルトの Lucene 類似性を使用します。