BM25A(k1,b) возвращает точное значение BM25A(). Требует ранжировщика expr и включённого index_field_lengths. Параметры k1 и b должны быть числами с плавающей точкой.

BM25F(k1, b, {field=weight, ...}) возвращает точное значение BM25F() и требует включённого index_field_lengths. Также необходим ранжировщик expr. Параметры k1 и b должны быть числами с плавающей точкой.

Заменяет несуществующие столбцы значениями по умолчанию. Возвращает либо значение атрибута, указанного в 'attr-name', либо 'default-value', если такой атрибут отсутствует. Атрибуты STRING или MVA не поддерживаются. Эта функция полезна при поиске по нескольким таблицам с разными схемами.

SELECT *, EXIST('gid', 6) as cnd FROM i1, i2 WHERE cnd>5

Возвращает значение ключа сортировки наихудшего элемента в текущих топ-N совпадениях, если ключ сортировки — число с плавающей точкой, иначе 0.

Возвращает вес наихудшего элемента в текущих топ-N совпадениях.

PACKEDFACTORS() можно использовать в запросах для отображения всех вычисленных факторов взвешивания во время сопоставления или для предоставления бинарного атрибута для создания пользовательской функции ранжирования UDF. Эта функция работает только при указании ранжировщика выражений и если запрос не является полным сканированием; в противном случае возвращается ошибка. PACKEDFACTORS() может принимать необязательный аргумент, отключающий вычисление фактора ранжирования ATC: PACKEDFACTORS({no_atc=1}). Вычисление ATC значительно замедляет обработку запроса, поэтому эта опция полезна, если нужно видеть факторы ранжирования, но ATC не требуется. PACKEDFACTORS() также может выводить данные в формате JSON: PACKEDFACTORS({json=1}). Соответствующие выводы в формате пар ключ-значение или JSON показаны ниже. (Обратите внимание, что приведённые примеры разбиты для удобства чтения; фактические возвращаемые значения будут в одной строке.)

mysql> SELECT id, PACKEDFACTORS() FROM test1
    -> WHERE MATCH('test one') OPTION ranker=expr('1') \G
*************************** 1\. row ***************************
             id: 1
packedfactors(): bm25=569, bm25a=0.617197, field_mask=2, doc_word_count=2,
    field1=(lcs=1, hit_count=2, word_count=2, tf_idf=0.152356,
        min_idf=-0.062982, max_idf=0.215338, sum_idf=0.152356, min_hit_pos=4,
        min_best_span_pos=4, exact_hit=0, max_window_hits=1, min_gaps=2,
        exact_order=1, lccs=1, wlccs=0.215338, atc=-0.003974),
    word0=(tf=1, idf=-0.062982),
    word1=(tf=1, idf=0.215338)
1 row in set (0.00 sec)

mysql> SELECT id, PACKEDFACTORS({json=1}) FROM test1
    -> WHERE MATCH('test one') OPTION ranker=expr('1') \G
*************************** 1\. row ***************************
                     id: 1
packedfactors({json=1}):
{
    "bm25": 569,
    "bm25a": 0.617197,
    "field_mask": 2,
    "doc_word_count": 2,
    "fields": [
        {
            "lcs": 1,
            "hit_count": 2,
            "word_count": 2,
            "tf_idf": 0.152356,
            "min_idf": -0.062982,
            "max_idf": 0.215338,
            "sum_idf": 0.152356,
            "min_hit_pos": 4,
            "min_best_span_pos": 4,
            "exact_hit": 0,
            "max_window_hits": 1,
            "min_gaps": 2,
            "exact_order": 1,
            "lccs": 1,
            "wlccs": 0.215338,
            "atc": -0.003974
        }
    ],
    "words": [
        {
            "tf": 1,
            "idf": -0.062982
        },
        {
            "tf": 1,
            "idf": 0.215338
        }
    ]
}
1 row in set (0.01 sec)

Эта функция может использоваться для реализации пользовательских функций ранжирования в UDF, например:

