Тип поля percolator

Тип поля percolator анализирует json-структуру в родной запрос и сохраняет этот запрос, чтобы запрос percolate мог использовать его для сопоставления предоставленных документов.

Любое поле, содержащее json-объект, можно настроить как поле percolator. Тип поля percolator не имеет настроек. Простое конфигурирование типа поля percolator достаточно, чтобы указать Elasticsearch на обработку поля как запроса.

Если следующая конфигурация отображения настраивает тип поля percolator для поля query:

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

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

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

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

Тогда вы можете индексировать запрос:

resp = client.index(
    index="my-index-000001",
    id="match_value",
    document={
        "query": {
            "match": {
                "field": "value"
            }
        }
    },
)
print(resp)

response = client.index(
  index: 'my-index-000001',
  id: 'match_value',
  body: {
    query: {
      match: {
        field: 'value'
      }
    }
  }
)
puts response

const response = await client.index({
  index: "my-index-000001",
  id: "match_value",
  document: {
    query: {
      match: {
        field: "value",
      },
    },
  },
});
console.log(response);

PUT my-index-000001/_doc/match_value
{
  "query": {
    "match": {
      "field": "value"
    }
  }
}

Переиндексация запросов percolator иногда требуется, чтобы воспользоваться улучшениями, внесенными в тип поля percolator в новых версиях.

Переиндексацию запросов percolator можно выполнить с помощью API переиндексации. Давайте рассмотрим следующий индекс с типом поля percolator:

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

resp1 = client.indices.update_aliases(
    actions=[
        {
            "add": {
                "index": "index",
                "alias": "queries"
            }
        }
    ],
)
print(resp1)

resp2 = client.index(
    index="queries",
    id="1",
    refresh=True,
    document={
        "query": {
            "match": {
                "body": "quick brown fox"
            }
        }
    },
)
print(resp2)

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

response = client.indices.update_aliases(
  body: {
    actions: [
      {
        add: {
          index: 'index',
          alias: 'queries'
        }
      }
    ]
  }
)
puts response

response = client.index(
  index: 'queries',
  id: 1,
  refresh: true,
  body: {
    query: {
      match: {
        body: 'quick brown fox'
      }
    }
  }
)
puts response

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

const response1 = await client.indices.updateAliases({
  actions: [
    {
      add: {
        index: "index",
        alias: "queries",
      },
    },
  ],
});
console.log(response1);

const response2 = await client.index({
  index: "queries",
  id: 1,
  refresh: "true",
  document: {
    query: {
      match: {
        body: "quick brown fox",
      },
    },
  },
});
console.log(response2);

PUT index
{
  "mappings": {
    "properties": {
      "query" : {
        "type" : "percolator"
      },
      "body" : {
        "type": "text"
      }
    }
  }
}

POST _aliases
{
  "actions": [
    {
      "add": {
        "index": "index",
        "alias": "queries" 
      }
    }
  ]
}

PUT queries/_doc/1?refresh
{
  "query" : {
    "match" : {
      "body" : "quick brown fox"
    }
  }
}

Предположим, что вы собираетесь обновиться до новой основной версии, и для того, чтобы новая версия Elasticsearch могла по-прежнему читать ваши запросы, вам нужно переиндексировать ваши запросы в новый индекс в текущей версии Elasticsearch:

resp = client.indices.create(
    index="new_index",
    mappings={
        "properties": {
            "query": {
                "type": "percolator"
            },
            "body": {
                "type": "text"
            }
        }
    },
)
print(resp)

resp1 = client.reindex(
    refresh=True,
    source={
        "index": "index"
    },
    dest={
        "index": "new_index"
    },
)
print(resp1)

resp2 = client.indices.update_aliases(
    actions=[
        {
            "remove": {
                "index": "index",
                "alias": "queries"
            }
        },
        {
            "add": {
                "index": "new_index",
                "alias": "queries"
            }
        }
    ],
)
print(resp2)

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

response = client.reindex(
  refresh: true,
  body: {
    source: {
      index: 'index'
    },
    dest: {
      index: 'new_index'
    }
  }
)
puts response

