│
└──────────────────────────────────────────────┘
```
## formatRowNoNewline
Introduzido em: v20.7.0
Igual a [`formatRow`](#formatRow), mas remove o caractere de nova linha de cada linha.
Converte expressões arbitrárias em uma string usando o formato especificado, mas remove quaisquer caracteres de nova linha no final do resultado.
**Sintaxe**
```sql theme={null}
formatRowNoNewline(format, x, y, ...)
```
**Argumentos**
* `format` — Formato de texto. Por exemplo, CSV, TSV. [`String`](/pt-BR/reference/data-types/string)
* `x, y, ...` — Expressões. [`Any`](/pt-BR/reference/data-types)
**Valor retornado**
Retorna uma string formatada sem quebras de linha. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Uso básico**
```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
Introduzido em: v20.5.0
Converte um timestamp Unix em microssegundos em um valor `DateTime64` com precisão de microssegundos.
O valor de entrada é tratado como um timestamp Unix com precisão de microssegundos (número de microssegundos desde 1970-01-01 00:00:00 UTC).
**Sintaxe**
```sql theme={null}
fromUnixTimestamp64Micro(value[, timezone])
```
**Argumentos**
* `value` — timestamp Unix em microssegundos. [`Int64`](/pt-BR/reference/data-types/int-uint)
* `timezone` — Opcional. Fuso horário do valor retornado. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor `DateTime64` com precisão de microssegundos. [`DateTime64(6)`](/pt-BR/reference/data-types/datetime64)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT fromUnixTimestamp64Micro(1640995200123456)
```
```response title=Response theme={null}
┌─fromUnixTimestamp64Micro(1640995200123456)─┐
│ 2022-01-01 00:00:00.123456 │
└────────────────────────────────────────────┘
```
## fromUnixTimestamp64Milli
Introduzido em: v20.5.0
Converte um timestamp Unix em milissegundos em um valor `DateTime64` com precisão de milissegundos.
O valor de entrada é tratado como um timestamp Unix com precisão de milissegundos (número de milissegundos desde 1970-01-01 00:00:00 UTC).
**Sintaxe**
```sql theme={null}
fromUnixTimestamp64Milli(value[, timezone])
```
**Argumentos**
* `value` — timestamp Unix em milissegundos. [`Int64`](/pt-BR/reference/data-types/int-uint)
* `timezone` — Opcional. Fuso horário do valor retornado. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Um valor `DateTime64` com precisão de milissegundos. [`DateTime64(3)`](/pt-BR/reference/data-types/datetime64)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT fromUnixTimestamp64Milli(1640995200123)
```
```response title=Response theme={null}
┌─fromUnixTimestamp64Milli(1640995200123)─┐
│ 2022-01-01 00:00:00.123 │
└─────────────────────────────────────────┘
```
## fromUnixTimestamp64Nano
Introduzido em: v20.5.0
Converte um timestamp Unix em nanossegundos em um valor [`DateTime64`](/pt-BR/reference/data-types/datetime64) com precisão de nanossegundos.
O valor de entrada é tratado como um timestamp Unix com precisão de nanossegundos (número de nanossegundos desde 1970-01-01 00:00:00 UTC).
Observe que o valor de entrada é tratado como um timestamp em UTC, e não com o fuso horário do valor de entrada.
**Sintaxe**
```sql theme={null}
fromUnixTimestamp64Nano(value[, timezone])
```
**Argumentos**
* `value` — Timestamp Unix em nanossegundos. [`Int64`](/pt-BR/reference/data-types/int-uint)
* `timezone` — Opcional. Fuso horário do valor retornado. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor `DateTime64` com precisão de nanossegundos. [`DateTime64(9)`](/pt-BR/reference/data-types/datetime64)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT fromUnixTimestamp64Nano(1640995200123456789)
```
```response title=Response theme={null}
┌─fromUnixTimestamp64Nano(1640995200123456789)─┐
│ 2022-01-01 00:00:00.123456789 │
└──────────────────────────────────────────────┘
```
## fromUnixTimestamp64Second
Introduzido em: v24.12.0
Converte um timestamp Unix em segundos em um valor `DateTime64` com precisão de segundo.
O valor de entrada é tratado como um timestamp Unix com precisão de segundo (número de segundos desde 1970-01-01 00:00:00 UTC).
**Sintaxe**
```sql theme={null}
fromUnixTimestamp64Second(value[, timezone])
```
**Argumentos**
* `value` — timestamp Unix em segundos. [`Int64`](/pt-BR/reference/data-types/int-uint)
* `timezone` — Opcional. Fuso horário do valor retornado. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor `DateTime64` com precisão de segundos. [`DateTime64(0)`](/pt-BR/reference/data-types/datetime64)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT fromUnixTimestamp64Second(1640995200)
```
```response title=Response theme={null}
┌─fromUnixTimestamp64Second(1640995200)─┐
│ 2022-01-01 00:00:00 │
└───────────────────────────────────────┘
```
## parseDateTime
Introduzido em: v23.3.0
Interpreta uma string de data e hora de acordo com uma String de formato de data do MySQL.
Esta função é o inverso de [`formatDateTime`](/pt-BR/reference/functions/regular-functions/date-time-functions).
Ela interpreta um argumento String usando uma String de formato. Retorna um valor do tipo DateTime.
**Sintaxe**
```sql theme={null}
parseDateTime(time_string, format[, timezone])
```
**Aliases**: `TO_UNIXTIME`
**Argumentos**
* `time_string` — `String` a ser convertida para DateTime. [`String`](/pt-BR/reference/data-types/string)
* `format` — String de formato que especifica como fazer o parse de `time_string`. [`String`](/pt-BR/reference/data-types/string)
* `timezone` — Opcional. Fuso horário. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um DateTime obtido a partir da string de entrada, de acordo com a string de formato no estilo MySQL. [`DateTime`](/pt-BR/reference/data-types/datetime)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v20.9.0
Converte uma representação textual de data e hora para o tipo de dado [`DateTime`](/pt-BR/reference/data-types/datetime).
A função analisa [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), os formatos de data e hora do ClickHouse e alguns outros formatos.
**Sintaxe**
```sql theme={null}
parseDateTime32BestEffort(time_string[, time_zone])
```
**Argumentos**
* `time_string` — String contendo uma data e hora a ser convertida. [`String`](/pt-BR/reference/data-types/string)
* `time_zone` — Opcional. Fuso horário segundo o qual `time_string` é interpretado [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna `time_string` como um `DateTime`. [`DateTime`](/pt-BR/reference/data-types/datetime)
**Exemplos**
**Exemplo de uso**
```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 │
└───────────────────────────┘
```
**Com fuso horário**
```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 timestamp**
```sql title=Query theme={null}
SELECT parseDateTime32BestEffort('1284101485')
AS parseDateTime32BestEffort
```
```response title=Response theme={null}
┌─parseDateTime32BestEffort─┐
│ 2015-07-07 12:04:41 │
└───────────────────────────┘
```
## parseDateTime32BestEffortOrNull
Introduzido em: v20.9.0
Igual a [`parseDateTime32BestEffort`](#parseDateTime32BestEffort), exceto que retorna `NULL` quando encontra um formato de data que não pode ser processado.
**Sintaxe**
```sql theme={null}
parseDateTime32BestEffortOrNull(time_string[, time_zone])
```
**Argumentos**
* `time_string` — `String` que contém uma data e hora a serem convertidas. [`String`](/pt-BR/reference/data-types/string)
* `time_zone` — Opcional. Fuso horário de acordo com o qual `time_string` é interpretado. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um objeto `DateTime` interpretado a partir da string, ou `NULL` se a interpretação falhar. [`DateTime`](/pt-BR/reference/data-types/datetime)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v20.9.0
Igual a [`parseDateTime32BestEffort`](#parseDateTime32BestEffort), exceto que retorna uma data zero ou data e hora zero quando encontra um formato de data que não pode ser processado.
**Sintaxe**
```sql theme={null}
parseDateTime32BestEffortOrZero(time_string[, time_zone])
```
**Argumentos**
* `time_string` — `String` que contém uma data e hora para converter. [`String`](/pt-BR/reference/data-types/string)
* `time_zone` — Opcional. Fuso horário com base no qual `time_string` é interpretado. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um objeto `DateTime` interpretado da string ou a data zero (`1970-01-01 00:00:00`) se a interpretação falhar. [`DateTime`](/pt-BR/reference/data-types/datetime)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v24.11.0
Interpreta uma string de data e hora com precisão de subsegundos de acordo com uma string de formato de data do MySQL.
Esta função é o inverso de [`formatDateTime`](/pt-BR/reference/functions/regular-functions/date-time-functions) para DateTime64.
Ela interpreta um argumento String usando uma string de formato. Retorna um tipo DateTime64, que pode representar datas de 1900 a 2299 com precisão de subsegundos.
**Sintaxe**
```sql theme={null}
parseDateTime64(time_string, format[, timezone])
```
**Argumentos**
* `time_string` — String a ser convertida em DateTime64. [`String`](/pt-BR/reference/data-types/string)
* `format` — String de formato que especifica como interpretar time\_string. [`String`](/pt-BR/reference/data-types/string)
* `timezone` — Opcional. Fuso horário. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um DateTime64 convertido da string de entrada de acordo com a string de formato no estilo MySQL. [`DateTime64`](/pt-BR/reference/data-types/datetime64)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v20.1.0
Igual à função [`parseDateTimeBestEffort`](#parseDateTimeBestEffort), mas também processa milissegundos e microssegundos e retorna o tipo de dado [`DateTime64`](/pt-BR/reference/data-types/datetime64).
**Sintaxe**
```sql theme={null}
parseDateTime64BestEffort(time_string[, precision[, time_zone]])
```
**Argumentos**
* `time_string` — `String` que contém uma data ou data com hora a ser convertida. [`String`](/pt-BR/reference/data-types/string)
* `precision` — Opcional. Precisão requerida. `3` para milissegundos, `6` para microssegundos. Padrão: `3`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
* `time_zone` — Opcional. Fuso horário. A função interpreta `time_string` de acordo com o fuso horário. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna `time_string` convertido para o tipo de dado [`DateTime64`](/pt-BR/reference/data-types/datetime64). [`DateTime64`](/pt-BR/reference/data-types/datetime64)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v20.1.0
Igual a [`parseDateTime64BestEffort`](#parseDateTime64BestEffort), exceto que retorna `NULL` quando encontra um formato de data que não pode ser processado.
**Sintaxe**
```sql theme={null}
parseDateTime64BestEffortOrNull(time_string[, precision[, time_zone]])
```
**Argumentos**
* `time_string` — `String` contendo uma data ou uma data e hora a ser convertida. [`String`](/pt-BR/reference/data-types/string)
* `precision` — Opcional. Precisão necessária. `3` para milissegundos, `6` para microssegundos. Padrão: `3`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
* `time_zone` — Opcional. Fuso horário. A função interpreta `time_string` de acordo com o fuso horário. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna `time_string` convertido para [`DateTime64`](/pt-BR/reference/data-types/datetime64), ou `NULL` se a entrada não puder ser interpretada. [`DateTime64`](/pt-BR/reference/data-types/datetime64) ou [`NULL`](/pt-BR/reference/syntax#null)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v20.1.0
Igual a [`parseDateTime64BestEffort`](#parseDateTime64BestEffort), exceto pelo fato de retornar data zero ou data e hora zero quando encontra um formato de data que não pode ser processado.
**Sintaxe**
```sql theme={null}
parseDateTime64BestEffortOrZero(time_string[, precision[, time_zone]])
```
**Argumentos**
* `time_string` — `String` contendo uma data ou data e hora para converter. [`String`](/pt-BR/reference/data-types/string)
* `precision` — Opcional. Precisão necessária. `3` para milissegundos, `6` para microssegundos. Padrão: `3`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
* `time_zone` — Opcional. Fuso horário. A função interpreta `time_string` de acordo com o fuso horário. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna `time_string` convertido para [`DateTime64`](/pt-BR/reference/data-types/datetime64), ou data/data e hora zero (`1970-01-01 00:00:00.000`) se a entrada não puder ser interpretada. [`DateTime64`](/pt-BR/reference/data-types/datetime64)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v22.8.0
Igual a [`parseDateTime64BestEffort`](#parseDateTime64BestEffort), exceto pelo fato de que esta função prioriza o formato de data dos EUA (`MM/DD/YYYY` etc.) em caso de ambiguidade.
**Sintaxe**
```sql theme={null}
parseDateTime64BestEffortUS(time_string [, precision [, time_zone]])
```
**Argumentos**
* `time_string` — String contendo uma data ou data e hora para converter. [`String`](/pt-BR/reference/data-types/string)
* `precision` — Opcional. Precisão necessária. `3` para milissegundos, `6` para microssegundos. Padrão: `3`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
* `time_zone` — Opcional. Fuso horário. A função interpreta `time_string` de acordo com o fuso horário. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna `time_string` convertido para [`DateTime64`](/pt-BR/reference/data-types/datetime64), usando a preferência de formato de data dos EUA em casos ambíguos. [`DateTime64`](/pt-BR/reference/data-types/datetime64)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v22.8.0
Igual a [`parseDateTime64BestEffort`](#parseDateTime64BestEffort), exceto que esta função dá preferência ao formato de data dos EUA (`MM/DD/YYYY` etc.) em caso de ambiguidade e retorna `NULL` ao encontrar um formato de data que não pode ser processado.
**Sintaxe**
```sql theme={null}
parseDateTime64BestEffortUSOrNull(time_string[, precision[, time_zone]])
```
**Argumentos**
* `time_string` — `String` que contém uma data ou uma data com hora a ser convertida. [`String`](/pt-BR/reference/data-types/string)
* `precision` — Opcional. Precisão desejada. `3` para milissegundos, `6` para microssegundos. Padrão: `3`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
* `time_zone` — Opcional. Fuso horário. A função interpreta `time_string` de acordo com o fuso horário. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna `time_string` convertido para [`DateTime64`](/pt-BR/reference/data-types/datetime64) seguindo a preferência de formato dos EUA, ou `NULL` se a entrada não puder ser interpretada. [`DateTime64`](/pt-BR/reference/data-types/datetime64) ou [`NULL`](/pt-BR/reference/syntax#null)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v22.8.0
Igual a [`parseDateTime64BestEffort`](#parseDateTime64BestEffort), exceto que esta função prioriza o formato de data dos EUA (`MM/DD/YYYY` etc.) em caso de ambiguidade e retorna data zero ou data e hora zero quando encontra um formato de data que não pode ser processado.
**Sintaxe**
```sql theme={null}
parseDateTime64BestEffortUSOrZero(time_string [, precision [, time_zone]])
```
**Argumentos**
* `time_string` — `String` que contém uma data ou uma data com hora para conversão. [`String`](/pt-BR/reference/data-types/string)
* `precision` — Opcional. Precisão necessária. `3` para milissegundos, `6` para microssegundos. Padrão: `3`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
* `time_zone` — Opcional. Fuso horário. A função analisa `time_string` de acordo com o fuso horário. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna `time_string` convertido para [`DateTime64`](/pt-BR/reference/data-types/datetime64) usando a preferência de formato dos EUA, ou data/data e hora zero (`1970-01-01 00:00:00.000`) se a entrada não puder ser analisada. [`DateTime64`](/pt-BR/reference/data-types/datetime64)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v24.10.0
Converte uma string de data e hora com precisão de frações de segundo de acordo com uma string de formato de data Joda.
Esta função é o inverso de [`formatDateTimeInJodaSyntax`](/pt-BR/reference/functions/regular-functions/date-time-functions#formatDateTimeInJodaSyntax) para DateTime64.
Ela converte um argumento String usando uma String de formato no estilo Joda. Retorna um tipo DateTime64, que pode representar datas de 1900 a 2299 com precisão de frações de segundo.
Consulte a [documentação do Joda Time](https://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html) para os padrões de formato.
**Sintaxe**
```sql theme={null}
parseDateTime64InJodaSyntax(time_string, format[, timezone])
```
**Argumentos**
* `time_string` — String a ser convertida em DateTime64. [`String`](/pt-BR/reference/data-types/string)
* `format` — String de formato na sintaxe Joda que especifica como interpretar time\_string. [`String`](/pt-BR/reference/data-types/string)
* `timezone` — Opcional. Fuso horário. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um DateTime64 obtido da string de entrada de acordo com a string de formato no estilo Joda. [`DateTime64`](/pt-BR/reference/data-types/datetime64)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v24.10.0
Igual a [`parseDateTime64InJodaSyntax`](#parseDateTime64InJodaSyntax), mas retorna `NULL` quando encontra um formato de data não analisável.
**Sintaxe**
```sql theme={null}
parseDateTime64InJodaSyntaxOrNull(time_string, format[, timezone])
```
**Argumentos**
* `time_string` — String a ser analisada como DateTime64. [`String`](/pt-BR/reference/data-types/string)
* `format` — String de formato na sintaxe Joda que especifica como analisar `time_string`. [`String`](/pt-BR/reference/data-types/string)
* `timezone` — Opcional. Fuso horário. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o DateTime64 analisado a partir da string de entrada, ou NULL se a análise falhar. [`Nullable(DateTime64)`](/pt-BR/reference/data-types/nullable)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v24.10.0
Igual a [`parseDateTime64InJodaSyntax`](#parseDateTime64InJodaSyntax), mas retorna a data zero quando encontra um formato de data que não pode ser analisado.
**Sintaxe**
```sql theme={null}
parseDateTime64InJodaSyntaxOrZero(time_string, format[, timezone])
```
**Argumentos**
* `time_string` — `String` a ser convertida em DateTime64. [`String`](/pt-BR/reference/data-types/string)
* `format` — String de formato na sintaxe Joda que especifica como interpretar time\_string. [`String`](/pt-BR/reference/data-types/string)
* `timezone` — Opcional. Fuso horário. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um DateTime64 interpretado da string de entrada, ou um DateTime64 zero se a interpretação falhar. [`DateTime64`](/pt-BR/reference/data-types/datetime64)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v24.11.0
Assim como [`parseDateTime64`](#parseDateTime64), mas retorna `NULL` quando encontra um formato de data que não pode ser interpretado.
**Sintaxe**
```sql theme={null}
parseDateTime64OrNull(time_string, format[, timezone])
```
**Argumentos**
* `time_string` — String a ser convertida em DateTime64. [`String`](/pt-BR/reference/data-types/string)
* `format` — String de formato que especifica como converter time\_string. [`String`](/pt-BR/reference/data-types/string)
* `timezone` — Opcional. Fuso horário. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o DateTime64 convertido da string de entrada, ou NULL se a conversão falhar. [`Nullable(DateTime64)`](/pt-BR/reference/data-types/nullable)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v24.11.0
Igual a [`parseDateTime64`](#parseDateTime64), mas retorna uma data zero quando encontra um formato de data que não pode ser analisado.
**Sintaxe**
```sql theme={null}
parseDateTime64OrZero(time_string, format[, timezone])
```
**Argumentos**
* `time_string` — String a ser convertida em DateTime64. [`String`](/pt-BR/reference/data-types/string)
* `format` — String de formato que especifica como interpretar time\_string. [`String`](/pt-BR/reference/data-types/string)
* `timezone` — Opcional. Fuso horário. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o DateTime64 interpretado da string de entrada ou DateTime64 zero se a conversão falhar. [`DateTime64`](/pt-BR/reference/data-types/datetime64)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Converte uma data e hora em representação String para o tipo de dado DateTime.
A função interpreta os formatos [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) Date and Time Specification, os formatos de data e hora do ClickHouse e alguns outros formatos.
Formatos não padrão suportados:
* Uma string contendo um timestamp Unix de 9..10 dígitos.
* Uma string com um componente de data e hora: `YYYYMMDDhhmmss`, `DD/MM/YYYY hh:mm:ss`, `DD-MM-YY hh:mm`, `YYYY-MM-DD hh:mm:ss`, etc.
* Uma string com uma data, mas sem componente de hora: `YYYY`, `YYYYMM`, `YYYY*MM`, `DD/MM/YYYY`, `DD-MM-YY` etc.
* Uma string com dia e hora: `DD`, `DD hh`, `DD hh:mm`. Nesse caso, `MM` é substituído por `01`.
* Uma string que inclui a data e hora junto com informações de deslocamento de fuso horário: `YYYY-MM-DD hh:mm:ss ±h:mm`, etc.
* Um timestamp de syslog: `Mmm dd hh:mm:ss`. Por exemplo, `Jun 9 14:20:32`.
Para todos os formatos com separador, a função interpreta nomes de meses expressos pelo nome completo ou pelas três primeiras letras do nome do mês.
Se o ano não for especificado, considera-se que ele é igual ao ano atual.
**Sintaxe**
```sql theme={null}
parseDateTimeBestEffort(time_string[, time_zone])
```
**Argumentos**
* `time_string` — `String` que contém uma data e hora a serem convertidas. [`String`](/pt-BR/reference/data-types/string)
* `time_zone` — Opcional. Fuso horário segundo o qual `time_string` é analisado. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna `time_string` como um `DateTime`. [`DateTime`](/pt-BR/reference/data-types/datetime)
**Exemplos**
**Exemplo de uso**
```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 │
└─────────────────────────┘
```
**Com fuso horário**
```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 │
└─────────────────────────┘
```
**timestamp Unix**
```sql title=Query theme={null}
SELECT parseDateTimeBestEffort('1735689600') AS parseDateTimeBestEffort
```
```response title=Response theme={null}
┌─parseDateTimeBestEffort─┐
│ 2025-01-01 00:00:00 │
└─────────────────────────┘
```
## parseDateTimeBestEffortOrNull
Introduzido em: v1.1.0
Igual a [`parseDateTimeBestEffort`](#parseDateTimeBestEffort), exceto que retorna `NULL` quando encontra um formato de data que não pode ser processado.
A função analisa [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), os formatos de data e hora do ClickHouse e alguns outros formatos.
Formatos não padrão compatíveis:
* Uma string contendo um timestamp Unix de 9..10 dígitos.
* Uma string com componentes de data e hora: `YYYYMMDDhhmmss`, `DD/MM/YYYY hh:mm:ss`, `DD-MM-YY hh:mm`, `YYYY-MM-DD hh:mm:ss` etc.
* Uma string com uma data, mas sem componente de hora: `YYYY`, `YYYYMM`, `YYYY*MM`, `DD/MM/YYYY`, `DD-MM-YY` etc.
* Uma string com dia e hora: `DD`, `DD hh`, `DD hh:mm`. Nesse caso, `MM` é substituído por `01`.
* Uma string que inclui data e hora junto com informações de deslocamento de fuso horário: `YYYY-MM-DD hh:mm:ss ±h:mm` etc.
* Um timestamp de syslog: `Mmm dd hh:mm:ss`. Por exemplo, `Jun 9 14:20:32`.
Em todos os formatos com separador, a função analisa nomes de meses escritos por extenso ou pelas três primeiras letras do nome do mês.
Se o ano não for especificado, ele será considerado igual ao ano atual.
**Sintaxe**
```sql theme={null}
parseDateTimeBestEffortOrNull(time_string[, time_zone])
```
**Argumentos**
* `time_string` — `String` que contém uma data e hora a ser convertida. [`String`](/pt-BR/reference/data-types/string)
* `time_zone` — Opcional. Fuso horário segundo o qual `time_string` é analisado. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna `time_string` como `DateTime`, ou `NULL` se a entrada não puder ser analisada. [`DateTime`](/pt-BR/reference/data-types/datetime) ou [`NULL`](/pt-BR/reference/syntax#null)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Igual a [`parseDateTimeBestEffort`](#parseDateTimeBestEffort), exceto pelo fato de retornar uma data zero ou data e hora zero quando encontra um formato de data que não pode ser processado.
A função analisa [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), os formatos de data e hora do ClickHouse e alguns outros formatos.
Formatos não padrão compatíveis:
* Uma string contendo um timestamp Unix de 9 a 10 dígitos.
* Uma string com um componente de data e hora: `YYYYMMDDhhmmss`, `DD/MM/YYYY hh:mm:ss`, `DD-MM-YY hh:mm`, `YYYY-MM-DD hh:mm:ss` etc.
* Uma string com uma data, mas sem componente de hora: `YYYY`, `YYYYMM`, `YYYY*MM`, `DD/MM/YYYY`, `DD-MM-YY` etc.
* Uma string com um dia e hora: `DD`, `DD hh`, `DD hh:mm`. Nesse caso, `MM` é substituído por `01`.
* Uma string que inclui a data e a hora junto com informações de deslocamento de fuso horário: `YYYY-MM-DD hh:mm:ss ±h:mm` etc.
* Um timestamp de syslog: `Mmm dd hh:mm:ss`. Por exemplo, `Jun 9 14:20:32`.
Para todos os formatos com separador, a função analisa nomes de meses expressos pelo nome completo ou pelas três primeiras letras do nome do mês.
Se o ano não for especificado, será considerado o ano atual.
**Sintaxe**
```sql theme={null}
parseDateTimeBestEffortOrZero(time_string[, time_zone])
```
**Argumentos**
* `time_string` — `String` contendo uma data e hora a serem convertidas. [`String`](/pt-BR/reference/data-types/string)
* `time_zone` — Opcional. Fuso horário segundo o qual `time_string` é analisado. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna `time_string` como um `DateTime` ou data/DateTime zero (`1970-01-01` ou `1970-01-01 00:00:00`) se a entrada não puder ser analisada. [`DateTime`](/pt-BR/reference/data-types/datetime)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Esta função se comporta como [`parseDateTimeBestEffort`](#parseDateTimeBestEffort) para formatos de data ISO, por exemplo, `YYYY-MM-DD hh:mm:ss`, e outros formatos de data em que os componentes de mês e dia podem ser extraídos sem ambiguidade, por exemplo, `YYYYMMDDhhmmss`, `YYYY-MM`, `DD hh` ou `YYYY-MM-DD hh:mm:ss ±h:mm`.
Se os componentes de mês e dia não puderem ser extraídos sem ambiguidade, por exemplo, `MM/DD/YYYY`, `MM-DD-YYYY` ou `MM-DD-YY`, ela prefere o formato de data dos EUA em vez de `DD/MM/YYYY`, `DD-MM-YYYY` ou `DD-MM-YY`.
Como exceção ao caso anterior, se o mês for maior que 12 e menor ou igual a 31, esta função retorna ao comportamento de [`parseDateTimeBestEffort`](#parseDateTimeBestEffort); por exemplo, `15/08/2020` é interpretado como `2020-08-15`.
**Sintaxe**
```sql theme={null}
parseDateTimeBestEffortUS(time_string[, time_zone])
```
**Argumentos**
* `time_string` — `String` que contém uma data e hora para converter. [`String`](/pt-BR/reference/data-types/string)
* `time_zone` — Opcional. Fuso horário de acordo com o qual `time_string` é interpretado. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna `time_string` como um `DateTime`, usando a preferência do formato de data dos EUA em casos ambíguos. [`DateTime`](/pt-BR/reference/data-types/datetime)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Igual à função [`parseDateTimeBestEffortUS`](#parseDateTimeBestEffortUS), exceto que retorna `NULL` quando encontra um formato de data que não pode ser processado.
Esta função se comporta como [`parseDateTimeBestEffort`](#parseDateTimeBestEffort) para formatos de data ISO, mas, em casos ambíguos, prefere o formato de data dos EUA e retorna `NULL` em caso de erros de parsing.
**Sintaxe**
```sql theme={null}
parseDateTimeBestEffortUSOrNull(time_string[, time_zone])
```
**Argumentos**
* `time_string` — String que contém uma data e hora a serem convertidas. [`String`](/pt-BR/reference/data-types/string)
* `time_zone` — Opcional. Fuso horário segundo o qual `time_string` é interpretado. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna `time_string` como um DateTime, com preferência pelo formato dos EUA, ou `NULL` se a entrada não puder ser interpretada. [`DateTime`](/pt-BR/reference/data-types/datetime) ou [`NULL`](/pt-BR/reference/syntax#null)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Igual à função [`parseDateTimeBestEffortUS`](#parseDateTimeBestEffortUS), exceto que retorna data zero (`1970-01-01`) ou data zero com hora (`1970-01-01 00:00:00`) ao encontrar um formato de data que não pode ser processado.
Esta função se comporta como [`parseDateTimeBestEffort`](#parseDateTimeBestEffort) para formatos de data ISO, mas prefere o formato de data dos EUA em casos ambíguos, retornando zero em caso de erro de parsing.
**Sintaxe**
```sql theme={null}
parseDateTimeBestEffortUSOrZero(time_string[, time_zone])
```
**Argumentos**
* `time_string` — `String` que contém uma data e hora para converter. [`String`](/pt-BR/reference/data-types/string)
* `time_zone` — Opcional. Fuso horário segundo o qual `time_string` é interpretado. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna `time_string` como `DateTime`, usando a preferência de formato dos EUA, ou a data zero/data e hora zero (`1970-01-01` ou `1970-01-01 00:00:00`) se a entrada não puder ser interpretada. [`DateTime`](/pt-BR/reference/data-types/datetime)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v23.3.0
Faz o parse de uma string de data e hora de acordo com uma string de formato de data do Joda.
Esta função é o inverso de [`formatDateTimeInJodaSyntax`](/pt-BR/reference/functions/regular-functions/date-time-functions#formatDateTimeInJodaSyntax).
Ela faz o parse de um argumento String usando uma String de formato no estilo Joda. Retorna um tipo DateTime.
Consulte a [documentação do Joda Time](https://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html) para os padrões de formato.
**Sintaxe**
```sql theme={null}
parseDateTimeInJodaSyntax(time_string, format[, timezone])
```
**Argumentos**
* `time_string` — String a ser convertida em DateTime. [`String`](/pt-BR/reference/data-types/string)
* `format` — String de formato na sintaxe Joda que especifica como analisar time\_string. [`String`](/pt-BR/reference/data-types/string)
* `timezone` — Opcional. Fuso horário. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um DateTime convertido da string de entrada de acordo com a string de formato no estilo Joda. [`DateTime`](/pt-BR/reference/data-types/datetime)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v23.3.0
Igual a [`parseDateTimeInJodaSyntax`](#parseDateTimeInJodaSyntax), mas retorna `NULL` quando encontra um formato de data que não pode ser analisado.
**Sintaxe**
```sql theme={null}
parseDateTimeInJodaSyntaxOrNull(time_string, format[, timezone])
```
**Argumentos**
* `time_string` — String a ser convertida em DateTime. [`String`](/pt-BR/reference/data-types/string)
* `format` — String de formato na sintaxe Joda que especifica como interpretar time\_string. [`String`](/pt-BR/reference/data-types/string)
* `timezone` — Opcional. Fuso horário. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o DateTime convertido da string de entrada, ou NULL se a conversão falhar. [`Nullable(DateTime)`](/pt-BR/reference/data-types/nullable)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v23.3.0
Igual a [`parseDateTimeInJodaSyntax`](#parseDateTimeInJodaSyntax), mas retorna a data zero quando encontra um formato de data que não pode ser analisado.
**Sintaxe**
```sql theme={null}
parseDateTimeInJodaSyntaxOrZero(time_string, format[, timezone])
```
**Argumentos**
* `time_string` — String a ser convertida em DateTime. [`String`](/pt-BR/reference/data-types/string)
* `format` — String de formato na sintaxe Joda que especifica como interpretar time\_string. [`String`](/pt-BR/reference/data-types/string)
* `timezone` — Opcional. Fuso horário. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o DateTime interpretado da string de entrada, ou um DateTime zero se a interpretação falhar. [`DateTime`](/pt-BR/reference/data-types/datetime)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v23.3.0
Igual a [`parseDateTime`](#parseDateTime), mas retorna `NULL` quando encontra um formato de data não analisável.
**Sintaxe**
```sql theme={null}
parseDateTimeOrNull(time_string, format[, timezone])
```
**Aliases**: `str_to_date`
**Argumentos**
* `time_string` — String a ser convertida em DateTime. [`String`](/pt-BR/reference/data-types/string)
* `format` — String de formato que especifica como interpretar time\_string. [`String`](/pt-BR/reference/data-types/string)
* `timezone` — Opcional. Fuso horário. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o DateTime obtido da string de entrada, ou NULL se a análise falhar. [`Nullable(DateTime)`](/pt-BR/reference/data-types/nullable)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v23.3.0
Igual a [`parseDateTime`](#parseDateTime), mas retorna a data zero quando encontra um formato de data não analisável.
**Sintaxe**
```sql theme={null}
parseDateTimeOrZero(time_string, format[, timezone])
```
**Argumentos**
* `time_string` — String a ser convertida em DateTime. [`String`](/pt-BR/reference/data-types/string)
* `format` — String de formato que especifica como interpretar time\_string. [`String`](/pt-BR/reference/data-types/string)
* `timezone` — Opcional. Fuso horário. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o DateTime convertido da string de entrada ou o DateTime zero se a interpretação falhar. [`DateTime`](/pt-BR/reference/data-types/datetime)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Usa a mesma sequência de bytes na memória de origem para o valor `x` fornecido e a reinterpreta como o tipo de destino.
**Sintaxe**
```sql theme={null}
reinterpret(x, type)
```
**Argumentos**
* `x` — Qualquer tipo. [`Any`](/pt-BR/reference/data-types)
* `type` — Tipo de destino. Se for um Array, o tipo de elemento do Array deverá ser de comprimento fixo. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Valor do tipo de destino. [`Any`](/pt-BR/reference/data-types)
**Exemplos**
**Exemplo de uso**
```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 │
└─────────────┴──────────────┴───────────────┘
```
**Exemplo de 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
Introduzido em: v1.1.0
Reinterpreta o valor de entrada como um valor Date (assumindo a ordem little endian), que é o número de dias desde o início da epoch Unix em 1970-01-01
**Sintaxe**
```sql theme={null}
reinterpretAsDate(x)
```
**Argumentos**
* `x` — Número de dias desde o início da epoch Unix. [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`Date`](/pt-BR/reference/data-types/date) ou [`DateTime`](/pt-BR/reference/data-types/datetime) ou [`UUID`](/pt-BR/reference/data-types/uuid) ou [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring)
**Valor retornado**
Date. [`Date`](/pt-BR/reference/data-types/date)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Reinterpreta o valor de entrada como um valor DateTime (assumindo a ordem little endian), que representa o número de dias desde o início da epoch Unix, em 1970-01-01
**Sintaxe**
```sql theme={null}
reinterpretAsDateTime(x)
```
**Argumentos**
* `x` — Número de segundos desde o início do epoch Unix. [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`Date`](/pt-BR/reference/data-types/date) ou [`DateTime`](/pt-BR/reference/data-types/datetime) ou [`UUID`](/pt-BR/reference/data-types/uuid) ou [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring)
**Valor retornado**
Data e hora. [`DateTime`](/pt-BR/reference/data-types/datetime)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Reinterpreta o valor de entrada como uma string de tamanho fixo (assumindo a ordem little endian).
Os bytes nulos no final são ignorados; por exemplo, para o valor UInt32 255, a função retorna uma string com um único caractere.
**Sintaxe**
```sql theme={null}
reinterpretAsFixedString(x)
```
**Argumentos**
* `x` — Valor a ser reinterpretado como string. [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`Date`](/pt-BR/reference/data-types/date) ou [`DateTime`](/pt-BR/reference/data-types/datetime)
**Valor retornado**
String fixa que contém os bytes que representam `x`. [`FixedString`](/pt-BR/reference/data-types/fixedstring)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Reinterpreta o valor de entrada como um valor do tipo Float32.
Ao contrário de [`CAST`](#CAST), a função não tenta preservar o valor original — se o tipo de destino não for capaz de representar o tipo de entrada, o resultado será indefinido.
**Sintaxe**
```sql theme={null}
reinterpretAsFloat32(x)
```
**Argumentos**
* `x` — Valor a ser reinterpretado como Float32. [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`Date`](/pt-BR/reference/data-types/date) ou [`DateTime`](/pt-BR/reference/data-types/datetime) ou [`UUID`](/pt-BR/reference/data-types/uuid) ou [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring)
**Valor retornado**
Retorna o valor reinterpretado `x`. [`Float32`](/pt-BR/reference/data-types/float)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Reinterpreta o valor de entrada como um valor do tipo Float64.
Ao contrário de [`CAST`](#CAST), a função não tenta preservar o valor original — se o tipo de destino não conseguir representar o tipo de entrada, o resultado será indefinido.
**Sintaxe**
```sql theme={null}
reinterpretAsFloat64(x)
```
**Argumentos**
* `x` — Valor a ser reinterpretado como Float64. [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`Date`](/pt-BR/reference/data-types/date) ou [`DateTime`](/pt-BR/reference/data-types/datetime) ou [`UUID`](/pt-BR/reference/data-types/uuid) ou [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring)
**Valor retornado**
Retorna o valor reinterpretado `x`. [`Float64`](/pt-BR/reference/data-types/float)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Reinterpreta o valor de entrada como um valor do tipo Int128.
Diferentemente de [`CAST`](#CAST), a função não tenta preservar o valor original — se o tipo de destino não for capaz de representar o tipo de entrada, o resultado será indefinido.
**Sintaxe**
```sql theme={null}
reinterpretAsInt128(x)
```
**Argumentos**
* `x` — Valor a ser reinterpretado como Int128. [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`Date`](/pt-BR/reference/data-types/date) ou [`DateTime`](/pt-BR/reference/data-types/datetime) ou [`UUID`](/pt-BR/reference/data-types/uuid) ou [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring)
**Valor retornado**
Retorna o valor reinterpretado `x`. [`Int128`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Reinterpreta o valor de entrada como um valor do tipo Int16.
Ao contrário de [`CAST`](#CAST), a função não tenta preservar o valor original — se o tipo de destino não conseguir representar o tipo de entrada, a saída será indefinida.
**Sintaxe**
```sql theme={null}
reinterpretAsInt16(x)
```
**Argumentos**
* `x` — Valor a ser reinterpretado como Int16. [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`Date`](/pt-BR/reference/data-types/date) ou [`DateTime`](/pt-BR/reference/data-types/datetime) ou [`UUID`](/pt-BR/reference/data-types/uuid) ou [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring)
**Valor retornado**
Retorna o valor `x` reinterpretado. [`Int16`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Reinterpreta o valor de entrada como um valor do tipo Int256.
Ao contrário de [`CAST`](#CAST), a função não tenta preservar o valor original — se o tipo de destino não conseguir representar o tipo de entrada, o resultado será indefinido.
**Sintaxe**
```sql theme={null}
reinterpretAsInt256(x)
```
**Argumentos**
* `x` — Valor a ser reinterpretado como Int256. [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`Date`](/pt-BR/reference/data-types/date) ou [`DateTime`](/pt-BR/reference/data-types/datetime) ou [`UUID`](/pt-BR/reference/data-types/uuid) ou [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring)
**Valor retornado**
Retorna o valor `x` reinterpretado. [`Int256`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Reinterpreta o valor de entrada como um valor do tipo Int32.
Ao contrário de [`CAST`](#CAST), a função não tenta preservar o valor original — se o tipo de destino não puder representar o tipo de entrada, a saída será indefinida.
**Sintaxe**
```sql theme={null}
reinterpretAsInt32(x)
```
**Argumentos**
* `x` — Valor a ser reinterpretado como Int32. [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`Date`](/pt-BR/reference/data-types/date) ou [`DateTime`](/pt-BR/reference/data-types/datetime) ou [`UUID`](/pt-BR/reference/data-types/uuid) ou [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring)
**Valor retornado**
Retorna o valor reinterpretado `x`. [`Int32`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Reinterpreta o valor de entrada como um valor do tipo Int64.
Diferentemente de [`CAST`](#CAST), a função não tenta preservar o valor original — se o tipo de destino não conseguir representar o tipo de entrada, o resultado é indefinido.
**Sintaxe**
```sql theme={null}
reinterpretAsInt64(x)
```
**Argumentos**
* `x` — Valor a ser reinterpretado como Int64. [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`Date`](/pt-BR/reference/data-types/date) ou [`DateTime`](/pt-BR/reference/data-types/datetime) ou [`UUID`](/pt-BR/reference/data-types/uuid) ou [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring)
**Valor retornado**
Retorna o valor `x` reinterpretado. [`Int64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Reinterpreta o valor de entrada como um valor do tipo Int8.
Ao contrário de [`CAST`](#CAST), a função não tenta preservar o valor original; se o tipo de destino não conseguir representar o tipo de entrada, a saída será indefinida.
**Sintaxe**
```sql theme={null}
reinterpretAsInt8(x)
```
**Argumentos**
* `x` — Valor a ser reinterpretado como Int8. [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`Date`](/pt-BR/reference/data-types/date) ou [`DateTime`](/pt-BR/reference/data-types/datetime) ou [`UUID`](/pt-BR/reference/data-types/uuid) ou [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring)
**Valor retornado**
Retorna o valor `x` reinterpretado. [`Int8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Reinterpreta o valor de entrada como uma string (assumindo a ordem little-endian).
Os bytes nulos no final são ignorados; por exemplo, para o valor UInt32 255, a função retorna uma string com um único caractere.
**Sintaxe**
```sql theme={null}
reinterpretAsString(x)
```
**Argumentos**
* `x` — Valor a ser reinterpretado como string. [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`Date`](/pt-BR/reference/data-types/date) ou [`DateTime`](/pt-BR/reference/data-types/datetime)
**Valor retornado**
String contendo os bytes que representam `x`. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Reinterpreta o valor de entrada como um valor do tipo UInt128.
Ao contrário de [`CAST`](#CAST), a função não tenta preservar o valor original — se o tipo de destino não puder representar o tipo de entrada, o resultado será indefinido.
**Sintaxe**
```sql theme={null}
reinterpretAsUInt128(x)
```
**Argumentos**
* `x` — Valor a ser reinterpretado como UInt128. [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`Date`](/pt-BR/reference/data-types/date) ou [`DateTime`](/pt-BR/reference/data-types/datetime) ou [`UUID`](/pt-BR/reference/data-types/uuid) ou [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring)
**Valor retornado**
Retorna o valor reinterpretado de `x`. [`UInt128`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Reinterpreta o valor de entrada como um valor do tipo UInt16.
Ao contrário de [`CAST`](#CAST), a função não tenta preservar o valor original — se o tipo de destino não for capaz de representar o tipo de entrada, a saída será indefinida.
**Sintaxe**
```sql theme={null}
reinterpretAsUInt16(x)
```
**Argumentos**
* `x` — Valor a ser reinterpretado como UInt16. [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`Date`](/pt-BR/reference/data-types/date) ou [`DateTime`](/pt-BR/reference/data-types/datetime) ou [`UUID`](/pt-BR/reference/data-types/uuid) ou [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring)
**Valor retornado**
Retorna o valor reinterpretado de `x`. [`UInt16`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Reinterpreta o valor de entrada como um valor do tipo UInt256.
Diferentemente de [`CAST`](#CAST), a função não tenta preservar o valor original — se o tipo de destino não conseguir representar o tipo de entrada, a saída será indefinida.
**Sintaxe**
```sql theme={null}
reinterpretAsUInt256(x)
```
**Argumentos**
* `x` — Valor a ser reinterpretado como UInt256. [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`Date`](/pt-BR/reference/data-types/date) ou [`DateTime`](/pt-BR/reference/data-types/datetime) ou [`UUID`](/pt-BR/reference/data-types/uuid) ou [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring)
**Valor retornado**
Retorna o valor `x` reinterpretado. [`UInt256`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Reinterpreta o valor de entrada como um valor do tipo UInt32.
Diferentemente de [`CAST`](#CAST), a função não tenta preservar o valor original — se o tipo de destino não conseguir representar o tipo de entrada, a saída será indefinida.
**Sintaxe**
```sql theme={null}
reinterpretAsUInt32(x)
```
**Argumentos**
* `x` — Valor a reinterpretar como UInt32. [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`Date`](/pt-BR/reference/data-types/date) ou [`DateTime`](/pt-BR/reference/data-types/datetime) ou [`UUID`](/pt-BR/reference/data-types/uuid) ou [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring)
**Valor retornado**
Retorna o valor `x` reinterpretado. [`UInt32`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Reinterpreta o valor de entrada como um valor do tipo UInt64.
Ao contrário de [`CAST`](#CAST), a função não tenta preservar o valor original — se o tipo de destino não for capaz de representar o tipo de entrada, a saída será indefinida.
**Sintaxe**
```sql theme={null}
reinterpretAsUInt64(x)
```
**Argumentos**
* `x` — Valor a ser reinterpretado como UInt64. [`Int*`](/pt-BR/reference/data-types/int-uint) ou [`UInt*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`Date`](/pt-BR/reference/data-types/date) ou [`DateTime`](/pt-BR/reference/data-types/datetime) ou [`UUID`](/pt-BR/reference/data-types/uuid) ou [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring)
**Valor retornado**
Retorna o valor reinterpretado de `x`. [`UInt64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Reinterpreta o valor de entrada como um valor do tipo UInt8.
Diferentemente de [`CAST`](#CAST), a função não tenta preservar o valor original — se o tipo de destino não puder representar o tipo de entrada, a saída será indefinida.
**Sintaxe**
```sql theme={null}
reinterpretAsUInt8(x)
```
**Argumentos**
* `x` — Valor a ser reinterpretado como UInt8. [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`Date`](/pt-BR/reference/data-types/date) ou [`DateTime`](/pt-BR/reference/data-types/datetime) ou [`UUID`](/pt-BR/reference/data-types/uuid) ou [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring)
**Valor retornado**
Retorna o valor reinterpretado de `x`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Aceita uma string de 16 bytes e retorna um UUID, interpretando cada metade de 8 bytes na ordem de bytes little-endian. Se a string não for longa o suficiente, a função se comporta como se ela fosse preenchida no final com a quantidade necessária de bytes nulos. Se a string tiver mais de 16 bytes, os bytes extras no final serão ignorados.
**Sintaxe**
```sql theme={null}
reinterpretAsUUID(fixed_string)
```
**Argumentos**
* `fixed_string` — Cadeia de bytes em big-endian. [`FixedString`](/pt-BR/reference/data-types/fixedstring)
**Valor retornado**
O valor do tipo UUID. [`UUID`](/pt-BR/reference/data-types/uuid)
**Exemplos**
**De string para 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
Introduzido na versão: v1.1.0
Converte um valor de entrada em um valor do tipo BFloat16.
Lança uma exceção em caso de erro.
Veja também:
* [`toBFloat16OrZero`](#toBFloat16OrZero).
* [`toBFloat16OrNull`](#toBFloat16OrNull).
**Sintaxe**
```sql theme={null}
toBFloat16(expr)
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação textual de um número. [`Expression`](/pt-BR/reference/data-types/special-data-types/expression)
**Valor retornado**
Retorna um valor `brain-float` de 16 bits. [`BFloat16`](/pt-BR/reference/data-types/float)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Converte um valor de entrada do tipo String em um valor do tipo BFloat16.
Se a string não representar um valor de ponto flutuante, a função retorna NULL.
Argumentos compatíveis:
* Representações em String de valores numéricos.
Argumentos não suportados (retornam `NULL`):
* Representações em String de valores binários e hexadecimais.
* Valores numéricos.
A função permite perda silenciosa de precisão ao converter a representação em String.
Veja também:
* [`toBFloat16`](#toBFloat16).
* [`toBFloat16OrZero`](#toBFloat16OrZero).
**Sintaxe**
```sql theme={null}
toBFloat16OrNull(x)
```
**Argumentos**
* `x` — Uma representação em `String` de um número. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor brain-float de 16 bits ou `NULL`. [`BFloat16`](/pt-BR/reference/data-types/float) ou [`NULL`](/pt-BR/reference/syntax#null)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT toBFloat16OrNull('0x5E'), -- argumentos sem suporte
toBFloat16OrNull('12.3'), -- uso típico
toBFloat16OrNull('12.3456789') -- perda silenciosa de precisão
```
```response title=Response theme={null}
\N
12.25
12.3125
```
## toBFloat16OrZero
Introduzido em: v1.1.0
Converte um valor de entrada String em um valor do tipo BFloat16.
Se a string não representar um valor de ponto flutuante, a função retorna zero.
Argumentos suportados:
* Representações String de valores numéricos.
Argumentos não suportados (retornam `0`):
* Representações String de valores binários e hexadecimais.
* Valores numéricos.
A função permite perda silenciosa de precisão ao converter a partir da representação String.
Veja também:
* [`toBFloat16`](#toBFloat16).
* [`toBFloat16OrNull`](#toBFloat16OrNull).
**Sintaxe**
```sql theme={null}
toBFloat16OrZero(x)
```
**Argumentos**
* `x` — Uma representação em string de um número. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor brain-float de 16 bits; caso contrário, `0`. [`BFloat16`](/pt-BR/reference/data-types/float)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT toBFloat16OrZero('0x5E'), -- argumentos sem suporte
toBFloat16OrZero('12.3'), -- uso comum
toBFloat16OrZero('12.3456789') -- perda silenciosa de precisão
```
```response title=Response theme={null}
0
12.25
12.3125
```
## toBool
Introduzido em: v22.2.0
Converte um valor de entrada em um valor do tipo Bool.
**Sintaxe**
```sql theme={null}
toBool(expr)
```
**Argumentos**
* `expr` — Expressão que retorna um número ou uma string. Para strings, aceita 'true' ou 'false' (sem distinção entre maiúsculas e minúsculas). [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`String`](/pt-BR/reference/data-types/string) ou [`Expression`](/pt-BR/reference/data-types/special-data-types/expression)
**Valor retornado**
Retorna `true` ou `false` com base na avaliação do argumento. [`Bool`](/pt-BR/reference/data-types/boolean)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Converte um valor de entrada para o tipo [`Date`](/pt-BR/reference/data-types/date).
É compatível com a conversão de String, FixedString, DateTime ou tipos numéricos.
**Sintaxe**
```sql theme={null}
toDate(x)
```
**Argumentos**
* `x` — Valor de entrada a ser convertido. [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring) ou [`DateTime`](/pt-BR/reference/data-types/datetime) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float)
**Valor retornado**
Retorna o valor de entrada convertido. [`Date`](/pt-BR/reference/data-types/date)
**Exemplos**
**Conversão de String para Date**
```sql title=Query theme={null}
SELECT toDate('2025-04-15')
```
```response title=Response theme={null}
2025-04-15
```
**Conversão de DateTime para Date**
```sql title=Query theme={null}
SELECT toDate(toDateTime('2025-04-15 10:30:00'))
```
```response title=Response theme={null}
2025-04-15
```
**Conversão de inteiro para data**
```sql title=Query theme={null}
SELECT toDate(20297)
```
```response title=Response theme={null}
2025-07-28
```
## toDate32
Introduzido em: v21.9.0
Converte o argumento para o tipo de dado [Date32](/pt-BR/reference/data-types/date32).
Se o valor estiver fora do intervalo, `toDate32` retorna os valores de limite suportados por [Date32](/pt-BR/reference/data-types/date32).
Se o argumento for do tipo [`Date`](/pt-BR/reference/data-types/date), seus limites serão considerados.
**Sintaxe**
```sql theme={null}
toDate32(expr)
```
**Argumentos**
* `expr` — O valor a ser convertido. [`String`](/pt-BR/reference/data-types/string) ou [`UInt32`](/pt-BR/reference/data-types/int-uint) ou [`Date`](/pt-BR/reference/data-types/date)
**Valor retornado**
Retorna uma data de calendário. [`Date32`](/pt-BR/reference/data-types/date32)
**Exemplos**
**No intervalo**
```sql title=Query theme={null}
SELECT toDate32('2025-01-01') AS value, toTypeName(value)
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
value: 2025-01-01
toTypeName(value): Date32
```
**Fora do intervalo**
```sql title=Query theme={null}
SELECT toDate32('1899-01-01') AS value, toTypeName(value)
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
value: 1900-01-01
toTypeName(value): Date32
```
## toDate32OrDefault
Introduzido em: v21.11.0
Converte o argumento para o tipo de dado [Date32](/pt-BR/reference/data-types/date32). Se o valor estiver fora do intervalo, `toDate32OrDefault` retornará o valor do limite inferior compatível com [Date32](/pt-BR/reference/data-types/date32). Se o argumento for do tipo [Date](/pt-BR/reference/data-types/date), os limites desse tipo serão levados em consideração. Retorna o valor padrão se um argumento inválido for recebido.
**Sintaxe**
```sql theme={null}
toDate32OrDefault(expr[, default])
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação textual de um número. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float)
* `default` — Opcional. O valor padrão a ser retornado se a análise não for bem-sucedida. [`Date32`](/pt-BR/reference/data-types/date32)
**Valor retornado**
Valor do tipo Date32 em caso de sucesso; caso contrário, retorna o valor padrão, se fornecido, ou 1900-01-01, se não. [`Date32`](/pt-BR/reference/data-types/date32)
**Exemplos**
**Conversão bem-sucedida**
```sql title=Query theme={null}
SELECT toDate32OrDefault('1930-01-01', toDate32('2020-01-01'))
```
```response title=Response theme={null}
1930-01-01
```
**Falha na conversão**
```sql title=Query theme={null}
SELECT toDate32OrDefault('xx1930-01-01', toDate32('2020-01-01'))
```
```response title=Response theme={null}
2020-01-01
```
## toDate32OrNull
Introduzido em: v21.9.0
Converte um valor de entrada em um valor do tipo Date32, mas retorna `NULL` se receber um argumento inválido.
Igual a [`toDate32`](#toDate32), mas retorna `NULL` se receber um argumento inválido.
**Sintaxe**
```sql theme={null}
toDate32OrNull(x)
```
**Argumentos**
* `x` — Uma representação textual de uma data. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor `Date32` em caso de sucesso; caso contrário, `NULL`. [`Date32`](/pt-BR/reference/data-types/date32) ou [`NULL`](/pt-BR/reference/syntax#null)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v21.9.0
Converte um valor de entrada em um valor do tipo [Date32](/pt-BR/reference/data-types/date32), mas retorna o limite inferior de [Date32](/pt-BR/reference/data-types/date32) se receber um argumento inválido.
É igual a [toDate32](#toDate32), mas retorna o limite inferior de [Date32](/pt-BR/reference/data-types/date32) se receber um argumento inválido.
Veja também:
* [`toDate32`](#toDate32)
* [`toDate32OrNull`](#toDate32OrNull)
* [`toDate32OrDefault`](#toDate32OrDefault)
**Sintaxe**
```sql theme={null}
toDate32OrZero(x)
```
**Argumentos**
* `x` — Uma representação textual de uma data. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor `Date32` em caso de sucesso; caso contrário, o limite inferior de `Date32` (`1900-01-01`). [`Date32`](/pt-BR/reference/data-types/date32)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v21.11.0
Assim como [toDate](#toDate), mas, em caso de falha, retorna um valor padrão, que é o segundo argumento (se especificado) ou, caso contrário, o limite inferior de [Date](/pt-BR/reference/data-types/date).
**Sintaxe**
```sql theme={null}
toDateOrDefault(expr[, default])
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação textual de um número. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float)
* `default` — Opcional. O valor padrão a ser retornado se o parsing não for bem-sucedido. [`Date`](/pt-BR/reference/data-types/date)
**Valor retornado**
Valor do tipo Date em caso de sucesso; caso contrário, retorna o valor padrão, se fornecido, ou 1970-01-01, se não. [`Date`](/pt-BR/reference/data-types/date)
**Exemplos**
**Conversão bem-sucedida**
```sql title=Query theme={null}
SELECT toDateOrDefault('2022-12-30')
```
```response title=Response theme={null}
2022-12-30
```
**Falha na conversão**
```sql title=Query theme={null}
SELECT toDateOrDefault('', CAST('2023-01-01', 'Date'))
```
```response title=Response theme={null}
2023-01-01
```
## toDateOrNull
Introduzido na versão: v1.1.0
Converte um valor de entrada em um valor do tipo `Date`, mas retorna `NULL` se receber um argumento inválido.
É o mesmo que [`toDate`](#toDate), mas retorna `NULL` se receber um argumento inválido.
**Sintaxe**
```sql theme={null}
toDateOrNull(x)
```
**Argumentos**
* `x` — Uma representação textual de uma data. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor `Date` em caso de sucesso; caso contrário, `NULL`. [`Date`](/pt-BR/reference/data-types/date) ou [`NULL`](/pt-BR/reference/syntax#null)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Converte um valor de entrada em um valor do tipo [`Date`](/pt-BR/reference/data-types/date), mas retorna o limite inferior de [`Date`](/pt-BR/reference/data-types/date) caso receba um argumento inválido.
É o mesmo que [toDate](#toDate), mas retorna o limite inferior de [`Date`](/pt-BR/reference/data-types/date) caso receba um argumento inválido.
Veja também:
* [`toDate`](#toDate)
* [`toDateOrNull`](#toDateOrNull)
* [`toDateOrDefault`](#toDateOrDefault)
**Sintaxe**
```sql theme={null}
toDateOrZero(x)
```
**Argumentos**
* `x` — Uma representação textual de uma data. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor do tipo Date em caso de sucesso; caso contrário, o limite inferior de Date (`1970-01-01`). [`Date`](/pt-BR/reference/data-types/date)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Converte um valor de entrada para o tipo [DateTime](/pt-BR/reference/data-types/datetime).
Se `expr` for um número, ele será interpretado como o número de segundos desde o início da epoch Unix (como timestamp Unix).
Se `expr` for uma [String](/pt-BR/reference/data-types/string), ela poderá ser interpretada como um timestamp Unix ou como uma representação em string de data / data com hora.
Assim, o parsing de representações em string de números curtos (até 4 dígitos) é explicitamente desabilitado devido à ambiguidade; por exemplo, uma string `'1999'` pode ser tanto um ano (uma representação em string incompleta de Date / DateTime) quanto um timestamp Unix. Strings numéricas mais longas são permitidas.
**Sintaxe**
```sql theme={null}
toDateTime(expr[, time_zone])
```
**Argumentos**
* `expr` — O valor. [`String`](/pt-BR/reference/data-types/string) ou [`Int`](/pt-BR/reference/data-types/int-uint) ou [`Date`](/pt-BR/reference/data-types/date) ou [`DateTime`](/pt-BR/reference/data-types/datetime)
* `time_zone` — Fuso horário. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor de data e hora. [`DateTime`](/pt-BR/reference/data-types/datetime)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT toDateTime('2025-01-01 00:00:00'), toDateTime(1735689600, 'UTC')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toDateTime('2025-01-01 00:00:00'): 2025-01-01 00:00:00
toDateTime(1735689600, 'UTC'): 2025-01-01 00:00:00
```
## toDateTime32
Introduzido na versão: v20.9.0
Converte um valor de entrada para o tipo `DateTime`.
Suporta a conversão de `String`, `FixedString`, `Date`, `Date32`, `DateTime` ou tipos numéricos (`(U)Int*`, `Float*`, `Decimal`).
`DateTime32` oferece um intervalo maior em comparação com `DateTime`, com suporte a datas de `1900-01-01` a `2299-12-31`.
**Sintaxe**
```sql theme={null}
toDateTime32(x[, timezone])
```
**Argumentos**
* `x` — Valor de entrada a ser convertido. [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring) ou [`UInt*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`Date`](/pt-BR/reference/data-types/date) ou [`DateTime`](/pt-BR/reference/data-types/datetime) ou [`DateTime64`](/pt-BR/reference/data-types/datetime64)
* `timezone` — Opcional. Fuso horário do valor `DateTime` retornado. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o valor de entrada convertido. [`DateTime`](/pt-BR/reference/data-types/datetime)
**Exemplos**
**O valor está dentro do intervalo**
```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) │
└─────────────────────────┴────────────────────────────────────────────────────────┘
```
**Como Decimal com precisão**
```sql title=Query theme={null}
SELECT toDateTime64(1735689600.000, 3) AS value, toTypeName(value);
-- sem o separador decimal, o valor ainda é tratado como Unix Timestamp em segundos
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) │
└─────────────────────────┴────────────────────────────────────────────┘
```
**Com fuso horário**
```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
Introduzido na: v20.1.0
Converte um valor de entrada em um valor do tipo [`DateTime64`](/pt-BR/reference/data-types/datetime64).
**Sintaxe**
```sql theme={null}
toDateTime64(expr, scale[, timezone])
```
**Argumentos**
* `expr` — Expressão que retorna um número ou uma representação textual de um número. [`Expression`](/pt-BR/reference/data-types/special-data-types/expression)
* `scale` — Tamanho do tick (precisão): 10^(-scale) segundos. [`UInt8`](/pt-BR/reference/data-types/int-uint)
* `timezone` — Opcional. Fuso horário do objeto `DateTime64` especificado. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna uma data e hora, com precisão de subsegundos. [`DateTime64`](/pt-BR/reference/data-types/datetime64)
**Exemplos**
**O valor está dentro do intervalo**
```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) │
└─────────────────────────┴────────────────────────────────────────────────────────┘
```
**Como Decimal com precisão especificada**
```sql title=Query theme={null}
SELECT toDateTime64(1546300800.000, 3) AS value, toTypeName(value);
-- Sem o separador decimal, o valor ainda é interpretado como timestamp Unix em segundos
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) │
└─────────────────────────┴────────────────────────────────────────────┘
```
**Com fuso horário**
```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
Introduzido em: v21.11.0
Assim como [toDateTime64](#toDateTime64), esta função converte um valor de entrada em um valor do tipo [DateTime64](/pt-BR/reference/data-types/datetime64),
mas retorna o valor padrão de [DateTime64](/pt-BR/reference/data-types/datetime64)
ou o valor padrão fornecido caso receba um argumento inválido.
**Sintaxe**
```sql theme={null}
toDateTime64OrDefault(expr, scale[, timezone, default])
```
**Argumentos**
* `expr` — Expressão que retorna um número ou uma representação textual de um número. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float)
* `scale` — Tamanho do tick (precisão): 10^-precisão segundos. [`UInt8`](/pt-BR/reference/data-types/int-uint)
* `timezone` — Opcional. Fuso horário. [`String`](/pt-BR/reference/data-types/string)
* `default` — Opcional. O valor padrão a ser retornado se o parsing falhar. [`DateTime64`](/pt-BR/reference/data-types/datetime64)
**Valor retornado**
Valor do tipo DateTime64 em caso de sucesso; caso contrário, retorna o valor padrão, se fornecido, ou 1970-01-01 00:00:00.000, se não. [`DateTime64`](/pt-BR/reference/data-types/datetime64)
**Exemplos**
**Conversão bem-sucedida**
```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
```
**Conversão malsucedida**
```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
Introduzido em: v20.1.0
Converte um valor de entrada para o tipo `DateTime64`, mas retorna `NULL` se receber um argumento inválido.
Igual a `toDateTime64`, mas retorna `NULL` se receber um argumento inválido.
**Sintaxe**
```sql theme={null}
toDateTime64OrNull(x)
```
**Argumentos**
* `x` — Uma representação textual de uma data e hora com precisão de frações de segundo. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor `DateTime64` em caso de sucesso; caso contrário, `NULL`. [`DateTime64`](/pt-BR/reference/data-types/datetime64) ou [`NULL`](/pt-BR/reference/syntax#null)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v20.1.0
Converte um valor de entrada em um valor do tipo [DateTime64](/pt-BR/reference/data-types/datetime64), mas retorna o limite inferior de [DateTime64](/pt-BR/reference/data-types/datetime64) se receber um argumento inválido.
Igual a [toDateTime64](#toDateTime64), mas retorna o limite inferior de [DateTime64](/pt-BR/reference/data-types/datetime64) se receber um argumento inválido.
Veja também:
* [toDateTime64](#toDateTime64).
* [toDateTime64OrNull](#toDateTime64OrNull).
* [toDateTime64OrDefault](#toDateTime64OrDefault).
**Sintaxe**
```sql theme={null}
toDateTime64OrZero(x)
```
**Argumentos**
* `x` — Uma representação textual de uma data com hora e precisão de frações de segundo. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor DateTime64 em caso de sucesso; caso contrário, o limite inferior de DateTime64 (`1970-01-01 00:00:00.000`). [`DateTime64`](/pt-BR/reference/data-types/datetime64)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v21.11.0
Semelhante a [toDateTime](#toDateTime), mas, se não for bem-sucedido, retorna um valor padrão, que é o terceiro argumento (se especificado) ou, caso contrário, o limite inferior de [DateTime](/pt-BR/reference/data-types/datetime).
**Sintaxe**
```sql theme={null}
toDateTimeOrDefault(expr[, timezone, default])
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação em string de um número. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float)
* `timezone` — Opcional. Fuso horário. [`String`](/pt-BR/reference/data-types/string)
* `default` — Opcional. O valor padrão a ser retornado se não for possível fazer o parsing. [`DateTime`](/pt-BR/reference/data-types/datetime)
**Valor retornado**
Valor do tipo DateTime em caso de sucesso; caso contrário, retorna o valor padrão, se ele tiver sido informado, ou 1970-01-01 00:00:00, se não. [`DateTime`](/pt-BR/reference/data-types/datetime)
**Exemplos**
**Conversão bem-sucedida**
```sql title=Query theme={null}
SELECT toDateTimeOrDefault('2022-12-30 13:44:17')
```
```response title=Response theme={null}
2022-12-30 13:44:17
```
**Falha de conversão**
```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
Introduzido na versão: v1.1.0
Converte um valor de entrada em um valor do tipo `DateTime`, mas retorna `NULL` se receber um argumento inválido.
O mesmo que [`toDateTime`](#toDateTime), mas retorna `NULL` se receber um argumento inválido.
**Sintaxe**
```sql theme={null}
toDateTimeOrNull(x)
```
**Argumentos**
* `x` — Uma representação textual de uma data com hora. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor `DateTime` em caso de sucesso; caso contrário, `NULL`. [`DateTime`](/pt-BR/reference/data-types/datetime) ou [`NULL`](/pt-BR/reference/syntax#null)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Converte um valor de entrada em um valor do tipo [DateTime](/pt-BR/reference/data-types/datetime), mas retorna o limite inferior de [DateTime](/pt-BR/reference/data-types/datetime) se receber um argumento inválido.
É igual a [toDateTime](#toDateTime), mas retorna o limite inferior de [DateTime](/pt-BR/reference/data-types/datetime) se receber um argumento inválido.
**Sintaxe**
```sql theme={null}
toDateTimeOrZero(x)
```
**Argumentos**
* `x` — Uma representação textual de uma data e hora. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor DateTime em caso de sucesso; caso contrário, retorna o limite inferior de DateTime (`1970-01-01 00:00:00`). [`DateTime`](/pt-BR/reference/data-types/datetime)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v18.12.0
Converte um valor de entrada em um valor do tipo [`Decimal(38, S)`](/pt-BR/reference/data-types/decimal) com escala `S`.
Lança uma exceção em caso de erro.
Argumentos compatíveis:
* Valores ou representações em string do tipo (U)Int\*.
* Valores ou representações em string do tipo Float\*.
Argumentos não compatíveis:
* Valores ou representações em string de valores Float\* `NaN` e `Inf` (sem distinção entre maiúsculas e minúsculas).
* Representações em string de valores binários e hexadecimais, por exemplo, `SELECT toDecimal128('0xc0fe', 1);`.
Pode ocorrer overflow se o valor de `expr` exceder os limites de `Decimal128`: `(-1*10^(38 - S), 1*10^(38 - S))`.
Dígitos excedentes na parte fracionária são descartados (não arredondados).
Dígitos excedentes na parte inteira resultarão em uma exceção.
As conversões descartam dígitos excedentes e podem se comportar de forma inesperada ao trabalhar com entradas Float32/Float64, pois as operações são realizadas usando instruções de ponto flutuante.
Por exemplo: `toDecimal128(1.15, 2)` é igual a `1.14` porque 1.15 \* 100 em ponto flutuante é 114.99.
Você pode usar uma entrada String para que as operações usem o tipo inteiro subjacente: `toDecimal128('1.15', 2) = 1.15`
**Sintaxe**
```sql theme={null}
toDecimal128(expr, S)
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação textual de um número. [`Expression`](/pt-BR/reference/data-types/special-data-types/expression)
* `S` — Parâmetro de escala entre 0 e 38, que especifica quantos dígitos a parte fracionária de um número pode ter. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um valor do tipo `Decimal(38, S)` [`Decimal128(S)`](/pt-BR/reference/data-types/decimal)
**Exemplos**
**Exemplo de uso**
```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}
Linha 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
Introduzido em: v21.11.0
Assim como [`toDecimal128`](#toDecimal128), esta função converte um valor de entrada para um valor do tipo [Decimal(38, S)](/pt-BR/reference/data-types/decimal), mas retorna o valor padrão em caso de erro.
**Sintaxe**
```sql theme={null}
toDecimal128OrDefault(expr, S[, default])
```
**Argumentos**
* `expr` — Uma representação textual de um número. [`String`](/pt-BR/reference/data-types/string)
* `S` — Parâmetro de escala entre 0 e 38, especificando quantos dígitos a parte fracionária de um número pode ter. [`UInt8`](/pt-BR/reference/data-types/int-uint)
* `default` — Opcional. O valor padrão a ser retornado se a conversão para o tipo Decimal128(S) não for bem-sucedida. [`Decimal128(S)`](/pt-BR/reference/data-types/decimal)
**Valor retornado**
Valor do tipo Decimal(38, S) em caso de sucesso; caso contrário, retorna o valor padrão, se fornecido, ou 0, caso não seja. [`Decimal128(S)`](/pt-BR/reference/data-types/decimal)
**Exemplos**
**Conversão bem-sucedida**
```sql title=Query theme={null}
SELECT toDecimal128OrDefault(toString(1/42), 18)
```
```response title=Response theme={null}
0.023809523809523808
```
**Falha na conversão**
```sql title=Query theme={null}
SELECT toDecimal128OrDefault('Inf', 0, CAST('-1', 'Decimal128(0)'))
```
```response title=Response theme={null}
-1
```
## toDecimal128OrNull
Introduzido em: v20.1.0
Converte um valor de entrada em um valor do tipo [`Decimal(38, S)`](/pt-BR/reference/data-types/decimal), mas retorna `NULL` em caso de erro.
Como [`toDecimal128`](#toDecimal128), mas retorna `NULL` em vez de lançar uma exceção em erros de conversão.
Argumentos aceitos:
* Valores ou representações em string do tipo (U)Int\*.
* Valores ou representações em string do tipo Float\*.
Argumentos não aceitos (retornam `NULL`):
* Valores ou representações em string de valores Float\* `NaN` e `Inf` (sem distinção entre maiúsculas e minúsculas).
* Representações em string de valores binários e hexadecimais.
* Valores que excedem os limites de `Decimal128`:`(-1*10^(38 - S), 1*10^(38 - S))`.
Veja também:
* [`toDecimal128`](#toDecimal128).
* [`toDecimal128OrZero`](#toDecimal128OrZero).
* [`toDecimal128OrDefault`](#toDecimal128OrDefault).
**Sintaxe**
```sql theme={null}
toDecimal128OrNull(expr, S)
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação textual de um número. [`Expression`](/pt-BR/reference/data-types/special-data-types/expression)
* `S` — Parâmetro de escala entre 0 e 38, que especifica quantos dígitos a parte fracionária de um número pode ter. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um valor Decimal(38, S) em caso de sucesso; caso contrário, `NULL`. [`Decimal128(S)`](/pt-BR/reference/data-types/decimal) ou [`NULL`](/pt-BR/reference/syntax#null)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v20.1.0
Converte um valor de entrada em um valor do tipo [Decimal(38, S)](/pt-BR/reference/data-types/decimal), mas retorna `0` em caso de erro.
É como [`toDecimal128`](#toDecimal128), mas retorna `0` em vez de lançar uma exceção em caso de erro de conversão.
Argumentos compatíveis:
* Valores ou representações em string do tipo (U)Int\*.
* Valores ou representações em string do tipo Float\*.
Argumentos sem suporte (retornam `0`):
* Valores ou representações em string de valores Float\* `NaN` e `Inf` (sem diferenciar maiúsculas de minúsculas).
* Representações em string de valores binários e hexadecimais.
Se o valor de entrada exceder os limites de `Decimal128`:`(-1*10^(38 - S), 1*10^(38 - S))`, a função retornará `0`.
**Sintaxe**
```sql theme={null}
toDecimal128OrZero(expr, S)
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação textual de um número. [`Expression`](/pt-BR/reference/data-types/special-data-types/expression)
* `S` — Parâmetro de escala entre 0 e 38, que especifica quantos dígitos a parte fracionária de um número pode ter. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um valor `Decimal(38, S)` em caso de sucesso; caso contrário, `0`. [`Decimal128(S)`](/pt-BR/reference/data-types/decimal)
**Exemplos**
**Uso básico**
```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
Introduzido em: v20.8.0
Converte um valor de entrada em um valor do tipo [`Decimal(76, S)`](/pt-BR/reference/data-types/decimal) com escala `S`. Gera uma exceção em caso de erro.
Argumentos aceitos:
* Valores ou representações em string do tipo (U)Int\*.
* Valores ou representações em string do tipo Float\*.
Argumentos não aceitos:
* Valores ou representações em string dos valores Float\* `NaN` e `Inf` (sem diferenciar maiúsculas de minúsculas).
* Representações em string de valores binários e hexadecimais, por exemplo, `SELECT toDecimal256('0xc0fe', 1);`.
Pode ocorrer overflow se o valor de `expr` exceder os limites de `Decimal256`:`(-1*10^(76 - S), 1*10^(76 - S))`.
Dígitos excedentes na parte fracionária são descartados (não arredondados).
Dígitos excedentes na parte inteira gerarão uma exceção.
As conversões descartam dígitos extras e podem se comportar de maneira inesperada ao trabalhar com entradas Float32/Float64, já que as operações são realizadas com instruções de ponto flutuante.
Por exemplo: `toDecimal256(1.15, 2)` é igual a `1.14` porque 1.15 \* 100 em ponto flutuante é 114.99.
Você pode usar uma entrada String para que as operações usem o tipo inteiro subjacente: `toDecimal256('1.15', 2) = 1.15`
**Sintaxe**
```sql theme={null}
toDecimal256(expr, S)
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação em string de um número. [`Expression`](/pt-BR/reference/data-types/special-data-types/expression)
* `S` — Parâmetro de escala entre 0 e 76, que especifica quantos dígitos a parte fracionária de um número pode ter. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um valor do tipo `Decimal(76, S)`. [`Decimal256(S)`](/pt-BR/reference/data-types/decimal)
**Exemplos**
**Exemplo de uso**
```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}
Linha 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
Introduzido em: v21.11.0
Assim como [`toDecimal256`](#toDecimal256), esta função converte um valor de entrada em um valor do tipo [Decimal(76, S)](/pt-BR/reference/data-types/decimal), mas retorna o valor padrão em caso de erro.
**Sintaxe**
```sql theme={null}
toDecimal256OrDefault(expr, S[, default])
```
**Argumentos**
* `expr` — Uma representação de um número em `String`. [`String`](/pt-BR/reference/data-types/string)
* `S` — Parâmetro de escala entre 0 e 76, que especifica quantos dígitos a parte fracionária de um número pode ter. [`UInt8`](/pt-BR/reference/data-types/int-uint)
* `default` — Opcional. O valor padrão a ser retornado se a conversão para o tipo Decimal256(S) falhar. [`Decimal256(S)`](/pt-BR/reference/data-types/decimal)
**Valor retornado**
Valor do tipo Decimal(76, S) em caso de sucesso; caso contrário, retorna o valor padrão, se informado, ou 0, se não. [`Decimal256(S)`](/pt-BR/reference/data-types/decimal)
**Exemplos**
**Conversão bem-sucedida**
```sql title=Query theme={null}
SELECT toDecimal256OrDefault(toString(1/42), 76)
```
```response title=Response theme={null}
0.023809523809523808
```
**Falha na conversão**
```sql title=Query theme={null}
SELECT toDecimal256OrDefault('Inf', 0, CAST('-1', 'Decimal256(0)'))
```
```response title=Response theme={null}
-1
```
## toDecimal256OrNull
Introduzido em: v20.8.0
Converte um valor de entrada em um valor do tipo [`Decimal(76, S)`](/pt-BR/reference/data-types/decimal), mas retorna `NULL` em caso de erro.
É semelhante a [`toDecimal256`](#toDecimal256), mas retorna `NULL` em vez de gerar uma exceção em caso de erro de conversão.
Argumentos suportados:
* Valores ou representações em string do tipo (U)Int\*.
* Valores ou representações em string do tipo Float\*.
Argumentos não suportados (retornam `NULL`):
* Valores ou representações em string de valores Float\* `NaN` e `Inf` (sem diferenciar maiúsculas de minúsculas).
* Representações em string de valores binários e hexadecimais.
* Valores que excedem os limites de `Decimal256`: `(-1 * 10^(76 - S), 1 * 10^(76 - S))`.
Veja também:
* [`toDecimal256`](#toDecimal256).
* [`toDecimal256OrZero`](#toDecimal256OrZero).
* [`toDecimal256OrDefault`](#toDecimal256OrDefault).
**Sintaxe**
```sql theme={null}
toDecimal256OrNull(expr, S)
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação textual de um número. [`Expression`](/pt-BR/reference/data-types/special-data-types/expression)
* `S` — Parâmetro de escala entre 0 e 76, que especifica quantos dígitos a parte fracionária de um número pode ter. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um valor `Decimal(76, S)` em caso de sucesso; caso contrário, `NULL`. [`Decimal256(S)`](/pt-BR/reference/data-types/decimal) ou [`NULL`](/pt-BR/reference/syntax#null)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v20.8.0
Converte um valor de entrada em um valor do tipo [Decimal(76, S)](/pt-BR/reference/data-types/decimal), mas retorna `0` em caso de erro.
Como [`toDecimal256`](#toDecimal256), mas retorna `0` em vez de lançar uma exceção em erros de conversão.
Argumentos aceitos:
* Valores ou representações em string do tipo (U)Int\*.
* Valores ou representações em string do tipo Float\*.
Argumentos não suportados (retornam `0`):
* Valores ou representações em string de valores Float\* `NaN` e `Inf` (sem diferenciar maiúsculas de minúsculas).
* Representações em string de valores binários e hexadecimais.
Se o valor de entrada exceder os limites de `Decimal256`:`(-1*10^(76 - S), 1*10^(76 - S))`, a função retorna `0`.
Veja também:
* [`toDecimal256`](#toDecimal256).
* [`toDecimal256OrNull`](#toDecimal256OrNull).
* [`toDecimal256OrDefault`](#toDecimal256OrDefault).
**Sintaxe**
```sql theme={null}
toDecimal256OrZero(expr, S)
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação em string de um número. [`Expression`](/pt-BR/reference/data-types/special-data-types/expression)
* `S` — Parâmetro de escala entre 0 e 76, que especifica quantos dígitos a parte fracionária de um número pode ter. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um valor Decimal(76, S) em caso de sucesso; caso contrário, `0`. [`Decimal256(S)`](/pt-BR/reference/data-types/decimal)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v18.12.0
Converte um valor de entrada para o tipo [`Decimal(9, S)`](/pt-BR/reference/data-types/decimal) com escala `S`. Lança uma exceção em caso de erro.
Argumentos com suporte:
* Valores ou representações em string do tipo (U)Int\*.
* Valores ou representações em string do tipo Float\*.
Argumentos sem suporte:
* Valores ou representações em string dos valores Float\* `NaN` e `Inf` (sem diferenciar maiúsculas de minúsculas).
* Representações em string de valores binários e hexadecimais, por exemplo, `SELECT toDecimal32('0xc0fe', 1);`.
Pode haver overflow se o valor de `expr` exceder os limites de `Decimal32`:`(-1*10^(9 - S), 1*10^(9 - S))`.
Dígitos excedentes na parte fracionária são descartados (não arredondados).
Dígitos excedentes na parte inteira causarão uma exceção.
As conversões descartam dígitos excedentes e podem se comportar de forma inesperada ao trabalhar com entradas Float32/Float64, pois as operações são realizadas usando instruções de ponto flutuante.
Por exemplo: `toDecimal32(1.15, 2)` é igual a `1.14` porque 1.15 \* 100 em ponto flutuante é 114.99.
Você pode usar uma entrada String para que as operações usem o tipo inteiro subjacente: `toDecimal32('1.15', 2) = 1.15`
**Sintaxe**
```sql theme={null}
toDecimal32(expr, S)
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação em string de um número. [`Expression`](/pt-BR/reference/data-types/special-data-types/expression)
* `S` — Parâmetro de escala entre 0 e 9, que especifica quantos dígitos a parte fracionária de um número pode ter. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um valor do tipo `Decimal(9, S)` [`Decimal32(S)`](/pt-BR/reference/data-types/decimal)
**Exemplos**
**Exemplo de uso**
```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}
Linha 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
Introduzido em: v21.11.0
Assim como [`toDecimal32`](#toDecimal32), esta função converte um valor de entrada em um valor do tipo [Decimal(9, S)](/pt-BR/reference/data-types/decimal), mas retorna o valor padrão em caso de erro.
**Sintaxe**
```sql theme={null}
toDecimal32OrDefault(expr, S[, default])
```
**Argumentos**
* `expr` — Uma representação em string de um número. [`String`](/pt-BR/reference/data-types/string)
* `S` — Parâmetro de escala entre 0 e 9, que especifica quantos dígitos a parte fracionária de um número pode ter. [`UInt8`](/pt-BR/reference/data-types/int-uint)
* `default` — Opcional. O valor padrão a ser retornado se a conversão para o tipo Decimal32(S) não for bem-sucedida. [`Decimal32(S)`](/pt-BR/reference/data-types/decimal)
**Valor retornado**
Valor do tipo Decimal(9, S) em caso de sucesso; caso contrário, retorna o valor padrão, se fornecido, ou 0, se não. [`Decimal32(S)`](/pt-BR/reference/data-types/decimal)
**Exemplos**
**Conversão bem-sucedida**
```sql title=Query theme={null}
SELECT toDecimal32OrDefault(toString(0.0001), 5)
```
```response title=Response theme={null}
0.0001
```
**Falha de conversão**
```sql title=Query theme={null}
SELECT toDecimal32OrDefault('Inf', 0, CAST('-1', 'Decimal32(0)'))
```
```response title=Response theme={null}
-1
```
## toDecimal32OrNull
Introduzido em: v20.1.0
Converte um valor de entrada em um valor do tipo [`Decimal(9, S)`](/pt-BR/reference/data-types/decimal), mas retorna `NULL` em caso de erro.
Assim como [`toDecimal32`](#toDecimal32), mas retorna `NULL` em vez de lançar uma exceção em caso de erro de conversão.
Argumentos aceitos:
* Valores ou representações em string do tipo (U)Int\*.
* Valores ou representações em string do tipo Float\*.
Argumentos não aceitos (retornam `NULL`):
* Valores ou representações em string de valores Float\* `NaN` e `Inf` (sem diferenciar maiúsculas de minúsculas).
* Representações em string de valores binários e hexadecimais.
* Valores que excedem os limites de `Decimal32`:`(-1*10^(9 - S), 1*10^(9 - S))`.
Veja também:
* [`toDecimal32`](#toDecimal32).
* [`toDecimal32OrZero`](#toDecimal32OrZero).
* [`toDecimal32OrDefault`](#toDecimal32OrDefault).
**Sintaxe**
```sql theme={null}
toDecimal32OrNull(expr, S)
```
**Argumentos**
* `expr` — Expressão que retorna um número ou uma representação textual de um número. [`Expressão`](/pt-BR/reference/data-types/special-data-types/expression)
* `S` — Parâmetro de escala entre 0 e 9, que especifica quantos dígitos a parte fracionária de um número pode ter. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um valor Decimal(9, S) em caso de sucesso; caso contrário, `NULL`. [`Decimal32(S)`](/pt-BR/reference/data-types/decimal) ou [`NULL`](/pt-BR/reference/syntax#null)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v20.1.0
Converte um valor de entrada em um valor do tipo [Decimal(9, S)](/pt-BR/reference/data-types/decimal), mas retorna `0` em caso de erro.
Semelhante a [`toDecimal32`](#toDecimal32), mas retorna `0` em vez de lançar uma exceção em erros de conversão.
Argumentos compatíveis:
* Valores ou representações em string do tipo (U)Int\*.
* Valores ou representações em string do tipo Float\*.
Argumentos sem suporte (retornam `0`):
* Valores ou representações em string de valores `NaN` e `Inf` do tipo Float\* (sem diferenciar maiúsculas de minúsculas).
* Representações em string de valores binários e hexadecimais.
Se o valor de entrada exceder os limites de `Decimal32`:`(-1*10^(9 - S), 1*10^(9 - S))`, a função retorna `0`.
**Sintaxe**
```sql theme={null}
toDecimal32OrZero(expr, S)
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação textual de um número. [`Expressão`](/pt-BR/reference/data-types/special-data-types/expression)
* `S` — Parâmetro de escala entre 0 e 9, que especifica quantos dígitos a parte fracionária de um número pode ter. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um valor `Decimal(9, S)` em caso de sucesso; caso contrário, `0`. [`Decimal32(S)`](/pt-BR/reference/data-types/decimal)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v18.12.0
Converte um valor de entrada em um valor do tipo [`Decimal(18, S)`](/pt-BR/reference/data-types/decimal), com escala `S`.
Lança uma exceção em caso de erro.
Argumentos aceitos:
* Valores ou representações em string do tipo (U)Int\*.
* Valores ou representações em string do tipo Float\*.
Argumentos não aceitos:
* Valores ou representações em string dos valores Float\* `NaN` e `Inf` (sem diferenciar maiúsculas de minúsculas).
* Representações em string de valores binários e hexadecimais, por exemplo, `SELECT toDecimal64('0xc0fe', 1);`.
Pode ocorrer overflow se o valor de `expr` exceder os limites de `Decimal64`:`(-1*10^(18 - S), 1*10^(18 - S))`.
Dígitos em excesso na parte fracionária são descartados (não arredondados).
Dígitos em excesso na parte inteira causarão uma exceção.
As conversões descartam dígitos extras e podem se comportar de forma inesperada ao trabalhar com entradas Float32/Float64, pois as operações são realizadas com instruções de ponto flutuante.
Por exemplo: `toDecimal64(1.15, 2)` é igual a `1.14` porque 1.15 \* 100 em ponto flutuante é 114.99.
Você pode usar uma entrada String para que as operações usem o tipo inteiro subjacente: `toDecimal64('1.15', 2) = 1.15`
**Sintaxe**
```sql theme={null}
toDecimal64(expr, S)
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação em string de um número. [`Expressão`](/pt-BR/reference/data-types/special-data-types/expression)
* `S` — Parâmetro de escala entre 0 e 18, que especifica quantos dígitos a parte fracionária de um número pode ter. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um valor decimal. [`Decimal(18, S)`](/pt-BR/reference/data-types/decimal)
**Exemplos**
**Exemplo de uso**
```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}
Linha 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
Introduzido em: v21.11.0
Assim como [`toDecimal64`](#toDecimal64), esta função converte um valor de entrada em um valor do tipo [Decimal(18, S)](/pt-BR/reference/data-types/decimal), mas retorna o valor padrão em caso de erro.
**Sintaxe**
```sql theme={null}
toDecimal64OrDefault(expr, S[, default])
```
**Argumentos**
* `expr` — Uma representação em string de um número. [`String`](/pt-BR/reference/data-types/string)
* `S` — Parâmetro de escala entre 0 e 18, que especifica quantos dígitos a parte fracionária de um número pode ter. [`UInt8`](/pt-BR/reference/data-types/int-uint)
* `default` — Opcional. O valor padrão a ser retornado caso a conversão para o tipo Decimal64(S) falhe. [`Decimal64(S)`](/pt-BR/reference/data-types/decimal)
**Valor retornado**
Um valor do tipo Decimal(18, S) em caso de sucesso; caso contrário, retorna o valor padrão, se ele tiver sido fornecido, ou 0, se não. [`Decimal64(S)`](/pt-BR/reference/data-types/decimal)
**Exemplos**
**Conversão bem-sucedida**
```sql title=Query theme={null}
SELECT toDecimal64OrDefault(toString(0.0001), 18)
```
```response title=Response theme={null}
0.0001
```
**Falha na conversão**
```sql title=Query theme={null}
SELECT toDecimal64OrDefault('Inf', 0, CAST('-1', 'Decimal64(0)'))
```
```response title=Response theme={null}
-1
```
## toDecimal64OrNull
Introduzido em: v20.1.0
Converte um valor de entrada em um valor do tipo [Decimal(18, S)](/pt-BR/reference/data-types/decimal), mas retorna `NULL` em caso de erro.
Como [`toDecimal64`](#toDecimal64), mas retorna `NULL` em vez de lançar uma exceção em erros de conversão.
Argumentos suportados:
* Valores ou representações em string do tipo (U)Int\*.
* Valores ou representações em string do tipo Float\*.
Argumentos não suportados (retornam `NULL`):
* Valores ou representações em string de valores Float\* `NaN` e `Inf` (sem diferenciar maiúsculas de minúsculas).
* Representações em string de valores binários e hexadecimais.
* Valores que excedem os limites de `Decimal64`:`(-1*10^(18 - S), 1*10^(18 - S))`.
Veja também:
* [`toDecimal64`](#toDecimal64).
* [`toDecimal64OrZero`](#toDecimal64OrZero).
* [`toDecimal64OrDefault`](#toDecimal64OrDefault).
**Sintaxe**
```sql theme={null}
toDecimal64OrNull(expr, S)
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação textual de um número. [`Expressão`](/pt-BR/reference/data-types/special-data-types/expression)
* `S` — Parâmetro de escala entre 0 e 18, especificando quantos dígitos a parte fracionária de um número pode ter. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um valor Decimal(18, S) em caso de sucesso; caso contrário, `NULL`. [`Decimal64(S)`](/pt-BR/reference/data-types/decimal) ou [`NULL`](/pt-BR/reference/syntax#null)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v20.1.0
Converte um valor de entrada para um valor do tipo [Decimal(18, S)](/pt-BR/reference/data-types/decimal), mas retorna `0` em caso de erro.
Semelhante a [`toDecimal64`](#toDecimal64), mas retorna `0` em vez de lançar uma exceção quando ocorrem erros de conversão.
Argumentos suportados:
* Valores ou representações textuais do tipo (U)Int\*.
* Valores ou representações textuais do tipo Float\*.
Argumentos não suportados (retornam `0`):
* Valores ou representações textuais de valores Float\* `NaN` e `Inf` (sem distinguir maiúsculas de minúsculas).
* Representações textuais de valores binários e hexadecimais.
Se o valor de entrada exceder os limites de `Decimal64`:`(-1*10^(18 - S), 1*10^(18 - S))`, a função retorna `0`.
Veja também:
* [`toDecimal64`](#toDecimal64).
* [`toDecimal64OrNull`](#toDecimal64OrNull).
* [`toDecimal64OrDefault`](#toDecimal64OrDefault).
**Sintaxe**
```sql theme={null}
toDecimal64OrZero(expr, S)
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação em string de um número. [`Expressão`](/pt-BR/reference/data-types/special-data-types/expression)
* `S` — Parâmetro de escala entre 0 e 18, que especifica quantos dígitos a parte fracionária de um número pode ter. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um valor `Decimal(18, S)` em caso de sucesso; caso contrário, `0`. [`Decimal64(S)`](/pt-BR/reference/data-types/decimal)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v23.3.0
Converte um valor numérico para uma String com o número especificado de dígitos fracionários.
A função arredonda o valor de entrada para o número especificado de casas decimais. Se o valor de entrada tiver menos dígitos fracionários
do que o solicitado, o resultado será preenchido com zeros para atingir exatamente o número de dígitos fracionários especificado.
**Sintaxe**
```sql theme={null}
toDecimalString(number, scale)
```
**Argumentos**
* `number` — O valor numérico a ser convertido em uma String. Pode ser qualquer tipo numérico (Int, UInt, Float, Decimal). [`Int8`](/pt-BR/reference/data-types/int-uint) ou [`Int16`](/pt-BR/reference/data-types/int-uint) ou [`Int32`](/pt-BR/reference/data-types/int-uint) ou [`Int64`](/pt-BR/reference/data-types/int-uint) ou [`UInt8`](/pt-BR/reference/data-types/int-uint) ou [`UInt16`](/pt-BR/reference/data-types/int-uint) ou [`UInt32`](/pt-BR/reference/data-types/int-uint) ou [`UInt64`](/pt-BR/reference/data-types/int-uint) ou [`Float32`](/pt-BR/reference/data-types/float) ou [`Float64`](/pt-BR/reference/data-types/float) ou [`Decimal`](/pt-BR/reference/data-types/decimal)
* `scale` — O número de dígitos a serem exibidos na parte fracionária. O resultado será arredondado, se necessário. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna uma representação em String do número com exatamente a quantidade especificada de dígitos fracionários. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Arredondar e formatar um número**
```sql title=Query theme={null}
SELECT toDecimalString(2.1456, 2)
```
```response title=Response theme={null}
┌─toDecimalString(2.1456, 2)─┐
│ 2.15 │
└────────────────────────────┘
```
**Completar com zeros**
```sql title=Query theme={null}
SELECT toDecimalString(5, 3)
```
```response title=Response theme={null}
┌─toDecimalString(5, 3)─┐
│ 5.000 │
└───────────────────────┘
```
**Diferentes tipos numéricos**
```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
Introduzido em: v1.1.0
Converte um argumento [`String`](/pt-BR/reference/data-types/string) em um tipo [`FixedString(N)`](/pt-BR/reference/data-types/fixedstring) (uma string com comprimento fixo N).
Se a string tiver menos bytes do que N, ela será preenchida com bytes nulos à direita.
Se a string tiver mais bytes do que N, uma exceção será gerada.
**Sintaxe**
```sql theme={null}
toFixedString(s, N)
```
**Argumentos**
* `s` — `String` a ser convertida. [`String`](/pt-BR/reference/data-types/string)
* `N` — Comprimento da `FixedString` resultante. [`const UInt*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna uma `FixedString` de comprimento N. [`FixedString(N)`](/pt-BR/reference/data-types/fixedstring)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT toFixedString('foo', 8) AS s;
```
```response title=Response theme={null}
┌─s─────────────┐
│ foo\0\0\0\0\0 │
└───────────────┘
```
## toFloat32
Introduzido em: v1.1.0
Converte um valor de entrada em um valor do tipo [Float32](/pt-BR/reference/data-types/float).
Lança uma exceção em caso de erro.
Argumentos suportados:
* Valores do tipo (U)Int\*.
* Representações em string de (U)Int8/16/32/128/256.
* Valores do tipo Float\*, incluindo `NaN` e `Inf`.
* Representações em string de Float\*, incluindo `NaN` e `Inf` (sem diferenciar maiúsculas de minúsculas).
Argumentos não suportados:
* Representações em string de valores binários e hexadecimais, por exemplo, `SELECT toFloat32('0xc0fe');`.
Veja também:
* [`toFloat32OrZero`](#toFloat32OrZero).
* [`toFloat32OrNull`](#toFloat32OrNull).
* [`toFloat32OrDefault`](#toFloat32OrDefault).
**Sintaxe**
```sql theme={null}
toFloat32(expr)
```
**Argumentos**
* `expr` — Expressão que retorna um número ou uma representação em string de um número. [`Expressão`](/pt-BR/reference/data-types/special-data-types/expression)
**Valor retornado**
Retorna um valor de ponto flutuante de 32 bits. [`Float32`](/pt-BR/reference/data-types/float)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toFloat32(42.7),
toFloat32('42.7'),
toFloat32('NaN')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toFloat32(42.7): 42.7
toFloat32('42.7'): 42.7
toFloat32('NaN'): nan
```
## toFloat32OrDefault
Introduzido em: v21.11.0
Assim como [`toFloat32`](#toFloat32), esta função converte um valor de entrada em um valor do tipo [Float32](/pt-BR/reference/data-types/float), mas retorna o valor padrão em caso de erro.
Se nenhum valor `default` for informado, `0` será retornado em caso de erro.
**Sintaxe**
```sql theme={null}
toFloat32OrDefault(expr[, default])
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação em string de um número. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float)
* `default` — Opcional. O valor padrão a ser retornado se a análise não for bem-sucedida. [`Float32`](/pt-BR/reference/data-types/float)
**Valor retornado**
Retorna um valor do tipo Float32 em caso de sucesso; caso contrário, retorna o valor padrão, se fornecido, ou 0, se não. [`Float32`](/pt-BR/reference/data-types/float)
**Exemplos**
**Conversão bem-sucedida**
```sql title=Query theme={null}
SELECT toFloat32OrDefault('8', CAST('0', 'Float32'))
```
```response title=Response theme={null}
8
```
**Falha na conversão**
```sql title=Query theme={null}
SELECT toFloat32OrDefault('abc', CAST('0', 'Float32'))
```
```response title=Response theme={null}
0
```
## toFloat32OrNull
Introduzido em: v1.1.0
Converte um valor de entrada em um valor do tipo [Float32](/pt-BR/reference/data-types/float), mas retorna `NULL` em caso de erro.
Semelhante a [`toFloat32`](#toFloat32), mas retorna `NULL` em vez de lançar uma exceção em caso de erro de conversão.
Argumentos suportados:
* Valores do tipo (U)Int\*.
* Representações em string de (U)Int8/16/32/128/256.
* Valores do tipo Float\*, incluindo `NaN` e `Inf`.
* Representações em string de Float\*, incluindo `NaN` e `Inf` (sem diferenciar maiúsculas de minúsculas).
Argumentos não suportados (retornam `NULL`):
* Representações em string de valores binários e hexadecimais, por exemplo, `SELECT toFloat32OrNull('0xc0fe');`.
* Formatos de string inválidos.
Veja também:
* [`toFloat32`](#toFloat32).
* [`toFloat32OrZero`](#toFloat32OrZero).
* [`toFloat32OrDefault`](#toFloat32OrDefault).
**Sintaxe**
```sql theme={null}
toFloat32OrNull(x)
```
**Argumentos**
* `x` — A representação em string de um número. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor `Float32` em caso de sucesso; caso contrário, `NULL`. [`Float32`](/pt-BR/reference/data-types/float) ou [`NULL`](/pt-BR/reference/syntax#null)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toFloat32OrNull('42.7'),
toFloat32OrNull('NaN'),
toFloat32OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toFloat32OrNull('42.7'): 42.7
toFloat32OrNull('NaN'): nan
toFloat32OrNull('abc'): \N
```
## toFloat32OrZero
Introduzido em: v1.1.0
Converte um valor de entrada em um valor do tipo [Float32](/pt-BR/reference/data-types/float), mas retorna `0` em caso de erro.
Semelhante a [`toFloat32`](#toFloat32), mas retorna `0` em vez de gerar uma exceção em caso de erro de conversão.
Veja também:
* [`toFloat32`](#toFloat32).
* [`toFloat32OrNull`](#toFloat32OrNull).
* [`toFloat32OrDefault`](#toFloat32OrDefault).
**Sintaxe**
```sql theme={null}
toFloat32OrZero(x)
```
**Argumentos**
* `x` — Uma representação textual de um número. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor `Float32` em caso de sucesso; caso contrário, `0`. [`Float32`](/pt-BR/reference/data-types/float)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toFloat32OrZero('42.7'),
toFloat32OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toFloat32OrZero('42.7'): 42.7
toFloat32OrZero('abc'): 0
```
## toFloat64
Introduzido em: v1.1.0
Converte um valor de entrada em um valor do tipo [`Float64`](/pt-BR/reference/data-types/float).
Lança uma exceção em caso de erro.
Argumentos aceitos:
* Valores do tipo (U)Int\*.
* Representações em string de (U)Int8/16/32/128/256.
* Valores do tipo Float\*, incluindo `NaN` e `Inf`.
* Representações em string do tipo Float\*, incluindo `NaN` e `Inf` (não diferencia maiúsculas de minúsculas).
Argumentos não aceitos:
* Representações em string de valores binários e hexadecimais, por exemplo, `SELECT toFloat64('0xc0fe');`.
Veja também:
* [`toFloat64OrZero`](#toFloat64OrZero).
* [`toFloat64OrNull`](#toFloat64OrNull).
* [`toFloat64OrDefault`](#toFloat64OrDefault).
**Sintaxe**
```sql theme={null}
toFloat64(expr)
```
**Argumentos**
* `expr` — Expressão que retorna um número ou uma representação textual de um número. [`Expression`](/pt-BR/reference/data-types/special-data-types/expression)
**Valor retornado**
Retorna um valor de ponto flutuante de 64 bits. [`Float64`](/pt-BR/reference/data-types/float)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toFloat64(42.7),
toFloat64('42.7'),
toFloat64('NaN')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toFloat64(42.7): 42.7
toFloat64('42.7'): 42.7
toFloat64('NaN'): nan
```
## toFloat64OrDefault
Introduzido em: v21.11.0
Assim como [`toFloat64`](#toFloat64), esta função converte um valor de entrada em um valor do tipo [Float64](/pt-BR/reference/data-types/float), mas retorna o valor padrão em caso de erro.
Se nenhum valor `default` for informado, `0` será retornado em caso de erro.
**Sintaxe**
```sql theme={null}
toFloat64OrDefault(expr[, default])
```
**Argumentos**
* `expr` — Expressão que retorna um número ou uma representação textual de um número. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float)
* `default` — Opcional. O valor padrão a ser retornado se a conversão não for bem-sucedida. [`Float64`](/pt-BR/reference/data-types/float)
**Valor retornado**
Retorna um valor do tipo Float64 se a conversão for bem-sucedida; caso contrário, retorna o valor padrão, se informado, ou 0, se não. [`Float64`](/pt-BR/reference/data-types/float)
**Exemplos**
**Conversão bem-sucedida**
```sql title=Query theme={null}
SELECT toFloat64OrDefault('8', CAST('0', 'Float64'))
```
```response title=Response theme={null}
8
```
**Falha na conversão**
```sql title=Query theme={null}
SELECT toFloat64OrDefault('abc', CAST('0', 'Float64'))
```
```response title=Response theme={null}
0
```
## toFloat64OrNull
Introduzido em: v1.1.0
Converte um valor de entrada para o tipo [Float64](/pt-BR/reference/data-types/float), mas retorna `NULL` em caso de erro.
Como [`toFloat64`](#toFloat64), mas retorna `NULL` em vez de lançar uma exceção em erros de conversão.
Argumentos suportados:
* Valores do tipo (U)Int\*.
* Representações em string de (U)Int8/16/32/128/256.
* Valores do tipo Float\*, incluindo `NaN` e `Inf`.
* Representações em string do tipo Float\*, incluindo `NaN` e `Inf` (sem diferenciar maiúsculas de minúsculas).
Argumentos não suportados (retornam `NULL`):
* Representações em string de valores binários e hexadecimais, por exemplo, `SELECT toFloat64OrNull('0xc0fe');`.
* Formatos de string inválidos.
Veja também:
* [`toFloat64`](#toFloat64).
* [`toFloat64OrZero`](#toFloat64OrZero).
* [`toFloat64OrDefault`](#toFloat64OrDefault).
**Sintaxe**
```sql theme={null}
toFloat64OrNull(x)
```
**Argumentos**
* `x` — Uma representação textual de um número. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor `Float64` em caso de sucesso; caso contrário, `NULL`. [`Float64`](/pt-BR/reference/data-types/float) ou [`NULL`](/pt-BR/reference/syntax#null)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toFloat64OrNull('42.7'),
toFloat64OrNull('NaN'),
toFloat64OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toFloat64OrNull('42.7'): 42.7
toFloat64OrNull('NaN'): nan
toFloat64OrNull('abc'): \N
```
## toFloat64OrZero
Introduzido em: v1.1.0
Converte um valor de entrada em um valor do tipo [Float64](/pt-BR/reference/data-types/float), mas retorna `0` em caso de erro.
Semelhante a [`toFloat64`](#toFloat64), mas retorna `0` em vez de lançar uma exceção em caso de erro de conversão.
Veja também:
* [`toFloat64`](#toFloat64).
* [`toFloat64OrNull`](#toFloat64OrNull).
* [`toFloat64OrDefault`](#toFloat64OrDefault).
**Sintaxe**
```sql theme={null}
toFloat64OrZero(x)
```
**Argumentos**
* `x` — A representação textual de um número. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor `Float64` em caso de sucesso; caso contrário, `0`. [`Float64`](/pt-BR/reference/data-types/float)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toFloat64OrZero('42.7'),
toFloat64OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toFloat64OrZero('42.7'): 42.7
toFloat64OrZero('abc'): 0
```
## toInt128
Introduzido em: v1.1.0
Converte um valor de entrada em um valor do tipo [Int128](/pt-BR/reference/data-types/int-uint).
Lança uma exceção em caso de erro.
A função usa arredondamento em direção a zero, ou seja, trunca os dígitos fracionários dos números.
Argumentos compatíveis:
* Valores ou representações em string do tipo (U)Int\*.
* Valores do tipo Float\*.
Argumentos não compatíveis:
* Representações em string de valores do tipo Float\*, incluindo `NaN` e `Inf`.
* Representações em string de valores binários e hexadecimais, por exemplo, `SELECT toInt128('0xc0fe');`.
Se o valor de entrada não puder ser representado dentro dos limites de Int128, o resultado sofrerá overflow ou underflow.
Isso não é considerado um erro.
Veja também:
* [`toInt128OrZero`](#toInt128OrZero).
* [`toInt128OrNull`](#toInt128OrNull).
* [`toInt128OrDefault`](#toInt128OrDefault).
**Sintaxe**
```sql theme={null}
toInt128(expr)
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação textual de um número. [`Expression`](/pt-BR/reference/data-types/special-data-types/expression)
**Valor retornado**
Retorna um valor inteiro de 128 bits. [`Int128`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toInt128(-128),
toInt128(-128.8),
toInt128('-128')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toInt128(-128): -128
toInt128(-128.8): -128
toInt128('-128'): -128
```
## toInt128OrDefault
Introduzido em: v21.11.0
Assim como [`toInt128`](#toInt128), esta função converte um valor de entrada em um valor do tipo [Int128](/pt-BR/reference/data-types/int-uint), mas retorna o valor padrão em caso de erro.
Se nenhum valor `default` for fornecido, `0` será retornado em caso de erro.
**Sintaxe**
```sql theme={null}
toInt128OrDefault(expr[, default])
```
**Argumentos**
* `expr` — Expressão que retorna um número ou uma representação textual de um número. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float)
* `default` — Opcional. O valor padrão a ser retornado se a análise falhar. [`Int128`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um valor do tipo Int128 em caso de sucesso; caso contrário, retorna o valor padrão, se fornecido, ou 0, se não. [`Int128`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Conversão bem-sucedida**
```sql title=Query theme={null}
SELECT toInt128OrDefault('-128', CAST('-1', 'Int128'))
```
```response title=Response theme={null}
-128
```
**Falha na conversão**
```sql title=Query theme={null}
SELECT toInt128OrDefault('abc', CAST('-1', 'Int128'))
```
```response title=Response theme={null}
-1
```
## toInt128OrNull
Introduzido em: v20.8.0
Assim como [`toInt128`](#toInt128), esta função converte um valor de entrada em um valor do tipo [Int128](/pt-BR/reference/data-types/int-uint), mas retorna `NULL` em caso de erro.
Argumentos aceitos:
* Representações de string de (U)Int\*.
Argumentos não aceitos (retornam `NULL`):
* Representações de string de valores Float\*, incluindo `NaN` e `Inf`.
* Representações de string de valores binários e hexadecimais, por exemplo, `SELECT toInt128OrNull('0xc0fe');`.
Se o valor de entrada não puder ser representado dentro dos limites de [Int128](/pt-BR/reference/data-types/int-uint), ocorrerá overflow ou underflow no resultado.
Isso não é considerado um erro.
Veja também:
* [`toInt128`](#toInt128).
* [`toInt128OrZero`](#toInt128OrZero).
* [`toInt128OrDefault`](#toInt128OrDefault).
**Sintaxe**
```sql theme={null}
toInt128OrNull(x)
```
**Argumentos**
* `x` — Uma representação textual de um número. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor do tipo Int128 ou `NULL` se a conversão não for bem-sucedida. [`Int128`](/pt-BR/reference/data-types/int-uint) ou [`NULL`](/pt-BR/reference/syntax#null)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toInt128OrNull('-128'),
toInt128OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toInt128OrNull('-128'): -128
toInt128OrNull('abc'): \N
```
## toInt128OrZero
Introduzido em: v20.8.0
Converte um valor de entrada para o tipo [Int128](/pt-BR/reference/data-types/int-uint), mas retorna `0` em caso de erro.
Semelhante a [`toInt128`](#toInt128), mas retorna `0` em vez de gerar uma exceção.
Veja também:
* [`toInt128`](#toInt128).
* [`toInt128OrNull`](#toInt128OrNull).
* [`toInt128OrDefault`](#toInt128OrDefault).
**Sintaxe**
```sql theme={null}
toInt128OrZero(x)
```
**Argumentos**
* `x` — Valor de entrada a ser convertido. [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`Decimal`](/pt-BR/reference/data-types/decimal) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Date`](/pt-BR/reference/data-types/date) ou [`DateTime`](/pt-BR/reference/data-types/datetime)
**Valor retornado**
Retorna o valor de entrada convertido ou `0` se a conversão falhar. [`Int128`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT toInt128OrZero('123')
```
```response title=Response theme={null}
123
```
**Conversões com falha retornam zero**
```sql title=Query theme={null}
SELECT toInt128OrZero('abc')
```
```response title=Response theme={null}
0
```
## toInt16
Introduzido em: v1.1.0
Converte um valor de entrada para um valor do tipo [`Int16`](/pt-BR/reference/data-types/int-uint).
Lança uma exceção em caso de erro.
Argumentos suportados:
* Valores ou representações em string do tipo (U)Int\*.
* Valores do tipo Float\*.
Argumentos não suportados:
* Representações em string de valores Float\*, incluindo `NaN` e `Inf`.
* Representações em string de valores binários e hexadecimais, por exemplo, `SELECT toInt16('0xc0fe');`.
Se o valor de entrada não puder ser representado dentro dos limites de [Int16](/pt-BR/reference/data-types/int-uint), ocorre overflow ou underflow no resultado.
Isso não é considerado um erro.
Por exemplo: `SELECT toInt16(32768) == -32768;`.
A função usa [arredondamento em direção a zero](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), ou seja, trunca os dígitos fracionários dos números.
Veja também:
* [`toInt16OrZero`](#toInt16OrZero).
* [`toInt16OrNull`](#toInt16OrNull).
* [`toInt16OrDefault`](#toInt16OrDefault).
**Sintaxe**
```sql theme={null}
toInt16(expr)
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação textual de um número. [`Expression`](/pt-BR/reference/data-types/special-data-types/expression)
**Valor retornado**
Retorna um valor inteiro de 16 bits. [`Int16`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toInt16(-16),
toInt16(-16.16),
toInt16('-16')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toInt16(-16): -16
toInt16(-16.16): -16
toInt16('-16'): -16
```
## toInt16OrDefault
Introduzido em: v21.11.0
Assim como [`toInt16`](#toInt16), esta função converte um valor de entrada em um valor do tipo [Int16](/pt-BR/reference/data-types/int-uint), mas retorna o valor padrão em caso de erro.
Se nenhum valor `default` for informado, `0` será retornado em caso de erro.
**Sintaxe**
```sql theme={null}
toInt16OrDefault(expr[, default])
```
**Argumentos**
* `expr` — Expressão que retorna um número ou uma representação textual de um número. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float)
* `default` — Opcional. O valor padrão a ser retornado se a conversão não for bem-sucedida. [`Int16`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um valor do tipo Int16 em caso de sucesso; caso contrário, retorna o valor padrão, se fornecido, ou 0, se não. [`Int16`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Conversão bem-sucedida**
```sql title=Query theme={null}
SELECT toInt16OrDefault('-16', CAST('-1', 'Int16'))
```
```response title=Response theme={null}
-16
```
**Falha de conversão**
```sql title=Query theme={null}
SELECT toInt16OrDefault('abc', CAST('-1', 'Int16'))
```
```response title=Response theme={null}
-1
```
## toInt16OrNull
Introduzido em: v1.1.0
Assim como [`toInt16`](#toInt16), esta função converte um valor de entrada para um valor do tipo [Int16](/pt-BR/reference/data-types/int-uint), mas retorna `NULL` em caso de erro.
Argumentos compatíveis:
* Representações em string de (U)Int\*.
Argumentos não compatíveis (retornam `NULL`):
* Representações em string de valores Float\*, incluindo `NaN` e `Inf`.
* Representações em string de valores binários e hexadecimais, por exemplo, `SELECT toInt16OrNull('0xc0fe');`.
Se o valor de entrada não puder ser representado dentro dos limites de [Int16](/pt-BR/reference/data-types/int-uint), ocorre overflow ou underflow no resultado.
Isso não é considerado um erro.
Veja também:
* [`toInt16`](#toInt16).
* [`toInt16OrZero`](#toInt16OrZero).
* [`toInt16OrDefault`](#toInt16OrDefault).
**Sintaxe**
```sql theme={null}
toInt16OrNull(x)
```
**Argumentos**
* `x` — Uma representação em `String` de um número. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor do tipo `Int16` ou `NULL`, caso a conversão não seja bem-sucedida. [`Int16`](/pt-BR/reference/data-types/int-uint) ou [`NULL`](/pt-BR/reference/syntax#null)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toInt16OrNull('-16'),
toInt16OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toInt16OrNull('-16'): -16
toInt16OrNull('abc'): \N
```
## toInt16OrZero
Introduzido em: v1.1.0
Assim como [`toInt16`](#toInt16), esta função converte um valor de entrada em um valor do tipo [Int16](/pt-BR/reference/data-types/int-uint), mas retorna `0` em caso de erro.
Argumentos compatíveis:
* Representações em string de (U)Int\*.
Argumentos incompatíveis (retornam `0`):
* Representações em string de valores Float\*, incluindo `NaN` e `Inf`.
* Representações em string de valores binários e hexadecimais, por exemplo, `SELECT toInt16OrZero('0xc0fe');`.
Se o valor de entrada não puder ser representado dentro dos limites de [Int16](/pt-BR/reference/data-types/int-uint), ocorrerá overflow ou underflow no resultado.
Isso não é considerado um erro.
Veja também:
* [`toInt16`](#toInt16).
* [`toInt16OrNull`](#toInt16OrNull).
* [`toInt16OrDefault`](#toInt16OrDefault).
**Sintaxe**
```sql theme={null}
toInt16OrZero(x)
```
**Argumentos**
* `x` — A representação textual de um número em String. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor do tipo Int16 ou `0`, se a conversão falhar. [`Int16`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toInt16OrZero('16'),
toInt16OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toInt16OrZero('16'): 16
toInt16OrZero('abc'): 0
```
## toInt256
Introduzido em: v1.1.0
Converte um valor de entrada em um valor do tipo [Int256](/pt-BR/reference/data-types/int-uint).
Lança uma exceção em caso de erro.
A função usa arredondamento em direção a zero, ou seja, trunca os dígitos fracionários dos números.
Argumentos suportados:
* Valores ou representações em string do tipo (U)Int\*.
* Valores do tipo Float\*.
Argumentos não suportados:
* Representações em string de valores Float\*, incluindo `NaN` e `Inf`.
* Representações em string de valores binários e hexadecimais, por exemplo, `SELECT toInt256('0xc0fe');`.
Se o valor de entrada não puder ser representado dentro dos limites de Int256, o resultado terá overflow ou underflow.
Isso não é considerado um erro.
Veja também:
* [`toInt256OrZero`](#toInt256OrZero).
* [`toInt256OrNull`](#toInt256OrNull).
* [`toInt256OrDefault`](#toInt256OrDefault).
**Sintaxe**
```sql theme={null}
toInt256(expr)
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação em string de um número. [`Expressão`](/pt-BR/reference/data-types/special-data-types/expression)
**Valor retornado**
Retorna um valor inteiro de 256 bits. [`Int256`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toInt256(-256),
toInt256(-256.256),
toInt256('-256')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toInt256(-256): -256
toInt256(-256.256): -256
toInt256('-256'): -256
```
## toInt256OrDefault
Introduzido em: v21.11.0
Assim como [`toInt256`](#toInt256), esta função converte um valor de entrada em um valor do tipo [Int256](/pt-BR/reference/data-types/int-uint), mas retorna o valor padrão em caso de erro.
Se nenhum valor `default` for informado, `0` será retornado em caso de erro.
**Sintaxe**
```sql theme={null}
toInt256OrDefault(expr[, default])
```
**Argumentos**
* `expr` — Expressão que retorna um número ou uma representação em string de um número. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float)
* `default` — Opcional. O valor padrão a ser retornado se a interpretação não for bem-sucedida. [`Int256`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um valor do tipo Int256 em caso de sucesso; caso contrário, retorna o valor padrão, se fornecido, ou 0, caso contrário. [`Int256`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Conversão bem-sucedida**
```sql title=Query theme={null}
SELECT toInt256OrDefault('-256', CAST('-1', 'Int256'))
```
```response title=Response theme={null}
-256
```
**Falha na conversão**
```sql title=Query theme={null}
SELECT toInt256OrDefault('abc', CAST('-1', 'Int256'))
```
```response title=Response theme={null}
-1
```
## toInt256OrNull
Introduzido em: v20.8.0
Assim como [`toInt256`](#toInt256), esta função converte um valor de entrada em um valor do tipo [Int256](/pt-BR/reference/data-types/int-uint), mas retorna `NULL` em caso de erro.
Argumentos suportados:
* representações em string de (U)Int\*.
Argumentos não suportados (retornam `NULL`):
* representações em string de valores Float\*, incluindo `NaN` e `Inf`.
* representações em string de valores binários e hexadecimais, por exemplo, `SELECT toInt256OrNull('0xc0fe');`.
Se o valor de entrada não puder ser representado dentro dos limites de [Int256](/pt-BR/reference/data-types/int-uint), ocorrerá overflow ou underflow do resultado.
Isso não é considerado um erro.
Veja também:
* [`toInt256`](#toInt256).
* [`toInt256OrZero`](#toInt256OrZero).
* [`toInt256OrDefault`](#toInt256OrDefault).
**Sintaxe**
```sql theme={null}
toInt256OrNull(x)
```
**Argumentos**
* `x` — A representação em string de um número. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor do tipo Int256; caso a conversão não seja bem-sucedida, retorna `NULL`. [`Int256`](/pt-BR/reference/data-types/int-uint) ou [`NULL`](/pt-BR/reference/syntax#null)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toInt256OrNull('-256'),
toInt256OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toInt256OrNull('-256'): -256
toInt256OrNull('abc'): \N
```
## toInt256OrZero
Introduzido em: v20.8.0
Converte um valor de entrada para o tipo [Int256](/pt-BR/reference/data-types/int-uint), mas retorna `0` em caso de erro.
Semelhante a [`toInt256`](#toInt256), mas retorna `0` em vez de gerar uma exceção.
Veja também:
* [`toInt256`](#toInt256).
* [`toInt256OrNull`](#toInt256OrNull).
* [`toInt256OrDefault`](#toInt256OrDefault).
**Sintaxe**
```sql theme={null}
toInt256OrZero(x)
```
**Argumentos**
* `x` — Valor de entrada a ser convertido. [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`Decimal`](/pt-BR/reference/data-types/decimal) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Date`](/pt-BR/reference/data-types/date) ou [`DateTime`](/pt-BR/reference/data-types/datetime)
**Valor retornado**
Retorna o valor de entrada convertido; caso a conversão falhe, retorna `0`. [`Int256`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT toInt256OrZero('123')
```
```response title=Response theme={null}
123
```
**Conversões com falha retornam zero**
```sql title=Query theme={null}
SELECT toInt256OrZero('abc')
```
```response title=Response theme={null}
0
```
## toInt32
Introduzido em: v1.1.0
Converte um valor de entrada em um valor do tipo [`Int32`](/pt-BR/reference/data-types/int-uint).
Lança uma exceção em caso de erro.
Argumentos compatíveis:
* Valores ou representações em string do tipo (U)Int\*.
* Valores do tipo Float\*.
Argumentos não compatíveis:
* representações em string de valores Float\*, incluindo `NaN` e `Inf`.
* representações em string de valores binários e hexadecimais, por exemplo, `SELECT toInt32('0xc0fe');`.
Se o valor de entrada não puder ser representado dentro dos limites de [Int32](/pt-BR/reference/data-types/int-uint), o resultado sofrerá overflow ou underflow.
Isso não é considerado um erro.
Por exemplo: `SELECT toInt32(2147483648) == -2147483648;`
A função usa [arredondamento em direção a zero](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), o que significa que ela trunca os dígitos fracionários dos números.
Veja também:
* [`toInt32OrZero`](#toInt32OrZero).
* [`toInt32OrNull`](#toInt32OrNull).
* [`toInt32OrDefault`](#toInt32OrDefault).
**Sintaxe**
```sql theme={null}
toInt32(expr)
```
**Argumentos**
* `expr` — Expressão que retorna um número ou uma representação textual de um número. [`Expressão`](/pt-BR/reference/data-types/special-data-types/expression)
**Valor retornado**
Retorna um inteiro de 32 bits. [`Int32`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toInt32(-32),
toInt32(-32.32),
toInt32('-32')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toInt32(-32): -32
toInt32(-32.32): -32
toInt32('-32'): -32
```
## toInt32OrDefault
Introduzido em: v21.11.0
Assim como [`toInt32`](#toInt32), esta função converte um valor de entrada em um valor do tipo [Int32](/pt-BR/reference/data-types/int-uint), mas retorna o valor padrão em caso de erro.
Se nenhum valor `default` for informado, `0` será retornado em caso de erro.
**Sintaxe**
```sql theme={null}
toInt32OrDefault(expr[, default])
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação em string de um número. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float)
* `default` — Opcional. O valor padrão a ser retornado se o parsing não for bem-sucedido. [`Int32`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um valor do tipo Int32 em caso de sucesso; caso contrário, retorna o valor padrão, se informado, ou 0, caso não tenha sido informado. [`Int32`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Conversão bem-sucedida**
```sql title=Query theme={null}
SELECT toInt32OrDefault('-32', CAST('-1', 'Int32'))
```
```response title=Response theme={null}
-32
```
**Falha na conversão**
```sql title=Query theme={null}
SELECT toInt32OrDefault('abc', CAST('-1', 'Int32'))
```
```response title=Response theme={null}
-1
```
## toInt32OrNull
Introduzido em: v1.1.0
Assim como [`toInt32`](#toInt32), esta função converte um valor de entrada em um valor do tipo [Int32](/pt-BR/reference/data-types/int-uint), mas retorna `NULL` em caso de erro.
Argumentos aceitos:
* Representações em string de (U)Int\*.
Argumentos não aceitos (retornam `NULL`):
* representações em string de valores Float\*, incluindo `NaN` e `Inf`.
* representações em string de valores binários e hexadecimais, por exemplo, `SELECT toInt32OrNull('0xc0fe');`.
Se o valor de entrada não puder ser representado dentro dos limites de [Int32](/pt-BR/reference/data-types/int-uint), ocorre overflow ou underflow no resultado.
Isso não é considerado um erro.
Veja também:
* [`toInt32`](#toInt32).
* [`toInt32OrZero`](#toInt32OrZero).
* [`toInt32OrDefault`](#toInt32OrDefault).
**Sintaxe**
```sql theme={null}
toInt32OrNull(x)
```
**Argumentos**
* `x` — A representação em `String` de um número. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor do tipo Int32 ou `NULL`, caso a conversão não seja bem-sucedida. [`Int32`](/pt-BR/reference/data-types/int-uint) ou [`NULL`](/pt-BR/reference/syntax#null)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toInt32OrNull('-32'),
toInt32OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toInt32OrNull('-32'): -32
toInt32OrNull('abc'): \N
```
## toInt32OrZero
Introduzido em: v1.1.0
Assim como [`toInt32`](#toInt32), esta função converte um valor de entrada em um valor do tipo [Int32](/pt-BR/reference/data-types/int-uint), mas retorna `0` em caso de erro.
Argumentos aceitos:
* Representações em string de (U)Int\*.
Argumentos não aceitos (retornam `0`):
* representações em string de valores Float\*, incluindo `NaN` e `Inf`.
* representações em string de valores binários e hexadecimais, por exemplo, `SELECT toInt32OrZero('0xc0fe');`.
Se o valor de entrada não puder ser representado nos limites de [Int32](/pt-BR/reference/data-types/int-uint), ocorrerá overflow ou underflow no resultado.
Isso não é considerado um erro.
Veja também:
* [`toInt32`](#toInt32).
* [`toInt32OrNull`](#toInt32OrNull).
* [`toInt32OrDefault`](#toInt32OrDefault).
**Sintaxe**
```sql theme={null}
toInt32OrZero(x)
```
**Argumentos**
* `x` — Uma representação em string de um número. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor do tipo Int32; caso a conversão falhe, retorna `0`. [`Int32`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toInt32OrZero('32'),
toInt32OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toInt32OrZero('32'): 32
toInt32OrZero('abc'): 0
```
## toInt64
Introduzido em: v1.1.0
Converte um valor de entrada em um valor do tipo [`Int64`](/pt-BR/reference/data-types/int-uint).
Lança uma exceção em caso de erro.
Argumentos compatíveis:
* Valores ou representações em string do tipo (U)Int\*.
* Valores do tipo Float\*.
Argumentos não compatíveis:
* Representações em string de valores Float\*, incluindo `NaN` e `Inf`.
* Representações em string de valores binários e hexadecimais, por exemplo: `SELECT toInt64('0xc0fe');`.
Se o valor de entrada não puder ser representado dentro dos limites de [Int64](/pt-BR/reference/data-types/int-uint), o resultado terá overflow ou underflow.
Isso não é considerado um erro.
Por exemplo: `SELECT toInt64(9223372036854775808) == -9223372036854775808;`
A função usa [arredondamento em direção a zero](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), ou seja, trunca os dígitos fracionários dos números.
Veja também:
* [`toInt64OrZero`](#toInt64OrZero).
* [`toInt64OrNull`](#toInt64OrNull).
* [`toInt64OrDefault`](#toInt64OrDefault).
**Sintaxe**
```sql theme={null}
toInt64(expr)
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação em string de um número. Compatível com: valores ou representações em string do tipo (U)Int\*; valores do tipo Float\*. Não compatível com: representações em string de valores Float\*, incluindo NaN e Inf; representações em string de valores binários e hexadecimais. [`Expressão`](/pt-BR/reference/data-types/special-data-types/expression)
**Valor retornado**
Retorna um valor inteiro de 64 bits. [`Int64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toInt64(-64),
toInt64(-64.64),
toInt64('-64')
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toInt64(-64): -64
toInt64(-64.64): -64
toInt64('-64'): -64
```
## toInt64OrDefault
Introduzido em: v21.11.0
Assim como [`toInt64`](#toInt64), esta função converte um valor de entrada em um valor do tipo [Int64](/pt-BR/reference/data-types/int-uint), mas retorna o valor padrão em caso de erro.
Se nenhum valor `default` for informado, `0` será retornado em caso de erro.
**Sintaxe**
```sql theme={null}
toInt64OrDefault(expr[, default])
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação textual de um número. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float)
* `default` — Opcional. O valor padrão a ser retornado se o parsing falhar. [`Int64`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um valor do tipo Int64 em caso de sucesso; caso contrário, retorna o valor padrão, se fornecido, ou 0. [`Int64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Conversão bem-sucedida**
```sql title=Query theme={null}
SELECT toInt64OrDefault('-64', CAST('-1', 'Int64'))
```
```response title=Response theme={null}
-64
```
**Falha na conversão**
```sql title=Query theme={null}
SELECT toInt64OrDefault('abc', CAST('-1', 'Int64'))
```
```response title=Response theme={null}
-1
```
## toInt64OrNull
Introduzido em: v1.1.0
Assim como [`toInt64`](#toInt64), esta função converte um valor de entrada em um valor do tipo [Int64](/pt-BR/reference/data-types/int-uint), mas retorna `NULL` em caso de erro.
Argumentos suportados:
* Representações em string de (U)Int\*.
Argumentos não suportados (retornam `NULL`):
* Representações em string de valores Float\*, incluindo `NaN` e `Inf`.
* Representações em string de valores binários e hexadecimais, por exemplo, `SELECT toInt64OrNull('0xc0fe');`.
Se o valor de entrada não puder ser representado dentro dos limites de [Int64](/pt-BR/reference/data-types/int-uint), ocorre overflow ou underflow no resultado.
Isso não é considerado um erro.
Veja também:
* [`toInt64`](#toInt64).
* [`toInt64OrZero`](#toInt64OrZero).
* [`toInt64OrDefault`](#toInt64OrDefault).
**Sintaxe**
```sql theme={null}
toInt64OrNull(x)
```
**Argumentos**
* `x` — A representação em string de um número. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor do tipo Int64; caso contrário, `NULL` se a conversão não for bem-sucedida. [`Int64`](/pt-BR/reference/data-types/int-uint) ou [`NULL`](/pt-BR/reference/syntax#null)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toInt64OrNull('-64'),
toInt64OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toInt64OrNull('-64'): -64
toInt64OrNull('abc'): \N
```
## toInt64OrZero
Introduzido em: v1.1.0
Converte um valor de entrada para o tipo [Int64](/pt-BR/reference/data-types/int-uint), mas retorna `0` em caso de erro.
Semelhante a [`toInt64`](#toInt64), mas retorna `0` em vez de lançar uma exceção.
Veja também:
* [`toInt64`](#toInt64).
* [`toInt64OrNull`](#toInt64OrNull).
* [`toInt64OrDefault`](#toInt64OrDefault).
**Sintaxe**
```sql theme={null}
toInt64OrZero(x)
```
**Argumentos**
* `x` — Valor de entrada a ser convertido. [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`Decimal`](/pt-BR/reference/data-types/decimal) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Date`](/pt-BR/reference/data-types/date) ou [`DateTime`](/pt-BR/reference/data-types/datetime)
**Valor retornado**
Retorna o valor de entrada convertido; caso contrário, `0` se a conversão falhar. [`Int64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT toInt64OrZero('123')
```
```response title=Response theme={null}
123
```
**Em caso de falha na conversão, retorna zero**
```sql title=Query theme={null}
SELECT toInt64OrZero('abc')
```
```response title=Response theme={null}
0
```
## toInt8
Introduzido em: v1.1.0
Converte um valor de entrada para o tipo [`Int8`](/pt-BR/reference/data-types/int-uint).
Lança uma exceção em caso de erro.
Argumentos compatíveis:
* Valores ou representações em string do tipo (U)Int\*.
* Valores do tipo Float\*.
Argumentos não compatíveis:
* Representações em string de valores Float\*, incluindo `NaN` e `Inf`.
* Representações em string de valores binários e hexadecimais, por exemplo, `SELECT toInt8('0xc0fe');`.
Se o valor de entrada não puder ser representado dentro dos limites de [Int8](/pt-BR/reference/data-types/int-uint), ocorrerá overflow ou underflow no resultado.
Isso não é considerado um erro.
Por exemplo: `SELECT toInt8(128) == -128;`.
A função usa [arredondamento em direção a zero](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), ou seja, trunca os dígitos fracionários dos números.
Veja também:
* [`toInt8OrZero`](#toInt8OrZero).
* [`toInt8OrNull`](#toInt8OrNull).
* [`toInt8OrDefault`](#toInt8OrDefault).
**Sintaxe**
```sql theme={null}
toInt8(expr)
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação textual de um número. [`Expressão`](/pt-BR/reference/data-types/special-data-types/expression)
**Valor retornado**
Retorna um valor inteiro de 8 bits. [`Int8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toInt8(-8),
toInt8(-8.8),
toInt8('-8')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toInt8(-8): -8
toInt8(-8.8): -8
toInt8('-8'): -8
```
## toInt8OrDefault
Introduzido em: v21.11.0
Assim como [`toInt8`](#toInt8), esta função converte um valor de entrada em um valor do tipo [Int8](/pt-BR/reference/data-types/int-uint), mas retorna o valor padrão em caso de erro.
Se nenhum valor `default` for informado, `0` será retornado em caso de erro.
**Sintaxe**
```sql theme={null}
toInt8OrDefault(expr[, default])
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação em string de um número. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float)
* `default` — Opcional. O valor padrão a ser retornado se o parsing não for bem-sucedido. [`Int8`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um valor do tipo Int8 se a conversão for bem-sucedida; caso contrário, retorna o valor padrão, se fornecido, ou 0, se não. [`Int8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Conversão bem-sucedida**
```sql title=Query theme={null}
SELECT toInt8OrDefault('-8', CAST('-1', 'Int8'))
```
```response title=Response theme={null}
-8
```
**Falha na conversão**
```sql title=Query theme={null}
SELECT toInt8OrDefault('abc', CAST('-1', 'Int8'))
```
```response title=Response theme={null}
-1
```
## toInt8OrNull
Introduzido em: v1.1.0
Assim como [`toInt8`](#toInt8), esta função converte um valor de entrada em um valor do tipo [Int8](/pt-BR/reference/data-types/int-uint), mas retorna `NULL` em caso de erro.
Argumentos suportados:
* Representações de string de (U)Int\*.
Argumentos não suportados (retornam `NULL`):
* Representações de string de valores Float\*, incluindo `NaN` e `Inf`.
* Representações de string de valores binários e hexadecimais, por exemplo, `SELECT toInt8OrNull('0xc0fe');`.
Se o valor de entrada não puder ser representado dentro dos limites de [Int8](/pt-BR/reference/data-types/int-uint), ocorre overflow ou underflow no resultado.
Isso não é considerado um erro.
Veja também:
* [`toInt8`](#toInt8).
* [`toInt8OrZero`](#toInt8OrZero).
* [`toInt8OrDefault`](#toInt8OrDefault).
**Sintaxe**
```sql theme={null}
toInt8OrNull(x)
```
**Argumentos**
* `x` — Uma representação em string de um número. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor do tipo Int8; caso contrário, `NULL` se a conversão não for bem-sucedida. [`Int8`](/pt-BR/reference/data-types/int-uint) ou [`NULL`](/pt-BR/reference/syntax#null)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toInt8OrNull('-8'),
toInt8OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toInt8OrNull('-8'): -8
toInt8OrNull('abc'): \N
```
## toInt8OrZero
Introduzido em: v1.1.0
Assim como [`toInt8`](#toInt8), esta função converte um valor de entrada em um valor do tipo [Int8](/pt-BR/reference/data-types/int-uint), mas retorna `0` em caso de erro.
Argumentos compatíveis:
* Representações em string de (U)Int\*.
Argumentos não compatíveis (retornam `0`):
* Representações em string de valores Float\*, incluindo `NaN` e `Inf`.
* Representações em string de valores binários e hexadecimais, por exemplo, `SELECT toInt8OrZero('0xc0fe');`.
Se o valor de entrada não puder ser representado dentro dos limites de [Int8](/pt-BR/reference/data-types/int-uint), ocorrerá overflow ou underflow no resultado.
Isso não é considerado um erro.
Veja também:
* [`toInt8`](#toInt8).
* [`toInt8OrNull`](#toInt8OrNull).
* [`toInt8OrDefault`](#toInt8OrDefault).
**Sintaxe**
```sql theme={null}
toInt8OrZero(x)
```
**Argumentos**
* `x` — A representação de um número em `String`. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor do tipo Int8 ou `0` caso a conversão falhe. [`Int8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toInt8OrZero('8'),
toInt8OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toInt8OrZero('8'): 8
toInt8OrZero('abc'): 0
```
## toInterval
Introduzido em: v25.4.0
Cria um valor Interval a partir de um valor numérico e de uma unidade em formato String.
Esta função fornece uma forma unificada de criar intervalos de diferentes tipos (segundos, minutos, horas, dias, semanas, meses, trimestres, anos)
a partir de uma única função, especificando a unidade como um argumento String. A unidade em String não diferencia maiúsculas de minúsculas.
Isso equivale a chamar funções específicas de tipo, como `toIntervalSecond`, `toIntervalMinute`, `toIntervalDay` etc.,
mas permite especificar a unidade dinamicamente como um parâmetro String.
**Sintaxe**
```sql theme={null}
toInterval(value, unit)
```
**Argumentos**
* `value` — O valor numérico que representa a quantidade de unidades. Pode ser qualquer tipo numérico: [`Int8`](/pt-BR/reference/data-types/int-uint) ou [`Int16`](/pt-BR/reference/data-types/int-uint) ou [`Int32`](/pt-BR/reference/data-types/int-uint) ou [`Int64`](/pt-BR/reference/data-types/int-uint) ou [`UInt8`](/pt-BR/reference/data-types/int-uint) ou [`UInt16`](/pt-BR/reference/data-types/int-uint) ou [`UInt32`](/pt-BR/reference/data-types/int-uint) ou [`UInt64`](/pt-BR/reference/data-types/int-uint) ou [`Float32`](/pt-BR/reference/data-types/float) ou [`Float64`](/pt-BR/reference/data-types/float)
* `unit` — A unidade de tempo. Deve ser uma string constante. Valores válidos: 'nanosecond', 'microsecond', 'millisecond', 'second', 'minute', 'hour', 'day', 'week', 'month', 'quarter', 'year'. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor do tipo Interval do tipo especificado. O tipo do resultado depende da unidade: IntervalNanosecond, IntervalMicrosecond, IntervalMillisecond, IntervalSecond, IntervalMinute, IntervalHour, IntervalDay, IntervalWeek, IntervalMonth, IntervalQuarter ou IntervalYear. [`Interval`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Criar intervalos com diferentes unidades**
```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 │
└─────────┴──────┴────────┘
```
**Use intervalos na aritmética de datas**
```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 │
└──────────────────────┴─────────────────────┴─────────────────────┘
```
**Criação dinâmica de intervalos**
```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
Introduzido em: v1.1.0
Retorna um intervalo de `n` dias do tipo de dados [`IntervalDay`](/pt-BR/reference/data-types/special-data-types/interval).
**Sintaxe**
```sql theme={null}
toIntervalDay(n)
```
**Argumentos**
* `n` — Número de dias. Números inteiros ou suas representações em formato de string, e números de ponto flutuante. [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um intervalo de `n` dias. [`Interval`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Retorna um intervalo de `n` horas do tipo de dados [`IntervalHour`](/pt-BR/reference/data-types/special-data-types/interval).
**Sintaxe**
```sql theme={null}
toIntervalHour(n)
```
**Argumentos**
* `n` — Número de horas. Números inteiros ou suas representações em string, e números de ponto flutuante. [`Int*`](/pt-BR/reference/data-types/int-uint) ou [`UInt*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um intervalo de `n` horas. [`Interval`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v22.6.0
Retorna um intervalo de `n` microssegundos do tipo de dados [`IntervalMicrosecond`](/pt-BR/reference/data-types/special-data-types/interval).
**Sintaxe**
```sql theme={null}
toIntervalMicrosecond(n)
```
**Argumentos**
* `n` — Número de microssegundos. [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um intervalo de `n` microssegundos. [`Interval`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v22.6.0
Retorna um intervalo de `n` milissegundos do tipo de dados [IntervalMillisecond](/pt-BR/reference/data-types/special-data-types/interval).
**Sintaxe**
```sql theme={null}
toIntervalMillisecond(n)
```
**Argumentos**
* `n` — Número de milissegundos. [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um intervalo de `n` milissegundos. [`Interval`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Retorna um intervalo de `n` minutos do tipo [`IntervalMinute`](/pt-BR/reference/data-types/special-data-types/interval).
**Sintaxe**
```sql theme={null}
toIntervalMinute(n)
```
**Argumentos**
* `n` — Número de minutos. Números inteiros ou suas representações em string, além de números de ponto flutuante. [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um intervalo de `n` minutos. [`Interval`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```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
Introduzido na versão: v1.1.0
Retorna um intervalo de `n` meses do tipo de dados [`IntervalMonth`](/pt-BR/reference/data-types/special-data-types/interval).
**Sintaxe**
```sql theme={null}
toIntervalMonth(n)
```
**Argumentos**
* `n` — Número de meses. [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um intervalo de `n` meses. [`Interval`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v22.6.0
Retorna um interval de `n` nanossegundos do tipo de dado [`IntervalNanosecond`](/pt-BR/reference/data-types/special-data-types/interval).
**Sintaxe**
```sql theme={null}
toIntervalNanosecond(n)
```
**Argumentos**
* `n` — Quantidade de nanossegundos. [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um intervalo de `n` nanossegundos. [`Interval`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Retorna um intervalo de `n` trimestres do tipo de dados [`IntervalQuarter`](/pt-BR/reference/data-types/special-data-types/interval).
**Sintaxe**
```sql theme={null}
toIntervalQuarter(n)
```
**Argumentos**
* `n` — Número de trimestres. [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um intervalo de `n` trimestres. [`Interval`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Retorna um intervalo de `n` segundos do tipo de dado [`IntervalSecond`](/pt-BR/reference/data-types/special-data-types/interval).
**Sintaxe**
```sql theme={null}
toIntervalSecond(n)
```
**Argumentos**
* `n` — Número de segundos. Números inteiros ou suas representações como string, e números de ponto flutuante. [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um intervalo de `n` segundos. [`Interval`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Retorna um intervalo de `n` semanas do tipo de dados [`IntervalWeek`](/pt-BR/reference/data-types/special-data-types/interval).
**Sintaxe**
```sql theme={null}
toIntervalWeek(n)
```
**Argumentos**
* `n` — Número de semanas. [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um intervalo de `n` semanas. [`Interval`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Retorna um intervalo de `n` anos do tipo de dado [`IntervalYear`](/pt-BR/reference/data-types/special-data-types/interval).
**Sintaxe**
```sql theme={null}
toIntervalYear(n)
```
**Argumentos**
* `n` — Número de anos. [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um intervalo de `n` anos. [`Interval`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v18.12.0
Converte o argumento de entrada para a versão [LowCardinality](/pt-BR/reference/data-types/lowcardinality) do mesmo tipo de dado.
Para converter do tipo de dado `LowCardinality` para um tipo de dado regular, use a função [CAST](#CAST).
Por exemplo: `CAST(x AS String)`.
**Sintaxe**
```sql theme={null}
toLowCardinality(expr)
```
**Argumentos**
* `expr` — Expressão que resulta em um dos tipos de dados compatíveis. [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring) ou [`Date`](/pt-BR/reference/data-types/date) ou [`DateTime`](/pt-BR/reference/data-types/datetime) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float)
**Valor retornado**
Retorna o valor de entrada convertido para o tipo de dados `LowCardinality`. [`LowCardinality`](/pt-BR/reference/data-types/lowcardinality)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT toLowCardinality('1')
```
```response title=Response theme={null}
┌─toLowCardinality('1')─┐
│ 1 │
└───────────────────────┘
```
## toString
Introduzido em: v1.1.0
Converte valores para sua representação textual.
Para argumentos DateTime, a função pode receber um segundo argumento String contendo o nome do fuso horário.
**Sintaxe**
```sql theme={null}
toString(value[, timezone])
```
**Argumentos**
* `value` — Valor a ser convertido para string. [`Any`](/pt-BR/reference/data-types)
* `timezone` — Opcional. Nome do fuso horário para a conversão de DateTime. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna uma representação em string do valor de entrada. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Aceita um argumento [String](/pt-BR/reference/data-types/string) ou [FixedString](/pt-BR/reference/data-types/fixedstring) e retorna uma String que contém uma cópia da string original truncada no primeiro byte nulo.
Bytes nulos (\0) são considerados terminadores de string.
Esta função é útil para processar strings no estilo C ou dados binários nos quais bytes nulos marcam o fim do conteúdo significativo.
**Sintaxe**
```sql theme={null}
toStringCutToZero(s)
```
**Argumentos**
* `s` — String ou FixedString a ser processado. [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring)
**Valor retornado**
Retorna uma String contendo os caracteres anteriores ao primeiro byte nulo. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toStringCutToZero('hello'),
toStringCutToZero('hello\0world')
```
```response title=Response theme={null}
┌─toStringCutToZero('hello')─┬─toStringCutToZero('hello\\0world')─┐
│ hello │ hello │
└────────────────────────────┴───────────────────────────────────┘
```
## toTime
Introduzido em: v1.1.0
Converte um valor de entrada para o tipo [Time](/pt-BR/reference/data-types/time).
Suporta conversão de String, FixedString, DateTime ou tipos numéricos que representam segundos desde a meia-noite.
**Sintaxe**
```sql theme={null}
toTime(x)
```
**Argumentos**
* `x` — Valor de entrada a converter. [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring) ou [`DateTime`](/pt-BR/reference/data-types/datetime) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float)
**Valor retornado**
Retorna o valor convertido. [`Time`](/pt-BR/reference/data-types/time)
**Exemplos**
**Conversão de String em Time**
```sql title=Query theme={null}
SELECT toTime('14:30:25')
```
```response title=Response theme={null}
14:30:25
```
**Conversão de DateTime para Time**
```sql title=Query theme={null}
SELECT toTime(toDateTime('2025-04-15 14:30:25'))
```
```response title=Response theme={null}
14:30:25
```
**Conversão de inteiro em Time**
```sql title=Query theme={null}
SELECT toTime(52225)
```
```response title=Response theme={null}
14:30:25
```
## toTime64
Introduzido em: v25.6.0
Converte um valor de entrada para o tipo [Time64](/pt-BR/reference/data-types/time64).
Oferece suporte à conversão de String, FixedString, DateTime64 ou tipos numéricos que representam microssegundos desde a meia-noite.
Fornece precisão de microssegundos para valores de hora.
**Sintaxe**
```sql theme={null}
toTime64(x)
```
**Argumentos**
* `x` — Valor de entrada a ser convertido. [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring) ou [`DateTime64`](/pt-BR/reference/data-types/datetime64) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float)
**Valor retornado**
Retorna o valor de entrada convertido com precisão de microssegundos. [`Time64(6)`](/pt-BR/reference/data-types/time64)
**Exemplos**
**Conversão de String em Time64**
```sql title=Query theme={null}
SELECT toTime64('14:30:25.123456')
```
```response title=Response theme={null}
14:30:25.123456
```
**Conversão de DateTime64 para 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
```
**Conversão de inteiro para Time64**
```sql title=Query theme={null}
SELECT toTime64(52225123456)
```
```response title=Response theme={null}
14:30:25.123456
```
## toTime64OrNull
Introduzido em: v25.6.0
Converte um valor de entrada em um valor do tipo `Time64`, mas retorna `NULL` em caso de erro.
É como [`toTime64`](#toTime64), mas retorna `NULL` em vez de gerar uma exceção em caso de erro de conversão.
Veja também:
* [`toTime64`](#toTime64)
* [`toTime64OrZero`](#toTime64OrZero)
**Sintaxe**
```sql theme={null}
toTime64OrNull(x)
```
**Argumentos**
* `x` — Uma representação textual de um horário com precisão de subsegundos. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor `Time64` em caso de sucesso; caso contrário, `NULL`. [`Time64`](/pt-BR/reference/data-types/time64) ou [`NULL`](/pt-BR/reference/syntax#null)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v25.6.0
Converte um valor de entrada em um valor do tipo Time64, mas retorna `00:00:00.000` em caso de erro.
Semelhante a [`toTime64`](#toTime64), mas retorna `00:00:00.000` em vez de lançar uma exceção em caso de erro de conversão.
**Sintaxe**
```sql theme={null}
toTime64OrZero(x)
```
**Argumentos**
* `x` — Uma representação textual de um horário com precisão de subsegundos. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor `Time64` em caso de sucesso; caso contrário, `00:00:00.000`. [`Time64`](/pt-BR/reference/data-types/time64)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Converte um valor de entrada em um valor do tipo Time, mas retorna `NULL` em caso de erro.
Semelhante a [`toTime`](#toTime), mas retorna `NULL` em vez de lançar uma exceção em caso de erro de conversão.
Veja também:
* [`toTime`](#toTime)
* [`toTimeOrZero`](#toTimeOrZero)
**Sintaxe**
```sql theme={null}
toTimeOrNull(x)
```
**Argumentos**
* `x` — Uma representação textual de um horário. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor `Time` em caso de sucesso; caso contrário, `NULL`. [`Time`](/pt-BR/reference/data-types/time) ou [`NULL`](/pt-BR/reference/syntax#null)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Converte um valor de entrada em um valor do tipo Time, mas retorna `00:00:00` em caso de erro.
Semelhante a `toTime`, mas retorna `00:00:00` em vez de lançar uma exceção em caso de erros de conversão.
**Sintaxe**
```sql theme={null}
toTimeOrZero(x)
```
**Argumentos**
* `x` — Uma representação textual de um horário. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor `Time` em caso de sucesso; caso contrário, `00:00:00`. [`Time`](/pt-BR/reference/data-types/time)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v1.1.0
Converte um valor de entrada em um valor do tipo [`UInt128`](/pt-BR/reference/functions/regular-functions/type-conversion-functions#toUInt128).
Lança uma exceção em caso de erro.
A função usa arredondamento em direção a zero, o que significa que trunca os dígitos fracionários dos números.
Argumentos aceitos:
* Valores ou representações em string do tipo (U)Int\*.
* Valores do tipo Float\*.
Argumentos não aceitos:
* Representações em string de valores Float\*, incluindo `NaN` e `Inf`.
* Representações em string de valores binários e hexadecimais, por exemplo, `SELECT toUInt128('0xc0fe');`.
Se o valor de entrada não puder ser representado dentro dos limites de UInt128, ocorrerá overflow ou underflow no resultado.
Isso não é considerado um erro.
Veja também:
* [`toUInt128OrZero`](#toUInt128OrZero).
* [`toUInt128OrNull`](#toUInt128OrNull).
* [`toUInt128OrDefault`](#toUInt128OrDefault).
**Sintaxe**
```sql theme={null}
toUInt128(expr)
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação textual de um número. [`Expressão`](/pt-BR/reference/data-types/special-data-types/expression)
**Valor retornado**
Retorna um valor inteiro sem sinal de 128 bits. [`UInt128`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toUInt128(128),
toUInt128(128.8),
toUInt128('128')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toUInt128(128): 128
toUInt128(128.8): 128
toUInt128('128'): 128
```
## toUInt128OrDefault
Introduzido em: v21.11.0
Assim como [`toUInt128`](#toUInt128), esta função converte um valor de entrada em um valor do tipo [`UInt128`](/pt-BR/reference/data-types/int-uint), mas retorna o valor padrão em caso de erro.
Se nenhum valor `default` for informado, `0` será retornado em caso de erro.
**Sintaxe**
```sql theme={null}
toUInt128OrDefault(expr[, default])
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação em string de um número. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float)
* `default` — Opcional. O valor padrão a ser retornado se a análise não for bem-sucedida. [`UInt128`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um valor do tipo UInt128 em caso de sucesso; caso contrário, retorna o valor padrão, se fornecido, ou 0, se não. [`UInt128`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Conversão bem-sucedida**
```sql title=Query theme={null}
SELECT toUInt128OrDefault('128', CAST('0', 'UInt128'))
```
```response title=Response theme={null}
128
```
**Conversão malsucedida**
```sql title=Query theme={null}
SELECT toUInt128OrDefault('abc', CAST('0', 'UInt128'))
```
```response title=Response theme={null}
0
```
## toUInt128OrNull
Introduzido em: v21.6.0
Assim como [`toUInt128`](#toUInt128), esta função converte um valor de entrada para o tipo [`UInt128`](/pt-BR/reference/data-types/int-uint), mas retorna `NULL` em caso de erro.
Argumentos suportados:
* Representações em string de (U)Int\*.
Argumentos não suportados (retornam `NULL`):
* Representações em string de valores Float\*, incluindo `NaN` e `Inf`.
* Representações em string de valores binários e hexadecimais, por exemplo, `SELECT toUInt128OrNull('0xc0fe');`.
Se o valor de entrada não puder ser representado nos limites de [`UInt128`](/pt-BR/reference/data-types/int-uint), ocorre overflow ou underflow no resultado.
Isso não é considerado um erro.
Veja também:
* [`toUInt128`](#toUInt128).
* [`toUInt128OrZero`](#toUInt128OrZero).
* [`toUInt128OrDefault`](#toUInt128OrDefault).
**Sintaxe**
```sql theme={null}
toUInt128OrNull(x)
```
**Argumentos**
* `x` — Uma representação textual de um número. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor do tipo UInt128 ou `NULL` se a conversão não for bem-sucedida. [`UInt128`](/pt-BR/reference/data-types/int-uint) ou [`NULL`](/pt-BR/reference/syntax#null)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toUInt128OrNull('128'),
toUInt128OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toUInt128OrNull('128'): 128
toUInt128OrNull('abc'): \N
```
## toUInt128OrZero
Introduzido em: v1.1.0
Assim como [`toUInt128`](#toUInt128), esta função converte um valor de entrada em um valor do tipo [`UInt128`](/pt-BR/reference/data-types/int-uint), mas retorna `0` em caso de erro.
Argumentos compatíveis:
* Representações em string de (U)Int\*.
Argumentos não compatíveis (retornam `0`):
* Representações em string de valores Float\*, incluindo `NaN` e `Inf`.
* Representações em string de valores binários e hexadecimais, por exemplo, `SELECT toUInt128OrZero('0xc0fe');`.
Se o valor de entrada não puder ser representado nos limites de [`UInt128`](/pt-BR/reference/data-types/int-uint), ocorre overflow ou underflow no resultado.
Isso não é considerado um erro.
Veja também:
* [`toUInt128`](#toUInt128).
* [`toUInt128OrNull`](#toUInt128OrNull).
* [`toUInt128OrDefault`](#toUInt128OrDefault).
**Sintaxe**
```sql theme={null}
toUInt128OrZero(x)
```
**Argumentos**
* `x` — Uma string que representa um número. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor do tipo UInt128; caso contrário, `0` se a conversão falhar. [`UInt128`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toUInt128OrZero('128'),
toUInt128OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toUInt128OrZero('128'): 128
toUInt128OrZero('abc'): 0
```
## toUInt16
Introduzido em: v1.1.0
Converte um valor de entrada em um valor do tipo [`UInt16`](/pt-BR/reference/data-types/int-uint).
Lança uma exceção em caso de erro.
Argumentos suportados:
* Valores ou representações em string do tipo (U)Int\*.
* Valores do tipo Float\*.
Argumentos não suportados:
* Representações em string de valores do tipo Float\*, incluindo `NaN` e `Inf`.
* Representações em string de valores binários e hexadecimais, por exemplo: `SELECT toUInt16('0xc0fe');`.
Se o valor de entrada não puder ser representado dentro dos limites de [`UInt16`](/pt-BR/reference/data-types/int-uint), ocorre overflow ou underflow no resultado.
Isso não é considerado um erro.
Por exemplo: `SELECT toUInt16(65536) == 0;`.
A função usa [arredondamento em direção a zero](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), ou seja, trunca os dígitos fracionários dos números.
Veja também:
* [`toUInt16OrZero`](#toUInt16OrZero).
* [`toUInt16OrNull`](#toUInt16OrNull).
* [`toUInt16OrDefault`](#toUInt16OrDefault).
**Sintaxe**
```sql theme={null}
toUInt16(expr)
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação textual de um número. [`Expressão`](/pt-BR/reference/data-types/special-data-types/expression)
**Valor retornado**
Retorna um valor inteiro sem sinal de 16 bits. [`UInt16`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toUInt16(16),
toUInt16(16.16),
toUInt16('16')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toUInt16(16): 16
toUInt16(16.16): 16
toUInt16('16'): 16
```
## toUInt16OrDefault
Introduzido em: v21.11.0
Assim como [`toUInt16`](#toUInt16), esta função converte um valor de entrada em um valor do tipo [UInt16](/pt-BR/reference/data-types/int-uint), mas retorna o valor padrão em caso de erro.
Se nenhum valor `default` for informado, `0` será retornado em caso de erro.
**Sintaxe**
```sql theme={null}
toUInt16OrDefault(expr[, default])
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação textual de um número. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float)
* `default` — Opcional. O valor padrão a ser retornado se o parsing não for bem-sucedido. [`UInt16`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um valor do tipo UInt16 em caso de sucesso; caso contrário, retorna o valor padrão, se fornecido, ou 0, se não. [`UInt16`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Conversão bem-sucedida**
```sql title=Query theme={null}
SELECT toUInt16OrDefault('16', CAST('0', 'UInt16'))
```
```response title=Response theme={null}
16
```
**Falha na conversão**
```sql title=Query theme={null}
SELECT toUInt16OrDefault('abc', CAST('0', 'UInt16'))
```
```response title=Response theme={null}
0
```
## toUInt16OrNull
Introduzido em: v1.1.0
Assim como [`toUInt16`](#toUInt16), esta função converte um valor de entrada em um valor do tipo [`UInt16`](/pt-BR/reference/data-types/int-uint), mas retorna `NULL` em caso de erro.
Argumentos compatíveis:
* Representações em string de (U)Int8/16/32/128/256.
Argumentos não compatíveis (retornam `NULL`):
* Representações em string de valores Float\*, incluindo `NaN` e `Inf`.
* Representações em string de valores binários e hexadecimais, por exemplo, `SELECT toUInt16OrNull('0xc0fe');`.
Se o valor de entrada não puder ser representado dentro dos limites de [`UInt16`](/pt-BR/reference/data-types/int-uint), ocorre overflow ou underflow no resultado.
Isso não é considerado um erro.
Veja também:
* [`toUInt16`](#toUInt16).
* [`toUInt16OrZero`](#toUInt16OrZero).
* [`toUInt16OrDefault`](#toUInt16OrDefault).
**Sintaxe**
```sql theme={null}
toUInt16OrNull(x)
```
**Argumentos**
* `x` — Uma representação em string de um número. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor do tipo `UInt16` ou `NULL`, caso a conversão não seja bem-sucedida. [`UInt16`](/pt-BR/reference/data-types/int-uint) ou [`NULL`](/pt-BR/reference/syntax#null)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toUInt16OrNull('16'),
toUInt16OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toUInt16OrNull('16'): 16
toUInt16OrNull('abc'): \N
```
## toUInt16OrZero
Introduzido em: v1.1.0
Assim como [`toUInt16`](#toUInt16), esta função converte um valor de entrada para um valor do tipo [`UInt16`](/pt-BR/reference/data-types/int-uint), mas retorna `0` em caso de erro.
Argumentos suportados:
* Representações em string de (U)Int8/16/32/128/256.
Argumentos não suportados (retornam `0`):
* Representações em string de valores Float\*, incluindo `NaN` e `Inf`.
* Representações em string de valores binários e hexadecimais, por exemplo, `SELECT toUInt16OrZero('0xc0fe');`.
Se o valor de entrada não puder ser representado dentro dos limites de [`UInt16`](/pt-BR/reference/data-types/int-uint), ocorre overflow ou underflow no resultado.
Isso não é considerado um erro.
Veja também:
* [`toUInt16`](#toUInt16).
* [`toUInt16OrNull`](#toUInt16OrNull).
* [`toUInt16OrDefault`](#toUInt16OrDefault).
**Sintaxe**
```sql theme={null}
toUInt16OrZero(x)
```
**Argumentos**
* `x` — Uma representação textual de um número. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor do tipo UInt16; caso a conversão não seja bem-sucedida, retorna `0`. [`UInt16`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toUInt16OrZero('16'),
toUInt16OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toUInt16OrZero('16'): 16
toUInt16OrZero('abc'): 0
```
## toUInt256
Introduzido em: v1.1.0
Converte um valor de entrada para o tipo UInt256.
Lança uma exceção em caso de erro.
A função usa arredondamento em direção a zero, ou seja, trunca os dígitos fracionários dos números.
Argumentos suportados:
* Valores ou representações em string do tipo (U)Int\*.
* Valores do tipo Float\*.
Argumentos não suportados:
* Representações em string de valores Float\*, incluindo `NaN` e `Inf`.
* Representações em string de valores binários e hexadecimais, por exemplo, `SELECT toUInt256('0xc0fe');`.
Se o valor de entrada não puder ser representado dentro dos limites de UInt256, ocorrerá overflow ou underflow no resultado.
Isso não é considerado um erro.
Veja também:
* [`toUInt256OrZero`](#toUInt256OrZero).
* [`toUInt256OrNull`](#toUInt256OrNull).
* [`toUInt256OrDefault`](#toUInt256OrDefault).
**Sintaxe**
```sql theme={null}
toUInt256(expr)
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação textual de um número. [`Expressão`](/pt-BR/reference/data-types/special-data-types/expression)
**Valor retornado**
Retorna um valor inteiro sem sinal de 256 bits. [`UInt256`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toUInt256(256),
toUInt256(256.256),
toUInt256('256')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toUInt256(256): 256
toUInt256(256.256): 256
toUInt256('256'): 256
```
## toUInt256OrDefault
Introduzido em: v21.11.0
Assim como [`toUInt256`](#toUInt256), esta função converte um valor de entrada em um valor do tipo [UInt256](/pt-BR/reference/data-types/int-uint), mas retorna o valor padrão em caso de erro.
Se nenhum valor `default` for informado, `0` será retornado em caso de erro.
**Sintaxe**
```sql theme={null}
toUInt256OrDefault(expr[, default])
```
**Argumentos**
* `expr` — Expressão que retorna um número ou uma representação textual de um número. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float)
* `default` — Opcional. O valor padrão a ser retornado se o parsing falhar. [`UInt256`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um valor do tipo UInt256 em caso de sucesso; caso contrário, retorna o valor padrão, se fornecido, ou 0, caso não seja. [`UInt256`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Conversão bem-sucedida**
```sql title=Query theme={null}
SELECT toUInt256OrDefault('-256', CAST('0', 'UInt256'))
```
```response title=Response theme={null}
0
```
**Conversão malsucedida**
```sql title=Query theme={null}
SELECT toUInt256OrDefault('abc', CAST('0', 'UInt256'))
```
```response title=Response theme={null}
0
```
## toUInt256OrNull
Introduzido em: v20.8.0
Assim como [`toUInt256`](#toUInt256), esta função converte um valor de entrada em um valor do tipo [`UInt256`](/pt-BR/reference/data-types/int-uint), mas retorna `NULL` em caso de erro.
Argumentos compatíveis:
* Representações em string de (U)Int\*.
Argumentos não compatíveis (retornam `NULL`):
* Representações em string de valores Float\*, incluindo `NaN` e `Inf`.
* Representações em string de valores binários e hexadecimais, por exemplo, `SELECT toUInt256OrNull('0xc0fe');`.
Se o valor de entrada não puder ser representado dentro dos limites de [`UInt256`](/pt-BR/reference/data-types/int-uint), ocorre overflow ou underflow no resultado.
Isso não é considerado um erro.
Veja também:
* [`toUInt256`](#toUInt256).
* [`toUInt256OrZero`](#toUInt256OrZero).
* [`toUInt256OrDefault`](#toUInt256OrDefault).
**Sintaxe**
```sql theme={null}
toUInt256OrNull(x)
```
**Argumentos**
* `x` — Uma representação textual de um número em `String`. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor do tipo UInt256 ou `NULL`, se a conversão não for bem-sucedida. [`UInt256`](/pt-BR/reference/data-types/int-uint) ou [`NULL`](/pt-BR/reference/syntax#null)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toUInt256OrNull('256'),
toUInt256OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toUInt256OrNull('256'): 256
toUInt256OrNull('abc'): \N
```
## toUInt256OrZero
Introduzido em: v20.8.0
Assim como [`toUInt256`](#toUInt256), esta função converte um valor de entrada em um valor do tipo [`UInt256`](/pt-BR/reference/data-types/int-uint), mas retorna `0` em caso de erro.
Argumentos suportados:
* Representações em string de (U)Int\*.
Argumentos não suportados (retornam `0`):
* Representações em string de valores Float\*, incluindo `NaN` e `Inf`.
* Representações em string de valores binários e hexadecimais, por exemplo, `SELECT toUInt256OrZero('0xc0fe');`.
Se o valor de entrada não puder ser representado dentro dos limites de [`UInt256`](/pt-BR/reference/data-types/int-uint), ocorrerá overflow ou underflow no resultado.
Isso não é considerado um erro.
Veja também:
* [`toUInt256`](#toUInt256).
* [`toUInt256OrNull`](#toUInt256OrNull).
* [`toUInt256OrDefault`](#toUInt256OrDefault).
**Sintaxe**
```sql theme={null}
toUInt256OrZero(x)
```
**Argumentos**
* `x` — Uma representação textual de um número. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor do tipo UInt256; caso a conversão não seja bem-sucedida, retorna `0`. [`UInt256`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toUInt256OrZero('256'),
toUInt256OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toUInt256OrZero('256'): 256
toUInt256OrZero('abc'): 0
```
## toUInt32
Introduzido em: v1.1.0
Converte um valor de entrada para um valor do tipo [`UInt32`](/pt-BR/reference/data-types/int-uint).
Lança uma exceção em caso de erro.
Argumentos suportados:
* Valores ou representações de string do tipo (U)Int\*.
* Valores do tipo Float\*.
Argumentos não suportados:
* Representações de string de valores Float\*, incluindo `NaN` e `Inf`.
* Representações de string de valores binários e hexadecimais, por exemplo, `SELECT toUInt32('0xc0fe');`.
Se o valor de entrada não puder ser representado dentro dos limites de [`UInt32`](/pt-BR/reference/data-types/int-uint), ocorre overflow ou underflow no resultado.
Isso não é considerado um erro.
Por exemplo: `SELECT toUInt32(4294967296) == 0;`
A função usa [arredondamento em direção a zero](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), o que significa que ela trunca os dígitos fracionários dos números.
Veja também:
* [`toUInt32OrZero`](#toUInt32OrZero).
* [`toUInt32OrNull`](#toUInt32OrNull).
* [`toUInt32OrDefault`](#toUInt32OrDefault).
**Sintaxe**
```sql theme={null}
toUInt32(expr)
```
**Argumentos**
* `expr` — Expressão que retorna um número ou sua representação textual. [`Expressão`](/pt-BR/reference/data-types/special-data-types/expression)
**Valor retornado**
Retorna um valor inteiro sem sinal de 32 bits. [`UInt32`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toUInt32(32),
toUInt32(32.32),
toUInt32('32')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toUInt32(32): 32
toUInt32(32.32): 32
toUInt32('32'): 32
```
## toUInt32OrDefault
Introduzido em: v21.11.0
Assim como [`toUInt32`](#toUInt32), esta função converte um valor de entrada em um valor do tipo [UInt32](/pt-BR/reference/data-types/int-uint), mas retorna o valor padrão em caso de erro.
Se nenhum valor `default` for fornecido, `0` será retornado em caso de erro.
**Sintaxe**
```sql theme={null}
toUInt32OrDefault(expr[, default])
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação textual de um número. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float)
* `default` — Opcional. O valor padrão a ser retornado se a análise falhar. [`UInt32`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um valor do tipo UInt32 em caso de sucesso; caso contrário, retorna o valor padrão, se fornecido, ou 0, se não. [`UInt32`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Conversão bem-sucedida**
```sql title=Query theme={null}
SELECT toUInt32OrDefault('32', CAST('0', 'UInt32'))
```
```response title=Response theme={null}
32
```
**Falha na conversão**
```sql title=Query theme={null}
SELECT toUInt32OrDefault('abc', CAST('0', 'UInt32'))
```
```response title=Response theme={null}
0
```
## toUInt32OrNull
Introduzido em: v1.1.0
Assim como [`toUInt32`](#toUInt32), esta função converte um valor de entrada em um valor do tipo [`UInt32`](/pt-BR/reference/data-types/int-uint), mas retorna `NULL` em caso de erro.
Argumentos compatíveis:
* Representações em string de (U)Int8/16/32/128/256.
Argumentos não compatíveis (retornam `NULL`):
* Representações em string de valores Float\*, incluindo `NaN` e `Inf`.
* Representações em string de valores binários e hexadecimais, por exemplo, `SELECT toUInt32OrNull('0xc0fe');`.
Se o valor de entrada não puder ser representado dentro dos limites de [`UInt32`](/pt-BR/reference/data-types/int-uint), ocorre overflow ou underflow no resultado.
Isso não é considerado um erro.
Veja também:
* [`toUInt32`](#toUInt32).
* [`toUInt32OrZero`](#toUInt32OrZero).
* [`toUInt32OrDefault`](#toUInt32OrDefault).
**Sintaxe**
```sql theme={null}
toUInt32OrNull(x)
```
**Argumentos**
* `x` — Uma representação de um número em `String`. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor do tipo `UInt32` ou `NULL`, se a conversão não for bem-sucedida. [`UInt32`](/pt-BR/reference/data-types/int-uint) ou [`NULL`](/pt-BR/reference/syntax#null)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toUInt32OrNull('32'),
toUInt32OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toUInt32OrNull('32'): 32
toUInt32OrNull('abc'): \N
```
## toUInt32OrZero
Introduzido em: v1.1.0
Assim como [`toUInt32`](#toUInt32), esta função converte um valor de entrada em um valor do tipo [`UInt32`](/pt-BR/reference/data-types/int-uint), mas retorna `0` em caso de erro.
Argumentos aceitos:
* Representações em string de (U)Int8/16/32/128/256.
Argumentos não aceitos (retornam `0`):
* Representações em string de valores Float\*, incluindo `NaN` e `Inf`.
* Representações em string de valores binários e hexadecimais, por exemplo, `SELECT toUInt32OrZero('0xc0fe');`.
Se o valor de entrada não puder ser representado dentro dos limites de [`UInt32`](/pt-BR/reference/data-types/int-uint), ocorrerá overflow ou underflow no resultado.
Isso não é considerado um erro.
Veja também:
* [`toUInt32`](#toUInt32).
* [`toUInt32OrNull`](#toUInt32OrNull).
* [`toUInt32OrDefault`](#toUInt32OrDefault).
**Sintaxe**
```sql theme={null}
toUInt32OrZero(x)
```
**Argumentos**
* `x` — Uma representação de um número como `String`. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor do tipo UInt32 ou `0`, se a conversão falhar. [`UInt32`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toUInt32OrZero('32'),
toUInt32OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toUInt32OrZero('32'): 32
toUInt32OrZero('abc'): 0
```
## toUInt64
Introduzido em: v1.1.0
Converte um valor de entrada em um valor do tipo [`UInt64`](/pt-BR/reference/data-types/int-uint).
Lança uma exceção em caso de erro.
Argumentos aceitos:
* Valores ou representações em string do tipo (U)Int\*.
* Valores do tipo Float\*.
Tipos não suportados:
* Representações em string de valores Float\*, incluindo `NaN` e `Inf`.
* Representações em string de valores binários e hexadecimais, por exemplo, `SELECT toUInt64('0xc0fe');`.
Se o valor de entrada não puder ser representado dentro dos limites de [`UInt64`](/pt-BR/reference/data-types/int-uint), o resultado sofrerá overflow ou underflow.
Isso não é considerado um erro.
Por exemplo: `SELECT toUInt64(18446744073709551616) == 0;`
A função usa [arredondamento em direção a zero](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), ou seja, trunca os dígitos fracionários dos números.
Veja também:
* [`toUInt64OrZero`](#toUInt64OrZero).
* [`toUInt64OrNull`](#toUInt64OrNull).
* [`toUInt64OrDefault`](#toUInt64OrDefault).
**Sintaxe**
```sql theme={null}
toUInt64(expr)
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação textual de um número. [`Expressão`](/pt-BR/reference/data-types/special-data-types/expression)
**Valor retornado**
Retorna um valor inteiro sem sinal de 64 bits. [`UInt64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toUInt64(64),
toUInt64(64.64),
toUInt64('64')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toUInt64(64): 64
toUInt64(64.64): 64
toUInt64('64'): 64
```
## toUInt64OrDefault
Introduzido em: v21.11.0
Assim como [`toUInt64`](#toUInt64), esta função converte um valor de entrada em um valor do tipo [UInt64](/pt-BR/reference/data-types/int-uint), mas retorna o valor padrão em caso de erro.
Se nenhum valor `default` for informado, `0` será retornado em caso de erro.
**Sintaxe**
```sql theme={null}
toUInt64OrDefault(expr[, default])
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação em string de um número. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float)
* `default` — Opcional. O valor padrão a ser retornado se a análise não for bem-sucedida. [`UInt64`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um valor do tipo UInt64 em caso de sucesso; caso contrário, retorna o valor padrão, se fornecido, ou 0, se não. [`UInt64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Conversão bem-sucedida**
```sql title=Query theme={null}
SELECT toUInt64OrDefault('64', CAST('0', 'UInt64'))
```
```response title=Response theme={null}
64
```
**Falha na conversão**
```sql title=Query theme={null}
SELECT toUInt64OrDefault('abc', CAST('0', 'UInt64'))
```
```response title=Response theme={null}
0
```
## toUInt64OrNull
Introduzido em: v1.1.0
Assim como [`toUInt64`](#toUInt64), esta função converte um valor de entrada em um valor do tipo [`UInt64`](/pt-BR/reference/data-types/int-uint), mas retorna `NULL` em caso de erro.
Argumentos suportados:
* Representações em string de (U)Int\*.
Argumentos não suportados (retornam `NULL`):
* Representações em string de valores Float\*, incluindo `NaN` e `Inf`.
* Representações em string de valores binários e hexadecimais, por exemplo, `SELECT toUInt64OrNull('0xc0fe');`.
Se o valor de entrada não puder ser representado dentro dos limites de [`UInt64`](/pt-BR/reference/data-types/int-uint), ocorre overflow ou underflow no resultado.
Isso não é considerado um erro.
Veja também:
* [`toUInt64`](#toUInt64).
* [`toUInt64OrZero`](#toUInt64OrZero).
* [`toUInt64OrDefault`](#toUInt64OrDefault).
**Sintaxe**
```sql theme={null}
toUInt64OrNull(x)
```
**Argumentos**
* `x` — Uma representação em String de um número. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor do tipo UInt64; caso a conversão não seja bem-sucedida, retorna `NULL`. [`UInt64`](/pt-BR/reference/data-types/int-uint) ou [`NULL`](/pt-BR/reference/syntax#null)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toUInt64OrNull('64'),
toUInt64OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toUInt64OrNull('64'): 64
toUInt64OrNull('abc'): \N
```
## toUInt64OrZero
Introduzido em: v1.1.0
Como [`toUInt64`](#toUInt64), esta função converte um valor de entrada em um valor do tipo [`UInt64`](/pt-BR/reference/data-types/int-uint), mas retorna `0` em caso de erro.
Argumentos compatíveis:
* Representações em string de (U)Int\*.
Argumentos não compatíveis (retornam `0`):
* Representações em string de valores Float\*, incluindo `NaN` e `Inf`.
* Representações em string de valores binários e hexadecimais, por exemplo, `SELECT toUInt64OrZero('0xc0fe');`.
Se o valor de entrada não puder ser representado dentro dos limites de [`UInt64`](/pt-BR/reference/data-types/int-uint), ocorrerá overflow ou underflow do resultado.
Isso não é considerado um erro.
Veja também:
* [`toUInt64`](#toUInt64).
* [`toUInt64OrNull`](#toUInt64OrNull).
* [`toUInt64OrDefault`](#toUInt64OrDefault).
**Sintaxe**
```sql theme={null}
toUInt64OrZero(x)
```
**Argumentos**
* `x` — Uma representação textual de um número. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor do tipo UInt64 ou `0` se a conversão não for bem-sucedida. [`UInt64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toUInt64OrZero('64'),
toUInt64OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toUInt64OrZero('64'): 64
toUInt64OrZero('abc'): 0
```
## toUInt8
Introduzido em: v1.1.0
Converte um valor de entrada em um valor do tipo [`UInt8`](/pt-BR/reference/data-types/int-uint).
Lança uma exceção em caso de erro.
Argumentos aceitos:
* Valores ou representações textuais do tipo (U)Int\*.
* Valores do tipo Float\*.
Argumentos não aceitos:
* Representações textuais de valores Float\*, incluindo `NaN` e `Inf`.
* Representações textuais de valores binários e hexadecimais, por exemplo, `SELECT toUInt8('0xc0fe');`.
Se o valor de entrada não puder ser representado dentro dos limites de [UInt8](/pt-BR/reference/data-types/int-uint), ocorrerá overflow ou underflow no resultado.
Isso não é considerado um erro.
Por exemplo: `SELECT toUInt8(256) == 0;`.
A função usa [arredondamento em direção a zero](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), ou seja, trunca os dígitos fracionários dos números.
Veja também:
* [`toUInt8OrZero`](#toUInt8OrZero).
* [`toUInt8OrNull`](#toUInt8OrNull).
* [`toUInt8OrDefault`](#toUInt8OrDefault).
**Sintaxe**
```sql theme={null}
toUInt8(expr)
```
**Argumentos**
* `expr` — Expressão que retorna um número ou uma representação textual de um número. [`Expressão`](/pt-BR/reference/data-types/special-data-types/expression)
**Valor retornado**
Retorna um valor inteiro sem sinal de 8 bits. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toUInt8(8),
toUInt8(8.8),
toUInt8('8')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toUInt8(8): 8
toUInt8(8.8): 8
toUInt8('8'): 8
```
## toUInt8OrDefault
Introduzido em: v21.11.0
Assim como [`toUInt8`](#toUInt8), esta função converte um valor de entrada em um valor do tipo [UInt8](/pt-BR/reference/data-types/int-uint), mas retorna o valor padrão em caso de erro.
Se nenhum valor `default` for informado, `0` será retornado em caso de erro.
**Sintaxe**
```sql theme={null}
toUInt8OrDefault(expr[, default])
```
**Argumentos**
* `expr` — Expressão que retorna um número ou a representação textual de um número. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float)
* `default` — Opcional. O valor padrão a ser retornado se a análise falhar. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um valor do tipo UInt8 em caso de sucesso; caso contrário, retorna o valor padrão, se fornecido, ou 0, se não. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Conversão bem-sucedida**
```sql title=Query theme={null}
SELECT toUInt8OrDefault('8', CAST('0', 'UInt8'))
```
```response title=Response theme={null}
8
```
**Falha na conversão**
```sql title=Query theme={null}
SELECT toUInt8OrDefault('abc', CAST('0', 'UInt8'))
```
```response title=Response theme={null}
0
```
## toUInt8OrNull
Introduzido em: v1.1.0
Assim como [`toUInt8`](#toUInt8), esta função converte um valor de entrada em um valor do tipo [`UInt8`](/pt-BR/reference/data-types/int-uint), mas retorna `NULL` em caso de erro.
Argumentos suportados:
* Representações em string de (U)Int8/16/32/128/256.
Argumentos não suportados (retornam `NULL`):
* Representações em string de valores Float\* convencionais, incluindo `NaN` e `Inf`.
* Representações em string de valores binários e hexadecimais, por exemplo: `SELECT toUInt8OrNull('0xc0fe');`.
Se o valor de entrada não puder ser representado dentro dos limites de [`UInt8`](/pt-BR/reference/data-types/int-uint), ocorrerá overflow ou underflow no resultado.
Isso não é considerado um erro.
Veja também:
* [`toUInt8`](#toUInt8).
* [`toUInt8OrZero`](#toUInt8OrZero).
* [`toUInt8OrDefault`](#toUInt8OrDefault).
**Sintaxe**
```sql theme={null}
toUInt8OrNull(x)
```
**Argumentos**
* `x` — Uma representação em string de um número. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor do tipo UInt8 ou `NULL` se a conversão não for bem-sucedida. [`UInt8`](/pt-BR/reference/data-types/int-uint) ou [`NULL`](/pt-BR/reference/syntax#null)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toUInt8OrNull('42'),
toUInt8OrNull('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toUInt8OrNull('42'): 42
toUInt8OrNull('abc'): \N
```
## toUInt8OrZero
Introduzido em: v1.1.0
Assim como [`toUInt8`](#toUInt8), esta função converte um valor de entrada em um valor do tipo [`UInt8`](/pt-BR/reference/data-types/int-uint), mas retorna `0` em caso de erro.
Argumentos com suporte:
* Representações em string de (U)Int8/16/32/128/256.
Argumentos sem suporte (retornam `0`):
* Representações em string de valores Float\* comuns, incluindo `NaN` e `Inf`.
* Representações em string de valores binários e hexadecimais, por exemplo, `SELECT toUInt8OrZero('0xc0fe');`.
Se o valor de entrada não puder ser representado dentro dos limites de [`UInt8`](/pt-BR/reference/data-types/int-uint), ocorre overflow ou underflow no resultado.
Isso não é considerado um erro.
Veja também:
* [`toUInt8`](#toUInt8).
* [`toUInt8OrNull`](#toUInt8OrNull).
* [`toUInt8OrDefault`](#toUInt8OrDefault).
**Sintaxe**
```sql theme={null}
toUInt8OrZero(x)
```
**Argumentos**
* `x` — Uma representação textual de um número. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor do tipo UInt8; se a conversão falhar, retorna `0`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
toUInt8OrZero('-8'),
toUInt8OrZero('abc')
FORMAT Vertical
```
```response title=Response theme={null}
Linha 1:
──────
toUInt8OrZero('-8'): 0
toUInt8OrZero('abc'): 0
```
## toUUID
Introduzido em: v1.1.0
Converte um valor do tipo String em um valor UUID.
**Sintaxe**
```sql theme={null}
toUUID(string)
```
**Argumentos**
* `string` — UUID em formato de string. [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring)
**Valor retornado**
Retorna um UUID a partir da representação em string do UUID. [`UUID`](/pt-BR/reference/data-types/uuid)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v20.12.0
Converte um valor de entrada em um valor do tipo [UUID](/pt-BR/reference/data-types/uuid), mas retorna um UUID zero em caso de erro.
Semelhante a [`toUUID`](/pt-BR/reference/functions/regular-functions/type-conversion-functions#toUUID), mas retorna um UUID zero (`00000000-0000-0000-0000-000000000000`) em vez de lançar uma exceção em erros de conversão.
Argumentos suportados:
* Representações de UUID em formato de string no formato padrão (8-4-4-4-12 dígitos hexadecimais).
* Representações de UUID em formato de string sem hífens (32 dígitos hexadecimais).
Argumentos não suportados (retornam UUID zero):
* Formatos de string inválidos.
* Tipos que não são string.
**Sintaxe**
```sql theme={null}
toUUIDOrZero(x)
```
**Argumentos**
* `x` — Uma representação textual de um UUID. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor UUID em caso de sucesso; caso contrário, retorna um UUID zero (`00000000-0000-0000-0000-000000000000`). [`UUID`](/pt-BR/reference/data-types/uuid)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v20.5.0
Converte um [`DateTime64`](/pt-BR/reference/data-types/datetime64) em um valor [`Int64`](/pt-BR/reference/data-types/int-uint) com precisão fixa de microssegundos.
O valor de entrada é ampliado ou reduzido conforme necessário, dependendo da sua precisão.
O valor de saída é relativo a UTC, não ao fuso horário do valor de entrada.
**Sintaxe**
```sql theme={null}
toUnixTimestamp64Micro(value)
```
**Argumentos**
* `value` — Valor do tipo DateTime64 com qualquer precisão. [`DateTime64`](/pt-BR/reference/data-types/datetime64)
**Valor retornado**
Retorna um timestamp Unix em microssegundos. [`Int64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v20.5.0
Converte um [`DateTime64`](/pt-BR/reference/data-types/datetime64) em um valor [`Int64`](/pt-BR/reference/data-types/int-uint) com precisão fixa de milissegundos.
O valor de entrada é ajustado para mais ou para menos conforme necessário, dependendo da sua precisão.
O valor de saída é relativo a UTC, não ao fuso horário do valor de entrada.
**Sintaxe**
```sql theme={null}
toUnixTimestamp64Milli(value)
```
**Argumentos**
* `value` — Valor do tipo DateTime64 com qualquer precisão. [`DateTime64`](/pt-BR/reference/data-types/datetime64)
**Valor retornado**
Retorna um timestamp Unix em milissegundos. [`Int64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```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
Introduzido em: v20.5.0
Converte um [`DateTime64`](/pt-BR/reference/data-types/datetime64) em um valor [`Int64`](/pt-BR/reference/functions/regular-functions/type-conversion-functions#toInt64) com precisão fixa em nanossegundos.
O valor de entrada é ajustado para mais ou para menos conforme necessário, dependendo da sua precisão.
O valor de saída é relativo a UTC, não ao fuso horário do valor de entrada.
**Sintaxe**
```sql theme={null}
toUnixTimestamp64Nano(value)
```
**Argumentos**
* `value` — Valor do tipo DateTime64 com qualquer precisão. [`DateTime64`](/pt-BR/reference/data-types/datetime64)
**Valor retornado**
Retorna um timestamp Unix em nanossegundos. [`Int64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```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
Introduzido na versão: v24.12.0
Converte um [`DateTime64`](/pt-BR/reference/data-types/datetime64) em um valor [`Int64`](/pt-BR/reference/data-types/int-uint) com precisão fixa de segundos.
O valor de entrada é ajustado para mais ou para menos conforme necessário, dependendo da sua precisão.
O valor de saída é relativo a UTC, não ao fuso horário do valor de entrada.
**Sintaxe**
```sql theme={null}
toUnixTimestamp64Second(value)
```
**Argumentos**
* `value` — Valor do tipo DateTime64 com qualquer precisão. [`DateTime64`](/pt-BR/reference/data-types/datetime64)
**Valor retornado**
Retorna um timestamp Unix em segundos. [`Int64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```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 │
└───────────────────────────────┘
```