SELECT *, CUSTOM_RANK(PACKEDFACTORS()) AS r
FROM my_index
WHERE match('hello')
ORDER BY r DESC
OPTION ranker=expr('1');

Где CUSTOM_RANK() — функция, реализованная в UDF. Она должна объявить структуру SPH_UDF_FACTORS (определённую в sphinxudf.h), инициализировать эту структуру, распаковать в неё факторы перед использованием и деинициализировать после, следующим образом:

SPH_UDF_FACTORS factors;
sphinx_factors_init(&factors);
sphinx_factors_unpack((DWORD*)args->arg_values[0], &factors);
// ... can use the contents of factors variable here ...
sphinx_factors_deinit(&factors);

Данные PACKEDFACTORS() доступны на всех этапах запроса, а не только во время начального прохода сопоставления и ранжирования. Это открывает ещё одно особенно интересное применение PACKEDFACTORS(): повторное ранжирование.

В приведённом выше примере мы использовали ранжировщик на основе выражений с фиктивным выражением и отсортировали набор результатов по значению, вычисленному нашей UDF. Другими словами, мы использовали UDF для ранжирования всех результатов. Теперь предположим для примера, что наша UDF чрезвычайно затратна в вычислении, с пропускной способностью всего 10 000 вызовов в секунду. Если наш запрос совпадает с 1 000 000 документов, мы хотели бы использовать гораздо более простое выражение для основной части ранжирования, чтобы сохранить разумную производительность. Затем мы применим дорогую UDF только к нескольким лучшим результатам, скажем, к топ-100. Другими словами, мы построим топ-100 результатов с помощью более простой функции ранжирования, а затем повторно отсортируем их с помощью более сложной. Это можно сделать с помощью подзапросов:

SELECT * FROM (
    SELECT *, CUSTOM_RANK(PACKEDFACTORS()) AS r
    FROM my_index WHERE match('hello')
    OPTION ranker=expr('sum(lcs)*1000+bm25')
    ORDER BY WEIGHT() DESC
    LIMIT 100
) ORDER BY r DESC LIMIT 10

В этом примере ранжировщик на основе выражений вызывается для каждого совпавшего документа для вычисления WEIGHT(), поэтому он вызывается 1 000 000 раз. Однако вычисление UDF можно отложить до внешней сортировки, и оно будет выполнено только для топ-100 совпадений по WEIGHT(), согласно внутреннему ограничению. Это означает, что UDF будет вызвана всего 100 раз. Наконец, выбираются и возвращаются приложению топ-10 совпадений по значению UDF.

Для справки, в распределённой конфигурации данные PACKEDFACTORS() передаются от агентов к мастер-узлу в бинарном формате. Это технически позволяет реализовать дополнительные проходы повторного ранжирования на мастер-узле при необходимости.

При использовании в SQL, но без вызова из UDF, результат PACKEDFACTORS() форматируется как простой текст, который можно использовать для ручной оценки факторов ранжирования. Обратите внимание, что эта функция в настоящее время не поддерживается API Manticore.

REMOVE_REPEATS ( result_set, column, offset, limit ) — удаляет повторяющиеся скорректированные строки с одинаковым значением 'column'.

SELECT REMOVE_REPEATS((SELECT * FROM dist1), gid, 0, 10)

Обратите внимание, что REMOVE_REPEATS не влияет на total_found в метаинформации поискового запроса.

Функция WEIGHT() возвращает вычисленный балл совпадения. Если порядок не задан, результат сортируется по убыванию балла, возвращаемого WEIGHT(). В этом примере мы сначала сортируем по весу, затем по целочисленному атрибуту.

Приведённый выше поиск выполняет простое сопоставление, где все слова должны присутствовать. Однако можно сделать больше (и это всего лишь простой пример):