response = client.indices.update_aliases(
  body: {
    actions: [
      {
        remove: {
          index: 'index',
          alias: 'queries'
        }
      },
      {
        add: {
          index: 'new_index',
          alias: 'queries'
        }
      }
    ]
  }
)
puts response

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

const response1 = await client.reindex({
  refresh: "true",
  source: {
    index: "index",
  },
  dest: {
    index: "new_index",
  },
});
console.log(response1);

const response2 = await client.indices.updateAliases({
  actions: [
    {
      remove: {
        index: "index",
        alias: "queries",
      },
    },
    {
      add: {
        index: "new_index",
        alias: "queries",
      },
    },
  ],
});
console.log(response2);

PUT new_index
{
  "mappings": {
    "properties": {
      "query" : {
        "type" : "percolator"
      },
      "body" : {
        "type": "text"
      }
    }
  }
}

POST /_reindex?refresh
{
  "source": {
    "index": "index"
  },
  "dest": {
    "index": "new_index"
  }
}

POST _aliases
{
  "actions": [ 
    {
      "remove": {
        "index" : "index",
        "alias": "queries"
      }
    },
    {
      "add": {
        "index": "new_index",
        "alias": "queries"
      }
    }
  ]
}

Выполнение запроса percolate через псевдоним queries:

resp = client.search(
    index="queries",
    query={
        "percolate": {
            "field": "query",
            "document": {
                "body": "fox jumps over the lazy dog"
            }
        }
    },
)
print(resp)

response = client.search(
  index: 'queries',
  body: {
    query: {
      percolate: {
        field: 'query',
        document: {
          body: 'fox jumps over the lazy dog'
        }
      }
    }
  }
)
puts response

const response = await client.search({
  index: "queries",
  query: {
    percolate: {
      field: "query",
      document: {
        body: "fox jumps over the lazy dog",
      },
    },
  },
});
console.log(response);

GET /queries/_search
{
  "query": {
    "percolate" : {
      "field" : "query",
      "document" : {
        "body" : "fox jumps over the lazy dog"
      }
    }
  }
}

теперь возвращает совпадения из нового индекса:

{
  "took": 3,
  "timed_out": false,
  "_shards": {
    "total": 1,
    "successful": 1,
    "skipped" : 0,
    "failed": 0
  },
  "hits": {
    "total" : {
        "value": 1,
        "relation": "eq"
    },
    "max_score": 0.13076457,
    "hits": [
      {
        "_index": "new_index", 
        "_id": "1",
        "_score": 0.13076457,
        "_source": {
          "query": {
            "match": {
              "body": "quick brown fox"
            }
          }
        },
        "fields" : {
          "_percolator_document_slot" : [0]
        }
      }
    ]
  }
}

Когда percolator проверяет совпадение кандидата, он будет анализировать, выполнять анализ текста во время выполнения запроса и фактически запускать запрос percolator на документе, который подвергается перколяционному анализу. Это делается для каждого совпадения кандидата и каждый раз, когда выполняется запрос percolate. Если анализ текста во время выполнения запроса является относительно дорогостоящей частью анализа запроса, то анализ текста может стать доминирующим фактором, на который тратится время при перколяционном анализе. Эта дополнительная нагрузка при анализе запроса может стать заметной, когда percolator проверяет множество совпадений запросов percolator.

Чтобы избежать самой дорогостоящей части анализа текста во время перколяционного анализа, можно выполнить дорогостоящую часть анализа текста при индексировании запроса percolator. Это требует использования двух различных анализаторов. Первый анализатор фактически выполняет анализ текста, который необходимо выполнить (дорогостоящая часть). Второй анализатор (обычно пробелы) просто разделяет сгенерированные токены, которые создал первый анализатор. Затем перед индексированием запроса percolator необходимо использовать API анализа для анализа текста запроса с помощью более дорогостоящего анализатора. Результат API анализа, токены, должны быть использованы для замены исходного текста запроса в запросе percolator. Важно, чтобы запрос теперь был настроен на переопределение анализатора из отображения и использовал только второй анализатор. Большинство текстовых запросов поддерживают опцию analyzer (match, query_string, simple_query_string). Используя этот подход, дорогостоящий анализ текста выполняется один раз вместо многократного повторения.

