Spec-Zone.ru › Elasticsearch 8
›Руководство по Elasticsearch [8.17] ›DSL-запросы ›Полные текстовые запросы

Запрос по интервалам

Возвращает документы, основанные на порядке и близости совпадающих терминов.

Запрос intervals использует правила соответствия, построенные на основе небольшого набора определений. Эти правила затем применяются к терминам из указанного field.

Определения генерируют последовательности минимальных интервалов, которые охватывают термины в тексте. Эти интервалы могут быть далее объединены и отфильтрованы родительскими источниками.

Пример запроса

Следующий intervals поиск возвращает документы, содержащие my favorite food без каких-либо разрывов, за которыми следуют hot water или cold porridge в поле my_text.

Этот поиск будет соответствовать значению my_text my favorite food is cold porridge, но не when it's cold my favorite food is porridge.

resp = client.search(
    query={
        "intervals": {
            "my_text": {
                "all_of": {
                    "ordered": True,
                    "intervals": [
                        {
                            "match": {
                                "query": "my favorite food",
                                "max_gaps": 0,
                                "ordered": True
                            }
                        },
                        {
                            "any_of": {
                                "intervals": [
                                    {
                                        "match": {
                                            "query": "hot water"
                                        }
                                    },
                                    {
                                        "match": {
                                            "query": "cold porridge"
                                        }
                                    }
                                ]
                            }
                        }
                    ]
                }
            }
        }
    },
)
print(resp)
response = client.search(
  body: {
    query: {
      intervals: {
        my_text: {
          all_of: {
            ordered: true,
            intervals: [
              {
                match: {
                  query: 'my favorite food',
                  max_gaps: 0,
                  ordered: true
                }
              },
              {
                any_of: {
                  intervals: [
                    {
                      match: {
                        query: 'hot water'
                      }
                    },
                    {
                      match: {
                        query: 'cold porridge'
                      }
                    }
                  ]
                }
              }
            ]
          }
        }
      }
    }
  }
)
puts response
const response = await client.search({
  query: {
    intervals: {
      my_text: {
        all_of: {
          ordered: true,
          intervals: [
            {
              match: {
                query: "my favorite food",
                max_gaps: 0,
                ordered: true,
              },
            },
            {
              any_of: {
                intervals: [
                  {
                    match: {
                      query: "hot water",
                    },
                  },
                  {
                    match: {
                      query: "cold porridge",
                    },
                  },
                ],
              },
            },
          ],
        },
      },
    },
  },
});
console.log(response);
POST _search
{
  "query": {
    "intervals" : {
      "my_text" : {
        "all_of" : {
          "ordered" : true,
          "intervals" : [
            {
              "match" : {
                "query" : "my favorite food",
                "max_gaps" : 0,
                "ordered" : true
              }
            },
            {
              "any_of" : {
                "intervals" : [
                  { "match" : { "query" : "hot water" } },
                  { "match" : { "query" : "cold porridge" } }
                ]
              }
            }
          ]
        }
      }
    }
  }
}

Параметры верхнего уровня для запроса по интервалам

<field>

(Обязательно, объект правила) Поле, которое вы хотите искать.

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

Допустимые правила включают:

  • match
  • prefix
  • wildcard
  • regexp
  • fuzzy
  • range
  • all_of
  • any_of

match параметры правила

Правило match сопоставляет проанализированный текст.

query
(Обязательно, строка) Текст, который вы хотите найти в предоставленном поле <field>.
max_gaps

(Необязательно, целое число) Максимальное количество позиций между совпадающими терминами. Термины, находящиеся на большем расстоянии, не считаются совпадениями. По умолчанию -1.

Если не указано или установлено в -1, ограничений по ширине совпадения нет. Если установлено в 0, термины должны находиться рядом друг с другом.

ordered
(Необязательно, Булево) Если true, совпадающие термины должны появляться в указанном порядке. По умолчанию false.
analyzer
(Необязательно, строка) анализатор, используемый для анализа терминов в поле query. По умолчанию — анализатор верхнего уровня <field>.
filter
(Необязательно, правило фильтра интервалов) Необязательный фильтр интервалов.
use_field
(Необязательно, строка) Если указано, интервалы соответствия будут извлекаться из этого поля, а не из верхнего уровня <field>. Термины анализируются с помощью анализирующего поля поиска. Это позволяет искать по нескольким полям, как если бы они были одним полем; например, вы можете индексировать один и тот же текст в полях со стемингом и без стеминга и искать термин со стемингом рядом с нестеменными.

