│
└──────────────────────────────────────────────┘
```
## formatRowNoNewline
Добавленный в: v20.7.0
То же, что и [`formatRow`](#formatRow), но без символа новой строки в конце каждой строки.
Преобразует произвольные выражения в строку в указанном формате, но удаляет из результата все конечные символы новой строки.
**Синтаксис**
```sql theme={null}
formatRowNoNewline(format, x, y, ...)
```
**Аргументы**
* `format` — Текстовый формат, например CSV или TSV. [`String`](/ru/reference/data-types/string)
* `x, y, ...` — Выражения. [`Any`](/ru/reference/data-types)
**Возвращаемое значение**
Возвращает отформатированную строку без символов новой строки. [`String`](/ru/reference/data-types/string)
**Примеры**
**Базовое использование**
```sql title=Query theme={null}
SELECT formatRowNoNewline('CSV', number, 'good')
FROM numbers(3)
```
```response title=Response theme={null}
┌─formatRowNoNewline('CSV', number, 'good')─┐
│ 0,"good" │
│ 1,"good" │
│ 2,"good" │
└───────────────────────────────────────────┘
```
## fromUnixTimestamp64Micro
Добавленный в: v20.5.0
Преобразует Unix-временную метку в микросекундах в значение `DateTime64` с точностью до микросекунд.
Входное значение интерпретируется как Unix-временная метка с микросекундной точностью (число микросекунд с 1970-01-01 00:00:00 UTC).
**Синтаксис**
```sql theme={null}
fromUnixTimestamp64Micro(value[, timezone])
```
**Аргументы**
* `value` — Unix-временная метка в микросекундах. [`Int64`](/ru/reference/data-types/int-uint)
* `timezone` — Необязательно. Часовой пояс возвращаемого значения. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение `DateTime64` с точностью до микросекунд. [`DateTime64(6)`](/ru/reference/data-types/datetime64)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT fromUnixTimestamp64Micro(1640995200123456)
```
```response title=Response theme={null}
┌─fromUnixTimestamp64Micro(1640995200123456)─┐
│ 2022-01-01 00:00:00.123456 │
└────────────────────────────────────────────┘
```
## fromUnixTimestamp64Milli
Добавленный в: v20.5.0
Преобразует Unix-временную метку в миллисекундах в значение `DateTime64` с миллисекундной точностью.
Входное значение интерпретируется как Unix-временная метка с миллисекундной точностью (количество миллисекунд, прошедших с 1970-01-01 00:00:00 UTC).
**Синтаксис**
```sql theme={null}
fromUnixTimestamp64Milli(value[, timezone])
```
**Аргументы**
* `value` — Unix-временная метка в миллисекундах. [`Int64`](/ru/reference/data-types/int-uint)
* `timezone` — Необязательный параметр. Часовой пояс возвращаемого значения. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Значение `DateTime64` с точностью до миллисекунд. [`DateTime64(3)`](/ru/reference/data-types/datetime64)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT fromUnixTimestamp64Milli(1640995200123)
```
```response title=Response theme={null}
┌─fromUnixTimestamp64Milli(1640995200123)─┐
│ 2022-01-01 00:00:00.123 │
└─────────────────────────────────────────┘
```
## fromUnixTimestamp64Nano
Добавленный в: v20.5.0
Преобразует Unix-временную метку в наносекундах в значение [`DateTime64`](/ru/reference/data-types/datetime64) с точностью до наносекунд.
Входное значение интерпретируется как Unix-временная метка с точностью до наносекунд (количество наносекунд, прошедших с 1970-01-01 00:00:00 UTC).
Обратите внимание: входное значение интерпретируется как временная метка в UTC, а не в часовом поясе входного значения.
**Синтаксис**
```sql theme={null}
fromUnixTimestamp64Nano(value[, timezone])
```
**Аргументы**
* `value` — Unix-временная метка в наносекундах. [`Int64`](/ru/reference/data-types/int-uint)
* `timezone` — Необязательно. Часовой пояс возвращаемого значения. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение `DateTime64` с точностью до наносекунд. [`DateTime64(9)`](/ru/reference/data-types/datetime64)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT fromUnixTimestamp64Nano(1640995200123456789)
```
```response title=Response theme={null}
┌─fromUnixTimestamp64Nano(1640995200123456789)─┐
│ 2022-01-01 00:00:00.123456789 │
└──────────────────────────────────────────────┘
```
## fromUnixTimestamp64Second
Добавленный в: v24.12.0
Преобразует Unix-временную метку в секундах в значение `DateTime64` с точностью до секунд.
Входное значение интерпретируется как Unix-временная метка с точностью до секунд (количество секунд с 1970-01-01 00:00:00 UTC).
**Синтаксис**
```sql theme={null}
fromUnixTimestamp64Second(value[, timezone])
```
**Аргументы**
* `value` — Unix-временная метка в секундах. [`Int64`](/ru/reference/data-types/int-uint)
* `timezone` — Необязательный. Часовой пояс для возвращаемого значения. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение `DateTime64` с точностью до секунды. [`DateTime64(0)`](/ru/reference/data-types/datetime64)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT fromUnixTimestamp64Second(1640995200)
```
```response title=Response theme={null}
┌─fromUnixTimestamp64Second(1640995200)─┐
│ 2022-01-01 00:00:00 │
└───────────────────────────────────────┘
```
## parseDateTime
Добавленный в: v23.3.0
Разбирает строку с датой и временем в соответствии со строкой формата даты MySQL.
Эта функция обратна [`formatDateTime`](/ru/reference/functions/regular-functions/date-time-functions).
Она разбирает аргумент типа String, используя строку формата String. Возвращает значение типа DateTime.
**Синтаксис**
```sql theme={null}
parseDateTime(time_string, format[, timezone])
```
**Псевдонимы**: `TO_UNIXTIME`
**Аргументы**
* `time_string` — Строка, которую нужно разобрать в DateTime. [`String`](/ru/reference/data-types/string)
* `format` — Строка формата, определяющая, как разбирать time\_string. [`String`](/ru/reference/data-types/string)
* `timezone` — Необязательно. Часовой пояс. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение DateTime, разобранное из входной строки в соответствии со строкой формата в стиле MySQL. [`DateTime`](/ru/reference/data-types/datetime)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT parseDateTime('2025-01-04+23:00:00', '%Y-%m-%d+%H:%i:%s')
```
```response title=Response theme={null}
┌─parseDateTime('2025-01-04+23:00:00', '%Y-%m-%d+%H:%i:%s')─┐
│ 2025-01-04 23:00:00 │
└───────────────────────────────────────────────────────────┘
```
## parseDateTime32BestEffort
Добавленный в: v20.9.0
Преобразует строковое представление даты и времени в тип данных [`DateTime`](/ru/reference/data-types/datetime).
Функция разбирает даты и время в форматах [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601), [RFC 1123 - 5.2.14 RFC-822 Date and Time Specification](https://tools.ietf.org/html/rfc1123#page-55), ClickHouse и некоторых других форматах.
**Синтаксис**
```sql theme={null}
parseDateTime32BestEffort(time_string[, time_zone])
```
**Аргументы**
* `time_string` — Строка `String`, содержащая дату и время для преобразования. [`String`](/ru/reference/data-types/string)
* `time_zone` — Необязательный. Часовой пояс, в соответствии с которым разбирается `time_string`. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает `time_string` в формате `DateTime`. [`DateTime`](/ru/reference/data-types/datetime)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT parseDateTime32BestEffort('23/10/2025 12:12:57')
AS parseDateTime32BestEffort
```
```response title=Response theme={null}
┌─parseDateTime32BestEffort─┐
│ 2025-10-23 12:12:57 │
└───────────────────────────┘
```
**С часовым поясом**
```sql title=Query theme={null}
SELECT parseDateTime32BestEffort('Sat, 18 Aug 2025 07:22:16 GMT', 'Asia/Istanbul')
AS parseDateTime32BestEffort
```
```response title=Response theme={null}
┌─parseDateTime32BestEffort─┐
│ 2025-08-18 10:22:16 │
└───────────────────────────┘
```
**Unix-временная метка**
```sql title=Query theme={null}
SELECT parseDateTime32BestEffort('1284101485')
AS parseDateTime32BestEffort
```
```response title=Response theme={null}
┌─parseDateTime32BestEffort─┐
│ 2015-07-07 12:04:41 │
└───────────────────────────┘
```
## parseDateTime32BestEffortOrNull
Добавленный в: v20.9.0
То же, что и [`parseDateTime32BestEffort`](#parseDateTime32BestEffort), но при обнаружении формата даты, который невозможно обработать, функция возвращает `NULL`.
**Синтаксис**
```sql theme={null}
parseDateTime32BestEffortOrNull(time_string[, time_zone])
```
**Аргументы**
* `time_string` — Строка `String`, содержащая дату и время для преобразования. [`String`](/ru/reference/data-types/string)
* `time_zone` — Необязательно. Часовой пояс, в соответствии с которым разбирается `time_string`. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает объект `DateTime`, разобранный из строки, или `NULL`, если разобрать строку не удалось. [`DateTime`](/ru/reference/data-types/datetime)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
parseDateTime32BestEffortOrNull('23/10/2025 12:12:57') AS valid,
parseDateTime32BestEffortOrNull('invalid date') AS invalid
```
```response title=Response theme={null}
┌─valid───────────────┬─invalid─┐
│ 2025-10-23 12:12:57 │ ᴺᵁᴸᴸ │
└─────────────────────┴─────────┘
```
## parseDateTime32BestEffortOrZero
Добавленный в: v20.9.0
То же, что и [`parseDateTime32BestEffort`](#parseDateTime32BestEffort), но при встрече с неподдерживаемым форматом даты функция возвращает нулевую дату или нулевое значение дата-время.
**Синтаксис**
```sql theme={null}
parseDateTime32BestEffortOrZero(time_string[, time_zone])
```
**Аргументы**
* `time_string` — Строка с датой и временем для преобразования. [`String`](/ru/reference/data-types/string)
* `time_zone` — Необязательно. Часовой пояс, в соответствии с которым разбирается `time_string`. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает объект `DateTime`, полученный при разборе строки, или нулевую дату (`1970-01-01 00:00:00`), если разбор не удался. [`DateTime`](/ru/reference/data-types/datetime)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
parseDateTime32BestEffortOrZero('23/10/2025 12:12:57') AS valid,
parseDateTime32BestEffortOrZero('invalid date') AS invalid
```
```response title=Response theme={null}
┌─valid───────────────┬─invalid─────────────┐
│ 2025-10-23 12:12:57 │ 1970-01-01 00:00:00 │
└─────────────────────┴─────────────────────┘
```
## parseDateTime64
Добавленный в: v24.11.0
Разбирает строку даты и времени с точностью до долей секунды в соответствии со строкой формата даты MySQL.
Эта функция является обратной к [`formatDateTime`](/ru/reference/functions/regular-functions/date-time-functions) для DateTime64.
Она разбирает аргумент типа String с помощью строки формата String. Возвращает тип DateTime64, который может представлять даты с 1900 по 2299 год с точностью до долей секунды.
**Синтаксис**
```sql theme={null}
parseDateTime64(time_string, format[, timezone])
```
**Аргументы**
* `time_string` — Строка, которую нужно разобрать как DateTime64. [`String`](/ru/reference/data-types/string)
* `format` — Строка формата, задающая способ разбора time\_string. [`String`](/ru/reference/data-types/string)
* `timezone` — Необязательно. Часовой пояс. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение DateTime64, разобранное из входной строки в соответствии со строкой формата в стиле MySQL. [`DateTime64`](/ru/reference/data-types/datetime64)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT parseDateTime64('2025-01-04 23:00:00.123', '%Y-%m-%d %H:%i:%s.%f')
```
```response title=Response theme={null}
┌─parseDateTime64('2025-01-04 23:00:00.123', '%Y-%m-%d %H:%i:%s.%f')─┐
│ 2025-01-04 23:00:00.123 │
└─────────────────────────────────────────────────────────────────────┘
```
## parseDateTime64BestEffort
Добавленный в: v20.1.0
То же, что и функция [`parseDateTimeBestEffort`](#parseDateTimeBestEffort), но также разбирает миллисекунды и микросекунды и возвращает тип данных [`DateTime64`](/ru/reference/data-types/datetime64).
**Синтаксис**
```sql theme={null}
parseDateTime64BestEffort(time_string[, precision[, time_zone]])
```
**Аргументы**
* `time_string` — Строка, содержащая дату или дату и время для преобразования. [`String`](/ru/reference/data-types/string)
* `precision` — Необязательно. Требуемая точность. `3` для миллисекунд, `6` для микросекунд. По умолчанию: `3`. [`UInt8`](/ru/reference/data-types/int-uint)
* `time_zone` — Необязательно. Часовой пояс. Функция разбирает `time_string` с учетом часового пояса. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает `time_string`, преобразованную в тип данных [`DateTime64`](/ru/reference/data-types/datetime64). [`DateTime64`](/ru/reference/data-types/datetime64)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT parseDateTime64BestEffort('2025-01-01') AS a, toTypeName(a) AS t
UNION ALL
SELECT parseDateTime64BestEffort('2025-01-01 01:01:00.12346') AS a, toTypeName(a) AS t
UNION ALL
SELECT parseDateTime64BestEffort('2025-01-01 01:01:00.12346',6) AS a, toTypeName(a) AS t
UNION ALL
SELECT parseDateTime64BestEffort('2025-01-01 01:01:00.12346',3,'Asia/Istanbul') AS a, toTypeName(a) AS t
FORMAT PrettyCompactMonoBlock
```
```response title=Response theme={null}
┌──────────────────────────a─┬─t──────────────────────────────┐
│ 2025-01-01 01:01:00.123000 │ DateTime64(3) │
│ 2025-01-01 00:00:00.000000 │ DateTime64(3) │
│ 2025-01-01 01:01:00.123460 │ DateTime64(6) │
│ 2025-12-31 22:01:00.123000 │ DateTime64(3, 'Asia/Istanbul') │
└────────────────────────────┴────────────────────────────────┘
```
## parseDateTime64BestEffortOrNull
Добавленный в: v20.1.0
То же, что и [`parseDateTime64BestEffort`](#parseDateTime64BestEffort), но возвращает `NULL`, если встречает формат даты, который невозможно обработать.
**Синтаксис**
```sql theme={null}
parseDateTime64BestEffortOrNull(time_string[, precision[, time_zone]])
```
**Аргументы**
* `time_string` — Строка, содержащая дату или дату и время для преобразования. [`String`](/ru/reference/data-types/string)
* `precision` — Необязательно. Требуемая точность. `3` для миллисекунд, `6` для микросекунд. По умолчанию: `3`. [`UInt8`](/ru/reference/data-types/int-uint)
* `time_zone` — Необязательно. Часовой пояс. Функция разбирает `time_string` в соответствии с часовым поясом. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает `time_string`, преобразованную в [`DateTime64`](/ru/reference/data-types/datetime64), или `NULL`, если входное значение не удаётся разобрать. [`DateTime64`](/ru/reference/data-types/datetime64) или [`NULL`](/ru/reference/syntax#null)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT parseDateTime64BestEffortOrNull('2025-01-01 01:01:00.123') AS valid,
parseDateTime64BestEffortOrNull('invalid') AS invalid
```
```response title=Response theme={null}
┌─valid───────────────────┬─invalid─┐
│ 2025-01-01 01:01:00.123 │ ᴺᵁᴸᴸ │
└─────────────────────────┴─────────┘
```
## parseDateTime64BestEffortOrZero
Добавленный в: v20.1.0
То же, что и [`parseDateTime64BestEffort`](#parseDateTime64BestEffort), за исключением того, что функция возвращает нулевую дату или нулевое значение дата-время, если встречает формат даты, который не может быть обработан.
**Синтаксис**
```sql theme={null}
parseDateTime64BestEffortOrZero(time_string[, precision[, time_zone]])
```
**Аргументы**
* `time_string` — Строка, содержащая дату или дату и время для преобразования. [`String`](/ru/reference/data-types/string)
* `precision` — Необязательно. Требуемая точность. `3` для миллисекунд, `6` для микросекунд. По умолчанию: `3`. [`UInt8`](/ru/reference/data-types/int-uint)
* `time_zone` — Необязательно. Часовой пояс. Функция разбирает `time_string` с учетом этого часового пояса. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение `time_string`, преобразованное в [`DateTime64`](/ru/reference/data-types/datetime64), или нулевую дату/дату и время (`1970-01-01 00:00:00.000`), если входное значение не удается разобрать. [`DateTime64`](/ru/reference/data-types/datetime64)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT parseDateTime64BestEffortOrZero('2025-01-01 01:01:00.123') AS valid,
parseDateTime64BestEffortOrZero('invalid') AS invalid
```
```response title=Response theme={null}
┌─valid───────────────────┬─invalid─────────────────┐
│ 2025-01-01 01:01:00.123 │ 1970-01-01 00:00:00.000 │
└─────────────────────────┴─────────────────────────┘
```
## parseDateTime64BestEffortUS
Добавленный в: v22.8.0
То же, что и [`parseDateTime64BestEffort`](#parseDateTime64BestEffort), но в неоднозначных случаях эта функция отдает предпочтение американскому формату даты (`MM/DD/YYYY` и т. д.).
**Синтаксис**
```sql theme={null}
parseDateTime64BestEffortUS(time_string [, precision [, time_zone]])
```
**Аргументы**
* `time_string` — Строка `String`, содержащая дату или дату и время для преобразования. [`String`](/ru/reference/data-types/string)
* `precision` — Необязательно. Требуемая точность. `3` для миллисекунд, `6` для микросекунд. По умолчанию: `3`. [`UInt8`](/ru/reference/data-types/int-uint)
* `time_zone` — Необязательно. Часовой пояс. Функция разбирает `time_string` в соответствии с указанным часовым поясом. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает `time_string`, преобразованную в [`DateTime64`](/ru/reference/data-types/datetime64), с предпочтением американского формата даты в неоднозначных случаях. [`DateTime64`](/ru/reference/data-types/datetime64)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT parseDateTime64BestEffortUS('02/10/2025 12:30:45.123') AS us_format,
parseDateTime64BestEffortUS('15/08/2025 10:15:30.456') AS fallback_to_standard
```
```response title=Response theme={null}
┌─us_format───────────────┬─fallback_to_standard────┐
│ 2025-02-10 12:30:45.123 │ 2025-08-15 10:15:30.456 │
└─────────────────────────┴─────────────────────────┘
```
## parseDateTime64BestEffortUSOrNull
Добавленный в: v22.8.0
То же, что и [`parseDateTime64BestEffort`](#parseDateTime64BestEffort), но в неоднозначных случаях эта функция отдаёт предпочтение американскому формату даты (`MM/DD/YYYY` и т. д.) и возвращает `NULL`, если встречает формат даты, который не может быть обработан.
**Синтаксис**
```sql theme={null}
parseDateTime64BestEffortUSOrNull(time_string[, precision[, time_zone]])
```
**Аргументы**
* `time_string` — Строка, содержащая дату или дата и время для преобразования. [`String`](/ru/reference/data-types/string)
* `precision` — Необязательный параметр. Требуемая точность. `3` для миллисекунд, `6` для микросекунд. По умолчанию: `3`. [`UInt8`](/ru/reference/data-types/int-uint)
* `time_zone` — Необязательный параметр. Часовой пояс. Функция разбирает `time_string` в соответствии с этим часовым поясом. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает `time_string`, преобразованную в [`DateTime64`](/ru/reference/data-types/datetime64) с приоритетом формата US, или `NULL`, если входное значение не удаётся разобрать. [`DateTime64`](/ru/reference/data-types/datetime64) или [`NULL`](/ru/reference/syntax#null)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT parseDateTime64BestEffortUSOrNull('02/10/2025 12:30:45.123') AS valid_us,
parseDateTime64BestEffortUSOrNull('invalid') AS invalid
```
```response title=Response theme={null}
┌─valid_us────────────────┬─invalid─┐
│ 2025-02-10 12:30:45.123 │ ᴺᵁᴸᴸ │
└─────────────────────────┴─────────┘
```
## parseDateTime64BestEffortUSOrZero
Добавленный в: v22.8.0
То же, что и [`parseDateTime64BestEffort`](#parseDateTime64BestEffort), но в неоднозначных случаях эта функция предпочитает американский формат даты (`MM/DD/YYYY` и т. д.) и возвращает нулевую дату или нулевое значение даты-времени, если встречает формат даты, который не может быть обработан.
**Синтаксис**
```sql theme={null}
parseDateTime64BestEffortUSOrZero(time_string [, precision [, time_zone]])
```
**Аргументы**
* `time_string` — Строка, содержащая дату или дату и время для преобразования. [`String`](/ru/reference/data-types/string)
* `precision` — Необязательно. Требуемая точность: `3` для миллисекунд, `6` для микросекунд. По умолчанию: `3`. [`UInt8`](/ru/reference/data-types/int-uint)
* `time_zone` — Необязательно. Часовой пояс. Функция разбирает `time_string` в соответствии с этим часовым поясом. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает `time_string`, преобразованную в [`DateTime64`](/ru/reference/data-types/datetime64) с предпочтением американского формата, или нулевую дату/дату и время (`1970-01-01 00:00:00.000`), если входное значение не удаётся разобрать. [`DateTime64`](/ru/reference/data-types/datetime64)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT parseDateTime64BestEffortUSOrZero('02/10/2025 12:30:45.123') AS valid_us,
parseDateTime64BestEffortUSOrZero('invalid') AS invalid
```
```response title=Response theme={null}
┌─valid_us────────────────┬─invalid─────────────────┐
│ 2025-02-10 12:30:45.123 │ 1970-01-01 00:00:00.000 │
└─────────────────────────┴─────────────────────────┘
```
## parseDateTime64InJodaSyntax
Добавленный в: v24.10.0
Разбирает строку даты и времени с точностью до долей секунды в соответствии со строкой формата даты и времени Joda.
Эта функция является обратной к [`formatDateTimeInJodaSyntax`](/ru/reference/functions/regular-functions/date-time-functions#formatDateTimeInJodaSyntax) для DateTime64.
Она разбирает аргумент типа String, используя строку формата в стиле Joda. Возвращает значение типа DateTime64, которое может представлять даты с 1900 по 2299 год с точностью до долей секунды.
Описание шаблонов формата см. в [документации Joda Time](https://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html).
**Синтаксис**
```sql theme={null}
parseDateTime64InJodaSyntax(time_string, format[, timezone])
```
**Аргументы**
* `time_string` — Строка `String`, которую нужно разобрать в DateTime64. [`String`](/ru/reference/data-types/string)
* `format` — Строка формата в синтаксисе Joda, задающая способ разбора time\_string. [`String`](/ru/reference/data-types/string)
* `timezone` — Необязательно. Часовой пояс. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение DateTime64, разобранное из входной строки в соответствии со строкой формата в стиле Joda. [`DateTime64`](/ru/reference/data-types/datetime64)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT parseDateTime64InJodaSyntax('2025-01-04 23:00:00.123', 'yyyy-MM-dd HH:mm:ss.SSS')
```
```response title=Response theme={null}
┌─parseDateTime64InJodaSyntax('2025-01-04 23:00:00.123', 'yyyy-MM-dd HH:mm:ss.SSS')─┐
│ 2025-01-04 23:00:00.123 │
└────────────────────────────────────────────────────────────────────────────────────┘
```
## parseDateTime64InJodaSyntaxOrNull
Добавленный в: v24.10.0
То же, что и [`parseDateTime64InJodaSyntax`](#parseDateTime64InJodaSyntax), но возвращает `NULL`, если указан неподдающийся разбору формат даты.
**Синтаксис**
```sql theme={null}
parseDateTime64InJodaSyntaxOrNull(time_string, format[, timezone])
```
**Аргументы**
* `time_string` — строка, которую нужно разобрать как DateTime64. [`String`](/ru/reference/data-types/string)
* `format` — строка формата в синтаксисе Joda, задающая способ разбора time\_string. [`String`](/ru/reference/data-types/string)
* `timezone` — необязательный параметр. Часовой пояс. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение DateTime64, разобранное из входной строки, или NULL, если разбор не удался. [`Nullable(DateTime64)`](/ru/reference/data-types/nullable)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT parseDateTime64InJodaSyntaxOrNull('2025-01-04 23:00:00.123', 'yyyy-MM-dd HH:mm:ss.SSS')
```
```response title=Response theme={null}
┌─parseDateTime64InJodaSyntaxOrNull('2025-01-04 23:00:00.123', 'yyyy-MM-dd HH:mm:ss.SSS')─┐
│ 2025-01-04 23:00:00.123 │
└──────────────────────────────────────────────────────────────────────────────────────────┘
```
## parseDateTime64InJodaSyntaxOrZero
Добавленный в: v24.10.0
То же, что и [`parseDateTime64InJodaSyntax`](#parseDateTime64InJodaSyntax), но при неподдающемся разбору формате даты возвращает нулевую дату.
**Синтаксис**
```sql theme={null}
parseDateTime64InJodaSyntaxOrZero(time_string, format[, timezone])
```
**Аргументы**
* `time_string` — Строка `String`, которую нужно преобразовать в DateTime64. [`String`](/ru/reference/data-types/string)
* `format` — Строка формата в синтаксисе Joda, задающая способ разбора time\_string. [`String`](/ru/reference/data-types/string)
* `timezone` — Необязательный параметр. Часовой пояс. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение DateTime64, разобранное из входной строки, или нулевое значение DateTime64, если разбор завершился неудачно. [`DateTime64`](/ru/reference/data-types/datetime64)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT parseDateTime64InJodaSyntaxOrZero('2025-01-04 23:00:00.123', 'yyyy-MM-dd HH:mm:ss.SSS')
```
```response title=Response theme={null}
┌─parseDateTime64InJodaSyntaxOrZero('2025-01-04 23:00:00.123', 'yyyy-MM-dd HH:mm:ss.SSS')─┐
│ 2025-01-04 23:00:00.123 │
└──────────────────────────────────────────────────────────────────────────────────────────┘
```
## parseDateTime64OrNull
Добавленный в: v24.11.0
То же, что и [`parseDateTime64`](#parseDateTime64), но возвращает `NULL`, если встречается неподдающийся разбору формат даты.
**Синтаксис**
```sql theme={null}
parseDateTime64OrNull(time_string, format[, timezone])
```
**Аргументы**
* `time_string` — Строка, которую нужно разобрать как DateTime64. [`String`](/ru/reference/data-types/string)
* `format` — Строка формата, задающая способ разбора time\_string. [`String`](/ru/reference/data-types/string)
* `timezone` — Необязательный параметр. Часовой пояс. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает DateTime64, разобранный из входной строки, или NULL, если разбор не удался. [`Nullable(DateTime64)`](/ru/reference/data-types/nullable)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT parseDateTime64OrNull('2025-01-04 23:00:00.123', '%Y-%m-%d %H:%i:%s.%f')
```
```response title=Response theme={null}
┌─parseDateTime64OrNull('2025-01-04 23:00:00.123', '%Y-%m-%d %H:%i:%s.%f')─┐
│ 2025-01-04 23:00:00.123 │
└───────────────────────────────────────────────────────────────────────────┘
```
## parseDateTime64OrZero
Добавленный в: v24.11.0
То же, что и [`parseDateTime64`](#parseDateTime64), но возвращает нулевую дату, если встречает неподдающийся разбору формат даты.
**Синтаксис**
```sql theme={null}
parseDateTime64OrZero(time_string, format[, timezone])
```
**Аргументы**
* `time_string` — Строка, которую нужно разобрать в DateTime64. [`String`](/ru/reference/data-types/string)
* `format` — Строка формата, задающая, как разобрать time\_string. [`String`](/ru/reference/data-types/string)
* `timezone` — Необязательный параметр. Часовой пояс. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает DateTime64, разобранный из входной строки, или нулевое значение DateTime64, если разбор не удался. [`DateTime64`](/ru/reference/data-types/datetime64)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT parseDateTime64OrZero('2025-01-04 23:00:00.123', '%Y-%m-%d %H:%i:%s.%f')
```
```response title=Response theme={null}
┌─parseDateTime64OrZero('2025-01-04 23:00:00.123', '%Y-%m-%d %H:%i:%s.%f')─┐
│ 2025-01-04 23:00:00.123 │
└───────────────────────────────────────────────────────────────────────────┘
```
## parseDateTimeBestEffort
Добавленный в: v1.1.0
Преобразует дату и время из строкового представления String в тип данных DateTime.
Функция разбирает форматы даты и времени [ISO 8601](https://www.iso.org/iso-8601-date-and-time-format.html), [RFC 1123 - 5.2.14 RFC-822](https://datatracker.ietf.org/doc/html/rfc822), формат ClickHouse, а также некоторые другие.
Поддерживаемые нестандартные форматы:
* Строка, содержащая 9–10-значную Unix-временную метку.
* Строка с датой и компонентом времени: `YYYYMMDDhhmmss`, `DD/MM/YYYY hh:mm:ss`, `DD-MM-YY hh:mm`, `YYYY-MM-DD hh:mm:ss` и т. д.
* Строка с датой, но без компонента времени: `YYYY`, `YYYYMM`, `YYYY*MM`, `DD/MM/YYYY`, `DD-MM-YY` и т. д.
* Строка с днем и временем: `DD`, `DD hh`, `DD hh:mm`. В этом случае `MM` заменяется на `01`.
* Строка, содержащая дату и время вместе с информацией о смещении часового пояса: `YYYY-MM-DD hh:mm:ss ±h:mm` и т. д.
* Временная метка syslog: `Mmm dd hh:mm:ss`. Например, `Jun 9 14:20:32`.
Для всех форматов с разделителями функция разбирает названия месяцев, записанные полностью или в виде первых трех букв названия месяца.
Если год не указан, считается, что он равен текущему году.
**Синтаксис**
```sql theme={null}
parseDateTimeBestEffort(time_string[, time_zone])
```
**Аргументы**
* `time_string` — Строка с датой и временем для преобразования. [`String`](/ru/reference/data-types/string)
* `time_zone` — Необязательный параметр. Часовой пояс, в соответствии с которым разбирается `time_string`. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает `time_string` в формате `DateTime`. [`DateTime`](/ru/reference/data-types/datetime)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT parseDateTimeBestEffort('23/10/2025 12:12:57') AS parseDateTimeBestEffort
```
```response title=Response theme={null}
┌─parseDateTimeBestEffort─┐
│ 2025-10-23 12:12:57 │
└─────────────────────────┘
```
**С указанием часового пояса**
```sql title=Query theme={null}
SELECT parseDateTimeBestEffort('Sat, 18 Aug 2025 07:22:16 GMT', 'Asia/Istanbul') AS parseDateTimeBestEffort
```
```response title=Response theme={null}
┌─parseDateTimeBestEffort─┐
│ 2025-08-18 10:22:16 │
└─────────────────────────┘
```
**Unix-временная метка**
```sql title=Query theme={null}
SELECT parseDateTimeBestEffort('1735689600') AS parseDateTimeBestEffort
```
```response title=Response theme={null}
┌─parseDateTimeBestEffort─┐
│ 2025-01-01 00:00:00 │
└─────────────────────────┘
```
## parseDateTimeBestEffortOrNull
Добавленный в: v1.1.0
То же, что и [`parseDateTimeBestEffort`](#parseDateTimeBestEffort), за исключением того, что функция возвращает `NULL`, если встречает формат даты, который не может обработать.
Функция разбирает [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601), [RFC 1123 - 5.2.14 RFC-822 Date and Time Specification](https://tools.ietf.org/html/rfc1123#page-55), форматы даты и времени ClickHouse, а также некоторые другие форматы.
Поддерживаемые нестандартные форматы:
* Строка, содержащая 9..10-значную Unix-временную метку.
* Строка с датой и компонентом времени: `YYYYMMDDhhmmss`, `DD/MM/YYYY hh:mm:ss`, `DD-MM-YY hh:mm`, `YYYY-MM-DD hh:mm:ss` и т. д.
* Строка с датой, но без компонента времени: `YYYY`, `YYYYMM`, `YYYY*MM`, `DD/MM/YYYY`, `DD-MM-YY` и т. д.
* Строка с днем и временем: `DD`, `DD hh`, `DD hh:mm`. В этом случае `MM` заменяется на `01`.
* Строка, включающая дату и время вместе с информацией о смещении часового пояса: `YYYY-MM-DD hh:mm:ss ±h:mm` и т. д.
* Syslog-временная метка: `Mmm dd hh:mm:ss`. Например, `Jun 9 14:20:32`.
Для всех форматов с разделителями функция разбирает названия месяцев, записанные полностью или по первым трем буквам.
Если год не указан, считается, что он равен текущему году.
**Синтаксис**
```sql theme={null}
parseDateTimeBestEffortOrNull(time_string[, time_zone])
```
**Аргументы**
* `time_string` — Строка, содержащая дату и время для преобразования. [`String`](/ru/reference/data-types/string)
* `time_zone` — Необязательно. Часовой пояс, в соответствии с которым разбирается `time_string`. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает `time_string` в виде `DateTime` или `NULL`, если входное значение не удаётся разобрать. [`DateTime`](/ru/reference/data-types/datetime) или [`NULL`](/ru/reference/syntax#null)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT parseDateTimeBestEffortOrNull('23/10/2025 12:12:57') AS valid,
parseDateTimeBestEffortOrNull('invalid') AS invalid
```
```response title=Response theme={null}
┌─valid───────────────┬─invalid─┐
│ 2025-10-23 12:12:57 │ ᴺᵁᴸᴸ │
└─────────────────────┴─────────┘
```
## parseDateTimeBestEffortOrZero
Добавленный в: v1.1.0
То же, что и [`parseDateTimeBestEffort`](#parseDateTimeBestEffort), за исключением того, что функция возвращает нулевую дату или нулевое значение дата-времени, если встречает формат даты, который не может быть обработан.
Функция разбирает [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601), [RFC 1123 - 5.2.14 RFC-822 Date and Time Specification](https://tools.ietf.org/html/rfc1123#page-55), а также форматы даты и времени ClickHouse и некоторые другие форматы.
Поддерживаемые нестандартные форматы:
* Строка, содержащая 9..10-значную Unix-временную метку.
* Строка с датой и временем: `YYYYMMDDhhmmss`, `DD/MM/YYYY hh:mm:ss`, `DD-MM-YY hh:mm`, `YYYY-MM-DD hh:mm:ss` и т. д.
* Строка с датой, но без времени: `YYYY`, `YYYYMM`, `YYYY*MM`, `DD/MM/YYYY`, `DD-MM-YY` и т. д.
* Строка с днём и временем: `DD`, `DD hh`, `DD hh:mm`. В этом случае вместо `MM` подставляется `01`.
* Строка, включающая дату и время вместе с информацией о смещении часового пояса: `YYYY-MM-DD hh:mm:ss ±h:mm` и т. д.
* Временная метка syslog: `Mmm dd hh:mm:ss`. Например, `Jun 9 14:20:32`.
Для всех форматов с разделителями функция разбирает названия месяцев, указанные полностью или в виде первых трёх букв.
Если год не указан, считается, что он равен текущему году.
**Синтаксис**
```sql theme={null}
parseDateTimeBestEffortOrZero(time_string[, time_zone])
```
**Аргументы**
* `time_string` — Строка `String`, содержащая дату и время для преобразования. [`String`](/ru/reference/data-types/string)
* `time_zone` — Необязательно. Часовой пояс, в соответствии с которым разбирается `time_string`. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает `time_string` в формате `DateTime` или нулевую дату/дату-время (`1970-01-01` или `1970-01-01 00:00:00`), если входное значение не удаётся разобрать. [`DateTime`](/ru/reference/data-types/datetime)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT parseDateTimeBestEffortOrZero('23/10/2025 12:12:57') AS valid,
parseDateTimeBestEffortOrZero('invalid') AS invalid
```
```response title=Response theme={null}
┌─valid───────────────┬─invalid─────────────┐
│ 2025-10-23 12:12:57 │ 1970-01-01 00:00:00 │
└─────────────────────┴─────────────────────┘
```
## parseDateTimeBestEffortUS
Добавленный в: v1.1.0
Эта функция ведёт себя как [`parseDateTimeBestEffort`](#parseDateTimeBestEffort) для дат в формате ISO, например `YYYY-MM-DD hh:mm:ss`, а также для других форматов даты, где месяц и день можно определить однозначно, например `YYYYMMDDhhmmss`, `YYYY-MM`, `DD hh` или `YYYY-MM-DD hh:mm:ss ±h:mm`.
Если месяц и день нельзя определить однозначно, например в `MM/DD/YYYY`, `MM-DD-YYYY` или `MM-DD-YY`, функция отдаёт предпочтение американскому формату даты, а не `DD/MM/YYYY`, `DD-MM-YYYY` или `DD-MM-YY`.
Исключение из этого правила: если значение месяца больше 12 и меньше либо равно 31, функция возвращается к поведению [`parseDateTimeBestEffort`](#parseDateTimeBestEffort); например, `15/08/2020` разбирается как `2020-08-15`.
**Синтаксис**
```sql theme={null}
parseDateTimeBestEffortUS(time_string[, time_zone])
```
**Аргументы**
* `time_string` — `String` с датой и временем для преобразования. [`String`](/ru/reference/data-types/string)
* `time_zone` — Необязательно. Часовой пояс, в соответствии с которым разбирается `time_string`. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает `time_string` в виде `DateTime`, отдавая предпочтение американскому формату даты в неоднозначных случаях. [`DateTime`](/ru/reference/data-types/datetime)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT parseDateTimeBestEffortUS('02/10/2025') AS us_format,
parseDateTimeBestEffortUS('15/08/2025') AS fallback_to_standard
```
```response title=Response theme={null}
┌─us_format───────────┬─fallback_to_standard─┐
│ 2025-02-10 00:00:00 │ 2025-08-15 00:00:00 │
└─────────────────────┴──────────────────────┘
```
## parseDateTimeBestEffortUSOrNull
Добавленный в: v1.1.0
То же, что и функция [`parseDateTimeBestEffortUS`](#parseDateTimeBestEffortUS), за исключением того, что при обнаружении формата даты, который не удается обработать, она возвращает `NULL`.
Для форматов дат ISO эта функция ведет себя как [`parseDateTimeBestEffort`](#parseDateTimeBestEffort), но в неоднозначных случаях предпочитает американский формат даты и при ошибках разбора возвращает `NULL`.
**Синтаксис**
```sql theme={null}
parseDateTimeBestEffortUSOrNull(time_string[, time_zone])
```
**Аргументы**
* `time_string` — Строка, содержащая дату и время для преобразования. [`String`](/ru/reference/data-types/string)
* `time_zone` — Необязательный. Часовой пояс, в соответствии с которым разбирается `time_string`. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает `time_string` как DateTime с приоритетом формата US или `NULL`, если входное значение не удаётся разобрать. [`DateTime`](/ru/reference/data-types/datetime) или [`NULL`](/ru/reference/syntax#null)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT parseDateTimeBestEffortUSOrNull('02/10/2025') AS valid_us,
parseDateTimeBestEffortUSOrNull('invalid') AS invalid
```
```response title=Response theme={null}
┌─valid_us────────────┬─invalid─┐
│ 2025-02-10 00:00:00 │ ᴺᵁᴸᴸ │
└─────────────────────┴─────────┘
```
## parseDateTimeBestEffortUSOrZero
Добавленный в: v1.1.0
То же, что и функция [`parseDateTimeBestEffortUS`](#parseDateTimeBestEffortUS), за исключением того, что при обнаружении формата даты, который не удаётся обработать, она возвращает нулевую дату (`1970-01-01`) или нулевую дату и время (`1970-01-01 00:00:00`).
Эта функция работает так же, как [`parseDateTimeBestEffort`](#parseDateTimeBestEffort), для дат в формате ISO, но в неоднозначных случаях предпочитает американский формат даты и при ошибках разбора возвращает ноль.
**Синтаксис**
```sql theme={null}
parseDateTimeBestEffortUSOrZero(time_string[, time_zone])
```
**Аргументы**
* `time_string` — Строка, содержащая дату и время для преобразования. [`String`](/ru/reference/data-types/string)
* `time_zone` — Необязательно. Часовой пояс, в соответствии с которым разбирается `time_string`. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает `time_string` в виде `DateTime` с предпочтением американского формата или нулевую дату/дату-время (`1970-01-01` или `1970-01-01 00:00:00`), если входное значение не удаётся разобрать. [`DateTime`](/ru/reference/data-types/datetime)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT parseDateTimeBestEffortUSOrZero('02/10/2025') AS valid_us,
parseDateTimeBestEffortUSOrZero('invalid') AS invalid
```
```response title=Response theme={null}
┌─valid_us────────────┬─invalid─────────────┐
│ 2025-02-10 00:00:00 │ 1970-01-01 00:00:00 │
└─────────────────────┴─────────────────────┘
```
## parseDateTimeInJodaSyntax
Добавленный в: v23.3.0
Разбирает строку с датой и временем в соответствии со строкой формата даты Joda.
Эта функция является обратной к [`formatDateTimeInJodaSyntax`](/ru/reference/functions/regular-functions/date-time-functions#formatDateTimeInJodaSyntax).
Она разбирает аргумент типа String, используя строку формата в стиле Joda. Возвращает значение типа DateTime.
Описание шаблонов формата см. в [документации Joda Time](https://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html).
**Синтаксис**
```sql theme={null}
parseDateTimeInJodaSyntax(time_string, format[, timezone])
```
**Аргументы**
* `time_string` — Строка для разбора в DateTime. [`String`](/ru/reference/data-types/string)
* `format` — Строка формата в синтаксисе Joda, задающая способ разбора time\_string. [`String`](/ru/reference/data-types/string)
* `timezone` — Необязательно. Часовой пояс. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение DateTime, полученное путём разбора входной строки в соответствии со строкой формата в стиле Joda. [`DateTime`](/ru/reference/data-types/datetime)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT parseDateTimeInJodaSyntax('2025-01-04 23:00:00', 'yyyy-MM-dd HH:mm:ss')
```
```response title=Response theme={null}
┌─parseDateTimeInJodaSyntax('2025-01-04 23:00:00', 'yyyy-MM-dd HH:mm:ss')─┐
│ 2025-01-04 23:00:00 │
└──────────────────────────────────────────────────────────────────────────┘
```
## parseDateTimeInJodaSyntaxOrNull
Добавленный в: v23.3.0
То же, что и [`parseDateTimeInJodaSyntax`](#parseDateTimeInJodaSyntax), но при неподдающемся разбору формате даты возвращает `NULL`.
**Синтаксис**
```sql theme={null}
parseDateTimeInJodaSyntaxOrNull(time_string, format[, timezone])
```
**Аргументы**
* `time_string` — Строка, которую нужно разобрать как DateTime. [`String`](/ru/reference/data-types/string)
* `format` — Строка формата в синтаксисе Joda, задающая способ разбора time\_string. [`String`](/ru/reference/data-types/string)
* `timezone` — Необязательно. Часовой пояс. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает DateTime, разобранный из входной строки, или NULL, если разбор завершился неудачно. [`Nullable(DateTime)`](/ru/reference/data-types/nullable)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT parseDateTimeInJodaSyntaxOrNull('2025-01-04 23:00:00', 'yyyy-MM-dd HH:mm:ss')
```
```response title=Response theme={null}
┌─parseDateTimeInJodaSyntaxOrNull('2025-01-04 23:00:00', 'yyyy-MM-dd HH:mm:ss')─┐
│ 2025-01-04 23:00:00 │
└────────────────────────────────────────────────────────────────────────────────┘
```
## parseDateTimeInJodaSyntaxOrZero
Добавленный в: v23.3.0
То же, что и [`parseDateTimeInJodaSyntax`](#parseDateTimeInJodaSyntax), но возвращает нулевую дату, если встречается неподдающийся разбору формат даты.
**Синтаксис**
```sql theme={null}
parseDateTimeInJodaSyntaxOrZero(time_string, format[, timezone])
```
**Аргументы**
* `time_string` — строка, которую нужно разобрать как DateTime. [`String`](/ru/reference/data-types/string)
* `format` — строка формата в синтаксисе Joda, задающая, как разбирать time\_string. [`String`](/ru/reference/data-types/string)
* `timezone` — Необязательно. Часовой пояс. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение DateTime, разобранное из входной строки, или нулевой DateTime, если разобрать строку не удалось. [`DateTime`](/ru/reference/data-types/datetime)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT parseDateTimeInJodaSyntaxOrZero('2025-01-04 23:00:00', 'yyyy-MM-dd HH:mm:ss')
```
```response title=Response theme={null}
┌─parseDateTimeInJodaSyntaxOrZero('2025-01-04 23:00:00', 'yyyy-MM-dd HH:mm:ss')─┐
│ 2025-01-04 23:00:00 │
└────────────────────────────────────────────────────────────────────────────────┘
```
## parseDateTimeOrNull
Добавленный в: v23.3.0
То же, что и [`parseDateTime`](#parseDateTime), но возвращает `NULL`, если встречает неподдающийся разбору формат даты.
**Синтаксис**
```sql theme={null}
parseDateTimeOrNull(time_string, format[, timezone])
```
**Псевдонимы**: `str_to_date`
**Аргументы**
* `time_string` — Строка, преобразуемая в DateTime. [`String`](/ru/reference/data-types/string)
* `format` — Строка формата, задающая способ разбора time\_string. [`String`](/ru/reference/data-types/string)
* `timezone` — Необязательный параметр. Часовой пояс. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает DateTime, разобранный из входной строки, или NULL, если разбор не удался. [`Nullable(DateTime)`](/ru/reference/data-types/nullable)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT parseDateTimeOrNull('2025-01-04+23:00:00', '%Y-%m-%d+%H:%i:%s')
```
```response title=Response theme={null}
┌─parseDateTimeOrNull('2025-01-04+23:00:00', '%Y-%m-%d+%H:%i:%s')─┐
│ 2025-01-04 23:00:00 │
└─────────────────────────────────────────────────────────────────┘
```
## parseDateTimeOrZero
Добавленный в: v23.3.0
То же, что и [`parseDateTime`](#parseDateTime), но при неподдающемся разбору формате даты возвращает нулевую дату.
**Синтаксис**
```sql theme={null}
parseDateTimeOrZero(time_string, format[, timezone])
```
**Аргументы**
* `time_string` — Строка для разбора в DateTime. [`String`](/ru/reference/data-types/string)
* `format` — Строка формата, задающая способ разбора time\_string. [`String`](/ru/reference/data-types/string)
* `timezone` — Необязательно. Часовой пояс. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает DateTime, разобранный из входной строки, или нулевой DateTime, если разбор не удался. [`DateTime`](/ru/reference/data-types/datetime)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT parseDateTimeOrZero('2025-01-04+23:00:00', '%Y-%m-%d+%H:%i:%s')
```
```response title=Response theme={null}
┌─parseDateTimeOrZero('2025-01-04+23:00:00', '%Y-%m-%d+%H:%i:%s')─┐
│ 2025-01-04 23:00:00 │
└─────────────────────────────────────────────────────────────────┘
```
## reinterpret
Добавленный в: v1.1.0
Использует ту же последовательность байтов в памяти исходного значения для значения `x` и интерпретирует её как целевой тип.
**Синтаксис**
```sql theme={null}
reinterpret(x, type)
```
**Аргументы**
* `x` — Любой тип. [`Any`](/ru/reference/data-types)
* `type` — Целевой тип. Если это массив, тип его элементов должен иметь фиксированную длину. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Значение целевого типа. [`Any`](/ru/reference/data-types)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT reinterpret(toInt8(-1), 'UInt8') AS int_to_uint,
reinterpret(toInt8(1), 'Float32') AS int_to_float,
reinterpret('1', 'UInt32') AS string_to_int
```
```response title=Response theme={null}
┌─int_to_uint─┬─int_to_float─┬─string_to_int─┐
│ 255 │ 1e-45 │ 49 │
└─────────────┴──────────────┴───────────────┘
```
**Пример типа Array**
```sql title=Query theme={null}
SELECT reinterpret(x'3108b4403108d4403108b4403108d440', 'Array(Float32)') AS string_to_array_of_Float32
```
```response title=Response theme={null}
┌─string_to_array_of_Float32─┐
│ [5.626,6.626,5.626,6.626] │
└────────────────────────────┘
```
## reinterpretAsDate
Добавленный в: v1.1.0
Переинтерпретирует входное значение как значение типа Date (предполагая порядок little endian), то есть как количество дней с начала эпохи Unix — 1970-01-01
**Синтаксис**
```sql theme={null}
reinterpretAsDate(x)
```
**Аргументы**
* `x` — Количество дней с начала эпохи Unix. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float), или [`Date`](/ru/reference/data-types/date), или [`DateTime`](/ru/reference/data-types/datetime), или [`UUID`](/ru/reference/data-types/uuid), или [`String`](/ru/reference/data-types/string), или [`FixedString`](/ru/reference/data-types/fixedstring)
**Возвращаемое значение**
Дата. [`Date`](/ru/reference/data-types/date)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT reinterpretAsDate(65), reinterpretAsDate('A')
```
```response title=Response theme={null}
┌─reinterpretAsDate(65)─┬─reinterpretAsDate('A')─┐
│ 1970-03-07 │ 1970-03-07 │
└───────────────────────┴────────────────────────┘
```
## reinterpretAsDateTime
Добавленный в: v1.1.0
Переинтерпретирует входное значение как значение DateTime (предполагая порядок little endian), представляющее собой количество дней с начала эпохи Unix 1970-01-01
**Синтаксис**
```sql theme={null}
reinterpretAsDateTime(x)
```
**Аргументы**
* `x` — Число секунд с начала эпохи Unix. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`Date`](/ru/reference/data-types/date) или [`DateTime`](/ru/reference/data-types/datetime) или [`UUID`](/ru/reference/data-types/uuid) или [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring)
**Возвращаемое значение**
Дата и время. [`DateTime`](/ru/reference/data-types/datetime)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT reinterpretAsDateTime(65), reinterpretAsDateTime('A')
```
```response title=Response theme={null}
┌─reinterpretAsDateTime(65)─┬─reinterpretAsDateTime('A')─┐
│ 1970-01-01 01:01:05 │ 1970-01-01 01:01:05 │
└───────────────────────────┴────────────────────────────┘
```
## reinterpretAsFixedString
Добавленный в: v1.1.0
Переинтерпретирует входное значение как строку фиксированной длины (предполагается порядок little endian).
Null-байты в конце игнорируются; например, для значения UInt32 255 функция возвращает строку из одного символа.
**Синтаксис**
```sql theme={null}
reinterpretAsFixedString(x)
```
**Аргументы**
* `x` — значение, которое нужно переинтерпретировать в строку. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`Date`](/ru/reference/data-types/date) или [`DateTime`](/ru/reference/data-types/datetime)
**Возвращаемое значение**
Строка фиксированной длины, содержащая байты, представляющие `x`. [`FixedString`](/ru/reference/data-types/fixedstring)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
reinterpretAsFixedString(toDateTime('1970-01-01 01:01:05')),
reinterpretAsFixedString(toDate('1970-03-07'))
```
```response title=Response theme={null}
┌─reinterpretAsFixedString(toDateTime('1970-01-01 01:01:05'))─┬─reinterpretAsFixedString(toDate('1970-03-07'))─┐
│ A │ A │
└─────────────────────────────────────────────────────────────┴────────────────────────────────────────────────┘
```
## reinterpretAsFloat32
Добавленный в: v1.1.0
Переинтерпретирует входное значение как значение типа Float32.
В отличие от [`CAST`](#CAST), функция не пытается сохранить исходное значение — если целевой тип не может представить входной тип, результат не определен.
**Синтаксис**
```sql theme={null}
reinterpretAsFloat32(x)
```
**Аргументы**
* `x` — Значение, переинтерпретируемое как Float32. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`Date`](/ru/reference/data-types/date) или [`DateTime`](/ru/reference/data-types/datetime) или [`UUID`](/ru/reference/data-types/uuid) или [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring)
**Возвращаемое значение**
Возвращает переинтерпретированное значение `x`. [`Float32`](/ru/reference/data-types/float)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT reinterpretAsUInt32(toFloat32(0.2)) AS x, reinterpretAsFloat32(x)
```
```response title=Response theme={null}
┌──────────x─┬─reinterpretAsFloat32(x)─┐
│ 1045220557 │ 0.2 │
└────────────┴─────────────────────────┘
```
## reinterpretAsFloat64
Добавленный в: v1.1.0
Переинтерпретирует входное значение как значение типа Float64.
В отличие от [`CAST`](#CAST), функция не пытается сохранить исходное значение — если целевой тип не способен представить входной тип, результат не определён.
**Синтаксис**
```sql theme={null}
reinterpretAsFloat64(x)
```
**Аргументы**
* `x` — Значение, переинтерпретируемое как Float64. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`Date`](/ru/reference/data-types/date) или [`DateTime`](/ru/reference/data-types/datetime) или [`UUID`](/ru/reference/data-types/uuid) или [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring)
**Возвращаемое значение**
Возвращает переинтерпретированное значение `x`. [`Float64`](/ru/reference/data-types/float)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT reinterpretAsUInt64(toFloat64(0.2)) AS x, reinterpretAsFloat64(x)
```
```response title=Response theme={null}
┌───────────────────x─┬─reinterpretAsFloat64(x)─┐
│ 4596373779694328218 │ 0.2 │
└─────────────────────┴─────────────────────────┘
```
## reinterpretAsInt128
Добавленный в: v1.1.0
Переинтерпретирует входное значение как значение типа Int128.
В отличие от [`CAST`](#CAST), функция не пытается сохранить исходное значение — если целевой тип не может представить входной тип, результат не определён.
**Синтаксис**
```sql theme={null}
reinterpretAsInt128(x)
```
**Аргументы**
* `x` — Значение, переинтерпретируемое как Int128. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`Date`](/ru/reference/data-types/date) или [`DateTime`](/ru/reference/data-types/datetime) или [`UUID`](/ru/reference/data-types/uuid) или [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring)
**Возвращаемое значение**
Возвращает значение `x`, переинтерпретированное как [`Int128`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toInt64(257) AS x,
toTypeName(x),
reinterpretAsInt128(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌───x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 257 │ Int64 │ 257 │ Int128 │
└─────┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsInt16
Добавленный в: v1.1.0
Переинтерпретирует входное значение как значение типа Int16.
В отличие от [`CAST`](#CAST), эта функция не пытается сохранить исходное значение: если целевой тип не может представить входной тип, результат не определён.
**Синтаксис**
```sql theme={null}
reinterpretAsInt16(x)
```
**Аргументы**
* `x` — Значение, переинтерпретируемое как Int16. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`Date`](/ru/reference/data-types/date) или [`DateTime`](/ru/reference/data-types/datetime) или [`UUID`](/ru/reference/data-types/uuid) или [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring)
**Возвращаемое значение**
Возвращает переинтерпретированное значение `x`. [`Int16`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toInt8(257) AS x,
toTypeName(x),
reinterpretAsInt16(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌─x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 1 │ Int8 │ 1 │ Int16 │
└───┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsInt256
Добавленный в: v1.1.0
Переинтерпретирует входное значение как значение типа Int256.
В отличие от [`CAST`](#CAST), функция не пытается сохранить исходное значение — если целевой тип не может представить входной тип, результат не определён.
**Синтаксис**
```sql theme={null}
reinterpretAsInt256(x)
```
**Аргументы**
* `x` — Значение для переинтерпретации в Int256. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`Date`](/ru/reference/data-types/date) или [`DateTime`](/ru/reference/data-types/datetime) или [`UUID`](/ru/reference/data-types/uuid) или [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring)
**Возвращаемое значение**
Возвращает переинтерпретированное значение `x`. [`Int256`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toInt128(257) AS x,
toTypeName(x),
reinterpretAsInt256(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌───x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 257 │ Int128 │ 257 │ Int256 │
└─────┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsInt32
Добавленный в: v1.1.0
Переинтерпретирует входное значение как значение типа Int32.
В отличие от [`CAST`](#CAST), функция не пытается сохранить исходное значение — если целевой тип не может представить входной тип, результат не определён.
**Синтаксис**
```sql theme={null}
reinterpretAsInt32(x)
```
**Аргументы**
* `x` — Значение, которое нужно реинтерпретировать как Int32. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`Date`](/ru/reference/data-types/date) или [`DateTime`](/ru/reference/data-types/datetime) или [`UUID`](/ru/reference/data-types/uuid) или [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring)
**Возвращаемое значение**
Возвращает значение `x`, реинтерпретированное как [`Int32`](/ru/reference/data-types/int-uint).
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toInt16(257) AS x,
toTypeName(x),
reinterpretAsInt32(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌───x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 257 │ Int16 │ 257 │ Int32 │
└─────┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsInt64
Добавленный в: v1.1.0
Переинтерпретирует входное значение как значение типа Int64.
В отличие от [`CAST`](#CAST), функция не пытается сохранить исходное значение — если целевой тип не может представить входной тип, результат не определён.
**Синтаксис**
```sql theme={null}
reinterpretAsInt64(x)
```
**Аргументы**
* `x` — значение, которое нужно переинтерпретировать как Int64. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`Date`](/ru/reference/data-types/date) или [`DateTime`](/ru/reference/data-types/datetime) или [`UUID`](/ru/reference/data-types/uuid) или [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring)
**Возвращаемое значение**
Переинтерпретированное значение `x`. [`Int64`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toInt32(257) AS x,
toTypeName(x),
reinterpretAsInt64(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌───x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 257 │ Int32 │ 257 │ Int64 │
└─────┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsInt8
Добавленный в: v1.1.0
Переинтерпретирует входное значение как значение типа Int8.
В отличие от [`CAST`](#CAST), функция не пытается сохранить исходное значение — если целевой тип не может представить входной тип, результат не определен.
**Синтаксис**
```sql theme={null}
reinterpretAsInt8(x)
```
**Аргументы**
* `x` — значение для переинтерпретации как Int8. [`(U)Int*`](/ru/reference/data-types/int-uint) or [`Float*`](/ru/reference/data-types/float) or [`Date`](/ru/reference/data-types/date) or [`DateTime`](/ru/reference/data-types/datetime) or [`UUID`](/ru/reference/data-types/uuid) or [`String`](/ru/reference/data-types/string) or [`FixedString`](/ru/reference/data-types/fixedstring)
**Возвращаемое значение**
Возвращает переинтерпретированное значение `x`. [`Int8`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toUInt8(257) AS x,
toTypeName(x),
reinterpretAsInt8(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌─x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 1 │ UInt8 │ 1 │ Int8 │
└───┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsString
Добавленный в: v1.1.0
Переинтерпретирует входное значение как строку (в порядке little endian).
Null-байты в конце игнорируются; например, для значения UInt32 255 функция возвращает строку из одного символа.
**Синтаксис**
```sql theme={null}
reinterpretAsString(x)
```
**Аргументы**
* `x` — Значение, которое нужно переинтерпретировать в строку. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`Date`](/ru/reference/data-types/date) или [`DateTime`](/ru/reference/data-types/datetime)
**Возвращаемое значение**
Строка, содержащая байты, представляющие `x`. [`String`](/ru/reference/data-types/string)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
reinterpretAsString(toDateTime('1970-01-01 01:01:05')),
reinterpretAsString(toDate('1970-03-07'))
```
```response title=Response theme={null}
┌─reinterpretAsString(toDateTime('1970-01-01 01:01:05'))─┬─reinterpretAsString(toDate('1970-03-07'))─┐
│ A │ A │
└────────────────────────────────────────────────────────┴───────────────────────────────────────────┘
```
## reinterpretAsUInt128
Добавленный в: v1.1.0
Переинтерпретирует входное значение как значение типа UInt128.
В отличие от [`CAST`](#CAST), функция не пытается сохранить исходное значение — если целевой тип не может представить входной тип, результат не определён.
**Синтаксис**
```sql theme={null}
reinterpretAsUInt128(x)
```
**Аргументы**
* `x` — Значение, которое нужно переинтерпретировать как UInt128. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`Date`](/ru/reference/data-types/date) или [`DateTime`](/ru/reference/data-types/datetime) или [`UUID`](/ru/reference/data-types/uuid) или [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring)
**Возвращаемое значение**
Возвращает переинтерпретированное значение `x`. [`UInt128`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toUInt64(257) AS x,
toTypeName(x),
reinterpretAsUInt128(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌───x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 257 │ UInt64 │ 257 │ UInt128 │
└─────┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsUInt16
Добавленный в: v1.1.0
Переинтерпретирует входное значение как значение типа UInt16.
В отличие от [`CAST`](#CAST), функция не пытается сохранить исходное значение — если входной тип не может быть представлен целевым типом, результат не определён.
**Синтаксис**
```sql theme={null}
reinterpretAsUInt16(x)
```
**Аргументы**
* `x` — Значение, которое нужно переинтерпретировать как UInt16. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`Date`](/ru/reference/data-types/date) или [`DateTime`](/ru/reference/data-types/datetime) или [`UUID`](/ru/reference/data-types/uuid) или [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring)
**Возвращаемое значение**
Возвращает переинтерпретированное значение `x`. [`UInt16`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toUInt8(257) AS x,
toTypeName(x),
reinterpretAsUInt16(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌─x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 1 │ UInt8 │ 1 │ UInt16 │
└───┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsUInt256
Добавленный в: v1.1.0
Переинтерпретирует входное значение как значение типа UInt256.
В отличие от [`CAST`](#CAST), функция не пытается сохранить исходное значение — если целевой тип не может представить входной тип, результат не определён.
**Синтаксис**
```sql theme={null}
reinterpretAsUInt256(x)
```
**Аргументы**
* `x` — значение, которое нужно переинтерпретировать как UInt256. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`Date`](/ru/reference/data-types/date) или [`DateTime`](/ru/reference/data-types/datetime) или [`UUID`](/ru/reference/data-types/uuid) или [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring)
**Возвращаемое значение**
Возвращает переинтерпретированное значение `x`. [`UInt256`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toUInt128(257) AS x,
toTypeName(x),
reinterpretAsUInt256(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌───x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 257 │ UInt128 │ 257 │ UInt256 │
└─────┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsUInt32
Добавленный в: v1.1.0
Переинтерпретирует входное значение как значение типа UInt32.
В отличие от [`CAST`](#CAST), функция не пытается сохранить исходное значение — если целевой тип не может представить входной тип, результат не определён.
**Синтаксис**
```sql theme={null}
reinterpretAsUInt32(x)
```
**Аргументы**
* `x` — Значение, которое нужно реинтерпретировать как UInt32. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`Date`](/ru/reference/data-types/date) или [`DateTime`](/ru/reference/data-types/datetime) или [`UUID`](/ru/reference/data-types/uuid) или [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring)
**Возвращаемое значение**
Возвращает значение `x`, реинтерпретированное как [`UInt32`](/ru/reference/data-types/int-uint).
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toUInt16(257) AS x,
toTypeName(x),
reinterpretAsUInt32(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌───x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 257 │ UInt16 │ 257 │ UInt32 │
└─────┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsUInt64
Добавленный в: v1.1.0
Переинтерпретирует входное значение как значение типа UInt64.
В отличие от [`CAST`](#CAST), функция не пытается сохранить исходное значение — если целевой тип не может представить входной тип, результат не определён.
**Синтаксис**
```sql theme={null}
reinterpretAsUInt64(x)
```
**Аргументы**
* `x` — Значение, которое нужно переинтерпретировать как UInt64. [`Int*`](/ru/reference/data-types/int-uint) или [`UInt*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`Date`](/ru/reference/data-types/date) или [`DateTime`](/ru/reference/data-types/datetime) или [`UUID`](/ru/reference/data-types/uuid) или [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring)
**Возвращаемое значение**
Переинтерпретированное значение `x`. [`UInt64`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toUInt32(257) AS x,
toTypeName(x),
reinterpretAsUInt64(x) AS res,
toTypeName(res)
```
```response title=Response theme={null}
┌───x─┬─toTypeName(x)─┬─res─┬─toTypeName(res)─┐
│ 257 │ UInt32 │ 257 │ UInt64 │
└─────┴───────────────┴─────┴─────────────────┘
```
## reinterpretAsUInt8
Добавленный в: v1.1.0
Переинтерпретирует входное значение как значение типа UInt8.
В отличие от [`CAST`](#CAST), функция не пытается сохранить исходное значение — если целевой тип не может представить входной тип, результат не определён.
**Синтаксис**
```sql theme={null}
reinterpretAsUInt8(x)
```
**Аргументы**
* `x` — Значение, которое нужно переинтерпретировать как UInt8. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`Date`](/ru/reference/data-types/date) или [`DateTime`](/ru/reference/data-types/datetime) или [`UUID`](/ru/reference/data-types/uuid) или [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring)
**Возвращаемое значение**
Переинтерпретированное значение `x`. [`UInt8`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toInt8(-1) AS val,
toTypeName(val),
reinterpretAsUInt8(val) AS res,
toTypeName(res);
```
```response title=Response theme={null}
┌─val─┬─toTypeName(val)─┬─res─┬─toTypeName(res)─┐
│ -1 │ Int8 │ 255 │ UInt8 │
└─────┴─────────────────┴─────┴─────────────────┘
```
## reinterpretAsUUID
Добавленный в: v1.1.0
Принимает строку длиной 16 байт и возвращает UUID, интерпретируя каждую 8-байтную половину в порядке little-endian. Если строка короче, чем нужно, функция работает так, как будто в конец строки дописано необходимое количество null-байтов. Если строка длиннее 16 байт, лишние байты в конце игнорируются.
**Синтаксис**
```sql theme={null}
reinterpretAsUUID(fixed_string)
```
**Аргументы**
* `fixed_string` — Байтовая строка в формате big-endian. [`FixedString`](/ru/reference/data-types/fixedstring)
**Возвращаемое значение**
Значение типа UUID. [`UUID`](/ru/reference/data-types/uuid)
**Примеры**
**Преобразование строки в UUID**
```sql title=Query theme={null}
SELECT reinterpretAsUUID(reverse(unhex('000102030405060708090a0b0c0d0e0f')))
```
```response title=Response theme={null}
┌─reinterpretAsUUID(reverse(unhex('000102030405060708090a0b0c0d0e0f')))─┐
│ 08090a0b-0c0d-0e0f-0001-020304050607 │
└───────────────────────────────────────────────────────────────────────┘
```
## toBFloat16
Добавленный в: v1.1.0
Преобразует входное значение в значение типа BFloat16.
В случае ошибки генерирует исключение.
См. также:
* [`toBFloat16OrZero`](#toBFloat16OrZero).
* [`toBFloat16OrNull`](#toBFloat16OrNull).
**Синтаксис**
```sql theme={null}
toBFloat16(expr)
```
**Аргументы**
* `expr` — выражение, возвращающее число или строковое представление числа. [`Выражение`](/ru/reference/data-types/special-data-types/expression)
**Возвращаемое значение**
Возвращает 16-битное значение формата brain floating point. [`BFloat16`](/ru/reference/data-types/float)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toBFloat16(toFloat32(42.7)),
toBFloat16(toFloat32('42.7')),
toBFloat16('42.7')
FORMAT Vertical;
```
```response title=Response theme={null}
toBFloat16(toFloat32(42.7)): 42.5
toBFloat16(t⋯32('42.7')): 42.5
toBFloat16('42.7'): 42.5
```
## toBFloat16OrNull
Добавленный в: v1.1.0
Преобразует входное значение String в значение типа BFloat16.
Если строка не представляет значение с плавающей запятой, функция возвращает NULL.
Поддерживаемые аргументы:
* Строковые представления числовых значений.
Неподдерживаемые аргументы (возвращают `NULL`):
* Строковые представления двоичных и шестнадцатеричных значений.
* Числовые значения.
Функция допускает потерю точности без уведомления при преобразовании из строкового представления.
См. также:
* [`toBFloat16`](#toBFloat16).
* [`toBFloat16OrZero`](#toBFloat16OrZero).
**Синтаксис**
```sql theme={null}
toBFloat16OrNull(x)
```
**Аргументы**
* `x` — Строковое представление числа. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает 16-битное значение в формате brain floating point, иначе — `NULL`. [`BFloat16`](/ru/reference/data-types/float) или [`NULL`](/ru/reference/syntax#null)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT toBFloat16OrNull('0x5E'), -- неподдерживаемые аргументы
toBFloat16OrNull('12.3'), -- типичное использование
toBFloat16OrNull('12.3456789') -- незаметная потеря точности
```
```response title=Response theme={null}
\N
12.25
12.3125
```
## toBFloat16OrZero
Добавленный в: v1.1.0
Преобразует входное значение String в значение типа BFloat16.
Если строка не представляет собой число с плавающей точкой, функция возвращает ноль.
Поддерживаемые аргументы:
* Строковые представления числовых значений.
Неподдерживаемые аргументы (возвращают `0`):
* Строковые представления двоичных и шестнадцатеричных значений.
* Числовые значения.
Функция допускает скрытую потерю точности при преобразовании из строкового представления.
См. также:
* [`toBFloat16`](#toBFloat16).
* [`toBFloat16OrNull`](#toBFloat16OrNull).
**Синтаксис**
```sql theme={null}
toBFloat16OrZero(x)
```
**Аргументы**
* `x` — Строковое представление числа. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает 16-битное значение формата brain floating point, иначе — `0`. [`BFloat16`](/ru/reference/data-types/float)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT toBFloat16OrZero('0x5E'), -- неподдерживаемые аргументы
toBFloat16OrZero('12.3'), -- типичное использование
toBFloat16OrZero('12.3456789') -- незаметная потеря точности
```
```response title=Response theme={null}
0
12.25
12.3125
```
## toBool
Добавленный в: v22.2.0
Преобразует входное значение в значение типа Bool.
**Синтаксис**
```sql theme={null}
toBool(expr)
```
**Аргументы**
* `expr` — выражение, возвращающее число или строку. Для строк принимает значения 'true' или 'false' (регистронезависимо). [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`String`](/ru/reference/data-types/string) или [`Expression`](/ru/reference/data-types/special-data-types/expression)
**Возвращаемое значение**
Возвращает `true` или `false` в зависимости от результата вычисления аргумента. [`Bool`](/ru/reference/data-types/boolean)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toBool(toUInt8(1)),
toBool(toInt8(-1)),
toBool(toFloat32(1.01)),
toBool('true'),
toBool('false'),
toBool('FALSE')
FORMAT Vertical
```
```response title=Response theme={null}
toBool(toUInt8(1)): true
toBool(toInt8(-1)): true
toBool(toFloat32(1.01)): true
toBool('true'): true
toBool('false'): false
toBool('FALSE'): false
```
## toDate
Добавленный в: v1.1.0
Преобразует входное значение в тип [`Date`](/ru/reference/data-types/date).
Поддерживает преобразование из типов String, FixedString, DateTime и числовых типов.
**Синтаксис**
```sql theme={null}
toDate(x)
```
**Аргументы**
* `x` — Входное значение для преобразования. [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring) или [`DateTime`](/ru/reference/data-types/datetime) или [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)
**Возвращаемое значение**
Преобразованное входное значение. [`Date`](/ru/reference/data-types/date)
**Примеры**
**Преобразование `String` в `Date`**
```sql title=Query theme={null}
SELECT toDate('2025-04-15')
```
```response title=Response theme={null}
2025-04-15
```
**Преобразование DateTime в Date**
```sql title=Query theme={null}
SELECT toDate(toDateTime('2025-04-15 10:30:00'))
```
```response title=Response theme={null}
2025-04-15
```
**Преобразование целого числа в тип Date**
```sql title=Query theme={null}
SELECT toDate(20297)
```
```response title=Response theme={null}
2025-07-28
```
## toDate32
Добавленный в: v21.9.0
Преобразует аргумент в тип данных [Date32](/ru/reference/data-types/date32).
Если значение выходит за пределы диапазона, `toDate32` возвращает граничные значения, поддерживаемые [Date32](/ru/reference/data-types/date32).
Если аргумент имеет тип [`Date`](/ru/reference/data-types/date), учитываются его границы.
**Синтаксис**
```sql theme={null}
toDate32(expr)
```
**Аргументы**
* `expr` — значение для преобразования. [`String`](/ru/reference/data-types/string), [`UInt32`](/ru/reference/data-types/int-uint) или [`Date`](/ru/reference/data-types/date)
**Возвращаемое значение**
Возвращает календарную дату. [`Date32`](/ru/reference/data-types/date32)
**Примеры**
**В допустимом диапазоне**
```sql title=Query theme={null}
SELECT toDate32('2025-01-01') AS value, toTypeName(value)
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
value: 2025-01-01
toTypeName(value): Date32
```
**Вне допустимого диапазона**
```sql title=Query theme={null}
SELECT toDate32('1899-01-01') AS value, toTypeName(value)
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
value: 1900-01-01
toTypeName(value): Date32
```
## toDate32OrDefault
Добавленный в: v21.11.0
Преобразует аргумент в тип данных [Date32](/ru/reference/data-types/date32). Если значение выходит за пределы диапазона, `toDate32OrDefault` возвращает значение нижней границы, поддерживаемое типом [Date32](/ru/reference/data-types/date32). Если аргумент имеет тип [Date](/ru/reference/data-types/date), учитываются его границы. Возвращает значение по умолчанию, если получен некорректный аргумент.
**Синтаксис**
```sql theme={null}
toDate32OrDefault(expr[, default])
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`String`](/ru/reference/data-types/string) или [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)
* `default` — Необязательно. Значение по умолчанию, возвращаемое, если преобразование не удалось. [`Date32`](/ru/reference/data-types/date32)
**Возвращаемое значение**
Значение типа Date32 в случае успешного выполнения; в противном случае возвращается значение по умолчанию, если оно передано, или 1900-01-01, если нет. [`Date32`](/ru/reference/data-types/date32)
**Примеры**
**Успешное преобразование**
```sql title=Query theme={null}
SELECT toDate32OrDefault('1930-01-01', toDate32('2020-01-01'))
```
```response title=Response theme={null}
1930-01-01
```
**Преобразование не удалось**
```sql title=Query theme={null}
SELECT toDate32OrDefault('xx1930-01-01', toDate32('2020-01-01'))
```
```response title=Response theme={null}
2020-01-01
```
## toDate32OrNull
Добавленный в: v21.9.0
Преобразует входное значение в значение типа Date32, но возвращает `NULL`, если передан некорректный аргумент.
То же, что и [`toDate32`](#toDate32), но возвращает `NULL`, если передан некорректный аргумент.
**Синтаксис**
```sql theme={null}
toDate32OrNull(x)
```
**Аргументы**
* `x` — строковое представление даты. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение `Date32` в случае успеха, в противном случае — `NULL`. [`Date32`](/ru/reference/data-types/date32) или [`NULL`](/ru/reference/syntax#null)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT toDate32OrNull('2025-01-01'), toDate32OrNull('invalid')
```
```response title=Response theme={null}
┌─toDate32OrNull('2025-01-01')─┬─toDate32OrNull('invalid')─┐
│ 2025-01-01 │ ᴺᵁᴸᴸ │
└──────────────────────────────┴───────────────────────────┘
```
## toDate32OrZero
Добавленный в: v21.9.0
Преобразует входное значение в значение типа [Date32](/ru/reference/data-types/date32), но при получении некорректного аргумента возвращает нижнюю границу [Date32](/ru/reference/data-types/date32).
То же, что и [toDate32](#toDate32), но при получении некорректного аргумента возвращает нижнюю границу [Date32](/ru/reference/data-types/date32).
См. также:
* [`toDate32`](#toDate32)
* [`toDate32OrNull`](#toDate32OrNull)
* [`toDate32OrDefault`](#toDate32OrDefault)
**Синтаксис**
```sql theme={null}
toDate32OrZero(x)
```
**Аргументы**
* `x` — строковое представление даты. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение Date32 в случае успеха, в противном случае — нижнюю границу Date32 (`1900-01-01`). [`Date32`](/ru/reference/data-types/date32)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT toDate32OrZero('2025-01-01'), toDate32OrZero('')
```
```response title=Response theme={null}
┌─toDate32OrZero('2025-01-01')─┬─toDate32OrZero('')─┐
│ 2025-01-01 │ 1900-01-01 │
└──────────────────────────────┴────────────────────┘
```
## toDateOrDefault
Добавленный в: v21.11.0
Как и [toDate](#toDate), но в случае ошибки возвращает значение по умолчанию: либо второй аргумент (если он указан), либо, в противном случае, нижнюю границу [Date](/ru/reference/data-types/date).
**Синтаксис**
```sql theme={null}
toDateOrDefault(expr[, default])
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`String`](/ru/reference/data-types/string) или [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)
* `default` — Необязательно. Значение по умолчанию, которое возвращается, если разбор завершился неуспешно. [`Date`](/ru/reference/data-types/date)
**Возвращаемое значение**
Значение типа Date в случае успешного выполнения; в противном случае возвращается значение по умолчанию, если оно передано, или 1970-01-01, если нет. [`Date`](/ru/reference/data-types/date)
**Примеры**
**Успешное преобразование**
```sql title=Query theme={null}
SELECT toDateOrDefault('2022-12-30')
```
```response title=Response theme={null}
2022-12-30
```
**Ошибка преобразования**
```sql title=Query theme={null}
SELECT toDateOrDefault('', CAST('2023-01-01', 'Date'))
```
```response title=Response theme={null}
2023-01-01
```
## toDateOrNull
Добавленный в: v1.1.0
Преобразует входное значение в значение типа `Date`, но возвращает `NULL`, если получает некорректный аргумент.
То же, что и [`toDate`](#toDate), но возвращает `NULL`, если получает некорректный аргумент.
**Синтаксис**
```sql theme={null}
toDateOrNull(x)
```
**Аргументы**
* `x` — Строковое представление даты. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение типа Date в случае успеха, в противном случае — `NULL`. [`Date`](/ru/reference/data-types/date) или [`NULL`](/ru/reference/syntax#null)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT toDateOrNull('2025-12-30'), toDateOrNull('invalid')
```
```response title=Response theme={null}
┌─toDateOrNull('2025-12-30')─┬─toDateOrNull('invalid')─┐
│ 2025-12-30 │ ᴺᵁᴸᴸ │
└────────────────────────────┴────────────────────────┘
```
## toDateOrZero
Добавленный в: v1.1.0
Преобразует входное значение в значение типа [`Date`](/ru/reference/data-types/date), но возвращает нижнюю границу [`Date`](/ru/reference/data-types/date), если передан некорректный аргумент.
То же, что и [toDate](#toDate), но при передаче некорректного аргумента возвращает нижнюю границу [`Date`](/ru/reference/data-types/date).
См. также:
* [`toDate`](#toDate)
* [`toDateOrNull`](#toDateOrNull)
* [`toDateOrDefault`](#toDateOrDefault)
**Синтаксис**
```sql theme={null}
toDateOrZero(x)
```
**Аргументы**
* `x` — строковое представление даты. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение типа Date в случае успешного преобразования, в противном случае — нижнюю границу типа Date (`1970-01-01`). [`Date`](/ru/reference/data-types/date)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT toDateOrZero('2025-12-30'), toDateOrZero('')
```
```response title=Response theme={null}
┌─toDateOrZero('2025-12-30')─┬─toDateOrZero('')─┐
│ 2025-12-30 │ 1970-01-01 │
└────────────────────────────┴──────────────────┘
```
## toDateTime
Добавленный в: v1.1.0
Преобразует входное значение в тип [DateTime](/ru/reference/data-types/datetime).
Если `expr` — число, оно интерпретируется как количество секунд с начала эпохи Unix (то есть как Unix-временная метка).
Если `expr` — это [String](/ru/reference/data-types/string), оно может интерпретироваться как Unix-временная метка или как строковое представление даты / даты и времени.
Поэтому разбор строковых представлений коротких чисел (до 4 цифр) явно отключён из-за неоднозначности: например, строка `'1999'` может обозначать как год (неполное строковое представление Date / DateTime), так и Unix-временную метку. Более длинные числовые строки допускаются.
**Синтаксис**
```sql theme={null}
toDateTime(expr[, time_zone])
```
**Аргументы**
* `expr` — Значение. [`String`](/ru/reference/data-types/string) или [`Int`](/ru/reference/data-types/int-uint) или [`Date`](/ru/reference/data-types/date) или [`DateTime`](/ru/reference/data-types/datetime)
* `time_zone` — Часовой пояс. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение типа дата-время. [`DateTime`](/ru/reference/data-types/datetime)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT toDateTime('2025-01-01 00:00:00'), toDateTime(1735689600, 'UTC')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toDateTime('2025-01-01 00:00:00'): 2025-01-01 00:00:00
toDateTime(1735689600, 'UTC'): 2025-01-01 00:00:00
```
## toDateTime32
Добавленный в: v20.9.0
Преобразует входное значение в тип `DateTime`.
Поддерживает преобразование из `String`, `FixedString`, `Date`, `Date32`, `DateTime` и числовых типов (`(U)Int*`, `Float*`, `Decimal`).
`DateTime32` имеет расширенный диапазон по сравнению с `DateTime` и поддерживает даты от `1900-01-01` до `2299-12-31`.
**Синтаксис**
```sql theme={null}
toDateTime32(x[, timezone])
```
**Аргументы**
* `x` — Входное значение, которое нужно преобразовать. [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring) или [`UInt*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`Date`](/ru/reference/data-types/date) или [`DateTime`](/ru/reference/data-types/datetime) или [`DateTime64`](/ru/reference/data-types/datetime64)
* `timezone` — Необязательно. Часовой пояс для возвращаемого значения `DateTime`. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Преобразованное входное значение. [`DateTime`](/ru/reference/data-types/datetime)
**Примеры**
**Значение находится в допустимом диапазоне**
```sql title=Query theme={null}
SELECT toDateTime64('2025-01-01 00:00:00.000', 3) AS value, toTypeName(value);
```
```response title=Response theme={null}
┌───────────────────value─┬─toTypeName(toDateTime64('20255-01-01 00:00:00.000', 3))─┐
│ 2025-01-01 00:00:00.000 │ DateTime64(3) │
└─────────────────────────┴────────────────────────────────────────────────────────┘
```
**В виде десятичного числа с точностью**
```sql title=Query theme={null}
SELECT toDateTime64(1735689600.000, 3) AS value, toTypeName(value);
-- без десятичной точки значение всё равно интерпретируется как Unix-временная метка в секундах
SELECT toDateTime64(1546300800000, 3) AS value, toTypeName(value);
```
```response title=Response theme={null}
┌───────────────────value─┬─toTypeName(toDateTime64(1735689600.000, 3))─┐
│ 2025-01-01 00:00:00.000 │ DateTime64(3) │
└─────────────────────────┴──────────────────────────────────────────┘
┌───────────────────value─┬─toTypeName(toDateTime64(1546300800000, 3))─┐
│ 2282-12-31 00:00:00.000 │ DateTime64(3) │
└─────────────────────────┴────────────────────────────────────────────┘
```
**С часовым поясом**
```sql title=Query theme={null}
SELECT toDateTime64('2025-01-01 00:00:00', 3, 'Asia/Istanbul') AS value, toTypeName(value);
```
```response title=Response theme={null}
┌───────────────────value─┬─toTypeName(toDateTime64('2025-01-01 00:00:00', 3, 'Asia/Istanbul'))─┐
│ 2025-01-01 00:00:00.000 │ DateTime64(3, 'Asia/Istanbul') │
└─────────────────────────┴─────────────────────────────────────────────────────────────────────┘
```
## toDateTime64
Добавленный в: v20.1.0
Преобразует входное значение в тип [`DateTime64`](/ru/reference/data-types/datetime64).
**Синтаксис**
```sql theme={null}
toDateTime64(expr, scale[, timezone])
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`Выражение`](/ru/reference/data-types/special-data-types/expression)
* `scale` — Размер тика (precision): 10^(-scale) секунд. [`UInt8`](/ru/reference/data-types/int-uint)
* `timezone` — Необязательно. Часовой пояс для указанного объекта `DateTime64`. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает календарную дату и время суток с точностью до долей секунды. [`DateTime64`](/ru/reference/data-types/datetime64)
**Примеры**
**Значение находится в диапазоне**
```sql title=Query theme={null}
SELECT toDateTime64('2025-01-01 00:00:00.000', 3) AS value, toTypeName(value);
```
```response title=Response theme={null}
┌───────────────────value─┬─toTypeName(toDateTime64('2025-01-01 00:00:00.000', 3))─┐
│ 2025-01-01 00:00:00.000 │ DateTime64(3) │
└─────────────────────────┴────────────────────────────────────────────────────────┘
```
**В формате десятичного числа с точностью**
```sql title=Query theme={null}
SELECT toDateTime64(1546300800.000, 3) AS value, toTypeName(value);
-- Без десятичной точки значение по-прежнему интерпретируется как Unix-временная метка в секундах
SELECT toDateTime64(1546300800000, 3) AS value, toTypeName(value);
```
```response title=Response theme={null}
┌───────────────────value─┬─toTypeName(toDateTime64(1546300800000, 3))─┐
│ 2282-12-31 00:00:00.000 │ DateTime64(3) │
└─────────────────────────┴────────────────────────────────────────────┘
```
**С указанием часового пояса**
```sql title=Query theme={null}
SELECT toDateTime64('2025-01-01 00:00:00', 3, 'Asia/Istanbul') AS value, toTypeName(value);
```
```response title=Response theme={null}
┌───────────────────value─┬─toTypeName(toDateTime64('2025-01-01 00:00:00', 3, 'Asia/Istanbul'))─┐
│ 2025-01-01 00:00:00.000 │ DateTime64(3, 'Asia/Istanbul') │
└─────────────────────────┴─────────────────────────────────────────────────────────────────────┘
```
## toDateTime64OrDefault
Добавленный в: v21.11.0
Как и [toDateTime64](#toDateTime64), эта функция преобразует входное значение в значение типа [DateTime64](/ru/reference/data-types/datetime64),
но при получении некорректного аргумента возвращает либо значение [DateTime64](/ru/reference/data-types/datetime64) по умолчанию,
либо указанное значение по умолчанию.
**Синтаксис**
```sql theme={null}
toDateTime64OrDefault(expr, scale[, timezone, default])
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`String`](/ru/reference/data-types/string) или [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)
* `scale` — Размер тика (precision): 10^-precision секунд. [`UInt8`](/ru/reference/data-types/int-uint)
* `timezone` — Необязательно. Часовой пояс. [`String`](/ru/reference/data-types/string)
* `default` — Необязательно. Значение по умолчанию, которое возвращается, если разбор завершился неудачно. [`DateTime64`](/ru/reference/data-types/datetime64)
**Возвращаемое значение**
Значение типа DateTime64 в случае успешного выполнения; в противном случае возвращается значение по умолчанию, если оно передано, или 1970-01-01 00:00:00.000, если нет. [`DateTime64`](/ru/reference/data-types/datetime64)
**Примеры**
**Успешное преобразование**
```sql title=Query theme={null}
SELECT toDateTime64OrDefault('1976-10-18 00:00:00.30', 3)
```
```response title=Response theme={null}
1976-10-18 00:00:00.300
```
**Ошибка преобразования**
```sql title=Query theme={null}
SELECT toDateTime64OrDefault('1976-10-18 00:00:00 30', 3, 'UTC', toDateTime64('2001-01-01 00:00:00.00',3))
```
```response title=Response theme={null}
2000-12-31 23:00:00.000
```
## toDateTime64OrNull
Добавленный в: v20.1.0
Преобразует входное значение в значение типа `DateTime64`, но возвращает `NULL`, если передан некорректный аргумент.
То же, что и `toDateTime64`, но возвращает `NULL`, если передан некорректный аргумент.
**Синтаксис**
```sql theme={null}
toDateTime64OrNull(x)
```
**Аргументы**
* `x` — строковое представление даты и времени с субсекундной точностью. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение DateTime64 в случае успеха, иначе — `NULL`. [`DateTime64`](/ru/reference/data-types/datetime64) или [`NULL`](/ru/reference/syntax#null)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT toDateTime64OrNull('2025-12-30 13:44:17.123'), toDateTime64OrNull('invalid')
```
```response title=Response theme={null}
┌─toDateTime64OrNull('2025-12-30 13:44:17.123')─┬─toDateTime64OrNull('invalid')─┐
│ 2025-12-30 13:44:17.123 │ ᴺᵁᴸᴸ │
└─────────────────────────────────────────────────┴───────────────────────────────┘
```
## toDateTime64OrZero
Добавленный в: v20.1.0
Преобразует входное значение в значение типа [DateTime64](/ru/reference/data-types/datetime64), но при получении некорректного аргумента возвращает нижнюю границу [DateTime64](/ru/reference/data-types/datetime64).
То же, что и [toDateTime64](#toDateTime64), но при получении некорректного аргумента возвращает нижнюю границу [DateTime64](/ru/reference/data-types/datetime64).
См. также:
* [toDateTime64](#toDateTime64).
* [toDateTime64OrNull](#toDateTime64OrNull).
* [toDateTime64OrDefault](#toDateTime64OrDefault).
**Синтаксис**
```sql theme={null}
toDateTime64OrZero(x)
```
**Аргументы**
* `x` — Строковое представление даты и времени с субсекундной точностью. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Если преобразование успешно, возвращает значение DateTime64, в противном случае — нижнюю границу типа DateTime64 (`1970-01-01 00:00:00.000`). [`DateTime64`](/ru/reference/data-types/datetime64)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT toDateTime64OrZero('2025-12-30 13:44:17.123'), toDateTime64OrZero('invalid')
```
```response title=Response theme={null}
┌─toDateTime64OrZero('2025-12-30 13:44:17.123')─┬─toDateTime64OrZero('invalid')─┐
│ 2025-12-30 13:44:17.123 │ 1970-01-01 00:00:00.000 │
└─────────────────────────────────────────────────┴─────────────────────────────────────┘
```
## toDateTimeOrDefault
Добавленный в: v21.11.0
Аналогично [toDateTime](#toDateTime), но в случае ошибки возвращает значение по умолчанию: либо третий аргумент (если он указан), либо нижнюю границу [DateTime](/ru/reference/data-types/datetime).
**Синтаксис**
```sql theme={null}
toDateTimeOrDefault(expr[, timezone, default])
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`String`](/ru/reference/data-types/string) или [`(U)Int*`](/ru/reference/data-types/int-uint), или [`Float*`](/ru/reference/data-types/float)
* `timezone` — Необязательно. Часовой пояс. [`String`](/ru/reference/data-types/string)
* `default` — Необязательно. Значение по умолчанию, которое возвращается, если разбор завершился неуспешно. [`DateTime`](/ru/reference/data-types/datetime)
**Возвращаемое значение**
Значение типа DateTime в случае успешного выполнения; в противном случае возвращается значение по умолчанию, если оно передано, или 1970-01-01 00:00:00, если нет. [`DateTime`](/ru/reference/data-types/datetime)
**Примеры**
**Успешное преобразование**
```sql title=Query theme={null}
SELECT toDateTimeOrDefault('2022-12-30 13:44:17')
```
```response title=Response theme={null}
2022-12-30 13:44:17
```
**Ошибка преобразования**
```sql title=Query theme={null}
SELECT toDateTimeOrDefault('', 'UTC', CAST('2023-01-01', 'DateTime(\'UTC\')'))
```
```response title=Response theme={null}
2023-01-01 00:00:00
```
## toDateTimeOrNull
Добавленный в: v1.1.0
Преобразует входное значение в значение типа `DateTime`, но возвращает `NULL`, если получает некорректный аргумент.
То же, что и [`toDateTime`](#toDateTime), но возвращает `NULL`, если получает некорректный аргумент.
**Синтаксис**
```sql theme={null}
toDateTimeOrNull(x)
```
**Аргументы**
* `x` — Строковое представление даты и времени. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение `DateTime` в случае успеха, в противном случае — `NULL`. [`DateTime`](/ru/reference/data-types/datetime) или [`NULL`](/ru/reference/syntax#null)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT toDateTimeOrNull('2025-12-30 13:44:17'), toDateTimeOrNull('invalid')
```
```response title=Response theme={null}
┌─toDateTimeOrNull('2025-12-30 13:44:17')─┬─toDateTimeOrNull('invalid')─┐
│ 2025-12-30 13:44:17 │ ᴺᵁᴸᴸ │
└─────────────────────────────────────────┴─────────────────────────────┘
```
## toDateTimeOrZero
Добавленный в: v1.1.0
Преобразует входное значение в значение типа [DateTime](/ru/reference/data-types/datetime), но при получении некорректного аргумента возвращает нижнюю границу [DateTime](/ru/reference/data-types/datetime).
То же, что и [toDateTime](#toDateTime), но при получении некорректного аргумента возвращает нижнюю границу [DateTime](/ru/reference/data-types/datetime).
**Синтаксис**
```sql theme={null}
toDateTimeOrZero(x)
```
**Аргументы**
* `x` — Строковое представление даты и времени. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение DateTime в случае успешного выполнения, в противном случае — нижнюю границу DateTime (`1970-01-01 00:00:00`). [`DateTime`](/ru/reference/data-types/datetime)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT toDateTimeOrZero('2025-12-30 13:44:17'), toDateTimeOrZero('invalid')
```
```response title=Response theme={null}
┌─toDateTimeOrZero('2025-12-30 13:44:17')─┬─toDateTimeOrZero('invalid')─┐
│ 2025-12-30 13:44:17 │ 1970-01-01 00:00:00 │
└─────────────────────────────────────────┴─────────────────────────────┘
```
## toDecimal128
Добавленный в: v18.12.0
Преобразует входное значение в значение типа [`Decimal(38, S)`](/ru/reference/data-types/decimal) с масштабом `S`.
Генерирует исключение в случае ошибки.
Поддерживаемые аргументы:
* Значения или строковые представления типа (U)Int\*.
* Значения или строковые представления типа Float\*.
Неподдерживаемые аргументы:
* Значения Float\* `NaN` и `Inf` или их строковые представления (регистронезависимо).
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toDecimal128('0xc0fe', 1);`.
Переполнение может возникнуть, если значение `expr` выходит за пределы `Decimal128`: `(-1*10^(38 - S), 1*10^(38 - S))`.
Лишние цифры в дробной части отбрасываются (без округления).
Лишние цифры в целой части приведут к исключению.
При преобразовании лишние цифры отбрасываются, и при работе со значениями Float32/Float64 результат может быть неожиданным, поскольку операции выполняются с использованием инструкций с плавающей запятой.
Например: `toDecimal128(1.15, 2)` равно `1.14`, потому что 1.15 \* 100 в арифметике с плавающей запятой дает 114.99.
Можно использовать строковый аргумент, чтобы операции выполнялись с базовым целочисленным типом: `toDecimal128('1.15', 2) = 1.15`
**Синтаксис**
```sql theme={null}
toDecimal128(expr, S)
```
**Аргументы**
* `expr` — выражение, возвращающее число или строковое представление числа. [`Expression`](/ru/reference/data-types/special-data-types/expression)
* `S` — параметр scale в диапазоне от 0 до 38, задающий, сколько цифр может быть в дробной части числа. [`UInt8`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
Возвращает значение типа `Decimal(38, S)` [`Decimal128(S)`](/ru/reference/data-types/decimal)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toDecimal128(99, 1) AS a, toTypeName(a) AS type_a,
toDecimal128(99.67, 2) AS b, toTypeName(b) AS type_b,
toDecimal128('99.67', 3) AS c, toTypeName(c) AS type_c
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
a: 99
type_a: Decimal(38, 1)
b: 99.67
type_b: Decimal(38, 2)
c: 99.67
type_c: Decimal(38, 3)
```
## toDecimal128OrDefault
Добавленный в: v21.11.0
Подобно [`toDecimal128`](#toDecimal128), эта функция преобразует входное значение в значение типа [Decimal(38, S)](/ru/reference/data-types/decimal), но в случае ошибки возвращает значение по умолчанию.
**Синтаксис**
```sql theme={null}
toDecimal128OrDefault(expr, S[, default])
```
**Аргументы**
* `expr` — Строковое представление числа. [`String`](/ru/reference/data-types/string)
* `S` — Параметр scale в диапазоне от 0 до 38, который указывает, сколько цифр может содержать дробная часть числа. [`UInt8`](/ru/reference/data-types/int-uint)
* `default` — Необязательно. Значение по умолчанию, возвращаемое, если преобразование в тип Decimal128(S) завершается неуспешно. [`Decimal128(S)`](/ru/reference/data-types/decimal)
**Возвращаемое значение**
Значение типа Decimal(38, S) в случае успешного преобразования; в противном случае возвращается переданное значение по умолчанию или 0, если оно не задано. [`Decimal128(S)`](/ru/reference/data-types/decimal)
**Примеры**
**Успешное преобразование**
```sql title=Query theme={null}
SELECT toDecimal128OrDefault(toString(1/42), 18)
```
```response title=Response theme={null}
0.023809523809523808
```
**Ошибка преобразования**
```sql title=Query theme={null}
SELECT toDecimal128OrDefault('Inf', 0, CAST('-1', 'Decimal128(0)'))
```
```response title=Response theme={null}
-1
```
## toDecimal128OrNull
Добавленный в: v20.1.0
Преобразует входное значение в значение типа [`Decimal(38, S)`](/ru/reference/data-types/decimal), но в случае ошибки возвращает `NULL`.
Аналогично [`toDecimal128`](#toDecimal128), но при ошибках преобразования возвращает `NULL` вместо того, чтобы генерировать исключение.
Поддерживаемые аргументы:
* Значения или строковые представления типа (U)Int\*.
* Значения или строковые представления типа Float\*.
Неподдерживаемые аргументы (возвращают `NULL`):
* Значения или строковые представления значений Float\* `NaN` и `Inf` (регистронезависимо).
* Строковые представления двоичных и шестнадцатеричных значений.
* Значения, выходящие за пределы `Decimal128`: `(-1*10^(38 - S), 1*10^(38 - S))`.
См. также:
* [`toDecimal128`](#toDecimal128).
* [`toDecimal128OrZero`](#toDecimal128OrZero).
* [`toDecimal128OrDefault`](#toDecimal128OrDefault).
**Синтаксис**
```sql theme={null}
toDecimal128OrNull(expr, S)
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`Expression`](/ru/reference/data-types/special-data-types/expression)
* `S` — Параметр scale в диапазоне от 0 до 38, задающий, сколько цифр может содержать дробная часть числа. [`UInt8`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
Возвращает значение типа Decimal(38, S) в случае успеха, иначе — `NULL`. [`Decimal128(S)`](/ru/reference/data-types/decimal) или [`NULL`](/ru/reference/syntax#null)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT toDecimal128OrNull('42.7', 2), toDecimal128OrNull('invalid', 2)
```
```response title=Response theme={null}
┌─toDecimal128OrNull('42.7', 2)─┬─toDecimal128OrNull('invalid', 2)─┐
│ 42.70 │ ᴺᵁᴸᴸ │
└───────────────────────────────┴──────────────────────────────────┘
```
## toDecimal128OrZero
Добавленный в: v20.1.0
Преобразует входное значение в значение типа [Decimal(38, S)](/ru/reference/data-types/decimal), но в случае ошибки возвращает `0`.
Аналогично [`toDecimal128`](#toDecimal128), но при ошибках преобразования возвращает `0` вместо того, чтобы генерировать исключение.
Поддерживаемые аргументы:
* Значения или строковые представления типа (U)Int\*.
* Значения или строковые представления типа Float\*.
Неподдерживаемые аргументы (возвращается `0`):
* Значения Float\* `NaN` и `Inf` или их строковые представления (регистронезависимо).
* Строковые представления двоичных и шестнадцатеричных значений.
Если входное значение выходит за пределы `Decimal128`:`(-1*10^(38 - S), 1*10^(38 - S))`, функция возвращает `0`.
**Синтаксис**
```sql theme={null}
toDecimal128OrZero(expr, S)
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`Expression`](/ru/reference/data-types/special-data-types/expression)
* `S` — параметр scale в диапазоне от 0 до 38, который задаёт, сколько цифр может быть в дробной части числа. [`UInt8`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
При успешном выполнении возвращает значение Decimal(38, S), в противном случае — `0`. [`Decimal128(S)`](/ru/reference/data-types/decimal)
**Примеры**
**Базовое использование**
```sql title=Query theme={null}
SELECT toDecimal128OrZero('42.7', 2), toDecimal128OrZero('invalid', 2)
```
```response title=Response theme={null}
┌─toDecimal128OrZero('42.7', 2)─┬─toDecimal128OrZero('invalid', 2)─┐
│ 42.70 │ 0.00 │
└───────────────────────────────┴──────────────────────────────────┘
```
## toDecimal256
Добавленный в: v20.8.0
Преобразует входное значение в значение типа [`Decimal(76, S)`](/ru/reference/data-types/decimal) с масштабом `S`. В случае ошибки генерирует исключение.
Поддерживаемые аргументы:
* Значения или строковые представления типа (U)Int\*.
* Значения или строковые представления типа Float\*.
Неподдерживаемые аргументы:
* Значения или строковые представления значений Float\* `NaN` и `Inf` (регистронезависимо).
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toDecimal256('0xc0fe', 1);`.
Переполнение может возникнуть, если значение `expr` выходит за пределы диапазона `Decimal256`: `(-1*10^(76 - S), 1*10^(76 - S))`.
Лишние цифры в дробной части отбрасываются (без округления).
Лишние цифры в целой части приводят к исключению.
При преобразовании лишние цифры отбрасываются, и при работе со входными значениями Float32/Float64 результат может оказаться неожиданным, поскольку операции выполняются с использованием инструкций с плавающей точкой.
Например: `toDecimal256(1.15, 2)` равно `1.14`, потому что 1.15 \* 100 в арифметике с плавающей точкой равно 114.99.
Можно использовать входное значение типа String, чтобы операции выполнялись с использованием базового целочисленного типа: `toDecimal256('1.15', 2) = 1.15`
**Синтаксис**
```sql theme={null}
toDecimal256(expr, S)
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`Expression`](/ru/reference/data-types/special-data-types/expression)
* `S` — параметр scale от 0 до 76, задающий, сколько знаков может быть в дробной части числа. [`UInt8`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
Возвращает значение типа `Decimal(76, S)`. [`Decimal256(S)`](/ru/reference/data-types/decimal)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toDecimal256(99, 1) AS a, toTypeName(a) AS type_a,
toDecimal256(99.67, 2) AS b, toTypeName(b) AS type_b,
toDecimal256('99.67', 3) AS c, toTypeName(c) AS type_c
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
a: 99
type_a: Decimal(76, 1)
b: 99.67
type_b: Decimal(76, 2)
c: 99.67
type_c: Decimal(76, 3)
```
## toDecimal256OrDefault
Добавленный в: v21.11.0
Как и [`toDecimal256`](#toDecimal256), эта функция преобразует входное значение в тип [Decimal(76, S)](/ru/reference/data-types/decimal), но в случае ошибки возвращает значение по умолчанию.
**Синтаксис**
```sql theme={null}
toDecimal256OrDefault(expr, S[, default])
```
**Аргументы**
* `expr` — Строковое представление числа. [`String`](/ru/reference/data-types/string)
* `S` — Параметр scale в диапазоне от 0 до 76, задающий, сколько цифр может быть в дробной части числа. [`UInt8`](/ru/reference/data-types/int-uint)
* `default` — Необязательно. Значение по умолчанию, которое возвращается, если разбор в тип Decimal256(S) завершается неуспешно. [`Decimal256(S)`](/ru/reference/data-types/decimal)
**Возвращаемое значение**
Значение типа Decimal(76, S) в случае успешного выполнения; в противном случае возвращается значение по умолчанию, если оно передано, или 0, если нет. [`Decimal256(S)`](/ru/reference/data-types/decimal)
**Примеры**
**Успешное преобразование**
```sql title=Query theme={null}
SELECT toDecimal256OrDefault(toString(1/42), 76)
```
```response title=Response theme={null}
0.023809523809523808
```
**Ошибка преобразования**
```sql title=Query theme={null}
SELECT toDecimal256OrDefault('Inf', 0, CAST('-1', 'Decimal256(0)'))
```
```response title=Response theme={null}
-1
```
## toDecimal256OrNull
Добавленный в: v20.8.0
Преобразует входное значение в значение типа [`Decimal(76, S)`](/ru/reference/data-types/decimal), но в случае ошибки возвращает `NULL`.
Аналогично [`toDecimal256`](#toDecimal256), но при ошибках преобразования возвращает `NULL` вместо того, чтобы генерировать исключение.
Поддерживаемые аргументы:
* Значения или строковые представления типа (U)Int\*.
* Значения или строковые представления типа Float\*.
Неподдерживаемые аргументы (возвращается `NULL`):
* Значения Float\* `NaN` и `Inf`, а также их строковые представления (регистронезависимо).
* Строковые представления двоичных и шестнадцатеричных значений.
* Значения, выходящие за пределы `Decimal256`: `(-1 * 10^(76 - S), 1 * 10^(76 - S))`.
См. также:
* [`toDecimal256`](#toDecimal256).
* [`toDecimal256OrZero`](#toDecimal256OrZero).
* [`toDecimal256OrDefault`](#toDecimal256OrDefault).
**Синтаксис**
```sql theme={null}
toDecimal256OrNull(expr, S)
```
**Аргументы**
* `expr` — выражение, возвращающее число или строковое представление числа. [`Выражение`](/ru/reference/data-types/special-data-types/expression)
* `S` — параметр scale в диапазоне от 0 до 76, задающий, сколько цифр может быть в дробной части числа. [`UInt8`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
В случае успеха возвращает значение Decimal(76, S), в противном случае — `NULL`. [`Decimal256(S)`](/ru/reference/data-types/decimal) или [`NULL`](/ru/reference/syntax#null)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT toDecimal256OrNull('42.7', 2), toDecimal256OrNull('invalid', 2)
```
```response title=Response theme={null}
┌─toDecimal256OrNull('42.7', 2)─┬─toDecimal256OrNull('invalid', 2)─┐
│ 42.70 │ ᴺᵁᴸᴸ │
└───────────────────────────────┴──────────────────────────────────┘
```
## toDecimal256OrZero
Добавленный в: v20.8.0
Преобразует входное значение в значение типа [Decimal(76, S)](/ru/reference/data-types/decimal), но в случае ошибки возвращает `0`.
Аналогична [`toDecimal256`](#toDecimal256), но при ошибках преобразования возвращает `0` вместо того, чтобы генерировать исключение.
Поддерживаемые аргументы:
* Значения или строковые представления типа (U)Int\*.
* Значения или строковые представления типа Float\*.
Неподдерживаемые аргументы (возвращается `0`):
* Значения или строковые представления значений Float\* `NaN` и `Inf` (регистронезависимо).
* Строковые представления двоичных и шестнадцатеричных значений.
Если входное значение выходит за пределы `Decimal256`: `(-1*10^(76 - S), 1*10^(76 - S))`, функция возвращает `0`.
См. также:
* [`toDecimal256`](#toDecimal256).
* [`toDecimal256OrNull`](#toDecimal256OrNull).
* [`toDecimal256OrDefault`](#toDecimal256OrDefault).
**Синтаксис**
```sql theme={null}
toDecimal256OrZero(expr, S)
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`Expression`](/ru/reference/data-types/special-data-types/expression)
* `S` — Параметр scale в диапазоне от 0 до 76, задающий количество цифр в дробной части числа. [`UInt8`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
Возвращает значение Decimal(76, S) в случае успеха, иначе `0`. [`Decimal256(S)`](/ru/reference/data-types/decimal)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT toDecimal256OrZero('42.7', 2), toDecimal256OrZero('invalid', 2)
```
```response title=Response theme={null}
┌─toDecimal256OrZero('42.7', 2)─┬─toDecimal256OrZero('invalid', 2)─┐
│ 42.70 │ 0.00 │
└───────────────────────────────┴──────────────────────────────────┘
```
## toDecimal32
Добавленный в: v18.12.0
Преобразует входное значение в значение типа [`Decimal(9, S)`](/ru/reference/data-types/decimal) с масштабом `S`. В случае ошибки генерирует исключение.
Поддерживаемые аргументы:
* Значения или строковые представления типа (U)Int\*.
* Значения или строковые представления типа Float\*.
Неподдерживаемые аргументы:
* Значения или строковые представления значений Float\* `NaN` и `Inf` (регистронезависимо).
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toDecimal32('0xc0fe', 1);`.
Переполнение может произойти, если значение `expr` выходит за пределы `Decimal32`: `(-1*10^(9 - S), 1*10^(9 - S))`.
Лишние цифры в дробной части отбрасываются (без округления).
Лишние цифры в целой части приводят к исключению.
При преобразовании лишние цифры отбрасываются, и при работе со входными значениями Float32/Float64 результат может оказаться неожиданным, поскольку операции выполняются с использованием инструкций для чисел с плавающей точкой.
Например: `toDecimal32(1.15, 2)` равно `1.14`, потому что в арифметике с плавающей точкой 1.15 \* 100 равно 114.99.
Можно использовать входное значение типа String, чтобы операции выполнялись с использованием базового целочисленного типа: `toDecimal32('1.15', 2) = 1.15`
**Синтаксис**
```sql theme={null}
toDecimal32(expr, S)
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`Выражение`](/ru/reference/data-types/special-data-types/expression)
* `S` — Параметр scale в диапазоне от 0 до 9, указывающий, сколько цифр может быть в дробной части числа. [`UInt8`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
Возвращает значение типа `Decimal(9, S)` [`Decimal32(S)`](/ru/reference/data-types/decimal)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toDecimal32(2, 1) AS a, toTypeName(a) AS type_a,
toDecimal32(4.2, 2) AS b, toTypeName(b) AS type_b,
toDecimal32('4.2', 3) AS c, toTypeName(c) AS type_c
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
a: 2
type_a: Decimal(9, 1)
b: 4.2
type_b: Decimal(9, 2)
c: 4.2
type_c: Decimal(9, 3)
```
## toDecimal32OrDefault
Добавленный в: v21.11.0
Как и [`toDecimal32`](#toDecimal32), эта функция преобразует входное значение в значение типа [Decimal(9, S)](/ru/reference/data-types/decimal), но в случае ошибки возвращает значение по умолчанию.
**Синтаксис**
```sql theme={null}
toDecimal32OrDefault(expr, S[, default])
```
**Аргументы**
* `expr` — Строковое представление числа. [`String`](/ru/reference/data-types/string)
* `S` — Параметр масштаба от 0 до 9, задающий, сколько цифр может быть в дробной части числа. [`UInt8`](/ru/reference/data-types/int-uint)
* `default` — Необязательно. Значение по умолчанию, которое возвращается, если не удалось выполнить разбор в тип Decimal32(S). [`Decimal32(S)`](/ru/reference/data-types/decimal)
**Возвращаемое значение**
Значение типа Decimal(9, S) в случае успешного выполнения; в противном случае возвращается переданное значение по умолчанию или 0, если оно не задано. [`Decimal32(S)`](/ru/reference/data-types/decimal)
**Примеры**
**Успешное преобразование**
```sql title=Query theme={null}
SELECT toDecimal32OrDefault(toString(0.0001), 5)
```
```response title=Response theme={null}
0.0001
```
**Ошибка преобразования**
```sql title=Query theme={null}
SELECT toDecimal32OrDefault('Inf', 0, CAST('-1', 'Decimal32(0)'))
```
```response title=Response theme={null}
-1
```
## toDecimal32OrNull
Добавленный в: v20.1.0
Преобразует входное значение в значение типа [`Decimal(9, S)`](/ru/reference/data-types/decimal), но в случае ошибки возвращает `NULL`.
Аналогична [`toDecimal32`](#toDecimal32), но при ошибках преобразования возвращает `NULL` вместо того, чтобы генерировать исключение.
Поддерживаемые аргументы:
* Значения или строковые представления типа (U)Int\*.
* Значения или строковые представления типа Float\*.
Неподдерживаемые аргументы (возвращает `NULL`):
* Значения или строковые представления значений Float\* `NaN` и `Inf` (регистронезависимо).
* Строковые представления двоичных и шестнадцатеричных значений.
* Значения, выходящие за границы `Decimal32`:`(-1*10^(9 - S), 1*10^(9 - S))`.
См. также:
* [`toDecimal32`](#toDecimal32).
* [`toDecimal32OrZero`](#toDecimal32OrZero).
* [`toDecimal32OrDefault`](#toDecimal32OrDefault).
**Синтаксис**
```sql theme={null}
toDecimal32OrNull(expr, S)
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`Выражение`](/ru/reference/data-types/special-data-types/expression)
* `S` — параметр масштаба в диапазоне от 0 до 9, задающий, сколько цифр может быть в дробной части числа. [`UInt8`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
В случае успеха возвращается значение Decimal(9, S), в противном случае — `NULL`. [`Decimal32(S)`](/ru/reference/data-types/decimal) или [`NULL`](/ru/reference/syntax#null)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT toDecimal32OrNull('42.7', 2), toDecimal32OrNull('invalid', 2)
```
```response title=Response theme={null}
┌─toDecimal32OrNull('42.7', 2)─┬─toDecimal32OrNull('invalid', 2)─┐
│ 42.70 │ ᴺᵁᴸᴸ │
└──────────────────────────────┴─────────────────────────────────┘
```
## toDecimal32OrZero
Добавленный в: v20.1.0
Преобразует входное значение в значение типа [Decimal(9, S)](/ru/reference/data-types/decimal), но в случае ошибки возвращает `0`.
Аналогично [`toDecimal32`](#toDecimal32), но при ошибках преобразования возвращает `0` вместо того, чтобы генерировать исключение.
Поддерживаемые аргументы:
* Значения или строковые представления типа (U)Int\*.
* Значения или строковые представления типа Float\*.
Неподдерживаемые аргументы (возвращается `0`):
* Значения или строковые представления значений Float\* `NaN` и `Inf` (регистронезависимые).
* Строковые представления двоичных и шестнадцатеричных значений.
Если входное значение выходит за пределы `Decimal32`: `(-1*10^(9 - S), 1*10^(9 - S))`, функция возвращает `0`.
**Синтаксис**
```sql theme={null}
toDecimal32OrZero(expr, S)
```
**Аргументы**
* `expr` — Выражение, возвращающее число или его строковое представление. [`Выражение`](/ru/reference/data-types/special-data-types/expression)
* `S` — параметр масштаба со значением от 0 до 9, задающий, сколько цифр может быть в дробной части числа. [`UInt8`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
В случае успеха возвращает значение Decimal(9, S), в противном случае — `0`. [`Decimal32(S)`](/ru/reference/data-types/decimal)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT toDecimal32OrZero('42.7', 2), toDecimal32OrZero('invalid', 2)
```
```response title=Response theme={null}
┌─toDecimal32OrZero('42.7', 2)─┬─toDecimal32OrZero('invalid', 2)─┐
│ 42.70 │ 0.00 │
└──────────────────────────────┴─────────────────────────────────┘
```
## toDecimal64
Добавленный в: v18.12.0
Преобразует входное значение в значение типа [`Decimal(18, S)`](/ru/reference/data-types/decimal) с масштабом `S`.
Генерирует исключение в случае ошибки.
Поддерживаемые аргументы:
* Значения или строковые представления типа (U)Int\*.
* Значения или строковые представления типа Float\*.
Неподдерживаемые аргументы:
* Значения или строковые представления значений Float\* `NaN` и `Inf` (регистронезависимо).
* Строковые представления бинарных и шестнадцатеричных значений, например `SELECT toDecimal64('0xc0fe', 1);`.
Переполнение может произойти, если значение `expr` выходит за пределы диапазона `Decimal64`: `(-1*10^(18 - S), 1*10^(18 - S))`.
Лишние цифры в дробной части отбрасываются (без округления).
Лишние цифры в целой части приведут к исключению.
При преобразовании лишние цифры отбрасываются, и при работе с входными значениями Float32/Float64 результат может быть неожиданным, поскольку операции выполняются с использованием арифметики с плавающей запятой.
Например: `toDecimal64(1.15, 2)` равно `1.14`, потому что 1.15 \* 100 в арифметике с плавающей запятой равно 114.99.
Можно использовать входное значение типа String, чтобы в операциях использовался базовый целочисленный тип: `toDecimal64('1.15', 2) = 1.15`
**Синтаксис**
```sql theme={null}
toDecimal64(expr, S)
```
**Аргументы**
* `expr` — Выражение, возвращающее число или его строковое представление. [`Выражение`](/ru/reference/data-types/special-data-types/expression)
* `S` — параметр масштаба от 0 до 18, указывающий, сколько цифр может быть в дробной части числа. [`UInt8`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
Возвращает десятичное значение. [`Decimal(18, S)`](/ru/reference/data-types/decimal)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toDecimal64(2, 1) AS a, toTypeName(a) AS type_a,
toDecimal64(4.2, 2) AS b, toTypeName(b) AS type_b,
toDecimal64('4.2', 3) AS c, toTypeName(c) AS type_c
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
a: 2.0
type_a: Decimal(18, 1)
b: 4.20
type_b: Decimal(18, 2)
c: 4.200
type_c: Decimal(18, 3)
```
## toDecimal64OrDefault
Добавленный в: v21.11.0
Как и [`toDecimal64`](#toDecimal64), эта функция преобразует входное значение в тип [Decimal(18, S)](/ru/reference/data-types/decimal), но в случае ошибки возвращает значение по умолчанию.
**Синтаксис**
```sql theme={null}
toDecimal64OrDefault(expr, S[, default])
```
**Аргументы**
* `expr` — Строковое представление числа. [`String`](/ru/reference/data-types/string)
* `S` — Параметр масштаба в диапазоне от 0 до 18, задающий, сколько цифр может содержать дробная часть числа. [`UInt8`](/ru/reference/data-types/int-uint)
* `default` — Необязательно. Значение по умолчанию, которое возвращается, если преобразование в тип Decimal64(S) не удалось. [`Decimal64(S)`](/ru/reference/data-types/decimal)
**Возвращаемое значение**
Значение типа Decimal(18, S) в случае успешного преобразования; в противном случае возвращается значение по умолчанию, если оно было передано, или 0, если нет. [`Decimal64(S)`](/ru/reference/data-types/decimal)
**Примеры**
**Успешное преобразование**
```sql title=Query theme={null}
SELECT toDecimal64OrDefault(toString(0.0001), 18)
```
```response title=Response theme={null}
0.0001
```
**Не удалось преобразовать**
```sql title=Query theme={null}
SELECT toDecimal64OrDefault('Inf', 0, CAST('-1', 'Decimal64(0)'))
```
```response title=Response theme={null}
-1
```
## toDecimal64OrNull
Добавленный в: v20.1.0
Преобразует входное значение в значение типа [Decimal(18, S)](/ru/reference/data-types/decimal), но в случае ошибки возвращает `NULL`.
Аналогично [`toDecimal64`](#toDecimal64), но при ошибках преобразования возвращает `NULL` вместо того, чтобы генерировать исключение.
Поддерживаемые аргументы:
* Значения или строковые представления типа (U)Int\*.
* Значения или строковые представления типа Float\*.
Неподдерживаемые аргументы (возвращают `NULL`):
* Значения Float\* `NaN` и `Inf`, а также их строковые представления (регистронезависимые).
* Строковые представления двоичных и шестнадцатеричных значений.
* Значения, выходящие за пределы `Decimal64`: `(-1*10^(18 - S), 1*10^(18 - S))`.
См. также:
* [`toDecimal64`](#toDecimal64).
* [`toDecimal64OrZero`](#toDecimal64OrZero).
* [`toDecimal64OrDefault`](#toDecimal64OrDefault).
**Синтаксис**
```sql theme={null}
toDecimal64OrNull(expr, S)
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`Выражение`](/ru/reference/data-types/special-data-types/expression)
* `S` — параметр масштаба в диапазоне от 0 до 18, задающий, сколько цифр может содержать дробная часть числа. [`UInt8`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
Возвращает значение Decimal(18, S) в случае успеха, иначе — `NULL`. [`Decimal64(S)`](/ru/reference/data-types/decimal) или [`NULL`](/ru/reference/syntax#null)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT toDecimal64OrNull('42.7', 2), toDecimal64OrNull('invalid', 2)
```
```response title=Response theme={null}
┌─toDecimal64OrNull('42.7', 2)─┬─toDecimal64OrNull('invalid', 2)─┐
│ 42.70 │ ᴺᵁᴸᴸ │
└──────────────────────────────┴─────────────────────────────────┘
```
## toDecimal64OrZero
Добавленный в: v20.1.0
Преобразует входное значение в значение типа [Decimal(18, S)](/ru/reference/data-types/decimal), но в случае ошибки возвращает `0`.
Аналогична [`toDecimal64`](#toDecimal64), но при ошибках преобразования возвращает `0` вместо того, чтобы генерировать исключение.
Поддерживаемые аргументы:
* Значения или строковые представления типа (U)Int\*.
* Значения или строковые представления типа Float\*.
Неподдерживаемые аргументы (возвращается `0`):
* Значения или строковые представления значений Float\* `NaN` и `Inf` (регистронезависимо).
* Строковые представления двоичных и шестнадцатеричных значений.
Если входное значение выходит за пределы `Decimal64`:`(-1*10^(18 - S), 1*10^(18 - S))`, функция возвращает `0`.
См. также:
* [`toDecimal64`](#toDecimal64).
* [`toDecimal64OrNull`](#toDecimal64OrNull).
* [`toDecimal64OrDefault`](#toDecimal64OrDefault).
**Синтаксис**
```sql theme={null}
toDecimal64OrZero(expr, S)
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`Выражение`](/ru/reference/data-types/special-data-types/expression)
* `S` — параметр масштаба в диапазоне от 0 до 18, определяющий, сколько цифр может быть в дробной части числа. [`UInt8`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
Возвращает значение `Decimal(18, S)` в случае успеха, иначе `0`. [`Decimal64(S)`](/ru/reference/data-types/decimal)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT toDecimal64OrZero('42.7', 2), toDecimal64OrZero('invalid', 2)
```
```response title=Response theme={null}
┌─toDecimal64OrZero('42.7', 2)─┬─toDecimal64OrZero('invalid', 2)─┐
│ 42.70 │ 0.00 │
└──────────────────────────────┴─────────────────────────────────┘
```
## toDecimalString
Добавленный в: v23.3.0
Преобразует числовое значение в String с указанным количеством знаков после запятой.
Функция округляет входное значение до указанного числа десятичных знаков. Если у входного значения меньше знаков после запятой, чем требуется, результат дополняется нулями, чтобы получить ровно указанное количество знаков после запятой.
**Синтаксис**
```sql theme={null}
toDecimalString(number, scale)
```
**Аргументы**
* `number` — Числовое значение, которое нужно преобразовать в строку. Может иметь любой числовой тип (Int, UInt, Float, Decimal). [`Int8`](/ru/reference/data-types/int-uint) or [`Int16`](/ru/reference/data-types/int-uint) or [`Int32`](/ru/reference/data-types/int-uint) or [`Int64`](/ru/reference/data-types/int-uint) or [`UInt8`](/ru/reference/data-types/int-uint) or [`UInt16`](/ru/reference/data-types/int-uint) or [`UInt32`](/ru/reference/data-types/int-uint) or [`UInt64`](/ru/reference/data-types/int-uint) or [`Float32`](/ru/reference/data-types/float) or [`Float64`](/ru/reference/data-types/float) or [`Decimal`](/ru/reference/data-types/decimal)
* `scale` — Количество цифр для отображения в дробной части. При необходимости результат будет округлён. [`UInt8`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
Возвращает строковое представление числа с ровно указанным количеством цифр в дробной части. [`String`](/ru/reference/data-types/string)
**Примеры**
**Округление и форматирование числа**
```sql title=Query theme={null}
SELECT toDecimalString(2.1456, 2)
```
```response title=Response theme={null}
┌─toDecimalString(2.1456, 2)─┐
│ 2.15 │
└────────────────────────────┘
```
**Заполнить нулями**
```sql title=Query theme={null}
SELECT toDecimalString(5, 3)
```
```response title=Response theme={null}
┌─toDecimalString(5, 3)─┐
│ 5.000 │
└───────────────────────┘
```
**Разные числовые типы**
```sql title=Query theme={null}
SELECT toDecimalString(CAST(123.456 AS Decimal(10,3)), 2) AS decimal_val,
toDecimalString(CAST(42.7 AS Float32), 4) AS float_val
```
```response title=Response theme={null}
┌─decimal_val─┬─float_val─┐
│ 123.46 │ 42.7000 │
└─────────────┴───────────┘
```
## toFixedString
Добавленный в: v1.1.0
Преобразует аргумент [`String`](/ru/reference/data-types/string) в тип [`FixedString(N)`](/ru/reference/data-types/fixedstring) (строку фиксированной длины N).
Если строка содержит меньше байтов, чем N, справа она дополняется null-байтами.
Если строка содержит больше байтов, чем N, генерируется исключение.
**Синтаксис**
```sql theme={null}
toFixedString(s, N)
```
**Аргументы**
* `s` — Строка, которую нужно преобразовать. [`String`](/ru/reference/data-types/string)
* `N` — Длина результирующей FixedString. [`const UInt*`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
Возвращает FixedString длиной N. [`FixedString(N)`](/ru/reference/data-types/fixedstring)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT toFixedString('foo', 8) AS s;
```
```response title=Response theme={null}
┌─s─────────────┐
│ foo\0\0\0\0\0 │
└───────────────┘
```
## toFloat32
Добавленный в: v1.1.0
Преобразует входное значение в значение типа [Float32](/ru/reference/data-types/float).
Генерирует исключение в случае ошибки.
Поддерживаемые аргументы:
* Значения типа (U)Int\*.
* Строковые представления (U)Int8/16/32/128/256.
* Значения типа Float\*, включая `NaN` и `Inf`.
* Строковые представления Float\*, включая `NaN` и `Inf` (регистронезависимые).
Неподдерживаемые аргументы:
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toFloat32('0xc0fe');`.
См. также:
* [`toFloat32OrZero`](#toFloat32OrZero).
* [`toFloat32OrNull`](#toFloat32OrNull).
* [`toFloat32OrDefault`](#toFloat32OrDefault).
**Синтаксис**
```sql theme={null}
toFloat32(expr)
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`Выражение`](/ru/reference/data-types/special-data-types/expression)
**Возвращаемое значение**
Возвращает 32-битное значение с плавающей точкой. [`Float32`](/ru/reference/data-types/float)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toFloat32(42.7),
toFloat32('42.7'),
toFloat32('NaN')
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
toFloat32(42.7): 42.7
toFloat32('42.7'): 42.7
toFloat32('NaN'): nan
```
## toFloat32OrDefault
Добавленный в: v21.11.0
Как и [`toFloat32`](#toFloat32), эта функция преобразует входное значение в значение типа [Float32](/ru/reference/data-types/float), но в случае ошибки возвращает значение по умолчанию.
Если значение `default` не указано, то в случае ошибки возвращается `0`.
**Синтаксис**
```sql theme={null}
toFloat32OrDefault(expr[, default])
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`String`](/ru/reference/data-types/string) или [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)
* `default` — Необязательно. Значение по умолчанию, которое возвращается, если не удалось выполнить разбор. [`Float32`](/ru/reference/data-types/float)
**Возвращаемое значение**
В случае успеха возвращает значение типа Float32, в противном случае — значение по умолчанию, если оно передано, или 0, если нет. [`Float32`](/ru/reference/data-types/float)
**Примеры**
**Успешное преобразование**
```sql title=Query theme={null}
SELECT toFloat32OrDefault('8', CAST('0', 'Float32'))
```
```response title=Response theme={null}
8
```
**Ошибка преобразования**
```sql title=Query theme={null}
SELECT toFloat32OrDefault('abc', CAST('0', 'Float32'))
```
```response title=Response theme={null}
0
```
## toFloat32OrNull
Добавленный в: v1.1.0
Преобразует входное значение в значение типа [Float32](/ru/reference/data-types/float), но в случае ошибки возвращает `NULL`.
Аналогично [`toFloat32`](#toFloat32), но при ошибках преобразования возвращает `NULL` вместо генерации исключения.
Поддерживаемые аргументы:
* Значения типа (U)Int\*.
* Строковые представления (U)Int8/16/32/128/256.
* Значения типа Float\*, включая `NaN` и `Inf`.
* Строковые представления Float\*, включая `NaN` и `Inf` (регистронезависимо).
Неподдерживаемые аргументы (возвращают `NULL`):
* Строковые представления двоичных и шестнадцатеричных значений, например: `SELECT toFloat32OrNull('0xc0fe');`.
* Недопустимые строковые форматы.
См. также:
* [`toFloat32`](#toFloat32).
* [`toFloat32OrZero`](#toFloat32OrZero).
* [`toFloat32OrDefault`](#toFloat32OrDefault).
**Синтаксис**
```sql theme={null}
toFloat32OrNull(x)
```
**Аргументы**
* `x` — Строковое представление числа. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение типа `Float32` в случае успеха, в противном случае — `NULL`. [`Float32`](/ru/reference/data-types/float) или [`NULL`](/ru/reference/syntax#null)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toFloat32OrNull('42.7'),
toFloat32OrNull('NaN'),
toFloat32OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
toFloat32OrNull('42.7'): 42.7
toFloat32OrNull('NaN'): nan
toFloat32OrNull('abc'): \N
```
## toFloat32OrZero
Добавленный в: v1.1.0
Преобразует входное значение в тип [Float32](/ru/reference/data-types/float), но в случае ошибки возвращает `0`.
Аналогично [`toFloat32`](#toFloat32), но при ошибках преобразования возвращает `0` вместо генерации исключения.
См. также:
* [`toFloat32`](#toFloat32).
* [`toFloat32OrNull`](#toFloat32OrNull).
* [`toFloat32OrDefault`](#toFloat32OrDefault).
**Синтаксис**
```sql theme={null}
toFloat32OrZero(x)
```
**Аргументы**
* `x` — Строковое представление числа. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает 32-битное значение `Float32` в случае успеха, иначе — `0`. [`Float32`](/ru/reference/data-types/float)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toFloat32OrZero('42.7'),
toFloat32OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
toFloat32OrZero('42.7'): 42.7
toFloat32OrZero('abc'): 0
```
## toFloat64
Добавленный в: v1.1.0
Преобразует входное значение в значение типа [`Float64`](/ru/reference/data-types/float).
Генерирует исключение в случае ошибки.
Поддерживаемые аргументы:
* Значения типа (U)Int\*.
* Строковые представления значений типа (U)Int8/16/32/128/256.
* Значения типа Float\*, включая `NaN` и `Inf`.
* Строковые представления значений типа Float\*, включая `NaN` и `Inf` (регистронезависимо).
Неподдерживаемые аргументы:
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toFloat64('0xc0fe');`.
См. также:
* [`toFloat64OrZero`](#toFloat64OrZero).
* [`toFloat64OrNull`](#toFloat64OrNull).
* [`toFloat64OrDefault`](#toFloat64OrDefault).
**Синтаксис**
```sql theme={null}
toFloat64(expr)
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`Expression`](/ru/reference/data-types/special-data-types/expression)
**Возвращаемое значение**
Возвращает 64-битное значение с плавающей точкой. [`Float64`](/ru/reference/data-types/float)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toFloat64(42.7),
toFloat64('42.7'),
toFloat64('NaN')
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
toFloat64(42.7): 42.7
toFloat64('42.7'): 42.7
toFloat64('NaN'): nan
```
## toFloat64OrDefault
Добавленный в: v21.11.0
Как и [`toFloat64`](#toFloat64), эта функция преобразует входное значение в значение типа [Float64](/ru/reference/data-types/float), но в случае ошибки возвращает значение по умолчанию.
Если значение `default` не указано, то в случае ошибки возвращается `0`.
**Синтаксис**
```sql theme={null}
toFloat64OrDefault(expr[, default])
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`String`](/ru/reference/data-types/string) или [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)
* `default` — Необязательно. Значение по умолчанию, возвращаемое при неуспешном парсинге. [`Float64`](/ru/reference/data-types/float)
**Возвращаемое значение**
При успешном выполнении возвращает значение типа Float64, в противном случае — значение по умолчанию, если оно передано, или 0, если нет. [`Float64`](/ru/reference/data-types/float)
**Примеры**
**Успешное преобразование**
```sql title=Query theme={null}
SELECT toFloat64OrDefault('8', CAST('0', 'Float64'))
```
```response title=Response theme={null}
8
```
**Преобразование не удалось**
```sql title=Query theme={null}
SELECT toFloat64OrDefault('abc', CAST('0', 'Float64'))
```
```response title=Response theme={null}
0
```
## toFloat64OrNull
Добавленный в: v1.1.0
Преобразует входное значение в значение типа [Float64](/ru/reference/data-types/float), но в случае ошибки возвращает `NULL`.
Аналогично [`toFloat64`](#toFloat64), но при ошибках преобразования возвращает `NULL` вместо того, чтобы генерировать исключение.
Поддерживаемые аргументы:
* Значения типа (U)Int\*.
* Строковые представления (U)Int8/16/32/128/256.
* Значения типа Float\*, включая `NaN` и `Inf`.
* Строковые представления значений типа Float\*, включая `NaN` и `Inf` (регистронезависимо).
Неподдерживаемые аргументы (возвращается `NULL`):
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toFloat64OrNull('0xc0fe');`.
* Недопустимые строковые форматы.
См. также:
* [`toFloat64`](#toFloat64).
* [`toFloat64OrZero`](#toFloat64OrZero).
* [`toFloat64OrDefault`](#toFloat64OrDefault).
**Синтаксис**
```sql theme={null}
toFloat64OrNull(x)
```
**Аргументы**
* `x` — строковое представление числа. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает 64-битное значение типа Float64 в случае успеха, в противном случае — `NULL`. [`Float64`](/ru/reference/data-types/float) или [`NULL`](/ru/reference/syntax#null)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toFloat64OrNull('42.7'),
toFloat64OrNull('NaN'),
toFloat64OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
строка 1:
──────
toFloat64OrNull('42.7'): 42.7
toFloat64OrNull('NaN'): nan
toFloat64OrNull('abc'): \N
```
## toFloat64OrZero
Добавленный в: v1.1.0
Преобразует входное значение в [Float64](/ru/reference/data-types/float), но в случае ошибки возвращает `0`.
Аналогично [`toFloat64`](#toFloat64), но при ошибках преобразования возвращает `0` вместо того, чтобы генерировать исключение.
См. также:
* [`toFloat64`](#toFloat64).
* [`toFloat64OrNull`](#toFloat64OrNull).
* [`toFloat64OrDefault`](#toFloat64OrDefault).
**Синтаксис**
```sql theme={null}
toFloat64OrZero(x)
```
**Аргументы**
* `x` — Строковое представление числа. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
В случае успеха возвращает 64-битное значение с плавающей точкой, в противном случае — `0`. [`Float64`](/ru/reference/data-types/float)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toFloat64OrZero('42.7'),
toFloat64OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
toFloat64OrZero('42.7'): 42.7
toFloat64OrZero('abc'): 0
```
## toInt128
Добавленный в: v1.1.0
Преобразует входное значение в значение типа [Int128](/ru/reference/data-types/int-uint).
В случае ошибки генерирует исключение.
Функция использует округление к нулю, то есть отбрасывает дробную часть числа.
Поддерживаемые аргументы:
* Значения или строковые представления типа (U)Int\*.
* Значения типа Float\*.
Неподдерживаемые аргументы:
* Строковые представления значений Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toInt128('0xc0fe');`.
Если входное значение не укладывается в диапазон Int128, происходит переполнение или потеря значащих разрядов.
Это не считается ошибкой.
См. также:
* [`toInt128OrZero`](#toInt128OrZero).
* [`toInt128OrNull`](#toInt128OrNull).
* [`toInt128OrDefault`](#toInt128OrDefault).
**Синтаксис**
```sql theme={null}
toInt128(expr)
```
**Аргументы**
* `expr` — Выражение, возвращающее число или его строковое представление. [`Expression`](/ru/reference/data-types/special-data-types/expression)
**Возвращаемое значение**
Возвращает 128-битное целое число. [`Int128`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toInt128(-128),
toInt128(-128.8),
toInt128('-128')
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
toInt128(-128): -128
toInt128(-128.8): -128
toInt128('-128'): -128
```
## toInt128OrDefault
Добавленный в: v21.11.0
Как и [`toInt128`](#toInt128), эта функция преобразует входное значение в тип [Int128](/ru/reference/data-types/int-uint), но в случае ошибки возвращает значение по умолчанию.
Если значение `default` не передано, то в случае ошибки возвращается `0`.
**Синтаксис**
```sql theme={null}
toInt128OrDefault(expr[, default])
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`String`](/ru/reference/data-types/string) или [`(U)Int*`](/ru/reference/data-types/int-uint), или [`Float*`](/ru/reference/data-types/float)
* `default` — Необязательно. Значение по умолчанию, которое возвращается, если разбор не удался. [`Int128`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
При успешном выполнении возвращает значение типа Int128, в противном случае — значение по умолчанию, если оно передано, или 0, если нет. [`Int128`](/ru/reference/data-types/int-uint)
**Примеры**
**Успешное преобразование**
```sql title=Query theme={null}
SELECT toInt128OrDefault('-128', CAST('-1', 'Int128'))
```
```response title=Response theme={null}
-128
```
**Преобразование не удалось**
```sql title=Query theme={null}
SELECT toInt128OrDefault('abc', CAST('-1', 'Int128'))
```
```response title=Response theme={null}
-1
```
## toInt128OrNull
Добавленный в: v20.8.0
Как и [`toInt128`](#toInt128), эта функция преобразует входное значение в значение типа [Int128](/ru/reference/data-types/int-uint), но в случае ошибки возвращает `NULL`.
Поддерживаемые аргументы:
* Строковые представления (U)Int\*.
Неподдерживаемые аргументы (возвращают `NULL`):
* Строковые представления значений Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных чисел, например `SELECT toInt128OrNull('0xc0fe');`.
Если входное значение не укладывается в диапазон [Int128](/ru/reference/data-types/int-uint), происходит переполнение или выход за нижнюю границу диапазона результата.
Это не считается ошибкой.
См. также:
* [`toInt128`](#toInt128).
* [`toInt128OrZero`](#toInt128OrZero).
* [`toInt128OrDefault`](#toInt128OrDefault).
**Синтаксис**
```sql theme={null}
toInt128OrNull(x)
```
**Аргументы**
* `x` — Строковое представление числа. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение типа Int128, а если преобразование не удалось — `NULL`. [`Int128`](/ru/reference/data-types/int-uint) или [`NULL`](/ru/reference/syntax#null)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toInt128OrNull('-128'),
toInt128OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
toInt128OrNull('-128'): -128
toInt128OrNull('abc'): \N
```
## toInt128OrZero
Добавленный в: v20.8.0
Преобразует входное значение в тип [Int128](/ru/reference/data-types/int-uint), но в случае ошибки возвращает `0`.
Работает как [`toInt128`](#toInt128), но возвращает `0` вместо того, чтобы генерировать исключение.
См. также:
* [`toInt128`](#toInt128).
* [`toInt128OrNull`](#toInt128OrNull).
* [`toInt128OrDefault`](#toInt128OrDefault).
**Синтаксис**
```sql theme={null}
toInt128OrZero(x)
```
**Аргументы**
* `x` — Входное значение для преобразования. [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring) или [`Float*`](/ru/reference/data-types/float) или [`Decimal`](/ru/reference/data-types/decimal) или [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Date`](/ru/reference/data-types/date) или [`DateTime`](/ru/reference/data-types/datetime)
**Возвращаемое значение**
Возвращает преобразованное входное значение или `0`, если преобразование не удалось. [`Int128`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT toInt128OrZero('123')
```
```response title=Response theme={null}
123
```
**При ошибке преобразования возвращается ноль**
```sql title=Query theme={null}
SELECT toInt128OrZero('abc')
```
```response title=Response theme={null}
0
```
## toInt16
Добавленный в: v1.1.0
Преобразует входное значение в значение типа [`Int16`](/ru/reference/data-types/int-uint).
Генерирует исключение в случае ошибки.
Поддерживаемые аргументы:
* Значения или строковые представления типа (U)Int\*.
* Значения типа Float\*.
Неподдерживаемые аргументы:
* Строковые представления значений типа Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных значений, например: `SELECT toInt16('0xc0fe');`.
Если входное значение не может быть представлено в пределах диапазона [Int16](/ru/reference/data-types/int-uint), происходит переполнение или выход за нижнюю границу диапазона.
Это не считается ошибкой.
Например: `SELECT toInt16(32768) == -32768;`.
Функция использует [округление к нулю](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), то есть отбрасывает дробную часть числа.
См. также:
* [`toInt16OrZero`](#toInt16OrZero).
* [`toInt16OrNull`](#toInt16OrNull).
* [`toInt16OrDefault`](#toInt16OrDefault).
**Синтаксис**
```sql theme={null}
toInt16(expr)
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`Expression`](/ru/reference/data-types/special-data-types/expression)
**Возвращаемое значение**
Возвращает 16-битное целое число. [`Int16`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toInt16(-16),
toInt16(-16.16),
toInt16('-16')
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
toInt16(-16): -16
toInt16(-16.16): -16
toInt16('-16'): -16
```
## toInt16OrDefault
Добавленный в: v21.11.0
Как и [`toInt16`](#toInt16), эта функция преобразует входное значение в тип [Int16](/ru/reference/data-types/int-uint), но в случае ошибки возвращает значение по умолчанию.
Если значение `default` не передано, то в случае ошибки возвращается `0`.
**Синтаксис**
```sql theme={null}
toInt16OrDefault(expr[, default])
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`String`](/ru/reference/data-types/string) или [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)
* `default` — Необязательно. Значение по умолчанию, которое возвращается, если преобразование не удалось. [`Int16`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
Возвращает значение типа Int16 в случае успешного преобразования; в противном случае возвращает значение по умолчанию, если оно передано, или 0, если нет. [`Int16`](/ru/reference/data-types/int-uint)
**Примеры**
**Успешное преобразование**
```sql title=Query theme={null}
SELECT toInt16OrDefault('-16', CAST('-1', 'Int16'))
```
```response title=Response theme={null}
-16
```
**Ошибка преобразования**
```sql title=Query theme={null}
SELECT toInt16OrDefault('abc', CAST('-1', 'Int16'))
```
```response title=Response theme={null}
-1
```
## toInt16OrNull
Добавленный в: v1.1.0
Как и [`toInt16`](#toInt16), эта функция преобразует входное значение в значение типа [Int16](/ru/reference/data-types/int-uint), но в случае ошибки возвращает `NULL`.
Поддерживаемые аргументы:
* Строковые представления (U)Int\*.
Неподдерживаемые аргументы (возвращается `NULL`):
* Строковые представления значений Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toInt16OrNull('0xc0fe');`.
Если входное значение не может быть представлено в диапазоне [Int16](/ru/reference/data-types/int-uint), происходит переполнение или выход за нижнюю границу диапазона результата.
Это не считается ошибкой.
См. также:
* [`toInt16`](#toInt16).
* [`toInt16OrZero`](#toInt16OrZero).
* [`toInt16OrDefault`](#toInt16OrDefault).
**Синтаксис**
```sql theme={null}
toInt16OrNull(x)
```
**Аргументы**
* `x` — строковое представление числа. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение типа `Int16`, а если преобразование не удалось — `NULL`. [`Int16`](/ru/reference/data-types/int-uint) или [`NULL`](/ru/reference/syntax#null)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toInt16OrNull('-16'),
toInt16OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
toInt16OrNull('-16'): -16
toInt16OrNull('abc'): \N
```
## toInt16OrZero
Добавленный в: v1.1.0
Подобно [`toInt16`](#toInt16), эта функция преобразует входное значение в значение типа [Int16](/ru/reference/data-types/int-uint), но в случае ошибки возвращает `0`.
Поддерживаемые аргументы:
* Строковые представления значений (U)Int\*.
Неподдерживаемые аргументы (возвращается `0`):
* Строковые представления значений Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toInt16OrZero('0xc0fe');`.
Если входное значение не может быть представлено в пределах диапазона [Int16](/ru/reference/data-types/int-uint), происходит переполнение или выход за нижнюю границу диапазона.
Это не считается ошибкой.
См. также:
* [`toInt16`](#toInt16).
* [`toInt16OrNull`](#toInt16OrNull).
* [`toInt16OrDefault`](#toInt16OrDefault).
**Синтаксис**
```sql theme={null}
toInt16OrZero(x)
```
**Аргументы**
* `x` — Строковое представление числа. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение типа Int16; если преобразование не удаётся, возвращается `0`. [`Int16`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toInt16OrZero('16'),
toInt16OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
toInt16OrZero('16'): 16
toInt16OrZero('abc'): 0
```
## toInt256
Добавленный в: v1.1.0
Преобразует входное значение в значение типа [Int256](/ru/reference/data-types/int-uint).
Генерирует исключение в случае ошибки.
Функция использует округление к нулю, то есть отбрасывает дробную часть числа.
Поддерживаемые аргументы:
* Значения или строковые представления типа (U)Int\*.
* Значения типа Float\*.
Неподдерживаемые аргументы:
* Строковые представления значений Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toInt256('0xc0fe');`.
Если входное значение не может быть представлено в диапазоне Int256, происходит переполнение или выход за нижнюю границу диапазона.
Это не считается ошибкой.
См. также:
* [`toInt256OrZero`](#toInt256OrZero).
* [`toInt256OrNull`](#toInt256OrNull).
* [`toInt256OrDefault`](#toInt256OrDefault).
**Синтаксис**
```sql theme={null}
toInt256(expr)
```
**Аргументы**
* `expr` — выражение, возвращающее число или его строковое представление. [`Expression`](/ru/reference/data-types/special-data-types/expression)
**Возвращаемое значение**
Возвращает 256-битное целое значение. [`Int256`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toInt256(-256),
toInt256(-256.256),
toInt256('-256')
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
toInt256(-256): -256
toInt256(-256.256): -256
toInt256('-256'): -256
```
## toInt256OrDefault
Добавленный в: v21.11.0
Как и [`toInt256`](#toInt256), эта функция преобразует входное значение в значение типа [Int256](/ru/reference/data-types/int-uint), но в случае ошибки возвращает значение по умолчанию.
Если значение `default` не указано, то в случае ошибки возвращается `0`.
**Синтаксис**
```sql theme={null}
toInt256OrDefault(expr[, default])
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`String`](/ru/reference/data-types/string), [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)
* `default` — Необязательно. Значение по умолчанию, которое возвращается, если парсинг не удался. [`Int256`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
При успешном выполнении возвращает значение типа Int256, в противном случае — значение по умолчанию, если оно было передано, или 0, если нет. [`Int256`](/ru/reference/data-types/int-uint)
**Примеры**
**Успешное преобразование**
```sql title=Query theme={null}
SELECT toInt256OrDefault('-256', CAST('-1', 'Int256'))
```
```response title=Response theme={null}
-256
```
**Ошибка преобразования**
```sql title=Query theme={null}
SELECT toInt256OrDefault('abc', CAST('-1', 'Int256'))
```
```response title=Response theme={null}
-1
```
## toInt256OrNull
Добавленный в: v20.8.0
Подобно [`toInt256`](#toInt256), эта функция преобразует входное значение в значение типа [Int256](/ru/reference/data-types/int-uint), но при ошибке возвращает `NULL`.
Поддерживаемые аргументы:
* Строковые представления (U)Int\*.
Неподдерживаемые аргументы (возвращается `NULL`):
* Строковые представления значений Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toInt256OrNull('0xc0fe');`.
Если входное значение не может быть представлено в пределах [Int256](/ru/reference/data-types/int-uint), происходит переполнение или выход за нижнюю границу диапазона результата.
Это не считается ошибкой.
См. также:
* [`toInt256`](#toInt256).
* [`toInt256OrZero`](#toInt256OrZero).
* [`toInt256OrDefault`](#toInt256OrDefault).
**Синтаксис**
```sql theme={null}
toInt256OrNull(x)
```
**Аргументы**
* `x` — строковое представление числа. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение типа Int256; если преобразование не удалось, возвращает `NULL`. [`Int256`](/ru/reference/data-types/int-uint) или [`NULL`](/ru/reference/syntax#null)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toInt256OrNull('-256'),
toInt256OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
toInt256OrNull('-256'): -256
toInt256OrNull('abc'): \N
```
## toInt256OrZero
Добавленный в: v20.8.0
Преобразует входное значение в тип [Int256](/ru/reference/data-types/int-uint), но в случае ошибки возвращает `0`.
Аналогична [`toInt256`](#toInt256), но возвращает `0` вместо генерации исключения.
См. также:
* [`toInt256`](#toInt256).
* [`toInt256OrNull`](#toInt256OrNull).
* [`toInt256OrDefault`](#toInt256OrDefault).
**Синтаксис**
```sql theme={null}
toInt256OrZero(x)
```
**Аргументы**
* `x` — Входное значение, которое нужно преобразовать. [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring) или [`Float*`](/ru/reference/data-types/float) или [`Decimal`](/ru/reference/data-types/decimal) или [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Date`](/ru/reference/data-types/date) или [`DateTime`](/ru/reference/data-types/datetime)
**Возвращаемое значение**
Преобразованное входное значение; если преобразование не удалось, возвращается `0`. [`Int256`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT toInt256OrZero('123')
```
```response title=Response theme={null}
123
```
**При ошибке преобразования возвращается ноль**
```sql title=Query theme={null}
SELECT toInt256OrZero('abc')
```
```response title=Response theme={null}
0
```
## toInt32
Добавленный в: v1.1.0
Преобразует входное значение в значение типа [`Int32`](/ru/reference/data-types/int-uint).
В случае ошибки генерирует исключение.
Поддерживаемые аргументы:
* Значения или строковые представления типа (U)Int\*.
* Значения типа Float\*.
Неподдерживаемые аргументы:
* Строковые представления значений типа Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toInt32('0xc0fe');`.
Если входное значение не может быть представлено в диапазоне [Int32](/ru/reference/data-types/int-uint), происходит переполнение или выход за нижнюю границу диапазона.
Это не считается ошибкой.
Например: `SELECT toInt32(2147483648) == -2147483648;`
Функция использует [округление к нулю](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), то есть отбрасывает дробную часть числа.
См. также:
* [`toInt32OrZero`](#toInt32OrZero).
* [`toInt32OrNull`](#toInt32OrNull).
* [`toInt32OrDefault`](#toInt32OrDefault).
**Синтаксис**
```sql theme={null}
toInt32(expr)
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`Expression`](/ru/reference/data-types/special-data-types/expression)
**Возвращаемое значение**
Возвращает 32-битное целое число. [`Int32`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toInt32(-32),
toInt32(-32.32),
toInt32('-32')
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
toInt32(-32): -32
toInt32(-32.32): -32
toInt32('-32'): -32
```
## toInt32OrDefault
Добавленный в: v21.11.0
Как и [`toInt32`](#toInt32), эта функция преобразует входное значение в значение типа [Int32](/ru/reference/data-types/int-uint), но в случае ошибки возвращает значение по умолчанию.
Если значение `default` не передано, при ошибке возвращается `0`.
**Синтаксис**
```sql theme={null}
toInt32OrDefault(expr[, default])
```
**Аргументы**
* `expr` — Выражение, возвращающее число или его строковое представление. [`String`](/ru/reference/data-types/string) или [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)
* `default` — Необязательно. Значение по умолчанию, которое возвращается, если парсинг завершился неудачно. [`Int32`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
При успешном выполнении возвращает значение типа Int32, в противном случае — значение по умолчанию, если оно передано, или 0, если нет. [`Int32`](/ru/reference/data-types/int-uint)
**Примеры**
**Успешное преобразование**
```sql title=Query theme={null}
SELECT toInt32OrDefault('-32', CAST('-1', 'Int32'))
```
```response title=Response theme={null}
-32
```
**Ошибка преобразования**
```sql title=Query theme={null}
SELECT toInt32OrDefault('abc', CAST('-1', 'Int32'))
```
```response title=Response theme={null}
-1
```
## toInt32OrNull
Добавленный в: v1.1.0
Как и [`toInt32`](#toInt32), эта функция преобразует входное значение в значение типа [Int32](/ru/reference/data-types/int-uint), но в случае ошибки возвращает `NULL`.
Поддерживаемые аргументы:
* Строковые представления (U)Int\*.
Неподдерживаемые аргументы (возвращает `NULL`):
* Строковые представления значений Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toInt32OrNull('0xc0fe');`.
Если входное значение не может быть представлено в диапазоне [Int32](/ru/reference/data-types/int-uint), происходит переполнение или выход за нижнюю границу диапазона результата.
Это не считается ошибкой.
См. также:
* [`toInt32`](#toInt32).
* [`toInt32OrZero`](#toInt32OrZero).
* [`toInt32OrDefault`](#toInt32OrDefault).
**Синтаксис**
```sql theme={null}
toInt32OrNull(x)
```
**Аргументы**
* `x` — Строковое представление числа. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение типа Int32, а если преобразование не удалось — `NULL`. [`Int32`](/ru/reference/data-types/int-uint) или [`NULL`](/ru/reference/syntax#null)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toInt32OrNull('-32'),
toInt32OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
toInt32OrNull('-32'): -32
toInt32OrNull('abc'): \N
```
## toInt32OrZero
Добавленный в: v1.1.0
Как и [`toInt32`](#toInt32), эта функция преобразует входное значение в значение типа [Int32](/ru/reference/data-types/int-uint), но в случае ошибки возвращает `0`.
Поддерживаемые аргументы:
* Строковые представления (U)Int\*.
Неподдерживаемые аргументы (возвращают `0`):
* Строковые представления значений Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toInt32OrZero('0xc0fe');`.
Если входное значение не может быть представлено в пределах [Int32](/ru/reference/data-types/int-uint), происходит переполнение или выход за нижнюю границу диапазона результата.
Это не считается ошибкой.
См. также:
* [`toInt32`](#toInt32).
* [`toInt32OrNull`](#toInt32OrNull).
* [`toInt32OrDefault`](#toInt32OrDefault).
**Синтаксис**
```sql theme={null}
toInt32OrZero(x)
```
**Аргументы**
* `x` — Строковое представление числа. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение типа Int32, а если преобразование невозможно — `0`. [`Int32`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toInt32OrZero('32'),
toInt32OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
toInt32OrZero('32'): 32
toInt32OrZero('abc'): 0
```
## toInt64
Добавленный в: v1.1.0
Преобразует входное значение в значение типа [`Int64`](/ru/reference/data-types/int-uint).
Генерирует исключение в случае ошибки.
Поддерживаемые аргументы:
* Значения или строковые представления типа (U)Int\*.
* Значения типа Float\*.
Неподдерживаемые аргументы:
* Строковые представления значений Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toInt64('0xc0fe');`.
Если входное значение не может быть представлено в диапазоне [Int64](/ru/reference/data-types/int-uint), происходит переполнение или выход за нижнюю границу диапазона.
Это не считается ошибкой.
Например: `SELECT toInt64(9223372036854775808) == -9223372036854775808;`
Функция использует [округление к нулю](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), то есть отбрасывает дробную часть числа.
См. также:
* [`toInt64OrZero`](#toInt64OrZero).
* [`toInt64OrNull`](#toInt64OrNull).
* [`toInt64OrDefault`](#toInt64OrDefault).
**Синтаксис**
```sql theme={null}
toInt64(expr)
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. Поддерживаются: значения или строковые представления значений типа (U)Int\*, значения типа Float\*. Не поддерживаются: строковые представления значений Float\*, включая NaN и Inf, а также строковые представления двоичных и шестнадцатеричных значений. [`Expression`](/ru/reference/data-types/special-data-types/expression)
**Возвращаемое значение**
Возвращает 64-битное целое число. [`Int64`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toInt64(-64),
toInt64(-64.64),
toInt64('-64')
FORMAT Vertical
```
```response title=Response theme={null}
строка 1:
──────
toInt64(-64): -64
toInt64(-64.64): -64
toInt64('-64'): -64
```
## toInt64OrDefault
Добавленный в: v21.11.0
Как и [`toInt64`](#toInt64), эта функция преобразует входное значение в тип [Int64](/ru/reference/data-types/int-uint), но в случае ошибки возвращает значение по умолчанию.
Если значение `default` не передано, то в случае ошибки возвращается `0`.
**Синтаксис**
```sql theme={null}
toInt64OrDefault(expr[, default])
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`String`](/ru/reference/data-types/string) или [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)
* `default` — Необязательный параметр. Значение по умолчанию, которое возвращается, если не удалось выполнить парсинг. [`Int64`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
Возвращает значение типа Int64 в случае успеха; в противном случае возвращает переданное значение по умолчанию, а если оно не указано — 0. [`Int64`](/ru/reference/data-types/int-uint)
**Примеры**
**Успешное преобразование**
```sql title=Query theme={null}
SELECT toInt64OrDefault('-64', CAST('-1', 'Int64'))
```
```response title=Response theme={null}
-64
```
**Не удалось преобразовать**
```sql title=Query theme={null}
SELECT toInt64OrDefault('abc', CAST('-1', 'Int64'))
```
```response title=Response theme={null}
-1
```
## toInt64OrNull
Добавленный в: v1.1.0
Как и [`toInt64`](#toInt64), эта функция преобразует входное значение в значение типа [Int64](/ru/reference/data-types/int-uint), но в случае ошибки возвращает `NULL`.
Поддерживаемые аргументы:
* Строковые представления значений (U)Int\*.
Неподдерживаемые аргументы (возвращается `NULL`):
* Строковые представления значений Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toInt64OrNull('0xc0fe');`.
Если входное значение не может быть представлено в диапазоне [Int64](/ru/reference/data-types/int-uint), происходит переполнение или выход за нижнюю границу диапазона результата.
Это не считается ошибкой.
См. также:
* [`toInt64`](#toInt64).
* [`toInt64OrZero`](#toInt64OrZero).
* [`toInt64OrDefault`](#toInt64OrDefault).
**Синтаксис**
```sql theme={null}
toInt64OrNull(x)
```
**Аргументы**
* `x` — Строковое представление числа. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение типа Int64; в противном случае — `NULL`, если преобразование выполнить не удалось. [`Int64`](/ru/reference/data-types/int-uint) или [`NULL`](/ru/reference/syntax#null)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toInt64OrNull('-64'),
toInt64OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
toInt64OrNull('-64'): -64
toInt64OrNull('abc'): \N
```
## toInt64OrZero
Добавленный в: v1.1.0
Преобразует входное значение в тип [Int64](/ru/reference/data-types/int-uint), но в случае ошибки возвращает `0`.
Аналогично [`toInt64`](#toInt64), но возвращает `0` вместо генерации исключения.
См. также:
* [`toInt64`](#toInt64).
* [`toInt64OrNull`](#toInt64OrNull).
* [`toInt64OrDefault`](#toInt64OrDefault).
**Синтаксис**
```sql theme={null}
toInt64OrZero(x)
```
**Аргументы**
* `x` — Входное значение для преобразования. [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring) или [`Float*`](/ru/reference/data-types/float) или [`Decimal`](/ru/reference/data-types/decimal) или [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Date`](/ru/reference/data-types/date) или [`DateTime`](/ru/reference/data-types/datetime)
**Возвращаемое значение**
Возвращает преобразованное входное значение; в случае ошибки преобразования возвращает `0`. [`Int64`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT toInt64OrZero('123')
```
```response title=Response theme={null}
123
```
**При неудачном преобразовании возвращается ноль**
```sql title=Query theme={null}
SELECT toInt64OrZero('abc')
```
```response title=Response theme={null}
0
```
## toInt8
Добавленный в: v1.1.0
Преобразует входное значение в значение типа [`Int8`](/ru/reference/data-types/int-uint).
При ошибке генерирует исключение.
Поддерживаемые аргументы:
* Значения или строковые представления значений типа (U)Int\*.
* Значения типа Float\*.
Неподдерживаемые аргументы:
* Строковые представления значений Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toInt8('0xc0fe');`.
Если входное значение не может быть представлено в диапазоне [Int8](/ru/reference/data-types/int-uint), происходит переполнение или выход за нижнюю границу диапазона результата.
Это не считается ошибкой.
Например: `SELECT toInt8(128) == -128;`.
Функция использует [округление к нулю](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), то есть отбрасывает дробную часть числа.
См. также:
* [`toInt8OrZero`](#toInt8OrZero).
* [`toInt8OrNull`](#toInt8OrNull).
* [`toInt8OrDefault`](#toInt8OrDefault).
**Синтаксис**
```sql theme={null}
toInt8(expr)
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`Выражение`](/ru/reference/data-types/special-data-types/expression)
**Возвращаемое значение**
Возвращает 8-битное целочисленное значение. [`Int8`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toInt8(-8),
toInt8(-8.8),
toInt8('-8')
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
toInt8(-8): -8
toInt8(-8.8): -8
toInt8('-8'): -8
```
## toInt8OrDefault
Добавленный в: v21.11.0
Как и [`toInt8`](#toInt8), эта функция преобразует входное значение в значение типа [Int8](/ru/reference/data-types/int-uint), но в случае ошибки возвращает значение по умолчанию.
Если значение `default` не передано, то при ошибке возвращается `0`.
**Синтаксис**
```sql theme={null}
toInt8OrDefault(expr[, default])
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`String`](/ru/reference/data-types/string) или [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)
* `default` — Необязательно. Значение по умолчанию, которое возвращается, если разбор завершился неудачно. [`Int8`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
В случае успеха возвращает значение типа Int8, в противном случае — значение по умолчанию, если оно было передано, или 0, если нет. [`Int8`](/ru/reference/data-types/int-uint)
**Примеры**
**Успешное преобразование**
```sql title=Query theme={null}
SELECT toInt8OrDefault('-8', CAST('-1', 'Int8'))
```
```response title=Response theme={null}
-8
```
**Не удалось преобразовать**
```sql title=Query theme={null}
SELECT toInt8OrDefault('abc', CAST('-1', 'Int8'))
```
```response title=Response theme={null}
-1
```
## toInt8OrNull
Добавленный в: v1.1.0
Как и [`toInt8`](#toInt8), эта функция преобразует входное значение в значение типа [Int8](/ru/reference/data-types/int-uint), но в случае ошибки возвращает `NULL`.
Поддерживаемые аргументы:
* Строковые представления (U)Int\*.
Неподдерживаемые аргументы (возвращают `NULL`):
* Строковые представления значений Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toInt8OrNull('0xc0fe');`.
Если входное значение не может быть представлено в пределах диапазона [Int8](/ru/reference/data-types/int-uint), происходит переполнение или выход за нижнюю границу диапазона.
Это не считается ошибкой.
См. также:
* [`toInt8`](#toInt8).
* [`toInt8OrZero`](#toInt8OrZero).
* [`toInt8OrDefault`](#toInt8OrDefault).
**Синтаксис**
```sql theme={null}
toInt8OrNull(x)
```
**Аргументы**
* `x` — Строковое представление числа. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение типа Int8 или `NULL`, если преобразование не удалось. [`Int8`](/ru/reference/data-types/int-uint) или [`NULL`](/ru/reference/syntax#null)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toInt8OrNull('-8'),
toInt8OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
toInt8OrNull('-8'): -8
toInt8OrNull('abc'): \N
```
## toInt8OrZero
Добавленный в: v1.1.0
Как и [`toInt8`](#toInt8), эта функция преобразует входное значение в значение типа [Int8](/ru/reference/data-types/int-uint), но в случае ошибки возвращает `0`.
Поддерживаемые аргументы:
* Строковые представления (U)Int\*.
Неподдерживаемые аргументы (возвращают `0`):
* Строковые представления значений Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toInt8OrZero('0xc0fe');`.
Если входное значение не может быть представлено в пределах [Int8](/ru/reference/data-types/int-uint), происходит переполнение или выход за нижнюю границу диапазона результата.
Это не считается ошибкой.
См. также:
* [`toInt8`](#toInt8).
* [`toInt8OrNull`](#toInt8OrNull).
* [`toInt8OrDefault`](#toInt8OrDefault).
**Синтаксис**
```sql theme={null}
toInt8OrZero(x)
```
**Аргументы**
* `x` — Строковое представление числа. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение типа Int8, а если преобразование не удалось — `0`. [`Int8`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toInt8OrZero('8'),
toInt8OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
toInt8OrZero('8'): 8
toInt8OrZero('abc'): 0
```
## toInterval
Добавленный в: v25.4.0
Создает значение Interval из числового значения и строки с единицей измерения.
Эта функция предоставляет единый способ создавать интервалы разных типов (секунды, минуты, часы, дни, недели, месяцы, кварталы, годы)
с помощью одной функции, указывая единицу измерения в виде строкового аргумента. Строка единицы измерения регистронезависима.
Это эквивалентно вызову функций для конкретных типов, таких как `toIntervalSecond`, `toIntervalMinute`, `toIntervalDay` и т. д.,
но позволяет динамически указывать единицу измерения в виде строкового параметра.
**Синтаксис**
```sql theme={null}
toInterval(value, unit)
```
**Аргументы**
* `value` — Числовое значение, задающее количество единиц. Может быть любого числового типа: [`Int8`](/ru/reference/data-types/int-uint) or [`Int16`](/ru/reference/data-types/int-uint) or [`Int32`](/ru/reference/data-types/int-uint) or [`Int64`](/ru/reference/data-types/int-uint) or [`UInt8`](/ru/reference/data-types/int-uint) or [`UInt16`](/ru/reference/data-types/int-uint) or [`UInt32`](/ru/reference/data-types/int-uint) or [`UInt64`](/ru/reference/data-types/int-uint) or [`Float32`](/ru/reference/data-types/float) or [`Float64`](/ru/reference/data-types/float)
* `unit` — Единица времени. Должна быть строковой константой. Допустимые значения: 'nanosecond', 'microsecond', 'millisecond', 'second', 'minute', 'hour', 'day', 'week', 'month', 'quarter', 'year'. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение типа Interval указанного вида. Тип результата зависит от единицы времени: IntervalNanosecond, IntervalMicrosecond, IntervalMillisecond, IntervalSecond, IntervalMinute, IntervalHour, IntervalDay, IntervalWeek, IntervalMonth, IntervalQuarter или IntervalYear. [`Interval`](/ru/reference/data-types/int-uint)
**Примеры**
**Создание интервалов с разными единицами времени**
```sql title=Query theme={null}
SELECT
toInterval(5, 'second') AS seconds,
toInterval(3, 'day') AS days,
toInterval(2, 'month') AS months
```
```response title=Response theme={null}
┌─seconds─┬─days─┬─months─┐
│ 5 │ 3 │ 2 │
└─────────┴──────┴────────┘
```
**Используйте интервалы в операциях с датами**
```sql title=Query theme={null}
SELECT
now() AS current_time,
now() + toInterval(1, 'hour') AS one_hour_later,
now() - toInterval(7, 'day') AS week_ago
```
```response title=Response theme={null}
┌─────────current_time─┬──one_hour_later─────┬────────────week_ago─┐
│ 2025-01-04 10:30:00 │ 2025-01-04 11:30:00 │ 2024-12-28 10:30:00 │
└──────────────────────┴─────────────────────┴─────────────────────┘
```
**Динамическое создание интервала**
```sql title=Query theme={null}
SELECT toDate('2025-01-01') + toInterval(number, 'day') AS dates
FROM numbers(5)
```
```response title=Response theme={null}
┌──────dates─┐
│ 2025-01-01 │
│ 2025-01-02 │
│ 2025-01-03 │
│ 2025-01-04 │
│ 2025-01-05 │
└────────────┘
```
## toIntervalDay
Добавленный в: v1.1.0
Возвращает интервал в `n` дней типа данных [`IntervalDay`](/ru/reference/data-types/special-data-types/interval).
**Синтаксис**
```sql theme={null}
toIntervalDay(n)
```
**Аргументы**
* `n` — Количество дней. Целые числа, их строковые представления, а также числа с плавающей точкой. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает интервал длиной в `n` дней. [`Interval`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
WITH
toDate('2025-06-15') AS date,
toIntervalDay(5) AS interval_to_days
SELECT date + interval_to_days AS result
```
```response title=Response theme={null}
┌─────result─┐
│ 2025-06-20 │
└────────────┘
```
## toIntervalHour
Добавленный в: v1.1.0
Возвращает интервал в `n` часов с типом данных [`IntervalHour`](/ru/reference/data-types/special-data-types/interval).
**Синтаксис**
```sql theme={null}
toIntervalHour(n)
```
**Аргументы**
* `n` — Количество часов. Целые числа, их строковые представления, а также числа с плавающей точкой. [`Int*`](/ru/reference/data-types/int-uint) или [`UInt*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает интервал длительностью `n` часов. [`Interval`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
WITH
toDate('2025-06-15') AS date,
toIntervalHour(12) AS interval_to_hours
SELECT date + interval_to_hours AS result
```
```response title=Response theme={null}
┌──────────────result─┐
│ 2025-06-15 12:00:00 │
└─────────────────────┘
```
## toIntervalMicrosecond
Добавленный в: v22.6.0
Возвращает интервал в `n` микросекунд типа [`IntervalMicrosecond`](/ru/reference/data-types/special-data-types/interval).
**Синтаксис**
```sql theme={null}
toIntervalMicrosecond(n)
```
**Аргументы**
* `n` — количество микросекунд. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает интервал длительностью `n` микросекунд. [`Interval`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
WITH
toDateTime('2025-06-15') AS date,
toIntervalMicrosecond(30) AS interval_to_microseconds
SELECT date + interval_to_microseconds AS result
```
```response title=Response theme={null}
┌─────────────────────result─┐
│ 2025-06-15 00:00:00.000030 │
└────────────────────────────┘
```
## toIntervalMillisecond
Добавленный в: v22.6.0
Возвращает интервал длиной `n` миллисекунд типа данных [IntervalMillisecond](/ru/reference/data-types/special-data-types/interval).
**Синтаксис**
```sql theme={null}
toIntervalMillisecond(n)
```
**Аргументы**
* `n` — число миллисекунд. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает интервал длиной в `n` миллисекунд. [`Interval`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
WITH
toDateTime('2025-06-15') AS date,
toIntervalMillisecond(30) AS interval_to_milliseconds
SELECT date + interval_to_milliseconds AS result
```
```response title=Response theme={null}
┌──────────────────result─┐
│ 2025-06-15 00:00:00.030 │
└─────────────────────────┘
```
## toIntervalMinute
Добавленный в: v1.1.0
Возвращает интервал длительностью `n` минут типа данных [`IntervalMinute`](/ru/reference/data-types/special-data-types/interval).
**Синтаксис**
```sql theme={null}
toIntervalMinute(n)
```
**Аргументы**
* `n` — Количество минут. Целые числа или их строковые представления, а также числа с плавающей точкой. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает интервал в `n` минут. [`Interval`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
WITH
toDate('2025-06-15') AS date,
toIntervalMinute(12) AS interval_to_minutes
SELECT date + interval_to_minutes AS result
```
```response title=Response theme={null}
┌──────────────result─┐
│ 2025-06-15 00:12:00 │
└─────────────────────┘
```
## toIntervalMonth
Добавленный в: v1.1.0
Возвращает интервал в `n` месяцев типа [`IntervalMonth`](/ru/reference/data-types/special-data-types/interval).
**Синтаксис**
```sql theme={null}
toIntervalMonth(n)
```
**Аргументы**
* `n` — количество месяцев. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает интервал в `n` месяцев. [`Interval`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
WITH
toDate('2025-06-15') AS date,
toIntervalMonth(1) AS interval_to_month
SELECT date + interval_to_month AS result
```
```response title=Response theme={null}
┌─────result─┐
│ 2025-07-15 │
└────────────┘
```
## toIntervalNanosecond
Добавленный в: v22.6.0
Возвращает интервал в `n` наносекунд типа данных [`IntervalNanosecond`](/ru/reference/data-types/special-data-types/interval).
**Синтаксис**
```sql theme={null}
toIntervalNanosecond(n)
```
**Аргументы**
* `n` — Количество наносекунд. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает интервал в `n` наносекунд. [`Interval`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
WITH
toDateTime('2025-06-15') AS date,
toIntervalNanosecond(30) AS interval_to_nanoseconds
SELECT date + interval_to_nanoseconds AS result
```
```response title=Response theme={null}
┌────────────────────────result─┐
│ 2025-06-15 00:00:00.000000030 │
└───────────────────────────────┘
```
## toIntervalQuarter
Добавленный в: v1.1.0
Возвращает интервал в `n` кварталов типа данных [`IntervalQuarter`](/ru/reference/data-types/special-data-types/interval).
**Синтаксис**
```sql theme={null}
toIntervalQuarter(n)
```
**Аргументы**
* `n` — количество кварталов. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает интервал в `n` кварталов. [`Interval`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
WITH
toDate('2025-06-15') AS date,
toIntervalQuarter(1) AS interval_to_quarter
SELECT date + interval_to_quarter AS result
```
```response title=Response theme={null}
┌─────result─┐
│ 2025-09-15 │
└────────────┘
```
## toIntervalSecond
Добавленный в: v1.1.0
Возвращает интервал длительностью `n` секунд типа данных [`IntervalSecond`](/ru/reference/data-types/special-data-types/interval).
**Синтаксис**
```sql theme={null}
toIntervalSecond(n)
```
**Аргументы**
* `n` — Количество секунд. Целые числа, их строковые представления, а также числа с плавающей точкой. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает интервал длительностью `n` секунд. [`Interval`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
WITH
toDate('2025-06-15') AS date,
toIntervalSecond(30) AS interval_to_seconds
SELECT date + interval_to_seconds AS result
```
```response title=Response theme={null}
┌──────────────result─┐
│ 2025-06-15 00:00:30 │
└─────────────────────┘
```
## toIntervalWeek
Добавленный в: v1.1.0
Возвращает интервал в `n` недель с типом данных [`IntervalWeek`](/ru/reference/data-types/special-data-types/interval).
**Синтаксис**
```sql theme={null}
toIntervalWeek(n)
```
**Аргументы**
* `n` — Количество недель. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает интервал длиной в `n` недель. [`Interval`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
WITH
toDate('2025-06-15') AS date,
toIntervalWeek(1) AS interval_to_week
SELECT date + interval_to_week AS result
```
```response title=Response theme={null}
┌─────result─┐
│ 2025-06-22 │
└────────────┘
```
## toIntervalYear
Добавленный в: v1.1.0
Возвращает интервал длиной в `n` лет типа данных [`IntervalYear`](/ru/reference/data-types/special-data-types/interval).
**Синтаксис**
```sql theme={null}
toIntervalYear(n)
```
**Аргументы**
* `n` — Количество лет. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает интервал длиной в `n` лет. [`Interval`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
WITH
toDate('2024-06-15') AS date,
toIntervalYear(1) AS interval_to_year
SELECT date + interval_to_year AS result
```
```response title=Response theme={null}
┌─────result─┐
│ 2025-06-15 │
└────────────┘
```
## toLowCardinality
Добавленный в: v18.12.0
Преобразует входной аргумент в версию [LowCardinality](/ru/reference/data-types/lowcardinality) того же типа данных.
Чтобы преобразовать тип данных `LowCardinality` в обычный тип данных, используйте функцию [CAST](#CAST).
Например: `CAST(x AS String)`.
**Синтаксис**
```sql theme={null}
toLowCardinality(expr)
```
**Аргументы**
* `expr` — выражение, результат которого имеет один из поддерживаемых типов данных: [`String`](/ru/reference/data-types/string), [`FixedString`](/ru/reference/data-types/fixedstring), [`Date`](/ru/reference/data-types/date), [`DateTime`](/ru/reference/data-types/datetime), [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)
**Возвращаемое значение**
Возвращает входное значение, преобразованное в тип данных `LowCardinality`. [`LowCardinality`](/ru/reference/data-types/lowcardinality)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT toLowCardinality('1')
```
```response title=Response theme={null}
┌─toLowCardinality('1')─┐
│ 1 │
└───────────────────────┘
```
## toString
Добавленный в: v1.1.0
Преобразует значения в строковое представление.
Для аргументов DateTime функция может принимать второй аргумент типа String, содержащий имя часового пояса.
**Синтаксис**
```sql theme={null}
toString(value[, timezone])
```
**Аргументы**
* `value` — Значение для преобразования в строку. [`Any`](/ru/reference/data-types)
* `timezone` — Необязательно. Имя часового пояса для преобразования значения DateTime. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает строковое представление входного значения. [`String`](/ru/reference/data-types/string)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
now() AS ts,
time_zone,
toString(ts, time_zone) AS str_tz_datetime
FROM system.time_zones
WHERE time_zone LIKE 'Europe%'
LIMIT 10
```
```response title=Response theme={null}
┌──────────────────ts─┬─time_zone─────────┬─str_tz_datetime─────┐
│ 2023-09-08 19:14:59 │ Europe/Amsterdam │ 2023-09-08 21:14:59 │
│ 2023-09-08 19:14:59 │ Europe/Andorra │ 2023-09-08 21:14:59 │
│ 2023-09-08 19:14:59 │ Europe/Astrakhan │ 2023-09-08 23:14:59 │
│ 2023-09-08 19:14:59 │ Europe/Athens │ 2023-09-08 22:14:59 │
│ 2023-09-08 19:14:59 │ Europe/Belfast │ 2023-09-08 20:14:59 │
└─────────────────────┴───────────────────┴─────────────────────┘
```
## toStringCutToZero
Добавленный в: v1.1.0
Принимает аргумент типа [String](/ru/reference/data-types/string) или [FixedString](/ru/reference/data-types/fixedstring) и возвращает String, содержащую копию исходной строки, обрезанную по первому null-байту.
Null-байты (`\0`) считаются символами окончания строки.
Эта функция полезна при обработке строк в стиле C или бинарных данных, где null-байты обозначают конец значимого содержимого.
**Синтаксис**
```sql theme={null}
toStringCutToZero(s)
```
**Аргументы**
* `s` — обрабатываемое значение типа `String` или `FixedString`. [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring)
**Возвращаемое значение**
Возвращает значение типа `String`, содержащее символы до первого null-байта. [`String`](/ru/reference/data-types/string)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toStringCutToZero('hello'),
toStringCutToZero('hello\0world')
```
```response title=Response theme={null}
┌─toStringCutToZero('hello')─┬─toStringCutToZero('hello\\0world')─┐
│ hello │ hello │
└────────────────────────────┴───────────────────────────────────┘
```
## toTime
Добавленный в: v1.1.0
Преобразует входное значение в тип [Time](/ru/reference/data-types/time).
Поддерживает преобразование из String, FixedString, DateTime или числовых типов, обозначающих количество секунд с полуночи.
**Синтаксис**
```sql theme={null}
toTime(x)
```
**Аргументы**
* `x` — Входное значение для преобразования. [`String`](/ru/reference/data-types/string) or [`FixedString`](/ru/reference/data-types/fixedstring) or [`DateTime`](/ru/reference/data-types/datetime) or [`(U)Int*`](/ru/reference/data-types/int-uint) or [`Float*`](/ru/reference/data-types/float)
**Возвращаемое значение**
Преобразованное значение. [`Time`](/ru/reference/data-types/time)
**Примеры**
**Преобразование из String в Time**
```sql title=Query theme={null}
SELECT toTime('14:30:25')
```
```response title=Response theme={null}
14:30:25
```
**Преобразование DateTime в тип Time**
```sql title=Query theme={null}
SELECT toTime(toDateTime('2025-04-15 14:30:25'))
```
```response title=Response theme={null}
14:30:25
```
**Преобразование целого числа в тип Time**
```sql title=Query theme={null}
SELECT toTime(52225)
```
```response title=Response theme={null}
14:30:25
```
## toTime64
Добавленный в: v25.6.0
Преобразует входное значение в тип [Time64](/ru/reference/data-types/time64).
Поддерживает преобразование из String, FixedString, DateTime64 или числовых типов, представляющих количество микросекунд, прошедших с полуночи.
Обеспечивает микросекундную точность значений времени.
**Синтаксис**
```sql theme={null}
toTime64(x)
```
**Аргументы**
* `x` — Входное значение для преобразования. [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring), или [`DateTime64`](/ru/reference/data-types/datetime64), или [`(U)Int*`](/ru/reference/data-types/int-uint), или [`Float*`](/ru/reference/data-types/float)
**Возвращаемое значение**
Возвращает преобразованное входное значение с точностью до микросекунд. [`Time64(6)`](/ru/reference/data-types/time64)
**Примеры**
**Преобразование `String` в `Time64`**
```sql title=Query theme={null}
SELECT toTime64('14:30:25.123456')
```
```response title=Response theme={null}
14:30:25.123456
```
**Преобразование DateTime64 в Time64**
```sql title=Query theme={null}
SELECT toTime64(toDateTime64('2025-04-15 14:30:25.123456', 6))
```
```response title=Response theme={null}
14:30:25.123456
```
**Преобразование целочисленного значения в Time64**
```sql title=Query theme={null}
SELECT toTime64(52225123456)
```
```response title=Response theme={null}
14:30:25.123456
```
## toTime64OrNull
Добавленный в: v25.6.0
Преобразует входное значение в значение типа `Time64`, но в случае ошибки возвращает `NULL`.
Аналогично [`toTime64`](#toTime64), но при ошибках преобразования возвращает `NULL` вместо генерации исключения.
См. также:
* [`toTime64`](#toTime64)
* [`toTime64OrZero`](#toTime64OrZero)
**Синтаксис**
```sql theme={null}
toTime64OrNull(x)
```
**Аргументы**
* `x` — строковое представление времени с субсекундной точностью. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
При успешном выполнении возвращает значение Time64, в противном случае — `NULL`. [`Time64`](/ru/reference/data-types/time64) или [`NULL`](/ru/reference/syntax#null)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT toTime64OrNull('12:30:45.123'), toTime64OrNull('invalid')
```
```response title=Response theme={null}
┌─toTime64OrNull('12:30:45.123')─┬─toTime64OrNull('invalid')─┐
│ 12:30:45.123 │ ᴺᵁᴸᴸ │
└────────────────────────────────┴───────────────────────────┘
```
## toTime64OrZero
Добавленный в: v25.6.0
Преобразует входное значение в значение типа Time64, но в случае ошибки возвращает `00:00:00.000`.
Аналогично [`toTime64`](#toTime64), но при ошибках преобразования возвращает `00:00:00.000` вместо генерации исключения.
**Синтаксис**
```sql theme={null}
toTime64OrZero(x)
```
**Аргументы**
* `x` — строковое представление времени с субсекундной точностью. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение типа Time64 в случае успеха, иначе — `00:00:00.000`. [`Time64`](/ru/reference/data-types/time64)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT toTime64OrZero('12:30:45.123'), toTime64OrZero('invalid')
```
```response title=Response theme={null}
┌─toTime64OrZero('12:30:45.123')─┬─toTime64OrZero('invalid')─┐
│ 12:30:45.123 │ 00:00:00.000 │
└────────────────────────────────┴──────────────────────────┘
```
## toTimeOrNull
Добавленный в: v1.1.0
Преобразует входное значение в значение типа Time, но в случае ошибки возвращает `NULL`.
Аналогично [`toTime`](#toTime), но при ошибках преобразования возвращает `NULL` вместо генерации исключения.
См. также:
* [`toTime`](#toTime)
* [`toTimeOrZero`](#toTimeOrZero)
**Синтаксис**
```sql theme={null}
toTimeOrNull(x)
```
**Аргументы**
* `x` — строковое представление времени. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение типа Time в случае успеха, в противном случае — `NULL`. [`Time`](/ru/reference/data-types/time) или [`NULL`](/ru/reference/syntax#null)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT toTimeOrNull('12:30:45'), toTimeOrNull('invalid')
```
```response title=Response theme={null}
┌─toTimeOrNull('12:30:45')─┬─toTimeOrNull('invalid')─┐
│ 12:30:45 │ ᴺᵁᴸᴸ │
└──────────────────────────┴─────────────────────────┘
```
## toTimeOrZero
Добавленный в: v1.1.0
Преобразует входное значение в значение типа Time, а в случае ошибки возвращает `00:00:00`.
Как и toTime, при ошибках преобразования возвращает `00:00:00` вместо того, чтобы генерировать исключение.
**Синтаксис**
```sql theme={null}
toTimeOrZero(x)
```
**Аргументы**
* `x` — Строковое представление времени. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение типа Time в случае успеха, в противном случае — `00:00:00`. [`Time`](/ru/reference/data-types/time)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT toTimeOrZero('12:30:45'), toTimeOrZero('invalid')
```
```response title=Response theme={null}
┌─toTimeOrZero('12:30:45')─┬─toTimeOrZero('invalid')─┐
│ 12:30:45 │ 00:00:00 │
└──────────────────────────┴─────────────────────────┘
```
## toUInt128
Добавленный в: v1.1.0
Преобразует входное значение в значение типа [`UInt128`](/ru/reference/functions/regular-functions/type-conversion-functions#toUInt128).
В случае ошибки генерирует исключение.
Функция использует округление к нулю, то есть отбрасывает дробную часть числа.
Поддерживаемые аргументы:
* Значения или строковые представления типа (U)Int\*.
* Значения типа Float\*.
Неподдерживаемые аргументы:
* Строковые представления значений Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toUInt128('0xc0fe');`.
Если входное значение не может быть представлено в пределах UInt128, происходит переполнение или потеря значащих разрядов.
Это не считается ошибкой.
См. также:
* [`toUInt128OrZero`](#toUInt128OrZero).
* [`toUInt128OrNull`](#toUInt128OrNull).
* [`toUInt128OrDefault`](#toUInt128OrDefault).
**Синтаксис**
```sql theme={null}
toUInt128(expr)
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`Выражение`](/ru/reference/data-types/special-data-types/expression)
**Возвращаемое значение**
Возвращает 128-битное беззнаковое целое значение. [`UInt128`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toUInt128(128),
toUInt128(128.8),
toUInt128('128')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt128(128): 128
toUInt128(128.8): 128
toUInt128('128'): 128
```
## toUInt128OrDefault
Добавленный в: v21.11.0
Как и [`toUInt128`](#toUInt128), эта функция преобразует входное значение в значение типа [`UInt128`](/ru/reference/data-types/int-uint), но в случае ошибки возвращает значение по умолчанию.
Если значение `default` не передано, то при ошибке возвращается `0`.
**Синтаксис**
```sql theme={null}
toUInt128OrDefault(expr[, default])
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`String`](/ru/reference/data-types/string) или [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)
* `default` — Необязательно. Значение по умолчанию, которое будет возвращено, если разбор не выполнен. [`UInt128`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
Возвращает значение типа UInt128 в случае успеха, в противном случае — значение по умолчанию, если оно передано, или 0, если нет. [`UInt128`](/ru/reference/data-types/int-uint)
**Примеры**
**Успешное преобразование**
```sql title=Query theme={null}
SELECT toUInt128OrDefault('128', CAST('0', 'UInt128'))
```
```response title=Response theme={null}
128
```
**Не удалось выполнить преобразование**
```sql title=Query theme={null}
SELECT toUInt128OrDefault('abc', CAST('0', 'UInt128'))
```
```response title=Response theme={null}
0
```
## toUInt128OrNull
Добавленный в: v21.6.0
Как и [`toUInt128`](#toUInt128), эта функция преобразует входное значение в значение типа [`UInt128`](/ru/reference/data-types/int-uint), но в случае ошибки возвращает `NULL`.
Поддерживаемые аргументы:
* Строковые представления (U)Int\*.
Неподдерживаемые аргументы (возвращают `NULL`):
* Строковые представления значений Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toUInt128OrNull('0xc0fe');`.
Если входное значение не может быть представлено в пределах диапазона [`UInt128`](/ru/reference/data-types/int-uint), происходит переполнение или выход за нижнюю границу диапазона.
Это не считается ошибкой.
См. также:
* [`toUInt128`](#toUInt128).
* [`toUInt128OrZero`](#toUInt128OrZero).
* [`toUInt128OrDefault`](#toUInt128OrDefault).
**Синтаксис**
```sql theme={null}
toUInt128OrNull(x)
```
**Аргументы**
* `x` — строковое представление числа. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение типа UInt128, а если преобразование не удалось — `NULL`. [`UInt128`](/ru/reference/data-types/int-uint) или [`NULL`](/ru/reference/syntax#null)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toUInt128OrNull('128'),
toUInt128OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
toUInt128OrNull('128'): 128
toUInt128OrNull('abc'): \N
```
## toUInt128OrZero
Добавленный в: v1.1.0
Подобно [`toUInt128`](#toUInt128), эта функция преобразует входное значение в значение типа [`UInt128`](/ru/reference/data-types/int-uint), но в случае ошибки возвращает `0`.
Поддерживаемые аргументы:
* Строковые представления (U)Int\*.
Неподдерживаемые аргументы (возвращается `0`):
* Строковые представления значений Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toUInt128OrZero('0xc0fe');`.
Если входное значение не может быть представлено в пределах [`UInt128`](/ru/reference/data-types/int-uint), происходит переполнение или выход за нижнюю границу диапазона результата.
Это не считается ошибкой.
См. также:
* [`toUInt128`](#toUInt128).
* [`toUInt128OrNull`](#toUInt128OrNull).
* [`toUInt128OrDefault`](#toUInt128OrDefault).
**Синтаксис**
```sql theme={null}
toUInt128OrZero(x)
```
**Аргументы**
* `x` — Строковое представление числа. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение типа UInt128, а если преобразование не удалось — `0`. [`UInt128`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toUInt128OrZero('128'),
toUInt128OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
toUInt128OrZero('128'): 128
toUInt128OrZero('abc'): 0
```
## toUInt16
Добавленный в: v1.1.0
Преобразует входное значение в значение типа [`UInt16`](/ru/reference/data-types/int-uint).
В случае ошибки генерирует исключение.
Поддерживаемые аргументы:
* Значения или строковые представления типа (U)Int\*.
* Значения типа Float\*.
Неподдерживаемые аргументы:
* Строковые представления значений Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toUInt16('0xc0fe');`.
Если входное значение не может быть представлено в границах [`UInt16`](/ru/reference/data-types/int-uint), происходит переполнение или выход за нижнюю границу диапазона результата.
Это не считается ошибкой.
Например: `SELECT toUInt16(65536) == 0;`.
Функция использует [округление к нулю](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), то есть отбрасывает дробную часть числа.
См. также:
* [`toUInt16OrZero`](#toUInt16OrZero).
* [`toUInt16OrNull`](#toUInt16OrNull).
* [`toUInt16OrDefault`](#toUInt16OrDefault).
**Синтаксис**
```sql theme={null}
toUInt16(expr)
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`Выражение`](/ru/reference/data-types/special-data-types/expression)
**Возвращаемое значение**
Возвращает 16-битное беззнаковое целое число. [`UInt16`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toUInt16(16),
toUInt16(16.16),
toUInt16('16')
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
toUInt16(16): 16
toUInt16(16.16): 16
toUInt16('16'): 16
```
## toUInt16OrDefault
Добавленный в: v21.11.0
Как и [`toUInt16`](#toUInt16), эта функция преобразует входное значение в тип [UInt16](/ru/reference/data-types/int-uint), но в случае ошибки возвращает значение по умолчанию.
Если значение `default` не передано, то в случае ошибки возвращается `0`.
**Синтаксис**
```sql theme={null}
toUInt16OrDefault(expr[, default])
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`String`](/ru/reference/data-types/string) или [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)
* `default` — Необязательный параметр. Значение по умолчанию, которое возвращается, если парсинг завершился неудачно. [`UInt16`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
Возвращает значение типа UInt16 в случае успеха; в противном случае — переданное значение по умолчанию, а если оно не передано, 0. [`UInt16`](/ru/reference/data-types/int-uint)
**Примеры**
**Успешное преобразование**
```sql title=Query theme={null}
SELECT toUInt16OrDefault('16', CAST('0', 'UInt16'))
```
```response title=Response theme={null}
16
```
**Ошибка преобразования**
```sql title=Query theme={null}
SELECT toUInt16OrDefault('abc', CAST('0', 'UInt16'))
```
```response title=Response theme={null}
0
```
## toUInt16OrNull
Добавленный в: v1.1.0
Подобно [`toUInt16`](#toUInt16), эта функция преобразует входное значение в значение типа [`UInt16`](/ru/reference/data-types/int-uint), но в случае ошибки возвращает `NULL`.
Поддерживаемые аргументы:
* Строковые представления (U)Int8/16/32/128/256.
Неподдерживаемые аргументы (возвращают `NULL`):
* Строковые представления значений Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toUInt16OrNull('0xc0fe');`.
Если входное значение не может быть представлено в пределах [`UInt16`](/ru/reference/data-types/int-uint), происходит переполнение или выход за нижнюю границу диапазона результата.
Это не считается ошибкой.
См. также:
* [`toUInt16`](#toUInt16).
* [`toUInt16OrZero`](#toUInt16OrZero).
* [`toUInt16OrDefault`](#toUInt16OrDefault).
**Синтаксис**
```sql theme={null}
toUInt16OrNull(x)
```
**Аргументы**
* `x` — Строковое представление числа. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение типа `UInt16`; если преобразование не удалось, возвращает `NULL`. [`UInt16`](/ru/reference/data-types/int-uint) или [`NULL`](/ru/reference/syntax#null)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toUInt16OrNull('16'),
toUInt16OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt16OrNull('16'): 16
toUInt16OrNull('abc'): \N
```
## toUInt16OrZero
Добавленный в: v1.1.0
Как и [`toUInt16`](#toUInt16), эта функция преобразует входное значение в значение типа [`UInt16`](/ru/reference/data-types/int-uint), но при ошибке возвращает `0`.
Поддерживаемые аргументы:
* Строковые представления (U)Int8/16/32/128/256.
Неподдерживаемые аргументы (возвращается `0`):
* Строковые представления значений Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toUInt16OrZero('0xc0fe');`.
Если входное значение не может быть представлено в пределах [`UInt16`](/ru/reference/data-types/int-uint), происходит переполнение или выход за нижнюю границу диапазона результата.
Это не считается ошибкой.
См. также:
* [`toUInt16`](#toUInt16).
* [`toUInt16OrNull`](#toUInt16OrNull).
* [`toUInt16OrDefault`](#toUInt16OrDefault).
**Синтаксис**
```sql theme={null}
toUInt16OrZero(x)
```
**Аргументы**
* `x` — Строковое представление числа. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение типа UInt16, либо `0`, если преобразование не удалось. [`UInt16`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toUInt16OrZero('16'),
toUInt16OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
toUInt16OrZero('16'): 16
toUInt16OrZero('abc'): 0
```
## toUInt256
Добавленный в: v1.1.0
Преобразует входное значение в значение типа UInt256.
Генерирует исключение в случае ошибки.
Функция использует округление к нулю, то есть отбрасывает дробную часть числа.
Поддерживаемые аргументы:
* Значения или строковые представления типа (U)Int\*.
* Значения типа Float\*.
Неподдерживаемые аргументы:
* Строковые представления значений Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toUInt256('0xc0fe');`.
Если входное значение не может быть представлено в диапазоне UInt256, происходит переполнение или выход за нижнюю границу диапазона.
Это не считается ошибкой.
См. также:
* [`toUInt256OrZero`](#toUInt256OrZero).
* [`toUInt256OrNull`](#toUInt256OrNull).
* [`toUInt256OrDefault`](#toUInt256OrDefault).
**Синтаксис**
```sql theme={null}
toUInt256(expr)
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`Выражение`](/ru/reference/data-types/special-data-types/expression)
**Возвращаемое значение**
Возвращает 256-битное беззнаковое целое число. [`UInt256`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toUInt256(256),
toUInt256(256.256),
toUInt256('256')
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
toUInt256(256): 256
toUInt256(256.256): 256
toUInt256('256'): 256
```
## toUInt256OrDefault
Добавленный в: v21.11.0
Как и [`toUInt256`](#toUInt256), эта функция преобразует входное значение в тип [UInt256](/ru/reference/data-types/int-uint), но в случае ошибки возвращает значение по умолчанию.
Если значение `default` не передано, то в случае ошибки возвращается `0`.
**Синтаксис**
```sql theme={null}
toUInt256OrDefault(expr[, default])
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`String`](/ru/reference/data-types/string), [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)
* `default` — Необязательно. Значение по умолчанию, которое возвращается, если не удалось выполнить разбор. [`UInt256`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
При успешном выполнении возвращает значение типа UInt256, в противном случае — значение по умолчанию, если оно передано, или 0, если нет. [`UInt256`](/ru/reference/data-types/int-uint)
**Примеры**
**Успешное преобразование**
```sql title=Query theme={null}
SELECT toUInt256OrDefault('-256', CAST('0', 'UInt256'))
```
```response title=Response theme={null}
0
```
**Ошибка преобразования**
```sql title=Query theme={null}
SELECT toUInt256OrDefault('abc', CAST('0', 'UInt256'))
```
```response title=Response theme={null}
0
```
## toUInt256OrNull
Добавленный в: v20.8.0
Как и [`toUInt256`](#toUInt256), эта функция преобразует входное значение в значение типа [`UInt256`](/ru/reference/data-types/int-uint), но в случае ошибки возвращает `NULL`.
Поддерживаемые аргументы:
* Строковые представления значений (U)Int\*.
Неподдерживаемые аргументы (возвращают `NULL`):
* Строковые представления значений Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toUInt256OrNull('0xc0fe');`.
Если входное значение не может быть представлено в пределах [`UInt256`](/ru/reference/data-types/int-uint), происходит переполнение или выход за нижнюю границу диапазона.
Это не считается ошибкой.
См. также:
* [`toUInt256`](#toUInt256).
* [`toUInt256OrZero`](#toUInt256OrZero).
* [`toUInt256OrDefault`](#toUInt256OrDefault).
**Синтаксис**
```sql theme={null}
toUInt256OrNull(x)
```
**Аргументы**
* `x` — строковое представление числа. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение типа UInt256, а если преобразование не удалось — `NULL`. [`UInt256`](/ru/reference/data-types/int-uint) или [`NULL`](/ru/reference/syntax#null)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toUInt256OrNull('256'),
toUInt256OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
toUInt256OrNull('256'): 256
toUInt256OrNull('abc'): \N
```
## toUInt256OrZero
Добавленный в: v20.8.0
Как и [`toUInt256`](#toUInt256), эта функция преобразует входное значение в значение типа [`UInt256`](/ru/reference/data-types/int-uint), но в случае ошибки возвращает `0`.
Поддерживаемые аргументы:
* Строковые представления (U)Int\*.
Неподдерживаемые аргументы (возвращает `0`):
* Строковые представления значений Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toUInt256OrZero('0xc0fe');`.
Если входное значение не может быть представлено в диапазоне [`UInt256`](/ru/reference/data-types/int-uint), происходит переполнение или выход за нижнюю границу диапазона результата.
Это не считается ошибкой.
См. также:
* [`toUInt256`](#toUInt256).
* [`toUInt256OrNull`](#toUInt256OrNull).
* [`toUInt256OrDefault`](#toUInt256OrDefault).
**Синтаксис**
```sql theme={null}
toUInt256OrZero(x)
```
**Аргументы**
* `x` — Строковое представление числа. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение типа UInt256, а если преобразование не удалось — `0`. [`UInt256`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toUInt256OrZero('256'),
toUInt256OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
toUInt256OrZero('256'): 256
toUInt256OrZero('abc'): 0
```
## toUInt32
Добавленный в: v1.1.0
Преобразует входное значение в значение типа [`UInt32`](/ru/reference/data-types/int-uint).
В случае ошибки генерирует исключение.
Поддерживаемые аргументы:
* Значения или строковые представления типа (U)Int\*.
* Значения типа Float\*.
Неподдерживаемые аргументы:
* Строковые представления значений Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toUInt32('0xc0fe');`.
Если входное значение не может быть представлено в пределах [`UInt32`](/ru/reference/data-types/int-uint), происходит переполнение или выход за нижнюю границу диапазона.
Это не считается ошибкой.
Например: `SELECT toUInt32(4294967296) == 0;`
Функция использует [округление к нулю](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), то есть отбрасывает дробную часть числа.
См. также:
* [`toUInt32OrZero`](#toUInt32OrZero).
* [`toUInt32OrNull`](#toUInt32OrNull).
* [`toUInt32OrDefault`](#toUInt32OrDefault).
**Синтаксис**
```sql theme={null}
toUInt32(expr)
```
**Аргументы**
* `expr` — выражение, возвращающее число или строковое представление числа. [`Выражение`](/ru/reference/data-types/special-data-types/expression)
**Возвращаемое значение**
Возвращает 32-битное беззнаковое целое значение. [`UInt32`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toUInt32(32),
toUInt32(32.32),
toUInt32('32')
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
toUInt32(32): 32
toUInt32(32.32): 32
toUInt32('32'): 32
```
## toUInt32OrDefault
Добавленный в: v21.11.0
Как и [`toUInt32`](#toUInt32), эта функция преобразует входное значение в значение типа [UInt32](/ru/reference/data-types/int-uint), но в случае ошибки возвращает значение по умолчанию.
Если значение `default` не указано, то в случае ошибки возвращается `0`.
**Синтаксис**
```sql theme={null}
toUInt32OrDefault(expr[, default])
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`String`](/ru/reference/data-types/string) или [`(U)Int*`](/ru/reference/data-types/int-uint), или [`Float*`](/ru/reference/data-types/float)
* `default` — Необязательно. Значение по умолчанию, которое возвращается, если parsing завершается неуспешно. [`UInt32`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
При успешном выполнении возвращает значение типа UInt32; в противном случае возвращает значение по умолчанию, если оно было передано, или 0, если нет. [`UInt32`](/ru/reference/data-types/int-uint)
**Примеры**
**Успешное преобразование**
```sql title=Query theme={null}
SELECT toUInt32OrDefault('32', CAST('0', 'UInt32'))
```
```response title=Response theme={null}
32
```
**Ошибка преобразования**
```sql title=Query theme={null}
SELECT toUInt32OrDefault('abc', CAST('0', 'UInt32'))
```
```response title=Response theme={null}
0
```
## toUInt32OrNull
Добавленный в: v1.1.0
Как и [`toUInt32`](#toUInt32), эта функция преобразует входное значение в значение типа [`UInt32`](/ru/reference/data-types/int-uint), но в случае ошибки возвращает `NULL`.
Поддерживаемые аргументы:
* Строковые представления (U)Int8/16/32/128/256.
Неподдерживаемые аргументы (возвращается `NULL`):
* Строковые представления значений Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toUInt32OrNull('0xc0fe');`.
Если входное значение не может быть представлено в диапазоне [`UInt32`](/ru/reference/data-types/int-uint), происходит переполнение или выход за нижнюю границу диапазона результата.
Это не считается ошибкой.
См. также:
* [`toUInt32`](#toUInt32).
* [`toUInt32OrZero`](#toUInt32OrZero).
* [`toUInt32OrDefault`](#toUInt32OrDefault).
**Синтаксис**
```sql theme={null}
toUInt32OrNull(x)
```
**Аргументы**
* `x` — Строковое представление числа. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение типа `UInt32`; если преобразование не удалось, возвращается `NULL`. [`UInt32`](/ru/reference/data-types/int-uint) или [`NULL`](/ru/reference/syntax#null)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toUInt32OrNull('32'),
toUInt32OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt32OrNull('32'): 32
toUInt32OrNull('abc'): \N
```
## toUInt32OrZero
Добавленный в: v1.1.0
Как и [`toUInt32`](#toUInt32), эта функция преобразует входное значение в значение типа [`UInt32`](/ru/reference/data-types/int-uint), но в случае ошибки возвращает `0`.
Поддерживаемые аргументы:
* Строковые представления (U)Int8/16/32/128/256.
Неподдерживаемые аргументы (возвращают `0`):
* Строковые представления значений Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toUInt32OrZero('0xc0fe');`.
Если входное значение не может быть представлено в диапазоне [`UInt32`](/ru/reference/data-types/int-uint), происходит переполнение или выход за нижнюю границу диапазона результата.
Это не считается ошибкой.
См. также:
* [`toUInt32`](#toUInt32).
* [`toUInt32OrNull`](#toUInt32OrNull).
* [`toUInt32OrDefault`](#toUInt32OrDefault).
**Синтаксис**
```sql theme={null}
toUInt32OrZero(x)
```
**Аргументы**
* `x` — строковое представление числа. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение типа UInt32, а если преобразование не удалось — `0`. [`UInt32`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toUInt32OrZero('32'),
toUInt32OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
toUInt32OrZero('32'): 32
toUInt32OrZero('abc'): 0
```
## toUInt64
Добавленный в: v1.1.0
Преобразует входное значение в значение типа [`UInt64`](/ru/reference/data-types/int-uint).
При ошибке генерирует исключение.
Поддерживаемые аргументы:
* Значения или строковые представления типа (U)Int\*.
* Значения типа Float\*.
Неподдерживаемые типы:
* Строковые представления значений Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toUInt64('0xc0fe');`.
Если входное значение не может быть представлено в пределах [`UInt64`](/ru/reference/data-types/int-uint), происходит переполнение или выход за нижнюю границу диапазона.
Это не считается ошибкой.
Например: `SELECT toUInt64(18446744073709551616) == 0;`
Функция использует [округление к нулю](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), то есть отбрасывает дробные цифры у чисел.
См. также:
* [`toUInt64OrZero`](#toUInt64OrZero).
* [`toUInt64OrNull`](#toUInt64OrNull).
* [`toUInt64OrDefault`](#toUInt64OrDefault).
**Синтаксис**
```sql theme={null}
toUInt64(expr)
```
**Аргументы**
* `expr` — Выражение, возвращающее число или его строковое представление. [`Выражение`](/ru/reference/data-types/special-data-types/expression)
**Возвращаемое значение**
Возвращает 64-битное беззнаковое целое число. [`UInt64`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toUInt64(64),
toUInt64(64.64),
toUInt64('64')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt64(64): 64
toUInt64(64.64): 64
toUInt64('64'): 64
```
## toUInt64OrDefault
Добавленный в: v21.11.0
Подобно [`toUInt64`](#toUInt64), эта функция преобразует входное значение в значение типа [UInt64](/ru/reference/data-types/int-uint), но в случае ошибки возвращает значение по умолчанию.
Если значение `default` не передано, то в случае ошибки возвращается `0`.
**Синтаксис**
```sql theme={null}
toUInt64OrDefault(expr[, default])
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`String`](/ru/reference/data-types/string) или [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)
* `default` — Необязательно. Значение по умолчанию, которое возвращается, если преобразование не удалось. [`UInt64`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
Если преобразование выполнено успешно, возвращает значение типа UInt64; в противном случае — переданное значение по умолчанию или 0, если оно не указано. [`UInt64`](/ru/reference/data-types/int-uint)
**Примеры**
**Успешное преобразование**
```sql title=Query theme={null}
SELECT toUInt64OrDefault('64', CAST('0', 'UInt64'))
```
```response title=Response theme={null}
64
```
**Не удалось выполнить преобразование**
```sql title=Query theme={null}
SELECT toUInt64OrDefault('abc', CAST('0', 'UInt64'))
```
```response title=Response theme={null}
0
```
## toUInt64OrNull
Добавленный в: v1.1.0
Как и [`toUInt64`](#toUInt64), эта функция преобразует входное значение в значение типа [`UInt64`](/ru/reference/data-types/int-uint), но в случае ошибки возвращает `NULL`.
Поддерживаемые аргументы:
* Строковые представления (U)Int\*.
Неподдерживаемые аргументы (возвращают `NULL`):
* Строковые представления значений Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toUInt64OrNull('0xc0fe');`.
Если входное значение не может быть представлено в пределах диапазона [`UInt64`](/ru/reference/data-types/int-uint), происходит переполнение или выход за нижнюю границу диапазона результата.
Это не считается ошибкой.
См. также:
* [`toUInt64`](#toUInt64).
* [`toUInt64OrZero`](#toUInt64OrZero).
* [`toUInt64OrDefault`](#toUInt64OrDefault).
**Синтаксис**
```sql theme={null}
toUInt64OrNull(x)
```
**Аргументы**
* `x` — строковое представление числа. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение типа UInt64, а если преобразование не удалось — `NULL`. [`UInt64`](/ru/reference/data-types/int-uint) или [`NULL`](/ru/reference/syntax#null)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toUInt64OrNull('64'),
toUInt64OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
toUInt64OrNull('64'): 64
toUInt64OrNull('abc'): \N
```
## toUInt64OrZero
Добавленный в: v1.1.0
Как и [`toUInt64`](#toUInt64), эта функция преобразует входное значение в значение типа [`UInt64`](/ru/reference/data-types/int-uint), но при ошибке возвращает `0`.
Поддерживаемые аргументы:
* Строковые представления (U)Int\*.
Неподдерживаемые аргументы (возвращается `0`):
* Строковые представления значений Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных значений, например: `SELECT toUInt64OrZero('0xc0fe');`.
Если входное значение не может быть представлено в пределах [`UInt64`](/ru/reference/data-types/int-uint), происходит переполнение или выход за нижнюю границу диапазона результата.
Это не считается ошибкой.
См. также:
* [`toUInt64`](#toUInt64).
* [`toUInt64OrNull`](#toUInt64OrNull).
* [`toUInt64OrDefault`](#toUInt64OrDefault).
**Синтаксис**
```sql theme={null}
toUInt64OrZero(x)
```
**Аргументы**
* `x` — Строковое представление числа. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение типа UInt64; если преобразование не удалось — `0`. [`UInt64`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toUInt64OrZero('64'),
toUInt64OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
toUInt64OrZero('64'): 64
toUInt64OrZero('abc'): 0
```
## toUInt8
Добавленный в: v1.1.0
Преобразует входное значение в значение типа [`UInt8`](/ru/reference/data-types/int-uint).
Генерирует исключение в случае ошибки.
Поддерживаемые аргументы:
* Значения или строковые представления типа (U)Int\*.
* Значения типа Float\*.
Неподдерживаемые аргументы:
* Строковые представления значений типа Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toUInt8('0xc0fe');`.
Если входное значение не может быть представлено в диапазоне [UInt8](/ru/reference/data-types/int-uint), происходит переполнение или выход за нижнюю границу диапазона результата.
Это не считается ошибкой.
Например: `SELECT toUInt8(256) == 0;`.
Функция использует [округление к нулю](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), то есть отбрасывает дробную часть числа.
См. также:
* [`toUInt8OrZero`](#toUInt8OrZero).
* [`toUInt8OrNull`](#toUInt8OrNull).
* [`toUInt8OrDefault`](#toUInt8OrDefault).
**Синтаксис**
```sql theme={null}
toUInt8(expr)
```
**Аргументы**
* `expr` — выражение, возвращающее число или строковое представление числа. [`Выражение`](/ru/reference/data-types/special-data-types/expression)
**Возвращаемое значение**
Возвращает 8-битное беззнаковое целое число. [`UInt8`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toUInt8(8),
toUInt8(8.8),
toUInt8('8')
FORMAT Vertical
```
```response title=Response theme={null}
Строка 1:
──────
toUInt8(8): 8
toUInt8(8.8): 8
toUInt8('8'): 8
```
## toUInt8OrDefault
Добавленный в: v21.11.0
Как и [`toUInt8`](#toUInt8), эта функция преобразует входное значение в значение типа [UInt8](/ru/reference/data-types/int-uint), но в случае ошибки возвращает значение по умолчанию.
Если значение `default` не передано, в случае ошибки возвращается `0`.
**Синтаксис**
```sql theme={null}
toUInt8OrDefault(expr[, default])
```
**Аргументы**
* `expr` — Выражение, возвращающее число или строковое представление числа. [`String`](/ru/reference/data-types/string) или [`(U)Int*`](/ru/reference/data-types/int-uint), или [`Float*`](/ru/reference/data-types/float)
* `default` — Необязательно. Значение по умолчанию, которое возвращается, если разбор не удался. [`UInt8`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
Возвращает значение типа UInt8 в случае успеха; в противном случае возвращает значение по умолчанию, если оно передано, или 0, если нет. [`UInt8`](/ru/reference/data-types/int-uint)
**Примеры**
**Успешное преобразование**
```sql title=Query theme={null}
SELECT toUInt8OrDefault('8', CAST('0', 'UInt8'))
```
```response title=Response theme={null}
8
```
**Ошибка преобразования**
```sql title=Query theme={null}
SELECT toUInt8OrDefault('abc', CAST('0', 'UInt8'))
```
```response title=Response theme={null}
0
```
## toUInt8OrNull
Добавленный в: v1.1.0
Как и [`toUInt8`](#toUInt8), эта функция преобразует входное значение в значение типа [`UInt8`](/ru/reference/data-types/int-uint), но при ошибке возвращает `NULL`.
Поддерживаемые аргументы:
* Строковые представления (U)Int8/16/32/128/256.
Неподдерживаемые аргументы (возвращается `NULL`):
* Строковые представления обычных значений типа Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toUInt8OrNull('0xc0fe');`.
Если входное значение не может быть представлено в диапазоне [`UInt8`](/ru/reference/data-types/int-uint), происходит переполнение или выход за нижнюю границу диапазона результата.
Это не считается ошибкой.
См. также:
* [`toUInt8`](#toUInt8).
* [`toUInt8OrZero`](#toUInt8OrZero).
* [`toUInt8OrDefault`](#toUInt8OrDefault).
**Синтаксис**
```sql theme={null}
toUInt8OrNull(x)
```
**Аргументы**
* `x` — строковое представление числа. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение типа UInt8; если преобразование не удалось, возвращается `NULL`. [`UInt8`](/ru/reference/data-types/int-uint) или [`NULL`](/ru/reference/syntax#null)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toUInt8OrNull('42'),
toUInt8OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt8OrNull('42'): 42
toUInt8OrNull('abc'): \N
```
## toUInt8OrZero
Добавленный в: v1.1.0
Как и [`toUInt8`](#toUInt8), эта функция преобразует входное значение в значение типа [`UInt8`](/ru/reference/data-types/int-uint), но в случае ошибки возвращает `0`.
Поддерживаемые аргументы:
* Строковые представления (U)Int8/16/32/128/256.
Неподдерживаемые аргументы (возвращается `0`):
* Строковые представления обычных значений типа Float\*, включая `NaN` и `Inf`.
* Строковые представления двоичных и шестнадцатеричных значений, например `SELECT toUInt8OrZero('0xc0fe');`.
Если входное значение не может быть представлено в пределах [`UInt8`](/ru/reference/data-types/int-uint), происходит переполнение или выход за нижнюю границу диапазона результата.
Это не считается ошибкой.
См. также:
* [`toUInt8`](#toUInt8).
* [`toUInt8OrNull`](#toUInt8OrNull).
* [`toUInt8OrDefault`](#toUInt8OrDefault).
**Синтаксис**
```sql theme={null}
toUInt8OrZero(x)
```
**Аргументы**
* `x` — строковое представление числа. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение типа UInt8; если преобразование не удалось, возвращает `0`. [`UInt8`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toUInt8OrZero('-8'),
toUInt8OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toUInt8OrZero('-8'): 0
toUInt8OrZero('abc'): 0
```
## toUUID
Добавленный в: v1.1.0
Преобразует значение типа String в значение типа UUID.
**Синтаксис**
```sql theme={null}
toUUID(string)
```
**Аргументы**
* `string` — UUID в строковом формате. [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring)
**Возвращаемое значение**
Возвращает UUID, полученный из строкового представления UUID. [`UUID`](/ru/reference/data-types/uuid)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT toUUID('61f0c404-5cb3-11e7-907b-a6006ad3dba0') AS uuid
```
```response title=Response theme={null}
┌─────────────────────────────────uuid─┐
│ 61f0c404-5cb3-11e7-907b-a6006ad3dba0 │
└──────────────────────────────────────┘
```
## toUUIDOrZero
Добавленный в: v20.12.0
Преобразует входное значение в значение типа [UUID](/ru/reference/data-types/uuid), но в случае ошибки возвращает нулевой UUID.
Как [`toUUID`](/ru/reference/functions/regular-functions/type-conversion-functions#toUUID), но при ошибках преобразования вместо генерации исключения возвращает нулевой UUID (`00000000-0000-0000-0000-000000000000`).
Поддерживаемые аргументы:
* Строковые представления UUID в стандартном формате (8-4-4-4-12 шестнадцатеричных цифр).
* Строковые представления UUID без дефисов (32 шестнадцатеричные цифры).
Неподдерживаемые аргументы (возвращается нулевой UUID):
* Недопустимые строковые форматы.
* Типы, отличные от строковых.
**Синтаксис**
```sql theme={null}
toUUIDOrZero(x)
```
**Аргументы**
* `x` — строковое представление UUID. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение UUID в случае успеха, в противном случае — нулевой UUID (`00000000-0000-0000-0000-000000000000`). [`UUID`](/ru/reference/data-types/uuid)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT
toUUIDOrZero('550e8400-e29b-41d4-a716-446655440000') AS valid_uuid,
toUUIDOrZero('invalid-uuid') AS invalid_uuid
```
```response title=Response theme={null}
┌─valid_uuid───────────────────────────┬─invalid_uuid─────────────────────────┐
│ 550e8400-e29b-41d4-a716-446655440000 │ 00000000-0000-0000-0000-000000000000 │
└──────────────────────────────────────┴──────────────────────────────────────┘
```
## toUnixTimestamp64Micro
Добавленный в: v20.5.0
Преобразует [`DateTime64`](/ru/reference/data-types/datetime64) в значение [`Int64`](/ru/reference/data-types/int-uint) с фиксированной точностью в микросекундах.
Входное значение соответствующим образом масштабируется в большую или меньшую сторону в зависимости от его точности.
Выходное значение задаётся относительно UTC, а не относительно часового пояса входного значения.
**Синтаксис**
```sql theme={null}
toUnixTimestamp64Micro(value)
```
**Аргументы**
* `value` — значение типа DateTime64 с любой точностью. [`DateTime64`](/ru/reference/data-types/datetime64)
**Возвращаемое значение**
Возвращает Unix-временную метку в микросекундах. [`Int64`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
WITH toDateTime64('2025-02-13 23:31:31.011123', 6, 'UTC') AS dt64
SELECT toUnixTimestamp64Micro(dt64);
```
```response title=Response theme={null}
┌─toUnixTimestamp64Micro(dt64)─┐
│ 1739489491011123 │
└────────────────────────────────┘
```
## toUnixTimestamp64Milli
Добавленный в: v20.5.0
Преобразует [`DateTime64`](/ru/reference/data-types/datetime64) в значение [`Int64`](/ru/reference/data-types/int-uint) с фиксированной точностью в миллисекундах.
Входное значение соответствующим образом масштабируется в зависимости от его точности.
Выходное значение задается относительно UTC, а не часового пояса входного значения.
**Синтаксис**
```sql theme={null}
toUnixTimestamp64Milli(value)
```
**Аргументы**
* `value` — значение типа DateTime64 с любой точностью. [`DateTime64`](/ru/reference/data-types/datetime64)
**Возвращаемое значение**
Возвращает Unix-временную метку в миллисекундах. [`Int64`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
WITH toDateTime64('2025-02-13 23:31:31.011', 3, 'UTC') AS dt64
SELECT toUnixTimestamp64Milli(dt64);
```
```response title=Response theme={null}
┌─toUnixTimestamp64Milli(dt64)─┐
│ 1739489491011 │
└──────────────────────────────┘
```
## toUnixTimestamp64Nano
Добавленный в: v20.5.0
Преобразует [`DateTime64`](/ru/reference/data-types/datetime64) в значение [`Int64`](/ru/reference/functions/regular-functions/type-conversion-functions#toInt64) с фиксированной точностью до наносекунд.
Входное значение соответствующим образом масштабируется вверх или вниз в зависимости от его точности.
Выходное значение рассчитывается относительно UTC, а не часового пояса входного значения.
**Синтаксис**
```sql theme={null}
toUnixTimestamp64Nano(value)
```
**Аргументы**
* `value` — значение типа DateTime64 с любой точностью. [`DateTime64`](/ru/reference/data-types/datetime64)
**Возвращаемое значение**
Возвращает Unix-временную метку в наносекундах. [`Int64`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
WITH toDateTime64('2025-02-13 23:31:31.011123456', 9, 'UTC') AS dt64
SELECT toUnixTimestamp64Nano(dt64);
```
```response title=Response theme={null}
┌─toUnixTimestamp64Nano(dt64)────┐
│ 1739489491011123456 │
└────────────────────────────────┘
```
## toUnixTimestamp64Second
Добавленный в: v24.12.0
Преобразует [`DateTime64`](/ru/reference/data-types/datetime64) в значение [`Int64`](/ru/reference/data-types/int-uint) с фиксированной точностью до секунд.
Входное значение соответствующим образом масштабируется в большую или меньшую сторону в зависимости от его точности.
Выходное значение задаётся относительно UTC, а не часового пояса входного значения.
**Синтаксис**
```sql theme={null}
toUnixTimestamp64Second(value)
```
**Аргументы**
* `value` — значение типа DateTime64 с любой точностью. [`DateTime64`](/ru/reference/data-types/datetime64)
**Возвращаемое значение**
Возвращает Unix-временную метку в секундах. [`Int64`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
WITH toDateTime64('2025-02-13 23:31:31.011', 3, 'UTC') AS dt64
SELECT toUnixTimestamp64Second(dt64);
```
```response title=Response theme={null}
┌─toUnixTimestamp64Second(dt64)─┐
│ 1739489491 │
└───────────────────────────────┘
```