Давайте продемонстрируем этот рабочий процесс на упрощенном примере.

Предположим, мы хотим индексировать следующий запрос percolator:

{
  "query" : {
    "match" : {
      "body" : {
        "query" : "missing bicycles"
      }
    }
  }
}

с этими настройками и отображением:

resp = client.indices.create(
    index="test_index",
    settings={
        "analysis": {
            "analyzer": {
                "my_analyzer": {
                    "tokenizer": "standard",
                    "filter": [
                        "lowercase",
                        "porter_stem"
                    ]
                }
            }
        }
    },
    mappings={
        "properties": {
            "query": {
                "type": "percolator"
            },
            "body": {
                "type": "text",
                "analyzer": "my_analyzer"
            }
        }
    },
)
print(resp)

response = client.indices.create(
  index: 'test_index',
  body: {
    settings: {
      analysis: {
        analyzer: {
          my_analyzer: {
            tokenizer: 'standard',
            filter: [
              'lowercase',
              'porter_stem'
            ]
          }
        }
      }
    },
    mappings: {
      properties: {
        query: {
          type: 'percolator'
        },
        body: {
          type: 'text',
          analyzer: 'my_analyzer'
        }
      }
    }
  }
)
puts response

const response = await client.indices.create({
  index: "test_index",
  settings: {
    analysis: {
      analyzer: {
        my_analyzer: {
          tokenizer: "standard",
          filter: ["lowercase", "porter_stem"],
        },
      },
    },
  },
  mappings: {
    properties: {
      query: {
        type: "percolator",
      },
      body: {
        type: "text",
        analyzer: "my_analyzer",
      },
    },
  },
});
console.log(response);

PUT /test_index
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer" : {
          "tokenizer": "standard",
          "filter" : ["lowercase", "porter_stem"]
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "query" : {
        "type": "percolator"
      },
      "body" : {
        "type": "text",
        "analyzer": "my_analyzer" 
      }
    }
  }
}

Сначала нам нужно использовать API анализа для выполнения анализа текста перед индексированием:

resp = client.indices.analyze(
    index="test_index",
    analyzer="my_analyzer",
    text="missing bicycles",
)
print(resp)

response = client.indices.analyze(
  index: 'test_index',
  body: {
    analyzer: 'my_analyzer',
    text: 'missing bicycles'
  }
)
puts response

const response = await client.indices.analyze({
  index: "test_index",
  analyzer: "my_analyzer",
  text: "missing bicycles",
});
console.log(response);

POST /test_index/_analyze
{
  "analyzer" : "my_analyzer",
  "text" : "missing bicycles"
}

Это приводит к следующему ответу:

{
  "tokens": [
    {
      "token": "miss",
      "start_offset": 0,
      "end_offset": 7,
      "type": "<ALPHANUM>",
      "position": 0
    },
    {
      "token": "bicycl",
      "start_offset": 8,
      "end_offset": 16,
      "type": "<ALPHANUM>",
      "position": 1
    }
  ]
}

Все токены в возвращенном порядке должны заменить текст запроса в запросе percolator:

resp = client.index(
    index="test_index",
    id="1",
    refresh=True,
    document={
        "query": {
            "match": {
                "body": {
                    "query": "miss bicycl",
                    "analyzer": "whitespace"
                }
            }
        }
    },
)
print(resp)

response = client.index(
  index: 'test_index',
  id: 1,
  refresh: true,
  body: {
    query: {
      match: {
        body: {
          query: 'miss bicycl',
          analyzer: 'whitespace'
        }
      }
    }
  }
)
puts response

const response = await client.index({
  index: "test_index",
  id: 1,
  refresh: "true",
  document: {
    query: {
      match: {
        body: {
          query: "miss bicycl",
          analyzer: "whitespace",
        },
      },
    },
  },
});
console.log(response);