prefix параметры правила

Правило prefix сопоставляет термины, начинающиеся с указанного набора символов. Этот префикс может расширяться, чтобы соответствовать максимум indices.query.bool.max_clause_count параметрам поиска. Если префикс соответствует большему количеству терминов, Elasticsearch возвращает ошибку. Вы можете использовать параметр index-prefixes в схеме поля, чтобы избежать этого ограничения.

prefix
(Обязательно, строка) Начальные символы терминов, которые вы хотите найти в верхнем уровне <field>.
analyzer
(Необязательно, строка) анализатор, используемый для нормализации prefix. По умолчанию — анализатор верхнего уровня <field>.
use_field

(Необязательно, строка) Если указано, интервалы соответствия будут извлекаться из этого поля, а не из верхнего уровня <field>.

prefix нормализуется с помощью анализирующего поля поиска, если отдельно не указан analyzer.

wildcard параметры правила

Правило wildcard сопоставляет термины, используя шаблон с подстановкой. Этот шаблон может расширяться, чтобы соответствовать максимум indices.query.bool.max_clause_count параметрам поиска. Если шаблон соответствует большему количеству терминов, Elasticsearch возвращает ошибку.

pattern

(Обязательно, строка) Шаблон с подстановкой, используемый для поиска совпадающих терминов.

Этот параметр поддерживает два оператора подстановки:

  • ?, который соответствует любому одиночному символу
  • *, который может соответствовать нулю или более символам, включая пустой

Избегайте шаблонов, начинающихся с * или ?. Это может увеличить количество итераций, необходимых для поиска совпадающих терминов, и замедлить производительность поиска.

analyzer
(Необязательно, строка) анализатор, используемый для нормализации pattern. По умолчанию — анализатор верхнего уровня <field>.
use_field

(Необязательно, строка) Если указано, интервалы соответствия будут извлекаться из этого поля, а не из верхнего уровня <field>.

pattern нормализуется с помощью анализирующего поля поиска, если отдельно не указан analyzer.

regexp параметры правила

Правило regexp сопоставляет термины, используя шаблон регулярного выражения. Этот шаблон может расширяться, чтобы соответствовать максимум indices.query.bool.max_clause_count параметрам поиска. Если шаблон соответствует большему количеству терминов, Elasticsearch возвращает ошибку.

pattern
(Обязательно, строка) Шаблон регулярного выражения, используемый для поиска совпадающих терминов. Список операторов, поддерживаемых шаблоном regexp, см. в синтаксисе регулярных выражений.