mysql> SELECT *,WEIGHT() FROM testrt WHERE MATCH('"list of business laptops"/3');
+------+------+-------------------------------------+---------------------------+----------+
| id   | gid  | title                               | content                   | weight() |
+------+------+-------------------------------------+---------------------------+----------+
|    1 |   10 | List of HP business laptops         | Elitebook Probook         |     2397 |
|    2 |   10 | List of Dell business laptops       | Latitude Precision Vostro |     2397 |
|    3 |   20 | List of Dell gaming laptops         | Inspirion Alienware       |     2375 |
|    5 |   30 | List of ASUS ultrabooks and laptops | Zenbook Vivobook          |     2375 |
+------+------+-------------------------------------+---------------------------+----------+
4 rows in set (0.00 sec)
mysql> SHOW META;
+----------------+----------+
| Variable_name  | Value    |
+----------------+----------+
| total          | 4        |
| total_found    | 4        |
| total_relation | eq       |
| time           | 0.000    |
| keyword[0]     | list     |
| docs[0]        | 5        |
| hits[0]        | 5        |
| keyword[1]     | of       |
| docs[1]        | 4        |
| hits[1]        | 4        |
| keyword[2]     | business |
| docs[2]        | 2        |
| hits[2]        | 2        |
| keyword[3]     | laptops  |
| docs[3]        | 5        |
| hits[3]        | 5        |
+----------------+----------+
16 rows in set (0.00 sec)

Здесь мы ищем четыре слова, но совпадение может произойти, если найдены только три из четырёх слов. Поиск будет ранжировать документы, содержащие все слова, выше.

Функция ZONESPANLIST() возвращает пары совпавших зональных интервалов. Каждая пара содержит идентификатор совпавшего зонального интервала, двоеточие и порядковый номер совпавшего зонального интервала. Например, если в документе содержится <emphasis role="bold"><i>text</i> the <i>text</i></emphasis>, и вы выполняете запрос 'ZONESPAN:(i,b) text', то ZONESPANLIST() вернёт строку "1:1 1:2 2:1", что означает, что первый зональный интервал совпал со словом "text" в интервалах 1 и 2, а второй зональный интервал — только в интервале 1.

QUERY() возвращает текущий поисковый запрос. QUERY() является выражением postlimit и предназначена для использования с SNIPPET().

Табличные функции — это механизм обработки набора результатов после выполнения запроса. Табличные функции принимают произвольный набор результатов на вход и возвращают новый, обработанный набор на выход. Первый аргумент должен быть входным набором результатов, но табличная функция может дополнительно принимать и обрабатывать другие аргументы. Табличные функции могут полностью изменить набор результатов, включая схему. В настоящее время поддерживаются только встроенные табличные функции. Табличные функции работают как для внешнего SELECT, так и для вложенного SELECT.

Приведение типов включает три основных действия: преобразование, переинтерпретацию и продвижение.

• Преобразование. Это процесс изменения типа данных значения на другой тип данных. Это требует дополнительных вычислений и выполняется исключительно функцией TO_STRING().
• Переинтерпретация. Это означает обработку двоичных данных, представляющих значение, как если бы они были другого типа данных, без фактического изменения исходных данных. Это выполняется функцией SINT(), не требует дополнительных вычислений; вместо этого просто переинтерпретирует существующие данные.
• Продвижение. Это процесс преобразования значения в "больший" или более точный тип данных. Это также не требует дополнительных вычислений; просто запрашивает у аргумента выдачу значения другого типа. Только JSON-поля и несколько других функций могут продвигать свои значения к целым числам. Если аргумент не может выдать значение другого типа, продвижение завершится неудачей. Например, функция TIMEDIFF() обычно возвращает строку, но может также возвращать число. Поэтому BIGINT(TIMEDIFF(1,2)) выполнится успешно, заставляя TIMEDIFF() выдавать целочисленное значение. Напротив, DATE_FORMAT() возвращает только строки и не может выдать число, значит BIGINT(DATE_FORMAT(...)) завершится неудачей.