PUT /test_index/_doc/1?refresh
{
  "query" : {
    "match" : {
      "body" : {
        "query" : "miss bicycl",
        "analyzer" : "whitespace" 
      }
    }
  }
}

Перед индексированием запроса percolator API анализа должен выполняться для каждого запроса percolator.

Во время выполнения запроса percolator ничего не меняется, и запрос percolate может быть определен обычно:

resp = client.search(
    index="test_index",
    query={
        "percolate": {
            "field": "query",
            "document": {
                "body": "Bycicles are missing"
            }
        }
    },
)
print(resp)

response = client.search(
  index: 'test_index',
  body: {
    query: {
      percolate: {
        field: 'query',
        document: {
          body: 'Bycicles are missing'
        }
      }
    }
  }
)
puts response

const response = await client.search({
  index: "test_index",
  query: {
    percolate: {
      field: "query",
      document: {
        body: "Bycicles are missing",
      },
    },
  },
});
console.log(response);

GET /test_index/_search
{
  "query": {
    "percolate" : {
      "field" : "query",
      "document" : {
        "body" : "Bycicles are missing"
      }
    }
  }
}

Это приводит к ответу подобному этому:

{
  "took": 6,
  "timed_out": false,
  "_shards": {
    "total": 1,
    "successful": 1,
    "skipped" : 0,
    "failed": 0
  },
  "hits": {
    "total" : {
        "value": 1,
        "relation": "eq"
    },
    "max_score": 0.13076457,
    "hits": [
      {
        "_index": "test_index",
        "_id": "1",
        "_score": 0.13076457,
        "_source": {
          "query": {
            "match": {
              "body": {
                "query": "miss bicycl",
                "analyzer": "whitespace"
              }
            }
          }
        },
        "fields" : {
          "_percolator_document_slot" : [0]
        }
      }
    ]
  }
}

Запросы с подстановкой являются более дорогостоящими, чем другие запросы для percolator, особенно если выражения подстановки большие.

В случае запросов wildcard с префиксными выражениями подстановки или просто запросом prefix, можно использовать фильтр токенов edge_ngram для замены этих запросов обычным запросом term на поле, где настроен фильтр токенов edge_ngram.

Создание индекса с пользовательскими настройками анализа:

resp = client.indices.create(
    index="my_queries1",
    settings={
        "analysis": {
            "analyzer": {
                "wildcard_prefix": {
                    "type": "custom",
                    "tokenizer": "standard",
                    "filter": [
                        "lowercase",
                        "wildcard_edge_ngram"
                    ]
                }
            },
            "filter": {
                "wildcard_edge_ngram": {
                    "type": "edge_ngram",
                    "min_gram": 1,
                    "max_gram": 32
                }
            }
        }
    },
    mappings={
        "properties": {
            "query": {
                "type": "percolator"
            },
            "my_field": {
                "type": "text",
                "fields": {
                    "prefix": {
                        "type": "text",
                        "analyzer": "wildcard_prefix",
                        "search_analyzer": "standard"
                    }
                }
            }
        }
    },
)
print(resp)

response = client.indices.create(
  index: 'my_queries1',
  body: {
    settings: {
      analysis: {
        analyzer: {
          wildcard_prefix: {
            type: 'custom',
            tokenizer: 'standard',
            filter: [
              'lowercase',
              'wildcard_edge_ngram'
            ]
          }
        },
        filter: {
          wildcard_edge_ngram: {
            type: 'edge_ngram',
            min_gram: 1,
            max_gram: 32
          }
        }
      }
    },
    mappings: {
      properties: {
        query: {
          type: 'percolator'
        },
        my_field: {
          type: 'text',
          fields: {
            prefix: {
              type: 'text',
              analyzer: 'wildcard_prefix',
              search_analyzer: 'standard'
            }
          }
        }
      }
    }
  }
)
puts response