Избегайте использования шаблонов с подстановкой, таких как .* или .*?+`. Это может увеличить количество итераций, необходимых для поиска совпадающих терминов, и замедлить производительность поиска.

analyzer
(Необязательно, строка) анализатор, используемый для нормализации pattern. По умолчанию — анализатор верхнего уровня <field>.
use_field

(Необязательно, строка) Если указано, интервалы соответствия будут извлекаться из этого поля, а не из верхнего уровня <field>.

pattern нормализуется с помощью анализирующего поля поиска, если отдельно не указан analyzer.

fuzzy параметры правила

Правило fuzzy соответствует терминам, похожим на предоставленный термин, в пределах расстояния редактирования, определенного параметром Fuzziness. Если расширение с учетом близости совпадает с более чем indices.query.bool.max_clause_count параметрами настроек поиска, Elasticsearch возвращает ошибку.

term
(Обязательно, строка) Термин для сопоставления
prefix_length
(Необязательно, целое число) Количество начальных символов, оставшихся неизменными при создании расширений. По умолчанию значение 0.
transpositions
(Необязательно, логическое значение) Указывает, включают ли правки транспозиции двух смежных символов (ab → ba). По умолчанию значение true.
fuzziness
(Необязательно, строка) Максимальное расстояние редактирования, разрешенное для сопоставления. См. Fuzziness для допустимых значений и дополнительной информации. По умолчанию значение auto.
analyzer
(Необязательно, строка) анализатор, используемый для нормализации term. По умолчанию анализатор верхнего уровня <field>.
use_field

(Необязательно, строка) При указании, сопоставлять интервалы из этого поля, а не из верхнего уровня <field>.

term нормализуется с помощью анализатора поиска из этого поля, если analyzer не указан отдельно.

range параметры правила

Правило range сопоставляет термины, содержащиеся в предоставленном диапазоне. Этот диапазон может расширяться, чтобы соответствовать максимум indices.query.bool.max_clause_count настроек поиска. Если диапазон соответствует большему количеству терминов, Elasticsearch возвращает ошибку.

gt
(Необязательно, строка) Больше, чем: сопоставить термины, большие, чем предоставленный термин.
gte
(Необязательно, строка) Больше или равно: сопоставить термины, большие или равные предоставленному термину.
lt
(Необязательно, строка) Меньше, чем: сопоставить термины, меньшие, чем предоставленный термин.
lte
(Необязательно, строка) Меньше или равно: сопоставить термины, меньшие или равные предоставленному термину.

Необходимо указать один из параметров gt или gte. Требуется указать один из параметров lt или lte.

analyzer
(Необязательно, строка) анализатор, используемый для нормализации pattern. По умолчанию анализатор верхнего уровня <field>.
use_field
(Необязательно, строка) Если указано, сопоставлять интервалы из этого поля, а не из верхнего уровня <field>.

all_of параметры правила

Правило all_of возвращает совпадения, охватывающие комбинацию других правил.

intervals
(Обязательно, массив объектов правила) Массив правил для объединения. Все правила должны соответствовать документу для соответствия исходному значению.
max_gaps

(Необязательно, целое число) Максимальное количество позиций между сопоставляемыми терминами. Интервалы, созданные правилами, которые находятся дальше, чем это значение, не считаются совпадениями. По умолчанию -1.

Если не указано или установлено значение -1, ограничений на ширину совпадения нет. Если установлено значение 0, термины должны появляться рядом.

ordered
(Необязательно, логическое значение) Если true, интервалы, созданные правилами, должны появляться в том порядке, в котором они указаны. По умолчанию false.
filter
(Необязательно, объект правила фильтра интервалов) Правило, используемое для фильтрации возвращаемых интервалов.

any_of параметры правила

Правило any_of возвращает интервалы, созданные любым из его подправил.

intervals
(Обязательно, массив объектов правила) Массив правил для сопоставления.
filter
(Необязательно, объект правила фильтра интервалов) Правило, используемое для фильтрации возвращаемых интервалов.

filter параметры правила

Правило filter возвращает интервалы, основанные на запросе. Смотрите Пример фильтра для примера.

after
(Необязательно, объект запроса) Запрос, используемый для возврата интервалов, которые следуют за интервалом из правила filter.
before
(Необязательно, объект запроса) Запрос, используемый для возврата интервалов, которые предшествуют интервалу из правила filter.
contained_by
(Необязательно, объект запроса) Запрос, используемый для возврата интервалов, содержащихся в интервале из правила filter.
containing
(Необязательно, объект запроса) Запрос, используемый для возврата интервалов, которые содержат интервал из правила filter.
not_contained_by
(Необязательно, объект запроса) Запрос, используемый для возврата интервалов, которые не содержатся в интервале из правила filter.
not_containing
(Необязательно, объект запроса) Запрос, используемый для возврата интервалов, которые не содержат интервал из правила filter.
not_overlapping
(Необязательно, объект запроса) Запрос, используемый для возврата интервалов, которые не перекрываются с интервалом из правила filter.
overlapping
(Необязательно, объект запроса) Запрос, используемый для возврата интервалов, которые перекрываются с интервалом из правила filter.
script
(Необязательно, объект скрипта) Скрипт, используемый для возврата соответствующих документов. Этот скрипт должен возвращать булево значение, true или false. Смотрите Фильтры скриптов для примера.

Примечания

Пример фильтра

Следующий поиск включает правило filter. Он возвращает документы, содержащие слова hot и porridge в пределах 10 позиций друг от друга без слова salty между ними:

resp = client.search(
    query={
        "intervals": {
            "my_text": {
                "match": {
                    "query": "hot porridge",
                    "max_gaps": 10,
                    "filter": {
                        "not_containing": {
                            "match": {
                                "query": "salty"
                            }
                        }
                    }
                }
            }
        }
    },
)
print(resp)
response = client.search(
  body: {
    query: {
      intervals: {
        my_text: {
          match: {
            query: 'hot porridge',
            max_gaps: 10,
            filter: {
              not_containing: {
                match: {
                  query: 'salty'
                }
              }
            }
          }
        }
      }
    }
  }
)
puts response
const response = await client.search({
  query: {
    intervals: {
      my_text: {
        match: {
          query: "hot porridge",
          max_gaps: 10,
          filter: {
            not_containing: {
              match: {
                query: "salty",
              },
            },
          },
        },
      },
    },
  },
});
console.log(response);
POST _search
{
  "query": {
    "intervals" : {
      "my_text" : {
        "match" : {
          "query" : "hot porridge",
          "max_gaps" : 10,
          "filter" : {
            "not_containing" : {
              "match" : {
                "query" : "salty"
              }
            }
          }
        }
      }
    }
  }
}

Скриптовые фильтры

Вы можете использовать скрипт для фильтрации интервалов на основе начальной позиции, конечной позиции и количества внутренних пробелов. Следующий filter скрипт использует переменную interval с методами start, end и gaps:

resp = client.search(
    query={
        "intervals": {
            "my_text": {
                "match": {
                    "query": "hot porridge",
                    "filter": {
                        "script": {
                            "source": "interval.start > 10 && interval.end < 20 && interval.gaps == 0"
                        }
                    }
                }
            }
        }
    },
)
print(resp)
response = client.search(
  body: {
    query: {
      intervals: {
        my_text: {
          match: {
            query: 'hot porridge',
            filter: {
              script: {
                source: 'interval.start > 10 && interval.end < 20 && interval.gaps == 0'
              }
            }
          }
        }
      }
    }
  }
)
puts response
const response = await client.search({
  query: {
    intervals: {
      my_text: {
        match: {
          query: "hot porridge",
          filter: {
            script: {
              source:
                "interval.start > 10 && interval.end < 20 && interval.gaps == 0",
            },
          },
        },
      },
    },
  },
});
console.log(response);
POST _search
{
  "query": {
    "intervals" : {
      "my_text" : {
        "match" : {
          "query" : "hot porridge",
          "filter" : {
            "script" : {
              "source" : "interval.start > 10 && interval.end < 20 && interval.gaps == 0"
            }
          }
        }
      }
    }
  }
}

Минимизация

Запрос к интервалам всегда минимизирует интервалы, чтобы запросы могли выполняться за линейное время. Это иногда приводит к неожиданным результатам, особенно при использовании max_gaps ограничений или фильтров. Например, рассмотрим следующий запрос, ищущий salty в фразе hot porridge:

resp = client.search(
    query={
        "intervals": {
            "my_text": {
                "match": {
                    "query": "salty",
                    "filter": {
                        "contained_by": {
                            "match": {
                                "query": "hot porridge"
                            }
                        }
                    }
                }
            }
        }
    },
)
print(resp)
response = client.search(
  body: {
    query: {
      intervals: {
        my_text: {
          match: {
            query: 'salty',
            filter: {
              contained_by: {
                match: {
                  query: 'hot porridge'
                }
              }
            }
          }
        }
      }
    }
  }
)
puts response
const response = await client.search({
  query: {
    intervals: {
      my_text: {
        match: {
          query: "salty",
          filter: {
            contained_by: {
              match: {
                query: "hot porridge",
              },
            },
          },
        },
      },
    },
  },
});
console.log(response);
POST _search
{
  "query": {
    "intervals" : {
      "my_text" : {
        "match" : {
          "query" : "salty",
          "filter" : {
            "contained_by" : {
              "match" : {
                "query" : "hot porridge"
              }
            }
          }
        }
      }
    }
  }
}

Этот запрос не соответствует документу, содержащему фразу hot porridge is salty porridge, потому что интервалы, возвращаемые запросом соответствия для hot porridge, покрывают только первые два термина в этом документе, и они не перекрывают интервалы, охватывающие salty.

© 2023-2025 Elasticsearch
As of September 2024, Elasticsearch is available under a choice of three licenses: the Server Side Public License (SSPL), the Elastic License, or the AGPLv3 (OSI approved).
Elasticsearch and the Elasticsearch logo are trademarks of Elasticsearch B.V., registered in the U.S. and in other countries.
https://www.elastic.co/guide/en/elasticsearch/reference/8.17/query-dsl-intervals-query.html

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API