Эта функция продвигает целочисленный аргумент к 64-битному типу, оставляя аргументы с плавающей точкой без изменений. Она предназначена для обеспечения вычисления определённых выражений (например, a*b) в 64-битном режиме, даже если все аргументы 32-битные.

Функция DOUBLE() продвигает свой аргумент к типу с плавающей точкой. Это предназначено для принудительного вычисления числовых JSON-полей.

Функция INTEGER() продвигает свой аргумент к 64-битному знаковому типу. Это предназначено для принудительного вычисления числовых JSON-полей.

Эта функция принудительно преобразует свой аргумент к строковому типу.

Функция UINT() продвигает свой аргумент к 32-битному беззнаковому целочисленному типу.

Функция UINT64() продвигает свой аргумент к 64-битному беззнаковому целочисленному типу.

Функция SINT() принудительно переинтерпретирует свой 32-битный беззнаковый целочисленный аргумент как знаковый и расширяет его до 64-битного типа (поскольку 32-битный тип беззнаковый). Например, выражение 1-2 обычно вычисляется как 4294967295, но SINT(1-2) вычисляется как -1.

select *, ALL(x>0 AND x<4 FOR x IN j.ar) from tbl

select *, ALL(x>0 AND x<4 FOR x IN j.ar) cond from tbl where cond=1

+------+--------------+--------------------------------+
| id   | j            | all(x>0 and x<4 for x in j.ar) |
+------+--------------+--------------------------------+
|    1 | {"ar":[1,3]} |                              1 |
|    2 | {"ar":[3,7]} |                              0 |
+------+--------------+--------------------------------+
2 rows in set (0.00 sec)

+------+--------------+------+
| id   | j            | cond |
+------+--------------+------+
|    1 | {"ar":[1,3]} |    1 |
+------+--------------+------+
1 row in set (0.00 sec)

select * from tbl where all(m) >= 1

select * from tbl where all(m) in (1, 3, 7, 10)

+------+------+
| id   | m    |
+------+------+
|    1 | 1,3  |
|    2 | 3,7  |
+------+------+
2 rows in set (0.00 sec)

+------+------+
| id   | m    |
+------+------+
|    1 | 1,3  |
|    2 | 3,7  |
+------+------+
2 rows in set (0.00 sec)

select * from tbl where all(m) not in (2, 4)

+------+------+
| id   | m    |
+------+------+
|    1 | 1,3  |
|    2 | 3,7  |
+------+------+
2 rows in set (0.00 sec)

select * from tbl where tags all('bug', 'release')

mysql> select * from tbl
+------+---------------------------+
| id   | tags                      |
+------+---------------------------+
|    1 | bug priority_high release |
|    2 | bug priority_low release  |
+------+---------------------------+
2 rows in set (0.00 sec)
mysql> select * from tbl where tags not all('bug')
Empty set (0.00 sec)

+------+---------------------------+
| id   | tags                      |
+------+---------------------------+
|    1 | bug priority_high release |
|    2 | bug priority_low release  |
+------+---------------------------+
2 rows in set (0.00 sec)

select *, ANY(x>5 AND x<10 FOR x IN j.ar) from tbl

select *, ANY(x>5 AND x<10 FOR x IN j.ar) cond from tbl where cond=1

+------+--------------+---------------------------------+
| id   | j            | any(x>5 and x<10 for x in j.ar) |
+------+--------------+---------------------------------+
|    1 | {"ar":[1,3]} |                               0 |
|    2 | {"ar":[3,7]} |                               1 |
+------+--------------+---------------------------------+
2 rows in set (0.00 sec)

+------+--------------+------+
| id   | j            | cond |
+------+--------------+------+
|    2 | {"ar":[3,7]} |    1 |
+------+--------------+------+
1 row in set (0.00 sec)

mysql> select * from tbl
+------+------+
| id   | m    |
+------+------+
|    1 | 1,3  |
|    2 | 3,7  |
+------+------+
2 rows in set (0.01 sec)
mysql> select * from tbl where any(m) > 5
+------+------+
| id   | m    |
+------+------+
|    2 | 3,7  |
+------+------+
1 row in set (0.00 sec)