const response = await client.indices.create({
  index: "my_queries1",
  settings: {
    analysis: {
      analyzer: {
        wildcard_prefix: {
          type: "custom",
          tokenizer: "standard",
          filter: ["lowercase", "wildcard_edge_ngram"],
        },
      },
      filter: {
        wildcard_edge_ngram: {
          type: "edge_ngram",
          min_gram: 1,
          max_gram: 32,
        },
      },
    },
  },
  mappings: {
    properties: {
      query: {
        type: "percolator",
      },
      my_field: {
        type: "text",
        fields: {
          prefix: {
            type: "text",
            analyzer: "wildcard_prefix",
            search_analyzer: "standard",
          },
        },
      },
    },
  },
});
console.log(response);

PUT my_queries1
{
  "settings": {
    "analysis": {
      "analyzer": {
        "wildcard_prefix": { 
          "type": "custom",
          "tokenizer": "standard",
          "filter": [
            "lowercase",
            "wildcard_edge_ngram"
          ]
        }
      },
      "filter": {
        "wildcard_edge_ngram": { 
          "type": "edge_ngram",
          "min_gram": 1,
          "max_gram": 32
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "query": {
        "type": "percolator"
      },
      "my_field": {
        "type": "text",
        "fields": {
          "prefix": { 
            "type": "text",
            "analyzer": "wildcard_prefix",
            "search_analyzer": "standard"
          }
        }
      }
    }
  }
}

Затем вместо индексирования следующего запроса:

{
  "query": {
    "wildcard": {
      "my_field": "abc*"
    }
  }
}

должен быть индексирован следующий запрос:

resp = client.index(
    index="my_queries1",
    id="1",
    refresh=True,
    document={
        "query": {
            "term": {
                "my_field.prefix": "abc"
            }
        }
    },
)
print(resp)

response = client.index(
  index: 'my_queries1',
  id: 1,
  refresh: true,
  body: {
    query: {
      term: {
        'my_field.prefix' => 'abc'
      }
    }
  }
)
puts response

const response = await client.index({
  index: "my_queries1",
  id: 1,
  refresh: "true",
  document: {
    query: {
      term: {
        "my_field.prefix": "abc",
      },
    },
  },
});
console.log(response);

PUT /my_queries1/_doc/1?refresh
{
  "query": {
    "term": {
      "my_field.prefix": "abc"
    }
  }
}

Таким образом, второй запрос обрабатывается более эффективно, чем первый.

Следующий запрос поиска будет соответствовать ранее индексированному запросу percolator:

resp = client.search(
    index="my_queries1",
    query={
        "percolate": {
            "field": "query",
            "document": {
                "my_field": "abcd"
            }
        }
    },
)
print(resp)

response = client.search(
  index: 'my_queries1',
  body: {
    query: {
      percolate: {
        field: 'query',
        document: {
          my_field: 'abcd'
        }
      }
    }
  }
)
puts response

const response = await client.search({
  index: "my_queries1",
  query: {
    percolate: {
      field: "query",
      document: {
        my_field: "abcd",
      },
    },
  },
});
console.log(response);

GET /my_queries1/_search
{
  "query": {
    "percolate": {
      "field": "query",
      "document": {
        "my_field": "abcd"
      }
    }
  }
}

{
  "took": 6,
  "timed_out": false,
  "_shards": {
    "total": 1,
    "successful": 1,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total" : {
        "value": 1,
        "relation": "eq"
    },
    "max_score": 0.18864399,
    "hits": [
      {
        "_index": "my_queries1",
        "_id": "1",
        "_score": 0.18864399,
        "_source": {
          "query": {
            "term": {
              "my_field.prefix": "abc"
            }
          }
        },
        "fields": {
          "_percolator_document_slot": [
            0
          ]
        }
      }
    ]
  }
}

Такая же техника может быть использована для ускорения поиска с суффиксными подстановочными знаками. Используя токен-фильтр reverse перед токен-фильтром edge_ngram.

resp = client.indices.create(
    index="my_queries2",
    settings={
        "analysis": {
            "analyzer": {
                "wildcard_suffix": {
                    "type": "custom",
                    "tokenizer": "standard",
                    "filter": [
                        "lowercase",
                        "reverse",
                        "wildcard_edge_ngram"
                    ]
                },
                "wildcard_suffix_search_time": {
                    "type": "custom",
                    "tokenizer": "standard",
                    "filter": [
                        "lowercase",
                        "reverse"
                    ]
                }
            },
            "filter": {
                "wildcard_edge_ngram": {
                    "type": "edge_ngram",
                    "min_gram": 1,
                    "max_gram": 32
                }
            }
        }
    },
    mappings={
        "properties": {
            "query": {
                "type": "percolator"
            },
            "my_field": {
                "type": "text",
                "fields": {
                    "suffix": {
                        "type": "text",
                        "analyzer": "wildcard_suffix",
                        "search_analyzer": "wildcard_suffix_search_time"
                    }
                }
            }
        }
    },
)
print(resp)

response = client.indices.create(
  index: 'my_queries2',
  body: {
    settings: {
      analysis: {
        analyzer: {
          wildcard_suffix: {
            type: 'custom',
            tokenizer: 'standard',
            filter: [
              'lowercase',
              'reverse',
              'wildcard_edge_ngram'
            ]
          },
          wildcard_suffix_search_time: {
            type: 'custom',
            tokenizer: 'standard',
            filter: [
              'lowercase',
              'reverse'
            ]
          }
        },
        filter: {
          wildcard_edge_ngram: {
            type: 'edge_ngram',
            min_gram: 1,
            max_gram: 32
          }
        }
      }
    },
    mappings: {
      properties: {
        query: {
          type: 'percolator'
        },
        my_field: {
          type: 'text',
          fields: {
            suffix: {
              type: 'text',
              analyzer: 'wildcard_suffix',
              search_analyzer: 'wildcard_suffix_search_time'
            }
          }
        }
      }
    }
  }
)
puts response

const response = await client.indices.create({
  index: "my_queries2",
  settings: {
    analysis: {
      analyzer: {
        wildcard_suffix: {
          type: "custom",
          tokenizer: "standard",
          filter: ["lowercase", "reverse", "wildcard_edge_ngram"],
        },
        wildcard_suffix_search_time: {
          type: "custom",
          tokenizer: "standard",
          filter: ["lowercase", "reverse"],
        },
      },
      filter: {
        wildcard_edge_ngram: {
          type: "edge_ngram",
          min_gram: 1,
          max_gram: 32,
        },
      },
    },
  },
  mappings: {
    properties: {
      query: {
        type: "percolator",
      },
      my_field: {
        type: "text",
        fields: {
          suffix: {
            type: "text",
            analyzer: "wildcard_suffix",
            search_analyzer: "wildcard_suffix_search_time",
          },
        },
      },
    },
  },
});
console.log(response);

PUT my_queries2
{
  "settings": {
    "analysis": {
      "analyzer": {
        "wildcard_suffix": {
          "type": "custom",
          "tokenizer": "standard",
          "filter": [
            "lowercase",
            "reverse",
            "wildcard_edge_ngram"
          ]
        },
        "wildcard_suffix_search_time": {
          "type": "custom",
          "tokenizer": "standard",
          "filter": [
            "lowercase",
            "reverse"
          ]
        }
      },
      "filter": {
        "wildcard_edge_ngram": {
          "type": "edge_ngram",
          "min_gram": 1,
          "max_gram": 32
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "query": {
        "type": "percolator"
      },
      "my_field": {
        "type": "text",
        "fields": {
          "suffix": {
            "type": "text",
            "analyzer": "wildcard_suffix",
            "search_analyzer": "wildcard_suffix_search_time" 
          }
        }
      }
    }
  }
}

Затем вместо индексации следующего запроса:

{
  "query": {
    "wildcard": {
      "my_field": "*xyz"
    }
  }
}

следует индексировать следующий запрос:

resp = client.index(
    index="my_queries2",
    id="2",
    refresh=True,
    document={
        "query": {
            "match": {
                "my_field.suffix": "xyz"
            }
        }
    },
)
print(resp)

response = client.index(
  index: 'my_queries2',
  id: 2,
  refresh: true,
  body: {
    query: {
      match: {
        'my_field.suffix' => 'xyz'
      }
    }
  }
)
puts response

const response = await client.index({
  index: "my_queries2",
  id: 2,
  refresh: "true",
  document: {
    query: {
      match: {
        "my_field.suffix": "xyz",
      },
    },
  },
});
console.log(response);

PUT /my_queries2/_doc/2?refresh
{
  "query": {
    "match": { 
      "my_field.suffix": "xyz"
    }
  }
}

Следующий запрос поиска будет соответствовать ранее индексированному запросу percolator:

resp = client.search(
    index="my_queries2",
    query={
        "percolate": {
            "field": "query",
            "document": {
                "my_field": "wxyz"
            }
        }
    },
)
print(resp)

response = client.search(
  index: 'my_queries2',
  body: {
    query: {
      percolate: {
        field: 'query',
        document: {
          my_field: 'wxyz'
        }
      }
    }
  }
)
puts response

const response = await client.search({
  index: "my_queries2",
  query: {
    percolate: {
      field: "query",
      document: {
        my_field: "wxyz",
      },
    },
  },
});
console.log(response);

GET /my_queries2/_search
{
  "query": {
    "percolate": {
      "field": "query",
      "document": {
        "my_field": "wxyz"
      }
    }
  }
}

Запросы Percolate можно добавить в любой индекс. Вместо добавления запросов Percolate в индекс, в котором хранятся данные, эти запросы также можно добавить в специализированный индекс. Преимущество этого в том, что этот специализированный индекс Percolator может иметь свои собственные настройки индекса (например, количество основных и реплицируемых фрагментов). Если вы решите использовать специализированный индекс Percolate, необходимо убедиться, что отображения из обычного индекса также доступны в индексе Percolate. В противном случае запросы Percolate могут быть неправильно обработаны.

В некоторых случаях неизвестно, какие типы запросов Percolate регистрируются, и если для полей, на которые ссылаются запросы Percolate, нет сопоставления полей, то добавление запроса Percolate завершается ошибкой. Это означает, что необходимо обновить сопоставление, чтобы поле имело соответствующие настройки, а затем можно добавить запрос Percolate. Но иногда достаточно, если все неопределённые поля обрабатываются как поля по умолчанию типа text. В таких случаях можно настроить настройку index.percolator.map_unmapped_fields_as_text на значение true (по умолчанию false), и тогда, если поле, на которое ссылается запрос Percolate, не существует, оно будет обработано как поле по умолчанию типа text, чтобы добавление запроса Percolate не завершилось ошибкой.

Поскольку запрос percolate обрабатывает один документ за раз, он не поддерживает запросы и фильтры, которые выполняются над дочерними документами, такие как has_child и has_parent.

Существует ряд запросов, которые извлекают данные с помощью вызова get во время анализа запроса. Например, запрос terms при использовании поиска по словам, запрос template при использовании индексированных скриптов и запрос geo_shape при использовании предварительно индексированных форм. Когда эти запросы индексируются типом поля percolator, вызов get выполняется один раз. Таким образом, каждый раз, когда запрос Percolate оценивает эти запросы, будут использоваться извлечённые термины, формы и т. д. важно отметить, что извлечение терминов, выполняемое этими запросами, происходит каждый раз, когда запрос Percolate индексируется как на основных, так и на реплицируемых фрагментах, поэтому термины, которые фактически индексируются, могут отличаться между копиями фрагментов, если исходный индекс изменился во время индексирования.

Скрипт внутри запроса script может получить доступ только к полям doc values. Запрос percolate индексирует предоставленный документ в индекс в оперативной памяти. Этот индекс в оперативной памяти не поддерживает сохранённые поля, и поэтому поле _source и другие сохранённые поля не сохраняются. Именно поэтому в запросе script поля _source и другие сохранённые поля недоступны.

Запросы Percolate, содержащие псевдонимы полей, могут не всегда вести себя как ожидается. В частности, если зарегистрирован запрос Percolate, содержащий псевдоним поля, а затем этот псевдоним обновляется в отображениях, чтобы ссылаться на другое поле, сохранённый запрос по-прежнему будет ссылаться на исходное целевое поле. Чтобы отразить изменения псевдонима поля, запрос Percolate необходимо явно переиндексировать.