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

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

Возвращает вес худшего элемента в текущих top-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() является выражением пост-лимита и предназначена для использования с 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 года, округлённое до ближайшего дня.