select * from tbl where any(m) in (1, 7, 10)

+------+------+
| id   | m    |
+------+------+
|    1 | 1,3  |
|    2 | 3,7  |
+------+------+
2 rows in set (0.00 sec)

mysql> select * from tbl
+------+------+
| id   | m    |
+------+------+
|    1 | 1,3  |
|    2 | 3,7  |
+------+------+
2 rows in set (0.00 sec)
mysql> select * from tbl where any(m) not in (1, 3, 5)
+------+------+
| id   | m    |
+------+------+
|    2 | 3,7  |
+------+------+
1 row in set (0.00 sec)

select * from tbl where tags any('bug', 'feature')

select * from tbl
--------------
+------+---------------------------+
| id   | tags                      |
+------+---------------------------+
|    1 | bug priority_high release |
|    2 | bug priority_low release  |
+------+---------------------------+
2 rows in set (0.00 sec)
--------------
select * from tbl where tags not any('feature', 'priority_low')
--------------
+------+---------------------------+
| id   | tags                      |
+------+---------------------------+
|    1 | bug priority_high release |
+------+---------------------------+
1 row in set (0.01 sec)

+------+---------------------------+
| id   | tags                      |
+------+---------------------------+
|    1 | bug priority_high release |
|    2 | bug priority_low release  |
+------+---------------------------+
2 rows in set (0.00 sec)

CONTAINS(polygon, x, y) проверяет, находится ли точка (x,y) внутри заданного полигона, и возвращает 1, если да, или 0, если нет. Полигон должен быть задан с помощью функции POLY2D(). Эта функция предназначена для "маленьких" полигонов, то есть со стороной менее 500 км (300 миль), и не учитывает кривизну Земли для ускорения. Для больших расстояний следует использовать GEOPOLY2D, который разбивает заданный полигон на меньшие части с учётом кривизны Земли.

IF ( sqrt(3)*sqrt(3)-3<>0, a, b )
IF ( sqrt(3)*sqrt(3)-3, a, b )

В первом случае оператор сравнения <> вернёт 0.0 (ложь) из-за порога, и IF() всегда вернёт ** как результат. Во втором случае выражение sqrt(3)*sqrt(3)-3 будет сравниваться с нулём без порога самой функцией IF(). Однако его значение будет немного отличаться от нуля из-за ограниченной точности вычислений с плавающей точкой. Из-за этого сравнение с 0.0, выполненное IF(), не пройдёт, и второй вариант вернёт 'a' как результат.

key_of_the_bucket = interval + offset * floor ( ( value - offset ) / interval )

SELECT COUNT(*),
HISTOGRAM(price, {hist_interval=100}) as price_range
FROM facets
GROUP BY price_range ORDER BY price_range ASC;

IN(expr,val1,val2,...) принимает 2 или более аргументов и возвращает 1, если первый аргумент (expr) равен любому из других аргументов (val1..valN), или 0 в противном случае. В настоящее время все проверяемые значения (но не само выражение) должны быть константами. Константы предварительно сортируются, и используется бинарный поиск, поэтому IN() даже при большом произвольном списке констант будет очень быстрым. Первый аргумент также может быть атрибутом MVA. В этом случае IN() вернет 1, если любое из значений MVA равно любому из других аргументов. IN() также поддерживает синтаксис IN(expr,@uservar) для проверки, принадлежит ли значение списку в данном глобальном пользовательском переменном. Первый аргумент может быть JSON-атрибутом.

Функция INDEXOF(cond FOR var IN json.array) перебирает все элементы массива и возвращает индекс первого элемента, для которого 'cond' истинно, и -1, если 'cond' ложно для каждого элемента массива.

INTERVAL(expr,point1,point2,point3,...) принимает 2 или более аргументов и возвращает индекс аргумента, который меньше первого аргумента: возвращает 0, если expr<point1, 1, если point1<=expr<point2 и так далее. Для корректной работы функции требуется, чтобы point1<point2<...<pointN.

