Важно: Данный раздел актуален для Платформы данных в Публичном облаке и On-Premise.
Поддержка часовых поясов.
Все функции по работе с датой и временем, для которых это имеет смысл, могут принимать второй, необязательный аргумент – имя часового пояса. Пример: Asia/Yekaterinburg. В этом случае, они используют не локальный часовой пояс (по умолчанию), а указанный:
SELECT
SELECT
toDateTime('2016-06-15 23:00:00') AS time,
toDate(time) AS date_local,
toDate(time, 'Asia/Yekaterinburg') AS date_yekat,
toString(time, 'US/Samoa') AS time_samoa
┌──────────────────time─┬─date_local─┬─date_yekat─┬─time_samoa───────────┐
│ 2016-06-15 23:00:00 │ 2016-06-15 │ 2016-06-16 │ 2016-06-15 09:00:00 │
└───────────────────────┴─────────────┴─────────────┴───────────────────────┘Переводит дату или дату-с-временем в указанный часовой пояс. Часовой пояс (таймзона) это атрибут типов Date/DateTime, внутреннее значение (количество секунд) поля таблицы или колонки результата не изменяется, изменяется тип поля и автоматически его текстовое отображение:
SELECT
toDateTime('2019-01-01 00:00:00', 'UTC') AS time_utc,
toTypeName(time_utc) AS type_utc,
toInt32(time_utc) AS int32utc,
toTimeZone(time_utc, 'Asia/Yekaterinburg') AS time_yekat,
toTypeName(time_yekat) AS type_yekat,
toInt32(time_yekat) AS int32yekat,
toTimeZone(time_utc, 'US/Samoa') AS time_samoa,
toTypeName(time_samoa) AS type_samoa,
toInt32(time_samoa) AS int32samoa
FORMAT Vertical;
Row 1:
──────
time_utc: 2019-01-01 00:00:00
type_utc: DateTime('UTC')
int32utc: 1546300800
time_yekat: 2019-01-01 05:00:00
type_yekat: DateTime('Asia/Yekaterinburg')
int32yekat: 1546300800
time_samoa: 2018-12-31 13:00:00
type_samoa: DateTime('US/Samoa')
int32samoa: 1546300800toTimeZone(time_utc, 'Asia/Yekaterinburg') изменяет тип DateTime('UTC') в DateTime('Asia/Yekaterinburg'). Значение (unix-время) 1546300800 остается неизменным, но текстовое отображение (результат функции toString()) меняется time_utc: 2019-01-01 00:00:00 в time_yekat: 2019-01-01 05:00:00.
Переводит дату или дату-с-временем в число типа UInt16, содержащее номер года (AD).
Синоним: YEAR.
Переводит дату или дату-с-временем в число типа UInt8, содержащее номер квартала.
Синоним: QUARTER.
Переводит дату или дату-с-временем в число типа UInt8, содержащее номер месяца (1-12).
Синоним: MONTH.
Переводит дату или дату-с-временем в число типа UInt16, содержащее номер дня года (1-366).
Синоним: DAYOFYEAR.
Переводит дату или дату-с-временем в число типа UInt8, содержащее номер дня в месяце (1-31).
Синонимы: DAYOFMONTH, DAY.
Переводит дату или дату-с-временем в число типа UInt8, содержащее номер дня в неделе (понедельник – 1, воскресенье – 7).
Синоним: DAYOFWEEK.
Переводит дату-с-временем в число типа UInt8, содержащее номер часа в сутках (0-23).
Функция исходит из допущения, что перевод стрелок вперёд, если осуществляется, то на час, в два часа ночи, а перевод стрелок назад, если осуществляется, то на час, в три часа ночи (что, в общем, не верно – даже в Москве два раза перевод стрелок был осуществлён в другое время).
Синоним: HOUR.
Переводит дату-с-временем в число типа UInt8, содержащее номер минуты в часе (0-59).
Синоним: MINUTE.
Переводит дату-с-временем в число типа UInt8, содержащее номер секунды в минуте (0-59).
Секунды координации не учитываются.
Синоним: SECOND.
Переводит дату-с-временем в число типа UInt32 -- Unix Timestamp (https://en.wikipedia.org/wiki/Unix_time).
Для аргумента String, строка конвертируется в дату и время в соответствии с часовым поясом (необязательный второй аргумент, часовой пояс сервера используется по умолчанию).
Синтаксис:
toUnixTimestamp(datetime)
toUnixTimestamp(str, [timezone])Возвращаемое значение:
Тип: UInt32.
Пример:
Запрос:
SELECT toUnixTimestamp('2017-11-05 08:07:47', 'Asia/Tokyo') AS unix_timestampРезультат:
┌─unix_timestamp─┐
│ 1509836867 │
└─────────────────┘Округляет дату или дату-с-временем вниз до первого дня года.
Возвращается дата.
Округляет дату или дату-с-временем вниз до первого дня ISO года. Возвращается дата.
Начало ISO года отличается от начала обычного года, потому что в соответствии с ISO 8601:1988 первая неделя года - это неделя с четырьмя или более днями в этом году.
1 Января 2017 г. – воскресение, т.е. первая ISO неделя 2017 года началась в понедельник 2 января, поэтому 1 января 2017 это 2016 ISO-год, который начался 2016-01-04:
SELECT toStartOfISOYear(toDate('2017-01-01')) AS ISOYear20170101;
┌─ISOYear20170101─┐
│ 2016-01-04 │
└──────────────────┘Округляет дату или дату-с-временем вниз до первого дня квартала.
Первый день квартала – это одно из 1 января, 1 апреля, 1 июля, 1 октября.
Возвращается дата.
Округляет дату или дату-с-временем вниз до первого дня месяца.
Возвращается дата.
Внимание: Возвращаемое значение для некорректных дат зависит от реализации. RT.WideStore может вернуть нулевую дату, выбросить исключение, или выполнить «естественное» перетекание дат между месяцами.
Округляет дату или дату-с-временем вниз до ближайшего понедельника.
Возвращается дата.
Округляет дату или дату со временем до ближайшего воскресенья или понедельника в соответствии с mode.
Возвращается дата.
Аргумент mode работает точно так же, как аргумент mode toWeek(). Если аргумент mode опущен, то используется режим 0.
Округляет дату-с-временем вниз до начала дня. Возвращается дата-с-временем.
Округляет дату-с-временем вниз до начала часа.
Округляет дату-с-временем вниз до начала минуты.
Отсекает доли секунды.
Синтаксис:
toStartOfSecond(value[, timezone])Параметры:
Возвращаемое значение:
Тип: DateTime64.
Примеры:
Пример без часового пояса:
WITH toDateTime64('2020-01-01 10:20:30.999', 3) AS dt64 SELECT toStartOfSecond(dt64);Результат:
┌───toStartOfSecond(dt64)─┐
│ 2020-01-01 10:20:30.000 │
└───────────────────────────┘Пример с часовым поясом:
WITH toDateTime64('2020-01-01 10:20:30.999', 3) AS dt64 SELECT toStartOfSecond(dt64, 'Europe/Moscow');Результат:
┌─toStartOfSecond(dt64, 'Europe/Moscow')─┐
│ 2020-01-01 13:20:30.000 │
└────────────────────────────────────────────┘См. также:
Округляет дату-с-временем вниз до начала пятиминутного интервала.
Округляет дату-с-временем вниз до начала десятиминутного интервала.
Округляет дату-с-временем вниз до начала пятнадцатиминутного интервала.
Обобщение остальных функций toStartOf*. Например,
toStartOfInterval(t, INTERVAL 1 year) возвращает то же самое, что и toStartOfYear(t),
toStartOfInterval(t, INTERVAL 1 month) возвращает то же самое, что и toStartOfMonth(t),
toStartOfInterval(t, INTERVAL 1 day) возвращает то же самое, что и toStartOfDay(t),
toStartOfInterval(t, INTERVAL 15 minute) возвращает то же самое, что и toStartOfFifteenMinutes(t), и т.п.
Переводит дату-с-временем на некоторую фиксированную дату, сохраняя при этом время.
Переводит дату-с-временем или дату в номер года, начиная с некоторого фиксированного момента в прошлом.
Переводит дату-с-временем или дату в номер квартала, начиная с некоторого фиксированного момента в прошлом.
Переводит дату-с-временем или дату в номер месяца, начиная с некоторого фиксированного момента в прошлом.
Переводит дату-с-временем или дату в номер недели, начиная с некоторого фиксированного момента в прошлом.
Переводит дату-с-временем или дату в номер дня, начиная с некоторого фиксированного момента в прошлом.
Переводит дату-с-временем в номер часа, начиная с некоторого фиксированного момента в прошлом.
Переводит дату-с-временем в номер минуты, начиная с некоторого фиксированного момента в прошлом.
Переводит дату-с-временем в номер секунды, начиная с некоторого фиксированного момента в прошлом.
Переводит дату-с-временем или дату в число типа UInt16, содержащее номер ISO года. ISO год отличается от обычного года, потому что в соответствии с ISO 8601:1988 ISO год начинается необязательно первого января.
Пример:
Запрос:
SELECT
toDate('2017-01-01') AS date,
toYear(date),
toISOYear(date)Результат:
┌───────date─┬─toYear(toDate('2017-01-01'))──┬─toISOYear(toDate('2017-01-01'))─┐
│ 2017-01-01 │ 2017 │ 2016 │
└─────────────┴─────────────────────────────────┴────────────────────────────────────┘Переводит дату-с-временем или дату в число типа UInt8, содержащее номер ISO недели.
Начало ISO года отличается от начала обычного года, потому что в соответствии с ISO 8601:1988 первая неделя года – это неделя с четырьмя или более днями в этом году.
1 Января 2017 г. – воскресение, т.е. первая ISO неделя 2017 года началась в понедельник 2 января, поэтому 1 января 2017 это последняя неделя 2016 года.
Пример:
Запрос:
SELECT
toISOWeek(toDate('2017-01-01')) AS ISOWeek20170101,
toISOWeek(toDate('2017-01-02')) AS ISOWeek20170102Результат:
┌─ISOWeek20170101─┬─ISOWeek20170102─┐
│ 52 │ 1 │
└───────────────────┴──────────────────┘Переводит дату-с-временем или дату в число UInt8, содержащее номер недели. Второй аргументам mode задает режим, начинается ли неделя с воскресенья или с понедельника и должно ли возвращаемое значение находиться в диапазоне от 0 до 53 или от 1 до 53. Если аргумент mode опущен, то используется режим 0.
toISOWeek() эквивалентно toWeek(date,3).
Описание режимов (mode):
|
Mode |
Первый день недели |
Диапазон |
Неделя 1 это первая неделя … |
|---|---|---|---|
| 0 | Воскресенье | 0-53 | с воскресеньем в этом году |
| 1 | Понедельник | 0-53 | с 4-мя или более днями в этом году |
| 2 | Воскресенье | 1-53 | с воскресеньем в этом году |
| 3 | Понедельник | 1-53 | с 4-мя или более днями в этом году |
| 4 | Воскресенье | 0-53 | с 4-мя или более днями в этом году |
| 5 | Понедельник | 0-53 | с понедельником в этом году |
| 6 | Воскресенье | 1-53 | с 4-мя или более днями в этом году |
| 7 | Понедельник | 1-53 | с понедельником в этом году |
| 8 | Воскресенье | 1-53 | содержащая 1 января |
| 9 | Понедельник | 1-53 | содержащая 1 января |
Для режимов со значением «с 4 или более днями в этом году» недели нумеруются в соответствии с ISO 8601:1988:
Для режимов со значением «содержит 1 января», неделя 1 – это неделя, содержащая 1 января. Не имеет значения, сколько дней в новом году содержала неделя, даже если она содержала только один день.
Пример:
Запрос:
SELECT toDate('2016-12-27') AS date, toWeek(date) AS week0, toWeek(date,1) AS week1, toWeek(date,9) AS week9;Результат:
┌───────date──┬─week0─┬─week1─┬─week9─┐
│ 2016-12-27 │ 52 │ 52 │ 1 │
└─────────────┴────────┴───────┴────────┘Возвращает год и неделю для даты. Год в результате может отличаться от года в аргументе даты для первой и последней недели года.
Аргумент mode работает точно так же, как аргумент mode toWeek(). Если mode не задан, используется режим 0.
toISOYear() эквивалентно intDiv(toYearWeek(date,3),100).
Пример:
Запрос:
SELECT toDate('2016-12-27') AS date, toYearWeek(date) AS yearWeek0, toYearWeek(date,1) AS yearWeek1, toYearWeek(date,9) AS yearWeek9;Результат:
┌───────date─┬─yearWeek0──┬─yearWeek1─┬─yearWeek9─┐
│ 2016-12-27 │ 201652 │ 201652 │ 201701 │
└─────────────┴────────────┴────────────┴────────────┘Отсекает от даты и времени части, меньшие чем указанная часть.
Синтаксис:
date_trunc(unit, value[, timezone])Синоним: dateTrunc.
Аргументы:
Возвращаемое значение:
Тип: Datetime.
Примеры:
Запрос без указания часового пояса:
SELECT now(), date_trunc('hour', now());Результат:
┌────────────────now()─┬─date_trunc('hour', now())─┐
│ 2020-09-28 10:40:45 │ 2020-09-28 10:00:00 │
└───────────────────────┴─────────────────────────────┘Запрос с указанием часового пояса:
SELECT now(), date_trunc('hour', now(), 'Europe/Moscow');Результат:
┌────────────────now()─┬─date_trunc('hour', now(), 'Europe/Moscow')─┐
│ 2020-09-28 10:46:26 │ 2020-09-28 13:00:00 │
└───────────────────────┴────────────────────────────────────────────────┘См. также:
Возвращает текущую дату и время.
Синтаксис:
now([timezone])Параметры
Возвращаемое значение:
Тип: Datetime.
Пример:
Запрос без указания часового пояса:
SELECT now();Результат:
┌────────────────now()─┐
│ 2020-10-17 07:42:09 │
└───────────────────────┘Запрос с указанием часового пояса:
SELECT now('Europe/Moscow');Результат:
┌─now('Europe/Moscow')─┐
│ 2020-10-17 10:42:23 │
└────────────────────────┘Принимает ноль аргументов и возвращает текущую дату на один из моментов выполнения запроса.
То же самое, что toDate(now()).
Принимает ноль аргументов и возвращает вчерашнюю дату на один из моментов выполнения запроса.
Делает то же самое, что today() - 1.
Вычисляет разницу между двумя значениями дат с временем.
Синтаксис:
dateDiff('unit', startdate, enddate, [timezone])Параметры:
Поддерживаемые значения:
| unit |
| ------ |
|second |
|minute |
|hour |
|day |
|week |
|month |
|quarter |
|year |
startdate – первая дата. Date или DateTime.
Возвращаемое значение:
Разница между startdate и enddate, выраженная в unit.
Тип: int.
Пример:
Запрос:
SELECT dateDiff('hour', toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00'));Результат:
┌─dateDiff('hour', toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00'))─┐
│ 25 │
└────────────────────────────────────────────────────────────────────────────────────────────────┘Вычитает интервал времени или даты из указанной даты или даты со временем.
Синтаксис:
date_sub(unit, value, date)Синонимы: dateSub, DATE_SUB.
Аргументы:
Возвращаемое значение:
Пример:
Запрос:
SELECT date_sub(YEAR, 3, toDate('2018-01-01'));Результат:
┌─minus(toDate('2018-01-01'), toIntervalYear(3))─┐
│ 2015-01-01 │
└────────────────────────────────────────────────────┘Округляет время до получаса.
Эта функция является специфичной, так как пол часа - минимальное время, для которого, если соседние по времени хиты одного посетителя на одном счётчике отстоят друг от друга строго более, чем на это время, визит может быть разбит на два визита. То есть, кортежи (номер счётчика, идентификатор посетителя, тайм-слот) могут использоваться для поиска хитов, входящий в соответствующий визит.
Для интервала времени, начинающегося в ‘StartTime’ и продолжающегося ‘Duration’ секунд, возвращает массив моментов времени, состоящий из округлений вниз до ‘Size’ точек в секундах из этого интервала. ‘Size’ - необязательный параметр, константный UInt32, по умолчанию равен 1800.
Например, timeSlots(toDateTime('2012-01-01 12:20:00'), toUInt32(600)) = [toDateTime('2012-01-01 12:00:00'), toDateTime('2012-01-01 12:30:00')].
Это нужно для поиска хитов, входящих в соответствующий визит.
Переводит дату или дату со временем в число типа UInt32, содержащее номер года и месяца (YYYY * 100 + MM).
Переводит дату или дату со временем в число типа UInt32, содержащее номер года, месяца и дня (YYYY * 10000 + MM * 100 + DD).
Переводит дату или дату со временем в число типа UInt64 содержащее номер года, месяца, дня и время (YYYY * 10000000000 + MM * 100000000 + DD * 1000000 + hh * 10000 + mm * 100 + ss).
Функция преобразует дату-и-время в строку по заданному шаблону. Важно: шаблон – константное выражение, поэтому использовать разные шаблоны в одной колонке не получится.
Синтаксис:
formatDateTime(Time, Format\[, Timezone\])Возвращаемое значение:
Поля подстановки:
Используйте поля подстановки для того, чтобы определить шаблон для выводимой строки. В колонке «Пример» результат работы функции для времени 2018-01-02 22:33:44.
|
Поле |
Описание |
Пример |
|---|---|---|
| %C | номер года, поделённый на 100 (00-99) | 20 |
| %d | день месяца, с ведущим нулём (01-31) | 02 |
| %D | короткая запись %m/%d/%y | 01/02/18 |
| %e | день месяца, с ведущим пробелом ( 1-31) | 2 |
| %F | короткая запись %Y-%m-%d | 2018-01-02 |
| %G | четырехзначный формат вывода ISO-года, который основывается на особом подсчете номера недели согласно стандарту ISO 8601, обычно используется вместе с %V | 2018 |
| %g | двузначный формат вывода года по стандарту ISO 8601 | 18 |
| %H | час в 24-часовом формате (00-23) | 22 |
| %I | час в 12-часовом формате (01-12) | 10 |
| %j | номер дня в году, с ведущими нулями (001-366) | 002 |
| %m | месяц, с ведущим нулём (01-12) | 01 |
| %M | минуты, с ведущим нулём (00-59) | 33 |
| %n | символ переноса строки (‘’) | |
| %p | обозначения AM или PM | PM |
| %R | короткая запись %H:%M | 22:33 |
| %S | секунды, с ведущими нулями (00-59) | 44 |
| %t | символ табуляции (’) | |
| %T | формат времени ISO 8601, одинаковый с %H:%M:%S | 22:33:44 |
| %u | номер дня недели согласно ISO 8601, понедельник - 1, воскресенье - 7 | 2 |
| %V | номер недели согласно ISO 8601 (01-53) | 01 |
| %w | номер дня недели, начиная с воскресенья (0-6) | 2 |
| %y | год, последние 2 цифры (00-99) | 18 |
| %Y | год, 4 цифры | 2018 |
| %% | символ % | % |
Пример:
Запрос:
SELECT formatDateTime(toDate('2010-01-04'), '%g');Результат:
┌─formatDateTime(toDate('2010-01-04'), '%g')─┐
│ 10 │
└────────────────────────────────────────────────┘Функция преобразует Unix timestamp в календарную дату и время.
Примеры:
Если указан только один аргумент типа Integer, то функция действует так же, как toDateTime, и возвращает тип DateTime.
Запрос:
SELECT FROM_UNIXTIME(423543535);Результат:
┌─FROM_UNIXTIME(423543535)─┐
│ 1983-06-04 10:58:55 │
└────────────────────────────┘В случае, когда есть два аргумента: первый типа Integer или DateTime, а второй является строкой постоянного формата – функция работает также, как formatDateTime, и возвращает значение типа String.
Запрос:
SELECT FROM_UNIXTIME(1234334543, '%Y-%m-%d %R:%S') AS DateTime;Результат:
┌─DateTime─────────────┐
│ 2009-02-11 14:42:23 │
└───────────────────────┘Возвращает 1 для пустой строки, и 0 для непустой строки.
Тип результата – UInt8.
Строка считается непустой, если содержит хотя бы один байт, пусть даже это пробел или нулевой байт.
Функция также работает для массивов.
Возвращает 0 для пустой строки, и 1 для непустой строки.
Тип результата – UInt8.
Функция также работает для массивов.
Возвращает длину строки в байтах (не символах, не кодовых точках).
Тип результата – UInt64.
Функция также работает для массивов.
Возвращает длину строки в кодовых точках Unicode (не символах), при допущении, что строка содержит набор байтов, являющийся текстом в кодировке UTF-8. Если допущение не выполнено, то возвращает какой-нибудь результат (не кидает исключение).
Тип результата – UInt64.
Возвращает длину строки в кодовых точках Unicode (не символах), при допущении, что строка содержит набор байтов, являющийся текстом в кодировке UTF-8. Если допущение не выполнено, возвращает какой-нибудь результат (не кидает исключение).
Тип результата – UInt64.
Возвращает длину строки в кодовых точках Unicode (не символах), при допущении, что строка содержит набор байтов, являющийся текстом в кодировке UTF-8. Если допущение не выполнено, возвращает какой-нибудь результат (не кидает исключение).
Тип результата – UInt64.
Переводит ASCII-символы латиницы в строке в нижний регистр.
Переводит ASCII-символы латиницы в строке в верхний регистр.
Переводит строку в нижний регистр, при допущении, что строка содержит набор байтов, представляющий текст в кодировке UTF-8.
Не учитывает язык. То есть, для турецкого языка, результат может быть не совсем верным.
Если длина UTF-8 последовательности байтов различна для верхнего и нижнего регистра кодовой точки, то для этой кодовой точки результат работы может быть некорректным.
Если строка содержит набор байтов, не являющийся UTF-8, то поведение не определено.
Переводит строку в верхний регистр, при допущении, что строка содержит набор байтов, представляющий текст в кодировке UTF-8.
Не учитывает язык. То есть, для турецкого языка, результат может быть не совсем верным.
Если длина UTF-8 последовательности байтов различна для верхнего и нижнего регистра кодовой точки, то для этой кодовой точки, результат работы может быть некорректным.
Если строка содержит набор байтов, не являющийся UTF-8, то поведение не определено.
Возвращает 1, если набор байтов является корректным в кодировке UTF-8, 0 иначе.
Заменяет некорректные символы UTF-8 на символ � (U+FFFD). Все идущие подряд некорректные символы схлопываются в один заменяющий символ.
Синтаксис:
toValidUTF8( input_string )Параметры:
Возвращаемое значение: Корректная строка UTF-8.
Пример:
SELECT toValidUTF8('\x61\xF0\x80\x80\x80b')
┌─toValidUTF8('a����b')─┐
│ a�b │
└─────────────────────────┘Повторяет строку определенное количество раз и объединяет повторяемые значения в одну строку.
Синоним: REPEAT.
Синтаксис:
repeat(s, n)Параметры:
Возвращаемое значение:
Тип: String.
Пример:
Запрос:
SELECT repeat('abc', 10)Ответ:
┌─repeat('abc', 10)───────────────┐
│ abcabcabcabcabcabcabcabcabcabc │
└───────────────────────────────────┘Разворачивает строку (как последовательность байтов).
Разворачивает последовательность кодовых точек Unicode, при допущении, что строка содержит набор байтов, представляющий текст в кодировке UTF-8. Иначе – что-то делает (не кидает исключение).
Форматирует константный шаблон со строками, перечисленными в аргументах. pattern – упрощенная версия шаблона в языке Python. Шаблон содержит «заменяющие поля», которые окружены фигурными скобками {}. Всё, что не содержится в скобках, интерпретируется как обычный текст и просто копируется. Если нужно использовать символ фигурной скобки, можно экранировать двойной скобкой {{ или }}. Имя полей могут быть числами (нумерация с нуля) или пустыми (тогда они интерпретируются как последовательные числа).
SELECT format('{1} {0} {1}', 'World', 'Hello')
┌─format('{1} {0} {1}', 'World', 'Hello')─┐
│ Hello World Hello │
└─────────────────────────────────────────────┘
SELECT format('{} {}', 'Hello', 'World')
┌─format('{} {}', 'Hello', 'World')─┐
│ Hello World │
└──────────────────────────────────────┘Склеивает строки, переданные в аргументы, в одну строку без разделителей.
Синтаксис:
concat(s1, s2, ...)Параметры:
Возвращаемое значение:
Если любой из аргументов имеет значение NULL, concat возвращает значение NULL.
Пример:
Запрос:
SELECT concat('Hello, ', 'World!')Ответ:
┌─concat('Hello, ', 'World!')─┐
│ Hello, World! │
└────────────────────────────────┘Аналогична concat. Разница заключается в том, что вам нужно убедиться, что concat(s1, s2, ...) → sn является инъективным, так как это предположение будет использоваться для оптимизации GROUP BY.
Функция называется «инъективной», если она возвращает разные значения для разных аргументов. Или, иными словами, функция никогда не выдаёт одно и то же значение, если аргументы разные.
Синтаксис:
concatAssumeInjective(s1, s2, ...)Параметры:
Возвращаемые значения:
Если любой из аргументов имеет значение NULL, concatAssumeInjective возвращает значение NULL.
Пример:
Вводная таблица:
CREATE TABLE key_val(`key1` String, `key2` String, `value` UInt32) ENGINE = TinyLog
INSERT INTO key_val VALUES ('Hello, ','World',1)('Hello, ','World',2)('Hello, ','World!',3)('Hello',', World!',2)
SELECT * from key_val
┌─key1─────┬─key2─────┬─value─┐
│ Hello, │ World │ 1 │
│ Hello, │ World │ 2 │
│ Hello, │ World! │ 3 │
│ Hello │ , World! │ 2 │
└──────────┴───────────┴───────┘Запрос:
SELECT concat(key1, key2), sum(value) FROM key_val GROUP BY (key1, key2)Ответ:
┌─concat(key1, key2)─┬─sum(value)─┐
│ Hello, World! │ 3 │
│ Hello, World! │ 2 │
│ Hello, World │ 3 │
└──────────────────────┴─────────────┘Возвращает подстроку, начиная с байта по индексу offset, длины length байт. Индексация символов – начиная с единицы (как в стандартном SQL). Аргументы offset и length должны быть константами.
Так же, как substring, но для кодовых точек Unicode. Работает при допущении, что строка содержит набор байтов, представляющий текст в кодировке UTF-8. Если допущение не выполнено, то возвращает какой-нибудь результат (не кидает исключение).
Если строка s непустая и не содержит символ c на конце, то добавляет символ c в конец.
Возвращает сконвертированную из кодировки from в кодировку to строку s.
Производит кодирование строки s в base64-представление.
Синоним: TO_BASE64.
Декодирует base64-представление s в исходную строку. При невозможности декодирования выбрасывает исключение
Синоним: FROM_BASE64.
Функционал аналогичен base64Decode, но при невозможности декодирования возвращает пустую строку.
Возвращает 1, если строка завершается указанным суффиксом, и 0 в противном случае.
Возвращает 1, если строка начинается указанным префиксом, в противном случае 0.
SELECT startsWith('Spider-Man', 'Spi');Возвращаемые значения:
Пример:
Запрос:
SELECT startsWith('Hello, world!', 'He');Ответ:
┌─startsWith('Hello, world!', 'He')─┐
│ 1 │
└──────────────────────────────────────┘Удаляет все указанные символы с начала или окончания строки.
По умолчанию удаляет все последовательные вхождения обычных пробелов (32 символ ASCII) с обоих концов строки.
Синтаксис:
trim([[LEADING|TRAILING|BOTH] trim_character FROM] input_string)Параметры:
Возвращаемое значение:
Тип: String.
Пример:
Запрос:
SELECT trim(BOTH ' ()' FROM '( Hello, world! )')Ответ:
┌─trim(BOTH ' ()' FROM '( Hello, world! )')─┐
│ Hello, world! │
└───────────────────────────────────────────────────┘Удаляет все последовательные вхождения обычных пробелов (32 символ ASCII) с левого конца строки. Не удаляет другие виды пробелов (табуляция, пробел без разрыва и т. д.).
Синтаксис:
trimLeft(input_string)Алиас: ltrim(input_string).
Параметры:
Возвращаемое значение:
Тип: String.
Пример:
Запрос:
SELECT trimLeft(' Hello, world! ')Ответ:
┌─trimLeft(' Hello, world! ')─┐
│ Hello, world! │
└────────────────────────────────────────┘Удаляет все последовательные вхождения обычных пробелов (32 символ ASCII) с правого конца строки. Не удаляет другие виды пробелов (табуляция, пробел без разрыва и т. д.).
Синтаксис:
trimRight(input_string)Алиас: rtrim(input_string).
Параметры:
Возвращаемое значение:
Тип: String.
Пример:
Запрос:
SELECT trimRight(' Hello, world! ')Ответ:
┌─trimRight(' Hello, world! ')─┐
│ Hello, world! │
└─────────────────────────────────────────┘Удаляет все последовательные вхождения обычных пробелов (32 символ ASCII) с обоих концов строки. Не удаляет другие виды пробелов (табуляция, пробел без разрыва и т. д.).
Синтаксис:
trimBoth(input_string)Алиас: trim(input_string).
Параметры:
Возвращаемое значение:
Тип: String.
Пример:
Запрос:
SELECT trimBoth(' Hello, world! ')Ответ:
┌─trimBoth(' Hello, world! ')─┐
│ Hello, world! │
└────────────────────────────────────────┘Возвращает чек сумму CRC32 данной строки, используется CRC-32-IEEE 802.3 многочлен и начальным значением 0xffffffff (т.к. используется реализация из zlib).
Тип результата – UInt32.
Возвращает чек сумму CRC32 данной строки, используется CRC-32-IEEE 802.3 многочлен.
Тип результата – UInt32.
Возвращает чек сумму CRC64 данной строки, используется CRC-64-ECMA многочлен.
Тип результата – UInt64.
Заменяет литералы, последовательности литералов и сложные псевдонимы заполнителями.
Синтаксис:
normalizeQuery(x)Параметры:
Возвращаемое значение:
Тип: String.
Пример:
Запрос:
SELECT normalizeQuery('[1, 2, 3, x]') AS query;Результат:
┌─query────┐
│ [?.., x] │
└───────────┘Возвращает идентичные 64-битные хэш - суммы без значений литералов для аналогичных запросов. Это помогает анализировать журнал запросов.
Синтаксис:
normalizedQueryHash(x)Параметры:
Возвращаемое значение:
Тип: UInt64.
Пример:
Запрос:
SELECT normalizedQueryHash('SELECT 1 AS `xyz`') != normalizedQueryHash('SELECT 1 AS `abc`') AS res;Результат:
┌─res─┐
│ 1 │
└─────┘Экранирует символы для размещения строки в текстовом узле или атрибуте XML.
Экранируются символы, которые в формате XML являются зарезервированными (служебными): <, &, >, ", '.
Синтаксис:
encodeXMLComponent(x)Параметры:
Возвращаемое значение:
Тип: String.
Пример:
Запрос:
SELECT encodeXMLComponent('Hello, "world"!');
SELECT encodeXMLComponent('<123>');
SELECT encodeXMLComponent('&clickhouse');
SELECT encodeXMLComponent('\'foo\'');Результат:
Hello, "world"!
<123>
&clickhouse
'foo'Заменяет символами предопределенные мнемоники XML: " & ' > <.
Также эта функция заменяет числовые ссылки соответствующими символами юникод. Поддерживаются десятичная (например, ✓) и шестнадцатеричная (✓) формы.
Синтаксис:
decodeXMLComponent(x)Параметры:
Возвращаемое значение:
Тип: String.
Пример:
Запрос:
SELECT decodeXMLComponent(''foo'');
SELECT decodeXMLComponent('< Σ >');Результат:
'foo'
< Σ >Смотрите также:
Во всех функциях, поиск регистрозависимый по умолчанию. Существуют варианты функций для регистронезависимого поиска.
Поиск подстроки needle в строке haystack.
Возвращает позицию (в байтах) найденной подстроки в строке, начиная с 1, или 0, если подстрока не найдена.
Для поиска без учета регистра используйте функцию positionCaseInsensitive.
Синтаксис:
position(haystack, needle[, start_pos])Алиас: locate(haystack, needle[, start_pos]).
Параметры:
Возвращаемые значения:
Тип: Integer.
Примеры:
Фраза «Hello, world!» содержит набор байт, представляющий текст в однобайтовой кодировке. Функция возвращает ожидаемый результат:
Запрос:
SELECT position('Hello, world!', '!')Ответ:
┌─position('Hello, world!', '!')─┐
│ 13 │
└───────────────────────────────────┘Аналогичная фраза на русском содержит символы, которые не могут быть представлены в однобайтовой кодировке. Функция возвращает неожиданный результат (используйте функцию positionUTF8 для символов, которые не могут быть представлены одним байтом):
Запрос:
SELECT position('Привет, мир!', '!')Ответ:
┌─position('Привет, мир!', '!')─┐
│ 21 │
└──────────────────────────────────┘Такая же, как и position, но работает без учета регистра. Возвращает позицию в байтах найденной подстроки в строке, начиная с 1.
Работает при допущении, что строка содержит набор байт, представляющий текст в однобайтовой кодировке. Если допущение не выполнено – то возвращает неопределенный результат (не кидает исключение). Если символ может быть представлен с помощью двух байтов, он будет представлен двумя байтами и так далее.
Синтаксис:
positionCaseInsensitive(haystack, needle[, start_pos])Параметры:
Возвращаемые значения:
Тип: Integer.
Пример:
Запрос:
SELECT positionCaseInsensitive('Hello, world!', 'hello')Ответ:
┌─positionCaseInsensitive('Hello, world!', 'hello')─┐
│ 1 │
└────────────────────────────────────────────────────────┘Возвращает позицию (в кодовых точках Unicode) найденной подстроки в строке, начиная с 1.
Работает при допущении, что строка содержит набор кодовых точек, представляющий текст в кодировке UTF-8. Если допущение не выполнено – то возвращает неопределенный результат (не кидает исключение). Если символ может быть представлен с помощью двух кодовых точек, он будет представлен двумя и так далее.
Для поиска без учета регистра используйте функцию positionCaseInsensitiveUTF8.
Синтаксис:
positionUTF8(haystack, needle[, start_pos])Параметры:
Возвращаемые значения:
Тип: Integer.
Примеры:
Фраза «Привет, мир!» содержит набор символов, каждый из которых можно представить с помощью одной кодовой точки. Функция возвращает ожидаемый результат:
Запрос:
SELECT positionUTF8('Привет, мир!', '!')Ответ:
┌─positionUTF8('Привет, мир!', '!')─┐
│ 12 │
└──────────────────────────────────────┘Фраза «Salut, étudiante!» содержит символ é, который может быть представлен одной кодовой точкой (U+00E9) или двумя (U+0065U+0301). Поэтому функция positionUTF8() может вернуть неожиданный результат:
Запрос для символа é, который представлен одной кодовой точкой U+00E9:
SELECT positionUTF8('Salut, étudiante!', '!')Ответ:
┌─positionUTF8('Salut, étudiante!', '!')─┐
│ 17 │
└────────────────────────────────────────────┘Запрос для символа é, который представлен двумя кодовыми точками U+0065U+0301:
SELECT positionUTF8('Salut, étudiante!', '!')Ответ:
┌─positionUTF8('Salut, étudiante!', '!')─┐
│ 18 │
└────────────────────────────────────────────┘Такая же, как и positionUTF8, но работает без учета регистра. Возвращает позицию (в кодовых точках Unicode) найденной подстроки в строке, начиная с 1.
Работает при допущении, что строка содержит набор кодовых точек, представляющий текст в кодировке UTF-8. Если допущение не выполнено – то возвращает неопределенный результат (не кидает исключение). Если символ может быть представлен с помощью двух кодовых точек, он будет представлен двумя и так далее.
Синтаксис:
positionCaseInsensitiveUTF8(haystack, needle[, start_pos])Параметры:
Возвращаемые значения:
Тип: Integer.
Пример:
Запрос:
SELECT positionCaseInsensitiveUTF8('Привет, мир!', 'Мир')Ответ:
┌─positionCaseInsensitiveUTF8('Привет, мир!', 'Мир')─┐
│ 9 │
└─────────────────────────────────────────────────────────┘То же самое, что и position, но возвращает массив позиций (в байтах) найденных соответствующих подстрок в строке. Позиции индексируются, начиная с 1.
Поиск выполняется по последовательностям байтов без учета строкового кодирования и сортировки.
Синтаксис:
multiSearchAllPositions(haystack, [needle1, needle2, ..., needlen])Параметры:
Возвращаемые значения:
Пример:
Запрос:
SELECT multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])Результат:
┌─multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])─┐
│ [0,13,0] │
└─────────────────────────────────────────────────────────────────────────┘Смотрите multiSearchAllPositions.
Так же, как и position, только возвращает оффсет первого вхождения любого из needles.
Для поиска без учета регистра и/или в кодировке UTF-8 используйте функции multiSearchFirstPositionCaseInsensitive, multiSearchFirstPositionUTF8, multiSearchFirstPositionCaseInsensitiveUTF8.
Возвращает индекс i (нумерация с единицы) первой найденной строки needlei в строке haystack и 0 иначе.
Для поиска без учета регистра и/или в кодировке UTF-8 используйте функции multiSearchFirstIndexCaseInsensitive, multiSearchFirstIndexUTF8, multiSearchFirstIndexCaseInsensitiveUTF8.
Возвращает 1, если хотя бы одна подстрока needlei нашлась в строке haystack и 0 иначе.
Для поиска без учета регистра и/или в кодировке UTF-8 используйте функции multiSearchAnyCaseInsensitive, multiSearchAnyUTF8, multiSearchAnyCaseInsensitiveUTF8.
Примечание: Во всех функциях multiSearch* количество needles должно быть меньше 28 из-за особенностей реализации.
Проверка строки на соответствие регулярному выражению pattern. Регулярное выражение re2. Синтаксис регулярных выражений re2 является более ограниченным по сравнению с регулярными выражениями Perl (подробнее).
Возвращает 0 (если не соответствует) или 1 (если соответствует).
Обратите внимание, что для экранирования в регулярном выражении, используется символ \ (обратный слеш). Этот же символ используется для экранирования в строковых литералах. Поэтому, чтобы экранировать символ в регулярном выражении, необходимо написать в строковом литерале \ (два обратных слеша).
Регулярное выражение работает со строкой как с набором байт. Регулярное выражение не может содержать нулевые байты.
Для шаблонов на поиск подстроки в строке, лучше используйте LIKE или position, так как они работают существенно быстрее.
То же, что и match, но возвращает ноль, если ни одно регулярное выражение не подошло и один, если хотя бы одно. Используется библиотека hyperscan для соответствия регулярных выражений. Для шаблонов на поиск многих подстрок в строке, лучше используйте multiSearchAny, так как она работает существенно быстрее.
Примечание: Длина любой строки из haystack должна быть меньше 232 байт, иначе бросается исключение. Это ограничение связано с ограничением hyperscan API.
То же, что и multiMatchAny, только возвращает любой индекс подходящего регулярного выражения.
То же, что и multiMatchAny, только возвращает массив всех индексов всех подходящих регулярных выражений в любом порядке.
То же, что и multiMatchAny, но возвращает 1 если любой pattern соответствует haystack в пределах константного редакционного расстояния. Эта функция также находится в экспериментальном режиме и может быть очень медленной. За подробностями обращайтесь к документации hyperscan.
То же, что и multiFuzzyMatchAny, только возвращает любой индекс подходящего регулярного выражения в пределах константного редакционного расстояния.
То же, что и multiFuzzyMatchAny, только возвращает массив всех индексов всех подходящих регулярных выражений в любом порядке в пределах константного редакционного расстояния.
Примечание
multiFuzzyMatch* функции не поддерживают UTF-8 закодированные регулярные выражения, и такие выражения рассматриваются как байтовые из-за ограничения hyperscan.
Примечание: Чтобы выключить все функции, использующие hyperscan, используйте настройку SET allow_hyperscan = 0.
Извлечение фрагмента строки по регулярному выражению. Если haystack не соответствует регулярному выражению pattern, то возвращается пустая строка. Если регулярное выражение не содержит subpattern-ов, то вынимается фрагмент, который подпадает под всё регулярное выражение. Иначе вынимается фрагмент, который подпадает под первый subpattern.
Извлечение всех фрагментов строки по регулярному выражению. Если haystack не соответствует регулярному выражению pattern, то возвращается пустая строка. Возвращается массив строк, состоящий из всех соответствий регулярному выражению. В остальном, поведение аналогично функции extract (по-прежнему, вынимается первый subpattern, или всё выражение, если subpattern-а нет).
Разбирает строку haystack на фрагменты, соответствующие группам регулярного выражения pattern. Возвращает массив массивов, где первый массив содержит все фрагменты, соответствующие первой группе регулярного выражения, второй массив - соответствующие второй группе, и т.д.
Замечание: Функция extractAllGroupsHorizontal работает медленнее, чем функция extractAllGroupsVertical.
Синтаксис:
extractAllGroupsHorizontal(haystack, pattern)Параметры:
Возвращаемое значение:
Если в строке haystack нет групп, соответствующих регулярному выражению pattern, возвращается массив пустых массивов.
Пример:
Запрос:
SELECT extractAllGroupsHorizontal('abc=111, def=222, ghi=333', '("[^"]+"|\\w+)=("[^"]+"|\\w+)')Результат:
┌─extractAllGroupsHorizontal('abc=111, def=222, ghi=333', '("[^"]+"|\\w+)=("[^"]+"|\\w+)')─┐
│ [['abc','def','ghi'],['111','222','333']] │
└──────────────────────────────────────────────────────────────────────────────────────────────────┘См. также:
Разбирает строку haystack на фрагменты, соответствующие группам регулярного выражения pattern. Возвращает массив массивов, где каждый массив содержит по одному фрагменту, соответствующему каждой группе регулярного выражения. Фрагменты группируются в массивы в соответствии с порядком появления в исходной строке.
Синтаксис:
extractAllGroupsVertical(haystack, pattern)Параметры:
Возвращаемое значение:
Если в строке haystack нет групп, соответствующих регулярному выражению pattern, возвращается пустой массив.
Пример:
Запрос:
SELECT extractAllGroupsVertical('abc=111, def=222, ghi=333', '("[^"]+"|\\w+)=("[^"]+"|\\w+)')Результат:
┌─extractAllGroupsVertical('abc=111, def=222, ghi=333', '("[^"]+"|\\w+)=("[^"]+"|\\w+)')─┐
│ [['abc','111'],['def','222'],['ghi','333']] │
└────────────────────────────────────────────────────────────────────────────────────────────────┘См. также:
Проверка строки на соответствие простому регулярному выражению.
Регулярное выражение может содержать метасимволы % и _.
% обозначает любое количество любых байт (в том числе, нулевое количество символов).
_ обозначает один любой байт.
Для экранирования метасимволов, используется символ \ (обратный слеш). Смотрите замечание об экранировании в описании функции match.
Для регулярных выражений вида %needle% действует более оптимальный код, который работает также быстро, как функция position.
Для остальных регулярных выражений, код аналогичен функции match.
То же, что like, но с отрицанием.
Нечувствительный к регистру вариант функции like. Вы можете использовать оператор ILIKE вместо функции ilike.
Синтаксис:
ilike(haystack, pattern)Параметры:
Некоторые примеры pattern:
'abc' ILIKE 'abc' true
'abc' ILIKE 'a%' true
'abc' ILIKE '_b_' true
'abc' ILIKE 'c' falseВозвращаемые значения:
Пример:
Входная таблица:
┌─id─┬─name─────┬─days─┐
│ 1 │ January │ 31 │
│ 2 │ February │ 29 │
│ 3 │ March │ 31 │
│ 4 │ April │ 30 │
└────┴───────────┴───────┘Запрос:
SELECT * FROM Months WHERE ilike(name, '%j%')Результат:
┌─id─┬─name────┬─days─┐
│ 1 │ January │ 31 │
└────┴──────────┴───────┘Смотрите также:
Вычисление 4-граммного расстояния между haystack и needle: считается симметрическая разность между двумя мультимножествами 4-грамм и нормализуется на сумму их мощностей. Возвращает число float от 0 до 1 – чем ближе к нулю, тем больше строки похожи друг на друга. Если константный needle или haystack больше чем 32КБ, кидается исключение. Если некоторые строки из неконстантного haystack или needle больше 32КБ, расстояние всегда равно единице.
Для поиска без учета регистра и/или в формате UTF-8 используйте функции ngramDistanceCaseInsensitive, ngramDistanceUTF8, ngramDistanceCaseInsensitiveUTF8.
То же, что и ngramDistance, но вычисляет несимметричную разность между needle и haystack – количество n-грамм из needle минус количество общих n-грамм, нормированное на количество n-грамм из needle. Чем ближе результат к единице, тем вероятнее, что needle внутри haystack. Может быть использовано для приближенного поиска.
Для поиска без учета регистра и/или в формате UTF-8 используйте функции ngramSearchCaseInsensitive, ngramSearchUTF8, ngramSearchCaseInsensitiveUTF8.
Примечание: Для случая UTF-8 мы используем триграммное расстояние. Вычисление n-граммного расстояния не совсем честное. Мы используем 2-х байтные хэши для хэширования n-грамм, а затем вычисляем (не)симметрическую разность между хэш таблицами – могут возникнуть коллизии. В формате UTF-8 без учета регистра мы не используем честную функцию tolower – мы обнуляем 5-й бит (нумерация с нуля) каждого байта кодовой точки, а также первый бит нулевого байта, если байтов больше 1 – это работает для латиницы и почти для всех кириллических букв.
Возвращает количество совпадений, найденных в строке haystack, для регулярного выражения pattern.
Синтаксис:
countMatches(haystack, pattern)Параметры:
Возвращаемое значение:
Тип: UInt64.
Примеры:
Запрос:
SELECT countMatches('foobar.com', 'o+');Результат:
┌─countMatches('foobar.com', 'o+')─┐
│ 2 │
└─────────────────────────────────────┘Запрос:
SELECT countMatches('aaaa', 'aa');Результат:
┌─countMatches('aaaa', 'aa')────┐
│ 2 │
└──────────────────────────────────┘Возвращает количество вхождений подстроки.
Для поиска без учета регистра, используйте функции countSubstringsCaseInsensitive или countSubstringsCaseInsensitiveUTF8
Синтаксис:
countSubstrings(haystack, needle[, start_pos])Параметры:
Возвращаемые значения:
Тип: UInt64.
Примеры:
Запрос:
SELECT countSubstrings('foobar.com', '.');Результат:
┌─countSubstrings('foobar.com', '.')─┐
│ 1 │
└───────────────────────────────────────┘Запрос:
SELECT countSubstrings('aaaa', 'aa');Результат:
┌─countSubstrings('aaaa', 'aa')─┐
│ 2 │
└──────────────────────────────────┘Запрос:
SELECT countSubstrings('abc___abc', 'abc', 4);Результат:
┌─countSubstrings('abc___abc', 'abc', 4)─┐
│ 1 │
└────────────────────────────────────────────┘Возвращает количество вхождений подстроки без учета регистра.
Синтаксис:
countSubstringsCaseInsensitive(haystack, needle[, start_pos])Параметры:
Возвращаемые значения:
Тип: UInt64.
Примеры:
Запрос:
select countSubstringsCaseInsensitive('aba', 'B');Результат:
┌─countSubstringsCaseInsensitive('aba', 'B')─┐
│ 1 │
└────────────────────────────────────────────────┘Запрос:
SELECT countSubstringsCaseInsensitive('foobar.com', 'CoM');Результат:
┌─countSubstringsCaseInsensitive('foobar.com', 'CoM')─┐
│ 1 │
└──────────────────────────────────────────────────────────┘Запрос:
SELECT countSubstringsCaseInsensitive('abC___abC', 'aBc', 2);Результат:
┌─countSubstringsCaseInsensitive('abC___abC', 'aBc', 2)─┐
│ 1 │
└────────────────────────────────────────────────────────────┘Возвращает количество вхождений подстроки в UTF-8 без учета регистра.
Синтаксис:
SELECT countSubstringsCaseInsensitiveUTF8(haystack, needle[, start_pos])Параметры:
Возвращаемые значения:
Тип: UInt64.
Примеры:
Запрос:
SELECT countSubstringsCaseInsensitiveUTF8('абв', 'A');Результат:
┌─countSubstringsCaseInsensitiveUTF8('абв', 'A')─┐
│ 1 │
└────────────────────────────────────────────────────┘Запрос:
SELECT countSubstringsCaseInsensitiveUTF8('аБв__АбВ__абв', 'Абв');Результат:
┌─countSubstringsCaseInsensitiveUTF8('аБв__АбВ__абв', 'Абв')─┐
│ 3 │
└─────────────────────────────────────────────────────────────────┘Замена первого вхождения, если такое есть, подстроки pattern в haystack на подстроку replacement.
Здесь и далее, pattern и replacement должны быть константами.
Замена всех вхождений подстроки pattern в haystack на подстроку replacement.
Замена по регулярному выражению pattern. Регулярное выражение re2.
Заменяется только первое вхождение, если есть.
В качестве replacement может быть указан шаблон для замен. Этот шаблон может включать в себя подстановки \0-\9.
Подстановка \0 - вхождение регулярного выражения целиком. Подстановки \1-\9 - соответствующие по номеру subpattern-ы.
Для указания символа \ в шаблоне, он должен быть экранирован с помощью символа \.
Также помните о том, что строковый литерал требует ещё одно экранирование.
Пример 1. Переведём дату в американский формат:
SELECT DISTINCT
EventDate,
replaceRegexpOne(toString(EventDate), '(\\d{4})-(\\d{2})-(\\d{2})', '\\2/\\3/\\1') AS res
FROM test.hits
LIMIT 7
FORMAT TabSeparated
2014-03-17 03/17/2014
2014-03-18 03/18/2014
2014-03-19 03/19/2014
2014-03-20 03/20/2014
2014-03-21 03/21/2014
2014-03-22 03/22/2014
2014-03-23 03/23/2014Пример 2. Размножить строку десять раз:
SELECT replaceRegexpOne('Hello, World!', '.*', '\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0') AS res
┌─res────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!Hello, World! │
└────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘То же самое, но делается замена всех вхождений. Пример:
SELECT replaceRegexpAll('Hello, World!', '.', '\\0\\0') AS res
┌─res──────────────────────────┐
│ HHeelllloo,, WWoorrlldd!! │
└──────────────────────────────┘В качестве исключения, если регулярное выражение сработало на пустой подстроке, то замена делается не более одного раза.
Пример:
SELECT replaceRegexpAll('Hello, World!', '^', 'here: ') AS res
┌─res───────────────────┐
│ here: Hello, World! │
└───────────────────────┘