Функция LENGTH(attr_mva) возвращает количество элементов в наборе MVA. Она работает как с 32-битными, так и с 64-битными атрибутами MVA. LENGTH(attr_json) возвращает длину поля в JSON. Возвращаемое значение зависит от типа поля. Например, LENGTH(json_attr.some_int) всегда возвращает 1, а LENGTH(json_attr.some_array) возвращает количество элементов в массиве. Функция LENGTH(string_expr) возвращает длину строки, полученной из выражения. TO_STRING() должна обрамлять выражение, независимо от того, возвращает ли выражение нестроковое значение или это просто строковый атрибут.

SELECT COUNT(*),
RANGE(price, {range_to=150},{range_from=150,range_to=300},{range_from=300}) price_range
FROM facets
GROUP BY price_range ORDER BY price_range ASC;

SELECT id, size, REMAP(size, 15, (5,6,7,8), (1,1,2,2)) s
FROM products
ORDER BY s ASC;

SELECT REMAP(userid, karmapoints, (1, 67), (999, 0)) FROM users;
SELECT REMAP(id%10, salary, (0), (0.0)) FROM employes;

Это поместит документы с размерами 5 и 6 первыми, за ними последуют размеры 7 и 8. В случае, если есть исходное значение, не указанное в массиве (например, размер 10), оно по умолчанию будет равно 15 и в этом случае будет размещено в конце.

Обратите внимание, что CURTIME(), UTC_TIME(), UTC_TIMESTAMP(), и TIMEDIFF() могут быть преобразованы в числовые типы с помощью произвольных функций преобразования, таких как BIGINT(), DOUBLE() и т.д.

select NOW();

+------------+
| NOW()      |
+------------+
| 1615788407 |
+------------+

select CURTIME();

+-----------+
| CURTIME() |
+-----------+
| 07:06:30  |
+-----------+

select curdate();

+------------+
| curdate()  |
+------------+
| 2023-08-02 |
+------------+

select UTC_TIME();

+------------+
| UTC_TIME() |
+------------+
| 06:06:18   |
+------------+

select UTC_TIMESTAMP();

+---------------------+
| UTC_TIMESTAMP()     |
+---------------------+
| 2021-03-15 06:06:03 |
+---------------------+

select second(now());

+---------------+
| second(now()) |
+---------------+
| 52            |
+---------------+

select minute(now());

+---------------+
| minute(now()) |
+---------------+
| 5             |
+---------------+

select hour(now());

+-------------+
| hour(now()) |
+-------------+
| 7           |
+-------------+

select day(now());

+------------+
| day(now()) |
+------------+
| 15         |
+------------+

select month(now());

+--------------+
| month(now()) |
+--------------+
| 3            |
+--------------+

select quarter(now());

+----------------+
| quarter(now()) |
+----------------+
| 2              |
+----------------+

select year(now());

+-------------+
| year(now()) |
+-------------+
| 2024        |
+-------------+

select dayname(now());

+----------------+
| dayname(now()) |
+----------------+
| Wednesday      |
+----------------+

select monthname(now());

+------------------+
| monthname(now()) |
+------------------+
| August           |
+------------------+

select dayofweek(now());

+------------------+
| dayofweek(now()) |
+------------------+
| 5                |
+------------------+

select dayofyear(now());

+------------------+
| dayofyear(now()) |
+------------------+
|              214 |
+------------------+

select yearweek(now());

+-----------------+
| yearweek(now()) |
+-----------------+
|         2023211 |
+-----------------+

select yearmonth(now());

+------------------+
| yearmonth(now()) |
+------------------+
| 202103           |
+------------------+

select yearmonthday(now());

+---------------------+
| yearmonthday(now()) |
+---------------------+
| 20210315            |
+---------------------+

select timediff(1615787586, 1613787583);

+----------------------------------+
| timediff(1615787586, 1613787583) |
+----------------------------------+
| 555:33:23                        |
+----------------------------------+

select datediff(1615787586, 1613787583);

+----------------------------------+
| datediff(1615787586, 1613787583) |
+----------------------------------+
|                               23 |
+----------------------------------+

select date(now());

+-------------+
| date(now()) |
+-------------+
| 2023-08-02  |
+-------------+

select time(now());

+-------------+
| time(now()) |
+-------------+
| 15:21:27    |
+-------------+

SELECT DATE_FORMAT(NOW(), 'year %Y and time %T');

+------------------------------------------+
| DATE_FORMAT(NOW(), 'year %Y and time %T') |
+------------------------------------------+
| year 2023 and time 11:54:52              |
+------------------------------------------+

Этот пример форматирует текущие дату и время, отображая четырехзначный год и время в 24-часовом формате.

DATE_HISTOGRAM(expr, {calendar_interval='unit_name'}) принимает размер корзины в виде названия единицы и возвращает номер корзины для значения. Значения округляются до ближайшей корзины. Ключевая функция:

key_of_the_bucket = interval * floor ( value / interval )

Интервалы могут быть указаны с помощью названия единицы, например week, или как одна единица, например 1M. Однако множественные единицы, такие как 2d, не поддерживаются с calendar_interval, но разрешены с fixed_interval.

Допустимые интервалы для calendar_interval:

• minute, 1m
• hour, 1h
• day, 1d
• week, 1w (неделя — это интервал между начальным днем недели, часом, минутой, секундой и следующей неделей, но в тот же день и время недели)
• month, 1M
• year, 1y (год — это интервал между начальным днем месяца, временем и следующим годом, но в тот же день месяца и время)

Допустимые интервалы для fixed_interval:

• minute, 2m
• hour, 3h
• day, 5d

Используется в агрегациях, FACET и группировках.

Пример:

SELECT COUNT(*),
DATE_HISTOGRAM(tm, {calendar_interval='month'}) AS months
FROM facets
GROUP BY months ORDER BY months ASC;

DATE_RANGE(expr, {range_from='date_math', range_to='date_math'}) принимает набор диапазонов и возвращает номер корзины для значения. Выражение включает значение range_from и исключает значение range_to для каждого диапазона. Диапазон может быть открытым — иметь только значение range_from или только range_to. Отличие от функции RANGE() в том, что значения range_from и range_to могут быть выражены в выражениях Date math.

Используется в агрегациях, FACET и группировках.

Пример:

SELECT COUNT(*),
DATE_RANGE(tm, {range_to='2017||+2M/M'},{range_from='2017||+2M/M',range_to='2017||+5M/M'},{range_from='2017||+5M/M'}) AS points
FROM idx_dates
GROUP BY points ORDER BY points ASC;

Date math позволяет работать с датами и временем непосредственно в ваших поисках. Это особенно полезно для обработки данных, которые меняются со временем. С помощью date math вы можете легко находить записи за определенный период, анализировать тенденции данных или управлять временем удаления информации. Это упрощает работу с датами, позволяя добавлять или вычитать время от заданной даты, округлять даты до ближайшей единицы времени и многое другое, всё это в рамках ваших поисковых запросов.

Для использования date math вы начинаете с базовой даты, которая может быть:

• now для текущей даты и времени,
• или конкретной строкой даты, заканчивающейся на ||.

Затем вы можете модифицировать эту дату операциями, такими как:

• +1y чтобы добавить один год,
• -1h чтобы вычесть один час,
• /m чтобы округлить до ближайшего месяца.

Вы можете использовать следующие единицы в операциях:

• s для секунд,
• m для минут,
• h (или H) для часов,
• d для дней,
• w для недель,
• M для месяцев,
• y для лет.

Вот несколько примеров использования date math:

• now+4h означает четыре часа от текущего момента.
• now-2d/d — время два дня назад, округленное до ближайшего дня.
• 2010-04-20||+2M/d — 20 июня 2010 года, округленное до ближайшего дня.