> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-8c05c8a2.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

> Documentación de funciones de conversión de tipos

# Funciones de conversión de tipos

<div id="common-issues-with-data-conversion">
  ## Problemas habituales con la conversión de datos
</div>

ClickHouse generalmente utiliza el [mismo comportamiento que los programas en C++](https://en.cppreference.com/w/cpp/language/implicit_conversion).

Las funciones `to<type>` y [cast](#CAST) se comportan de manera diferente en algunos casos, por ejemplo con [LowCardinality](/es/reference/data-types/lowcardinality): [cast](#CAST) elimina la propiedad [LowCardinality](/es/reference/data-types/lowcardinality), mientras que las funciones `to<type>` no. Lo mismo ocurre con [Nullable](/es/reference/data-types/nullable); este comportamiento no es compatible con el estándar SQL y puede modificarse mediante la configuración [cast\_keep\_nullable](/es/reference/settings/session-settings#cast_keep_nullable).

<Note>
  Tenga en cuenta la posible pérdida de datos si los valores de un tipo de datos se convierten a otro más pequeño (por ejemplo, de `Int64` a `Int32`) o entre
  tipos de datos incompatibles (por ejemplo, de `String` a `Int`). Asegúrese de comprobar cuidadosamente si el resultado es el esperado.
</Note>

Ejemplo:

```sql theme={null}
SELECT
    toTypeName(toLowCardinality('') AS val) AS source_type,
    toTypeName(toString(val)) AS to_type_result_type,
    toTypeName(CAST(val, 'String')) AS cast_result_type

┌─source_type────────────┬─to_type_result_type────┬─cast_result_type─┐
│ LowCardinality(String) │ LowCardinality(String) │ String           │
└────────────────────────┴────────────────────────┴──────────────────┘

SELECT
    toTypeName(toNullable('') AS val) AS source_type,
    toTypeName(toString(val)) AS to_type_result_type,
    toTypeName(CAST(val, 'String')) AS cast_result_type

┌─source_type──────┬─to_type_result_type─┬─cast_result_type─┐
│ Nullable(String) │ Nullable(String)    │ String           │
└──────────────────┴─────────────────────┴──────────────────┘

SELECT
    toTypeName(toNullable('') AS val) AS source_type,
    toTypeName(toString(val)) AS to_type_result_type,
    toTypeName(CAST(val, 'String')) AS cast_result_type
SETTINGS cast_keep_nullable = 1

┌─source_type──────┬─to_type_result_type─┬─cast_result_type─┐
│ Nullable(String) │ Nullable(String)    │ Nullable(String) │
└──────────────────┴─────────────────────┴──────────────────┘
```

<div id="to-string-functions">
  ## Notas sobre las funciones `toString`
</div>

La familia de funciones `toString` permite convertir entre números, cadenas (pero no cadenas de longitud fija), fechas y valores de fecha y hora.
Todas estas funciones aceptan un argumento.

* Al convertir una cadena o a partir de una cadena, el valor se formatea o se analiza según las mismas reglas que en el formato TabSeparated (y en casi todos los demás formatos de texto). Si la cadena no se puede analizar, se lanza una excepción y se cancela la solicitud.
* Al convertir fechas en números o viceversa, la fecha corresponde al número de días transcurridos desde el inicio de la época Unix.
* Al convertir valores de fecha y hora en números o viceversa, el valor de fecha y hora corresponde al número de segundos transcurridos desde el inicio de la época Unix.
* La función `toString` del argumento `DateTime` puede aceptar un segundo argumento String que contenga el nombre de la zona horaria, por ejemplo: `Europe/Amsterdam`. En este caso, la hora se formatea según la zona horaria especificada.

<div id="to-date-and-date-time-functions">
  ## Notas sobre las funciones `toDate`/`toDateTime`
</div>

Los formatos de fecha y fecha con hora de las funciones `toDate`/`toDateTime` se definen de la siguiente manera:

```response theme={null}
YYYY-MM-DD
YYYY-MM-DD hh:mm:ss
```

Como excepción, si se convierte de tipos numéricos UInt32, Int32, UInt64 o Int64 a Date, y si el número es mayor o igual que 65536, este se interpreta como una marca de tiempo Unix (y no como un número de días) y se redondea a una fecha.
Esto permite admitir el caso habitual de escribir `toDate(unix_timestamp)`, que de otro modo sería un error y obligaría a escribir la forma más engorrosa `toDate(toDateTime(unix_timestamp))`.

La conversión entre una fecha y una fecha con hora se realiza de la forma natural: añadiendo una hora nula o eliminando la hora.

La conversión entre tipos numéricos utiliza las mismas reglas que las asignaciones entre distintos tipos numéricos en C++.

**Ejemplo**

```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 │
│ 2023-09-08 19:14:59 │ Europe/Belgrade   │ 2023-09-08 21:14:59 │
│ 2023-09-08 19:14:59 │ Europe/Berlin     │ 2023-09-08 21:14:59 │
│ 2023-09-08 19:14:59 │ Europe/Bratislava │ 2023-09-08 21:14:59 │
│ 2023-09-08 19:14:59 │ Europe/Brussels   │ 2023-09-08 21:14:59 │
│ 2023-09-08 19:14:59 │ Europe/Bucharest  │ 2023-09-08 22:14:59 │
└─────────────────────┴───────────────────┴─────────────────────┘
```

Consulte también la función [`toUnixTimestamp`](/es/reference/functions/regular-functions/date-time-functions#toUnixTimestamp).

{/*AUTOGENERATED_START*/}

<div id="CAST">
  ## CAST
</div>

Introducido en: v1.1.0

Convierte un valor a un tipo de dato especificado.
A diferencia de la función reinterpret, CAST intenta generar el mismo valor en el tipo de destino.
Si no es posible, se genera una excepción.

**Sintaxis**

```sql theme={null}
CAST(x, T)
or CAST(x AS T)
or x::T
```

**Argumentos**

* `x` — Un valor de cualquier tipo. [`Any`](/es/reference/data-types/index)
* `T` — El tipo de dato de destino. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el valor convertido al tipo de dato de destino. [`Any`](/es/reference/data-types/index)

**Ejemplos**

**Uso básico**

```sql title=Query theme={null}
SELECT CAST(42, 'String')
```

```response title=Response theme={null}
┌─CAST(42, 'String')─┐
│ 42                 │
└────────────────────┘
```

**Uso de la sintaxis AS**

```sql title=Query theme={null}
SELECT CAST('2025-01-01' AS Date)
```

```response title=Response theme={null}
┌─CAST('2025-01-01', 'Date')─┐
│                 2025-01-01 │
└────────────────────────────┘
```

**Uso de la sintaxis ::**

```sql title=Query theme={null}
SELECT '123'::UInt32
```

```response title=Response theme={null}
┌─CAST('123', 'UInt32')─┐
│                   123 │
└───────────────────────┘
```

<div id="DATE">
  ## DATE
</div>

Introducido en: v21.2.0

Convierte el argumento al tipo de dato Date. Es un alias de compatibilidad con MySQL para `toDate`. Se comporta igual que `toDate`.

**Sintaxis**

```sql theme={null}
DATE(expr)
```

**Argumentos**

* `expr` — El valor que se va a convertir. [`String`](/es/reference/data-types/string) o [`UInt32`](/es/reference/data-types/int-uint) o [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime)

**Valor devuelto**

Devuelve un valor de tipo Date. [`Date`](/es/reference/data-types/date)

**Ejemplos**

**Uso básico**

```sql title=Query theme={null}
SELECT DATE('2023-01-01')
```

```response title=Response theme={null}
2023-01-01
```

<div id="accurateCast">
  ## accurateCast
</div>

Introducido en: v1.1.0

Convierte un valor al tipo de dato especificado. A diferencia de [`CAST`](#CAST), `accurateCast` realiza una comprobación de tipos más estricta y lanza una excepción si la conversión provoca una pérdida de precisión de los datos o si la conversión no es posible.

Esta función es más segura que `CAST`, ya que evita la pérdida de precisión y las conversiones no válidas.

**Sintaxis**

```sql theme={null}
accurateCast(x, T)
```

**Argumentos**

* `x` — Un valor para convertir. [`Any`](/es/reference/data-types/index)
* `T` — El nombre del tipo de dato de destino. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el valor convertido al tipo de dato de destino. [`Any`](/es/reference/data-types/index)

**Ejemplos**

**Conversión correcta**

```sql title=Query theme={null}
SELECT accurateCast(42, 'UInt16')
```

```response title=Response theme={null}
┌─accurateCast(42, 'UInt16')─┐
│                        42 │
└───────────────────────────┘
```

**De String a número**

```sql title=Query theme={null}
SELECT accurateCast('123.45', 'Float64')
```

```response title=Response theme={null}
┌─accurateCast('123.45', 'Float64')─┐
│                            123.45 │
└───────────────────────────────────┘
```

<div id="accurateCastOrDefault">
  ## accurateCastOrDefault
</div>

Introducido en: v21.1.0

Convierte un valor a un tipo de dato especificado.
Como [`accurateCast`](#accurateCast), pero devuelve un valor predeterminado en lugar de lanzar una excepción si la conversión no puede realizarse con precisión.

Si se proporciona un valor predeterminado como segundo argumento, debe ser del tipo de destino.
Si no se proporciona ningún valor predeterminado, se utiliza el valor predeterminado del tipo de destino.

**Sintaxis**

```sql theme={null}
accurateCastOrDefault(x, T[, default_value])
```

**Argumentos**

* `x` — Un valor que se convertirá. [`Any`](/es/reference/data-types/index)
* `T` — El nombre del tipo de dato de destino. [`const String`](/es/reference/data-types/string)
* `default_value` — Opcional. Valor por defecto que se devuelve si la conversión falla. [`Any`](/es/reference/data-types/index)

**Valor devuelto**

Devuelve el valor convertido al tipo de dato de destino, o el valor por defecto si la conversión no es posible. [`Any`](/es/reference/data-types/index)

**Ejemplos**

**Conversión exitosa**

```sql title=Query theme={null}
SELECT accurateCastOrDefault(42, 'String')
```

```response title=Response theme={null}
┌─accurateCastOrDefault(42, 'String')─┐
│ 42                                  │
└─────────────────────────────────────┘
```

**Conversión fallida con valor predeterminado explícito**

```sql title=Query theme={null}
SELECT accurateCastOrDefault('abc', 'UInt32', 999::UInt32)
```

```response title=Response theme={null}
┌─accurateCastOrDefault('abc', 'UInt32', 999)─┐
│                                         999 │
└─────────────────────────────────────────────┘
```

**Conversión fallida con valor predeterminado implícito**

```sql title=Query theme={null}
SELECT accurateCastOrDefault('abc', 'UInt32')
```

```response title=Response theme={null}
┌─accurateCastOrDefault('abc', 'UInt32')─┐
│                                      0 │
└────────────────────────────────────────┘
```

<div id="accurateCastOrNull">
  ## accurateCastOrNull
</div>

Introducido en: v1.1.0

Convierte un valor a un tipo de dato especificado.
Como [`accurateCast`](#accurateCast), pero devuelve `NULL` en lugar de generar una excepción si la conversión no puede realizarse con precisión.

Esta función combina la seguridad de [`accurateCast`](#accurateCast) con un manejo adecuado de errores.

**Sintaxis**

```sql theme={null}
accurateCastOrNull(x, T)
```

**Argumentos**

* `x` — Un valor que se va a convertir. [`Any`](/es/reference/data-types/index)
* `T` — El nombre del tipo de dato de destino. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el valor convertido al tipo de dato de destino, o `NULL` si la conversión no es posible. [`Any`](/es/reference/data-types/index)

**Ejemplos**

**Conversión correcta**

```sql title=Query theme={null}
SELECT accurateCastOrNull(42, 'String')
```

```response title=Response theme={null}
┌─accurateCastOrNull(42, 'String')─┐
│ 42                               │
└──────────────────────────────────┘
```

**Si la conversión falla, devuelve NULL**

```sql title=Query theme={null}
SELECT accurateCastOrNull('abc', 'UInt32')
```

```response title=Response theme={null}
┌─accurateCastOrNull('abc', 'UInt32')─┐
│                                ᴺᵁᴸᴸ │
└─────────────────────────────────────┘
```

<div id="formatRow">
  ## formatRow
</div>

Introducido en: v20.7.0

Convierte expresiones arbitrarias en una cadena usando el formato indicado.

<Note>
  Si el formato contiene un sufijo/prefijo, se escribirá en cada fila.
  Esta función solo admite formatos por filas.
</Note>

**Sintaxis**

```sql theme={null}
formatRow(format, x, y, ...)
```

**Argumentos**

* `format` — Formato de texto. Por ejemplo, CSV, TSV. [`String`](/es/reference/data-types/string)
* `x, y, ...` — Expresiones. [`Any`](/es/reference/data-types/index)

**Valor devuelto**

Una cadena formateada. (en los formatos de texto, suele terminar con un carácter de nueva línea). [`String`](/es/reference/data-types/string)

**Ejemplos**

**Uso básico**

```sql title=Query theme={null}
SELECT formatRow('CSV', number, 'good')
FROM numbers(3)
```

```response title=Response theme={null}
┌─formatRow('CSV', number, 'good')─┐
│ 0,"good"
                         │
│ 1,"good"
                         │
│ 2,"good"
                         │
└──────────────────────────────────┘
```

**Con formato personalizado**

```sql title=Query theme={null}
SELECT formatRow('CustomSeparated', number, 'good')
FROM numbers(3)
SETTINGS format_custom_result_before_delimiter='<prefix>\n', format_custom_result_after_delimiter='<suffix>'
```

```response title=Response theme={null}
┌─formatRow('CustomSeparated', number, 'good')─┐
│ <prefix>
0    good
<suffix>                   │
│ <prefix>
1    good
<suffix>                   │
│ <prefix>
2    good
<suffix>                   │
└──────────────────────────────────────────────┘
```

<div id="formatRowNoNewline">
  ## formatRowNoNewline
</div>

Introducido en: v20.7.0

Igual que [`formatRow`](#formatRow), pero elimina el carácter de nueva línea de cada fila.

Convierte expresiones arbitrarias en una cadena con el formato especificado, pero elimina cualquier carácter de nueva línea al final del resultado.

**Sintaxis**

```sql theme={null}
formatRowNoNewline(format, x, y, ...)
```

**Argumentos**

* `format` — Formato de texto. Por ejemplo, CSV, TSV. [`String`](/es/reference/data-types/string)
* `x, y, ...` — Expresiones. [`Any`](/es/reference/data-types/index)

**Valor devuelto**

Devuelve una cadena formateada sin saltos de línea. [`String`](/es/reference/data-types/string)

**Ejemplos**

**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"                                  │
└───────────────────────────────────────────┘
```

<div id="fromUnixTimestamp64Micro">
  ## fromUnixTimestamp64Micro
</div>

Introducido en: v20.5.0

Convierte una marca de tiempo Unix en microsegundos en un valor `DateTime64` con precisión de microsegundos.

El valor de entrada se interpreta como una marca de tiempo Unix con precisión de microsegundos (número de microsegundos desde 1970-01-01 00:00:00 UTC).

**Sintaxis**

```sql theme={null}
fromUnixTimestamp64Micro(value[, timezone])
```

**Argumentos**

* `value` — Marca de tiempo Unix en microsegundos. [`Int64`](/es/reference/data-types/int-uint)
* `timezone` — Opcional. Zona horaria del valor devuelto. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor `DateTime64` con precisión de microsegundos. [`DateTime64(6)`](/es/reference/data-types/datetime64)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT fromUnixTimestamp64Micro(1640995200123456)
```

```response title=Response theme={null}
┌─fromUnixTimestamp64Micro(1640995200123456)─┐
│                 2022-01-01 00:00:00.123456 │
└────────────────────────────────────────────┘
```

<div id="fromUnixTimestamp64Milli">
  ## fromUnixTimestamp64Milli
</div>

Introducido en: v20.5.0

Convierte una marca de tiempo Unix en milisegundos en un valor `DateTime64` con precisión de milisegundos.

El valor de entrada se trata como una marca de tiempo Unix con precisión de milisegundos (número de milisegundos transcurridos desde 1970-01-01 00:00:00 UTC).

**Sintaxis**

```sql theme={null}
fromUnixTimestamp64Milli(value[, timezone])
```

**Argumentos**

* `value` — Marca de tiempo Unix en milisegundos. [`Int64`](/es/reference/data-types/int-uint)
* `timezone` — Opcional. Zona horaria del valor devuelto. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Un valor `DateTime64` con precisión de milisegundos. [`DateTime64(3)`](/es/reference/data-types/datetime64)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT fromUnixTimestamp64Milli(1640995200123)
```

```response title=Response theme={null}
┌─fromUnixTimestamp64Milli(1640995200123)─┐
│                 2022-01-01 00:00:00.123 │
└─────────────────────────────────────────┘
```

<div id="fromUnixTimestamp64Nano">
  ## fromUnixTimestamp64Nano
</div>

Introducido en: v20.5.0

Convierte una marca de tiempo Unix en nanosegundos en un valor [`DateTime64`](/es/reference/data-types/datetime64) con precisión de nanosegundos.

El valor de entrada se interpreta como una marca de tiempo Unix con precisión de nanosegundos (número de nanosegundos transcurridos desde 1970-01-01 00:00:00 UTC).

<Note>
  Ten en cuenta que el valor de entrada se interpreta como una marca de tiempo en UTC, no según la zona horaria del valor de entrada.
</Note>

**Sintaxis**

```sql theme={null}
fromUnixTimestamp64Nano(value[, timezone])
```

**Argumentos**

* `value` — marca de tiempo Unix en nanosegundos. [`Int64`](/es/reference/data-types/int-uint)
* `timezone` — Opcional. Zona horaria del valor devuelto. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor `DateTime64` con precisión de nanosegundos. [`DateTime64(9)`](/es/reference/data-types/datetime64)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT fromUnixTimestamp64Nano(1640995200123456789)
```

```response title=Response theme={null}
┌─fromUnixTimestamp64Nano(1640995200123456789)─┐
│                2022-01-01 00:00:00.123456789 │
└──────────────────────────────────────────────┘
```

<div id="fromUnixTimestamp64Second">
  ## fromUnixTimestamp64Second
</div>

Introducido en: v24.12.0

Convierte una marca de tiempo Unix en segundos en un valor `DateTime64` con precisión de segundos.

El valor de entrada se trata como una marca de tiempo Unix con precisión de segundos (número de segundos desde 1970-01-01 00:00:00 UTC).

**Sintaxis**

```sql theme={null}
fromUnixTimestamp64Second(value[, timezone])
```

**Argumentos**

* `value` — marca de tiempo Unix en segundos. [`Int64`](/es/reference/data-types/int-uint)
* `timezone` — Opcional. Zona horaria del valor devuelto. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor `DateTime64` con precisión de segundos. [`DateTime64(0)`](/es/reference/data-types/datetime64)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT fromUnixTimestamp64Second(1640995200)
```

```response title=Response theme={null}
┌─fromUnixTimestamp64Second(1640995200)─┐
│                   2022-01-01 00:00:00 │
└───────────────────────────────────────┘
```

<div id="parseDateTime">
  ## parseDateTime
</div>

Introducido en: v23.3.0

Convierte una cadena de fecha y hora según una cadena de formato de fecha de MySQL.

Esta función es la inversa de [`formatDateTime`](/es/reference/functions/regular-functions/date-time-functions).
Convierte un argumento String usando una String de formato. Devuelve un valor de tipo DateTime.

**Sintaxis**

```sql theme={null}
parseDateTime(time_string, format[, timezone])
```

**Aliases**: `TO_UNIXTIME`

**Argumentos**

* `time_string` — Cadena que se analizará para convertirla en DateTime. [`String`](/es/reference/data-types/string)
* `format` — Cadena de formato que especifica cómo analizar time\_string. [`String`](/es/reference/data-types/string)
* `timezone` — Opcional. Zona horaria. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un DateTime obtenido al analizar la cadena de entrada según la cadena de formato de estilo MySQL. [`DateTime`](/es/reference/data-types/datetime)

**Ejemplos**

**Ejemplo 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 │
└───────────────────────────────────────────────────────────┘
```

<div id="parseDateTime32BestEffort">
  ## parseDateTime32BestEffort
</div>

Introducido en: v20.9.0

Convierte una representación textual de una fecha y hora al tipo de dato [`DateTime`](/es/reference/data-types/datetime).

La función interpreta [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), los formatos de fecha y hora de ClickHouse y algunos otros.

**Sintaxis**

```sql theme={null}
parseDateTime32BestEffort(time_string[, time_zone])
```

**Argumentos**

* `time_string` — `String` que contiene una fecha y hora para convertir. [`String`](/es/reference/data-types/string)
* `time_zone` — Opcional. Zona horaria usada para analizar `time_string` [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve `time_string` como un `DateTime`. [`DateTime`](/es/reference/data-types/datetime)

**Ejemplos**

**Ejemplo 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 │
└───────────────────────────┘
```

**Con zona horaria**

```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 │
└───────────────────────────┘
```

**marca de tiempo Unix**

```sql title=Query theme={null}
SELECT parseDateTime32BestEffort('1284101485')
AS parseDateTime32BestEffort
```

```response title=Response theme={null}
┌─parseDateTime32BestEffort─┐
│       2015-07-07 12:04:41 │
└───────────────────────────┘
```

<div id="parseDateTime32BestEffortOrNull">
  ## parseDateTime32BestEffortOrNull
</div>

Introducido en: v20.9.0

Igual que [`parseDateTime32BestEffort`](#parseDateTime32BestEffort), salvo que devuelve `NULL` cuando encuentra un formato de fecha que no se puede procesar.

**Sintaxis**

```sql theme={null}
parseDateTime32BestEffortOrNull(time_string[, time_zone])
```

**Argumentos**

* `time_string` — String que contiene una fecha y hora que se va a convertir. [`String`](/es/reference/data-types/string)
* `time_zone` — Opcional. Zona horaria según la cual se analiza `time_string`. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un objeto `DateTime` obtenido al analizar la cadena, o `NULL` si el análisis falla. [`DateTime`](/es/reference/data-types/datetime)

**Ejemplos**

**Ejemplo 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 │    ᴺᵁᴸᴸ │
└─────────────────────┴─────────┘
```

<div id="parseDateTime32BestEffortOrZero">
  ## parseDateTime32BestEffortOrZero
</div>

Introducido en: v20.9.0

Igual que [`parseDateTime32BestEffort`](#parseDateTime32BestEffort), salvo que devuelve una fecha cero o una fecha y hora cero cuando encuentra un formato de fecha que no se puede procesar.

**Sintaxis**

```sql theme={null}
parseDateTime32BestEffortOrZero(time_string[, time_zone])
```

**Argumentos**

* `time_string` — `String` que contiene una fecha y hora para convertir. [`String`](/es/reference/data-types/string)
* `time_zone` — Opcional. Zona horaria según la cual se analiza `time_string`. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un objeto `DateTime` obtenido a partir de la cadena o la fecha cero (`1970-01-01 00:00:00`) si el análisis falla. [`DateTime`](/es/reference/data-types/datetime)

**Ejemplos**

**Ejemplo 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 │
└─────────────────────┴─────────────────────┘
```

<div id="parseDateTime64">
  ## parseDateTime64
</div>

Introducido en: v24.11.0

Analiza una cadena de fecha y hora con precisión de subsegundos según una cadena de formato de fecha de MySQL.

Esta función es la inversa de [`formatDateTime`](/es/reference/functions/regular-functions/date-time-functions) para DateTime64.
Analiza un argumento de tipo String usando un formato String. Devuelve un valor de tipo DateTime64 que puede representar fechas de 1900 a 2299 con precisión de subsegundos.

**Sintaxis**

```sql theme={null}
parseDateTime64(time_string, format[, timezone])
```

**Argumentos**

* `time_string` — Cadena que se interpretará como DateTime64. [`String`](/es/reference/data-types/string)
* `format` — Cadena de formato que especifica cómo interpretar time\_string. [`String`](/es/reference/data-types/string)
* `timezone` — Opcional. Zona horaria. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un DateTime64 obtenido al interpretar la cadena de entrada según la cadena de formato de estilo MySQL. [`DateTime64`](/es/reference/data-types/datetime64)

**Ejemplos**

**Ejemplo 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       │
└─────────────────────────────────────────────────────────────────────┘
```

<div id="parseDateTime64BestEffort">
  ## parseDateTime64BestEffort
</div>

Introducido en: v20.1.0

Igual que la función [`parseDateTimeBestEffort`](#parseDateTimeBestEffort), pero también analiza milisegundos y microsegundos, y devuelve el tipo de dato [`DateTime64`](/es/reference/data-types/datetime64).

**Sintaxis**

```sql theme={null}
parseDateTime64BestEffort(time_string[, precision[, time_zone]])
```

**Argumentos**

* `time_string` — Cadena que contiene una fecha o una fecha con hora para convertir. [`String`](/es/reference/data-types/string)
* `precision` — Opcional. Precisión requerida. `3` para milisegundos, `6` para microsegundos. Valor predeterminado: `3`. [`UInt8`](/es/reference/data-types/int-uint)
* `time_zone` — Opcional. Zona horaria. La función interpreta `time_string` según la zona horaria. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve `time_string` convertido al tipo de dato [`DateTime64`](/es/reference/data-types/datetime64). [`DateTime64`](/es/reference/data-types/datetime64)

**Ejemplos**

**Ejemplo 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') │
└────────────────────────────┴────────────────────────────────┘
```

<div id="parseDateTime64BestEffortOrNull">
  ## parseDateTime64BestEffortOrNull
</div>

Introducido en: v20.1.0

Igual que [`parseDateTime64BestEffort`](#parseDateTime64BestEffort), excepto que devuelve `NULL` cuando encuentra un formato de fecha que no puede procesarse.

**Sintaxis**

```sql theme={null}
parseDateTime64BestEffortOrNull(time_string[, precision[, time_zone]])
```

**Argumentos**

* `time_string` — Cadena que contiene una fecha o una fecha con hora para convertir. [`String`](/es/reference/data-types/string)
* `precision` — Opcional. Precisión requerida. `3` para milisegundos, `6` para microsegundos. Valor predeterminado: `3`. [`UInt8`](/es/reference/data-types/int-uint)
* `time_zone` — Opcional. Zona horaria. La función interpreta `time_string` según la zona horaria. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve `time_string` convertido a [`DateTime64`](/es/reference/data-types/datetime64), o `NULL` si no se puede interpretar la entrada. [`DateTime64`](/es/reference/data-types/datetime64) o [`NULL`](/es/reference/syntax#null)

**Ejemplos**

**Ejemplo 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 │    ᴺᵁᴸᴸ │
└─────────────────────────┴─────────┘
```

<div id="parseDateTime64BestEffortOrZero">
  ## parseDateTime64BestEffortOrZero
</div>

Introducido en: v20.1.0

Igual que [`parseDateTime64BestEffort`](#parseDateTime64BestEffort), excepto que devuelve una fecha cero o una fecha y hora cero cuando encuentra un formato de fecha que no puede procesarse.

**Sintaxis**

```sql theme={null}
parseDateTime64BestEffortOrZero(time_string[, precision[, time_zone]])
```

**Argumentos**

* `time_string` — `String` que contiene una fecha o una fecha con hora para convertir. [`String`](/es/reference/data-types/string)
* `precision` — Opcional. Precisión requerida. `3` para milisegundos, `6` para microsegundos. Valor predeterminado: `3`. [`UInt8`](/es/reference/data-types/int-uint)
* `time_zone` — Opcional. Zona horaria. La función interpreta `time_string` según la zona horaria. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve `time_string` convertido a [`DateTime64`](/es/reference/data-types/datetime64), o una fecha cero/datetime (`1970-01-01 00:00:00.000`) si no se puede analizar la entrada. [`DateTime64`](/es/reference/data-types/datetime64)

**Ejemplos**

**Ejemplo 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 │
└─────────────────────────┴─────────────────────────┘
```

<div id="parseDateTime64BestEffortUS">
  ## parseDateTime64BestEffortUS
</div>

Introducido en: v22.8.0

Igual que [`parseDateTime64BestEffort`](#parseDateTime64BestEffort), salvo que esta función prioriza el formato de fecha de EE. UU. (`MM/DD/YYYY`, etc.) en caso de ambigüedad.

**Sintaxis**

```sql theme={null}
parseDateTime64BestEffortUS(time_string [, precision [, time_zone]])
```

**Argumentos**

* `time_string` — Cadena que contiene una fecha o una fecha con hora para convertir. [`String`](/es/reference/data-types/string)
* `precision` — Opcional. Precisión requerida. `3` para milisegundos, `6` para microsegundos. Valor predeterminado: `3`. [`UInt8`](/es/reference/data-types/int-uint)
* `time_zone` — Opcional. Zona horaria. La función interpreta `time_string` según la zona horaria. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve `time_string` convertido a [`DateTime64`](/es/reference/data-types/datetime64), con preferencia por el formato de fecha de EE. UU. en casos ambiguos. [`DateTime64`](/es/reference/data-types/datetime64)

**Ejemplos**

**Ejemplo 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 │
└─────────────────────────┴─────────────────────────┘
```

<div id="parseDateTime64BestEffortUSOrNull">
  ## parseDateTime64BestEffortUSOrNull
</div>

Introducido en: v22.8.0

Igual que [`parseDateTime64BestEffort`](#parseDateTime64BestEffort), salvo que esta función prioriza el formato de fecha de EE. UU. (`MM/DD/YYYY`, etc.) en caso de ambigüedad y devuelve `NULL` cuando encuentra un formato de fecha que no puede procesarse.

**Sintaxis**

```sql theme={null}
parseDateTime64BestEffortUSOrNull(time_string[, precision[, time_zone]])
```

**Argumentos**

* `time_string` — Cadena que contiene una fecha o una fecha con hora para convertir. [`String`](/es/reference/data-types/string)
* `precision` — Opcional. Precisión requerida. `3` para milisegundos, `6` para microsegundos. Valor predeterminado: `3`. [`UInt8`](/es/reference/data-types/int-uint)
* `time_zone` — Opcional. Zona horaria. La función interpreta `time_string` según la zona horaria. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve `time_string` convertido a [`DateTime64`](/es/reference/data-types/datetime64) con preferencia por el formato de EE. UU., o `NULL` si la entrada no se puede interpretar. [`DateTime64`](/es/reference/data-types/datetime64) o [`NULL`](/es/reference/syntax#null)

**Ejemplos**

**Ejemplo 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 │    ᴺᵁᴸᴸ │
└─────────────────────────┴─────────┘
```

<div id="parseDateTime64BestEffortUSOrZero">
  ## parseDateTime64BestEffortUSOrZero
</div>

Introducido en: v22.8.0

Igual que [`parseDateTime64BestEffort`](#parseDateTime64BestEffort), salvo que esta función da preferencia al formato de fecha de EE. UU. (`MM/DD/YYYY`, etc.) en caso de ambigüedad y devuelve una fecha cero o una fecha y hora cero cuando encuentra un formato de fecha que no puede procesarse.

**Sintaxis**

```sql theme={null}
parseDateTime64BestEffortUSOrZero(time_string [, precision [, time_zone]])
```

**Argumentos**

* `time_string` — `String` que contiene una fecha o una fecha con hora para convertir. [`String`](/es/reference/data-types/string)
* `precision` — Opcional. Precisión requerida. `3` para milisegundos, `6` para microsegundos. Valor predeterminado: `3`. [`UInt8`](/es/reference/data-types/int-uint)
* `time_zone` — Opcional. Zona horaria. La función interpreta `time_string` según la zona horaria. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve `time_string` convertido a [`DateTime64`](/es/reference/data-types/datetime64) con preferencia por el formato de EE. UU., o una fecha/fecha y hora cero (`1970-01-01 00:00:00.000`) si no se puede analizar la entrada. [`DateTime64`](/es/reference/data-types/datetime64)

**Ejemplos**

**Ejemplo 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 │
└─────────────────────────┴─────────────────────────┘
```

<div id="parseDateTime64InJodaSyntax">
  ## parseDateTime64InJodaSyntax
</div>

Introducido en: v24.10.0

Analiza una cadena de fecha y hora con precisión inferior al segundo según una cadena de formato de fecha de Joda.

Esta función es la inversa de [`formatDateTimeInJodaSyntax`](/es/reference/functions/regular-functions/date-time-functions#formatDateTimeInJodaSyntax) para DateTime64.
Analiza un argumento String con una cadena de formato String de estilo Joda. Devuelve un tipo DateTime64 que puede representar fechas de 1900 a 2299 con precisión inferior al segundo.

Consulta la [documentación de Joda Time](https://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html) para conocer los patrones de formato.

**Sintaxis**

```sql theme={null}
parseDateTime64InJodaSyntax(time_string, format[, timezone])
```

**Argumentos**

* `time_string` — Cadena que se convertirá en DateTime64. [`String`](/es/reference/data-types/string)
* `format` — Cadena de formato en sintaxis Joda que especifica cómo interpretar time\_string. [`String`](/es/reference/data-types/string)
* `timezone` — Opcional. Zona horaria. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un DateTime64 obtenido a partir de la cadena de entrada según la cadena de formato de estilo Joda. [`DateTime64`](/es/reference/data-types/datetime64)

**Ejemplos**

**Ejemplo 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   │
└────────────────────────────────────────────────────────────────────────────────────┘
```

<div id="parseDateTime64InJodaSyntaxOrNull">
  ## parseDateTime64InJodaSyntaxOrNull
</div>

Introducido en: v24.10.0

Igual que [`parseDateTime64InJodaSyntax`](#parseDateTime64InJodaSyntax), pero devuelve `NULL` cuando encuentra un formato de fecha que no se puede analizar.

**Sintaxis**

```sql theme={null}
parseDateTime64InJodaSyntaxOrNull(time_string, format[, timezone])
```

**Argumentos**

* `time_string` — Cadena que se analizará como DateTime64. [`String`](/es/reference/data-types/string)
* `format` — Cadena de formato en sintaxis Joda que especifica cómo analizar time\_string. [`String`](/es/reference/data-types/string)
* `timezone` — Opcional. Zona horaria. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el valor DateTime64 analizado a partir de la cadena de entrada, o NULL si el análisis falla. [`Nullable(DateTime64)`](/es/reference/data-types/nullable)

**Ejemplos**

**Ejemplo 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      │
└──────────────────────────────────────────────────────────────────────────────────────────┘
```

<div id="parseDateTime64InJodaSyntaxOrZero">
  ## parseDateTime64InJodaSyntaxOrZero
</div>

Introducido en: v24.10.0

Igual que [`parseDateTime64InJodaSyntax`](#parseDateTime64InJodaSyntax), pero devuelve una fecha cero cuando encuentra un formato de fecha que no se puede analizar.

**Sintaxis**

```sql theme={null}
parseDateTime64InJodaSyntaxOrZero(time_string, format[, timezone])
```

**Argumentos**

* `time_string` — String que se convertirá en DateTime64. [`String`](/es/reference/data-types/string)
* `format` — Cadena de formato en sintaxis Joda que especifica cómo interpretar time\_string. [`String`](/es/reference/data-types/string)
* `timezone` — Opcional. Zona horaria. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el DateTime64 interpretado a partir de la cadena de entrada, o el valor cero de DateTime64 si el análisis falla. [`DateTime64`](/es/reference/data-types/datetime64)

**Ejemplos**

**Ejemplo 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     │
└──────────────────────────────────────────────────────────────────────────────────────────┘
```

<div id="parseDateTime64OrNull">
  ## parseDateTime64OrNull
</div>

Introducido en: v24.11.0

Igual que [`parseDateTime64`](#parseDateTime64), pero devuelve `NULL` cuando encuentra un formato de fecha que no se puede analizar.

**Sintaxis**

```sql theme={null}
parseDateTime64OrNull(time_string, format[, timezone])
```

**Argumentos**

* `time_string` — Cadena que se analizará como DateTime64. [`String`](/es/reference/data-types/string)
* `format` — Cadena de formato que especifica cómo analizar time\_string. [`String`](/es/reference/data-types/string)
* `timezone` — Opcional. Zona horaria. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el valor DateTime64 analizado a partir de la cadena de entrada, o NULL si el análisis falla. [`Nullable(DateTime64)`](/es/reference/data-types/nullable)

**Ejemplos**

**Ejemplo 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        │
└───────────────────────────────────────────────────────────────────────────┘
```

<div id="parseDateTime64OrZero">
  ## parseDateTime64OrZero
</div>

Introducido en: v24.11.0

Igual que [`parseDateTime64`](#parseDateTime64), pero devuelve una fecha cero cuando encuentra un formato de fecha que no se puede analizar.

**Sintaxis**

```sql theme={null}
parseDateTime64OrZero(time_string, format[, timezone])
```

**Argumentos**

* `time_string` — Cadena que se interpretará como DateTime64. [`String`](/es/reference/data-types/string)
* `format` — Cadena de formato que especifica cómo interpretar time\_string. [`String`](/es/reference/data-types/string)
* `timezone` — Opcional. Zona horaria. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un DateTime64 interpretado a partir de la cadena de entrada, o el valor cero de DateTime64 si el análisis falla. [`DateTime64`](/es/reference/data-types/datetime64)

**Ejemplos**

**Ejemplo 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       │
└───────────────────────────────────────────────────────────────────────────┘
```

<div id="parseDateTimeBestEffort">
  ## parseDateTimeBestEffort
</div>

Introducido en: v1.1.0

Convierte una fecha y hora en representación String al tipo de dato DateTime.
La función analiza [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, los formatos de fecha y hora de ClickHouse y algunos otros.

Formatos no estándar compatibles:

* Una cadena que contiene un `Unix timestamp` de 9..10 dígitos.
* Una cadena con una fecha y un componente de hora: `YYYYMMDDhhmmss`, `DD/MM/YYYY hh:mm:ss`, `DD-MM-YY hh:mm`, `YYYY-MM-DD hh:mm:ss`, etc.
* Una cadena con una fecha, pero sin componente de hora: `YYYY`, `YYYYMM`, `YYYY*MM`, `DD/MM/YYYY`, `DD-MM-YY` etc.
* Una cadena con un día y una hora: `DD`, `DD hh`, `DD hh:mm`. En este caso, `MM` se sustituye por `01`.
* Una cadena que incluye la fecha y hora junto con información del desfase de zona horaria: `YYYY-MM-DD hh:mm:ss ±h:mm`, etc.
* Una marca de tiempo de syslog: `Mmm dd hh:mm:ss`. Por ejemplo, `Jun  9 14:20:32`.

En todos los formatos con separador, la función analiza nombres de meses expresados con el nombre completo o con las tres primeras letras del nombre del mes.
Si no se especifica el año, se considera que es el año actual.

**Sintaxis**

```sql theme={null}
parseDateTimeBestEffort(time_string[, time_zone])
```

**Argumentos**

* `time_string` — Cadena que contiene una fecha y una hora para convertir. [`String`](/es/reference/data-types/string)
* `time_zone` — Opcional. Zona horaria según la cual se analiza `time_string`. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve `time_string` como `DateTime`. [`DateTime`](/es/reference/data-types/datetime)

**Ejemplos**

**Ejemplo 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 │
└─────────────────────────┘
```

**Con zona horaria**

```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 │
└─────────────────────────┘
```

**Marca temporal Unix**

```sql title=Query theme={null}
SELECT parseDateTimeBestEffort('1735689600') AS parseDateTimeBestEffort
```

```response title=Response theme={null}
┌─parseDateTimeBestEffort─┐
│     2025-01-01 00:00:00 │
└─────────────────────────┘
```

<div id="parseDateTimeBestEffortOrNull">
  ## parseDateTimeBestEffortOrNull
</div>

Introducido en: v1.1.0

Igual que [`parseDateTimeBestEffort`](#parseDateTimeBestEffort), excepto que devuelve `NULL` cuando encuentra un formato de fecha que no se puede procesar.
La función analiza [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), los formatos de fecha y hora de ClickHouse y algunos otros.

Formatos no estándar admitidos:

* Una cadena que contiene un Unix timestamp de 9..10 dígitos.
* Una cadena con una fecha y un componente de hora: `YYYYMMDDhhmmss`, `DD/MM/YYYY hh:mm:ss`, `DD-MM-YY hh:mm`, `YYYY-MM-DD hh:mm:ss`, etc.
* Una cadena con una fecha, pero sin componente de hora: `YYYY`, `YYYYMM`, `YYYY*MM`, `DD/MM/YYYY`, `DD-MM-YY`, etc.
* Una cadena con un día y una hora: `DD`, `DD hh`, `DD hh:mm`. En este caso, `MM` se sustituye por `01`.
* Una cadena que incluye la fecha y la hora junto con información de desplazamiento de zona horaria: `YYYY-MM-DD hh:mm:ss ±h:mm`, etc.
* Un timestamp de syslog: `Mmm dd hh:mm:ss`. Por ejemplo, `Jun  9 14:20:32`.

En todos los formatos con separador, la función analiza nombres de meses expresados con su nombre completo o con las tres primeras letras del nombre del mes.
Si no se especifica el año, se considera que es el año actual.

**Sintaxis**

```sql theme={null}
parseDateTimeBestEffortOrNull(time_string[, time_zone])
```

**Argumentos**

* `time_string` — `String` que contiene una fecha y hora para convertir. [`String`](/es/reference/data-types/string)
* `time_zone` — Opcional. Zona horaria según la que se interpreta `time_string`. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve `time_string` como `DateTime`, o `NULL` si la entrada no se puede interpretar. [`DateTime`](/es/reference/data-types/datetime) o [`NULL`](/es/reference/syntax#null)

**Ejemplos**

**Ejemplo 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 │    ᴺᵁᴸᴸ │
└─────────────────────┴─────────┘
```

<div id="parseDateTimeBestEffortOrZero">
  ## parseDateTimeBestEffortOrZero
</div>

Introducido en: v1.1.0

Igual que [`parseDateTimeBestEffort`](#parseDateTimeBestEffort), excepto que devuelve una fecha cero o una fecha y hora cero cuando encuentra un formato de fecha que no puede procesar.
La función analiza [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), los formatos de fecha y hora de ClickHouse y algunos otros.

Formatos no estándar compatibles:

* Una cadena que contiene una marca de tiempo Unix de 9..10 dígitos.
* Una cadena con una fecha y un componente de hora: `YYYYMMDDhhmmss`, `DD/MM/YYYY hh:mm:ss`, `DD-MM-YY hh:mm`, `YYYY-MM-DD hh:mm:ss`, etc.
* Una cadena con una fecha, pero sin componente de hora: `YYYY`, `YYYYMM`, `YYYY*MM`, `DD/MM/YYYY`, `DD-MM-YY` etc.
* Una cadena con un día y una hora: `DD`, `DD hh`, `DD hh:mm`. En este caso, `MM` se sustituye por `01`.
* Una cadena que incluye la fecha y la hora junto con información del desfase de zona horaria: `YYYY-MM-DD hh:mm:ss ±h:mm`, etc.
* Una marca de tiempo de syslog: `Mmm dd hh:mm:ss`. Por ejemplo, `Jun  9 14:20:32`.

Para todos los formatos con separador, la función analiza nombres de meses expresados con su nombre completo o con las tres primeras letras del nombre del mes.
Si no se especifica el año, se considera igual al año actual.

**Sintaxis**

```sql theme={null}
parseDateTimeBestEffortOrZero(time_string[, time_zone])
```

**Argumentos**

* `time_string` — `String` que contiene una fecha y hora para convertir. [`String`](/es/reference/data-types/string)
* `time_zone` — Opcional. Zona horaria según la cual se interpreta `time_string`. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve `time_string` como un `DateTime`, o una fecha cero/fecha y hora cero (`1970-01-01` o `1970-01-01 00:00:00`) si no se puede interpretar la entrada. [`DateTime`](/es/reference/data-types/datetime)

**Ejemplos**

**Ejemplo 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 │
└─────────────────────┴─────────────────────┘
```

<div id="parseDateTimeBestEffortUS">
  ## parseDateTimeBestEffortUS
</div>

Introducido en: v1.1.0

Esta función se comporta como [`parseDateTimeBestEffort`](#parseDateTimeBestEffort) para formatos de fecha ISO, p. ej., `YYYY-MM-DD hh:mm:ss`, y otros formatos de fecha en los que los componentes de mes y día pueden extraerse de forma inequívoca, p. ej., `YYYYMMDDhhmmss`, `YYYY-MM`, `DD hh` o `YYYY-MM-DD hh:mm:ss ±h:mm`.
Si los componentes de mes y día no pueden extraerse de forma inequívoca, p. ej., `MM/DD/YYYY`, `MM-DD-YYYY` o `MM-DD-YY`, da preferencia al formato de fecha de EE. UU. en lugar de `DD/MM/YYYY`, `DD-MM-YYYY` o `DD-MM-YY`.
Como excepción a lo anterior, si el mes es mayor que 12 y menor o igual que 31, esta función vuelve al comportamiento de [`parseDateTimeBestEffort`](#parseDateTimeBestEffort); p. ej., `15/08/2020` se interpreta como `2020-08-15`.

**Sintaxis**

```sql theme={null}
parseDateTimeBestEffortUS(time_string[, time_zone])
```

**Argumentos**

* `time_string` — `String` que contiene una fecha y hora que se convertirán. [`String`](/es/reference/data-types/string)
* `time_zone` — Opcional. Zona horaria según la cual se interpreta `time_string`. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve `time_string` como `DateTime` y, en casos ambiguos, prioriza el formato de fecha de EE. UU. [`DateTime`](/es/reference/data-types/datetime)

**Ejemplos**

**Ejemplo 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 │
└─────────────────────┴──────────────────────┘
```

<div id="parseDateTimeBestEffortUSOrNull">
  ## parseDateTimeBestEffortUSOrNull
</div>

Introducido en: v1.1.0

Igual que la función [`parseDateTimeBestEffortUS`](#parseDateTimeBestEffortUS), salvo que devuelve `NULL` cuando encuentra un formato de fecha que no se puede procesar.

Esta función se comporta como [`parseDateTimeBestEffort`](#parseDateTimeBestEffort) con los formatos de fecha ISO, pero en los casos ambiguos da prioridad al formato de fecha de EE. UU. y devuelve `NULL` si se producen errores de análisis.

**Sintaxis**

```sql theme={null}
parseDateTimeBestEffortUSOrNull(time_string[, time_zone])
```

**Argumentos**

* `time_string` — `String` que contiene una fecha y hora para convertir. [`String`](/es/reference/data-types/string)
* `time_zone` — Opcional. Zona horaria según la cual se interpreta `time_string`. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve `time_string` como un DateTime con preferencia por el formato de EE. UU., o `NULL` si la entrada no se puede interpretar. [`DateTime`](/es/reference/data-types/datetime) o [`NULL`](/es/reference/syntax#null)

**Ejemplos**

**Ejemplo 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 │    ᴺᵁᴸᴸ │
└─────────────────────┴─────────┘
```

<div id="parseDateTimeBestEffortUSOrZero">
  ## parseDateTimeBestEffortUSOrZero
</div>

Introducido en: v1.1.0

Igual que la función [`parseDateTimeBestEffortUS`](#parseDateTimeBestEffortUS), salvo que devuelve una fecha cero (`1970-01-01`) o una fecha cero con hora (`1970-01-01 00:00:00`) cuando encuentra un formato de fecha que no puede procesarse.

Esta función se comporta como [`parseDateTimeBestEffort`](#parseDateTimeBestEffort) para los formatos de fecha ISO, pero en los casos ambiguos da prioridad al formato de fecha de EE. UU. y devuelve un valor cero si se producen errores de análisis.

**Sintaxis**

```sql theme={null}
parseDateTimeBestEffortUSOrZero(time_string[, time_zone])
```

**Argumentos**

* `time_string` — `String` que contiene una fecha y hora que se va a convertir. [`String`](/es/reference/data-types/string)
* `time_zone` — Opcional. Zona horaria según la cual se interpreta `time_string`. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve `time_string` como un `DateTime` usando la preferencia de formato de EE. UU., o una fecha/fecha y hora cero (`1970-01-01` o `1970-01-01 00:00:00`) si no se puede interpretar la entrada. [`DateTime`](/es/reference/data-types/datetime)

**Ejemplos**

**Ejemplo 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 │
└─────────────────────┴─────────────────────┘
```

<div id="parseDateTimeInJodaSyntax">
  ## parseDateTimeInJodaSyntax
</div>

Introducido en: v23.3.0

Interpreta una cadena de fecha y hora según una cadena de formato de fecha de Joda.

Esta función es la inversa de [`formatDateTimeInJodaSyntax`](/es/reference/functions/regular-functions/date-time-functions#formatDateTimeInJodaSyntax).
Interpreta un argumento de tipo String usando una cadena de formato de estilo Joda. Devuelve un valor de tipo DateTime.

Consulta la [documentación de Joda Time](https://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html) para conocer los patrones de formato.

**Sintaxis**

```sql theme={null}
parseDateTimeInJodaSyntax(time_string, format[, timezone])
```

**Argumentos**

* `time_string` — Cadena para analizar como DateTime. [`String`](/es/reference/data-types/string)
* `format` — Cadena de formato en sintaxis Joda que especifica cómo interpretar time\_string. [`String`](/es/reference/data-types/string)
* `timezone` — Opcional. Zona horaria. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un DateTime interpretado a partir de la cadena de entrada según la cadena de formato de estilo Joda. [`DateTime`](/es/reference/data-types/datetime)

**Ejemplos**

**Ejemplo 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 │
└──────────────────────────────────────────────────────────────────────────┘
```

<div id="parseDateTimeInJodaSyntaxOrNull">
  ## parseDateTimeInJodaSyntaxOrNull
</div>

Introducido en: v23.3.0

Igual que [`parseDateTimeInJodaSyntax`](#parseDateTimeInJodaSyntax), pero devuelve `NULL` cuando encuentra un formato de fecha que no se puede analizar.

**Sintaxis**

```sql theme={null}
parseDateTimeInJodaSyntaxOrNull(time_string, format[, timezone])
```

**Argumentos**

* `time_string` — Cadena para analizar como DateTime. [`String`](/es/reference/data-types/string)
* `format` — Cadena de formato en sintaxis Joda que especifica cómo interpretar time\_string. [`String`](/es/reference/data-types/string)
* `timezone` — Opcional. Zona horaria. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el valor DateTime obtenido al interpretar la cadena de entrada, o NULL si el análisis falla. [`Nullable(DateTime)`](/es/reference/data-types/nullable)

**Ejemplos**

**Ejemplo 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    │
└────────────────────────────────────────────────────────────────────────────────┘
```

<div id="parseDateTimeInJodaSyntaxOrZero">
  ## parseDateTimeInJodaSyntaxOrZero
</div>

Introducido en: v23.3.0

Igual que [`parseDateTimeInJodaSyntax`](#parseDateTimeInJodaSyntax), pero devuelve la fecha cero cuando encuentra un formato de fecha que no se puede analizar.

**Sintaxis**

```sql theme={null}
parseDateTimeInJodaSyntaxOrZero(time_string, format[, timezone])
```

**Argumentos**

* `time_string` — Cadena que se analizará para convertirla en DateTime. [`String`](/es/reference/data-types/string)
* `format` — Cadena de formato en sintaxis Joda que especifica cómo analizar time\_string. [`String`](/es/reference/data-types/string)
* `timezone` — Opcional. Zona horaria. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el DateTime obtenido al analizar la cadena de entrada, o el DateTime cero si el análisis falla. [`DateTime`](/es/reference/data-types/datetime)

**Ejemplos**

**Ejemplo 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   │
└────────────────────────────────────────────────────────────────────────────────┘
```

<div id="parseDateTimeOrNull">
  ## parseDateTimeOrNull
</div>

Introducido en: v23.3.0

Igual que [`parseDateTime`](#parseDateTime), pero devuelve `NULL` cuando encuentra un formato de fecha que no se puede analizar.

**Sintaxis**

```sql theme={null}
parseDateTimeOrNull(time_string, format[, timezone])
```

**Alias**: `str_to_date`

**Argumentos**

* `time_string` — Cadena para analizar como DateTime. [`String`](/es/reference/data-types/string)
* `format` — Cadena de formato que especifica cómo analizar `time_string`. [`String`](/es/reference/data-types/string)
* `timezone` — Opcional. Zona horaria. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el DateTime obtenido a partir de la cadena de entrada, o NULL si el análisis falla. [`Nullable(DateTime)`](/es/reference/data-types/nullable)

**Ejemplos**

**Ejemplo 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  │
└─────────────────────────────────────────────────────────────────┘
```

<div id="parseDateTimeOrZero">
  ## parseDateTimeOrZero
</div>

Introducido en: v23.3.0

Igual que [`parseDateTime`](#parseDateTime), pero devuelve una fecha cero cuando encuentra un formato de fecha que no se puede analizar.

**Sintaxis**

```sql theme={null}
parseDateTimeOrZero(time_string, format[, timezone])
```

**Argumentos**

* `time_string` — Cadena que se debe analizar como DateTime. [`String`](/es/reference/data-types/string)
* `format` — Cadena de formato que especifica cómo analizar time\_string. [`String`](/es/reference/data-types/string)
* `timezone` — Opcional. Zona horaria. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el DateTime analizado a partir de la cadena de entrada, o un DateTime con valor cero si el análisis falla. [`DateTime`](/es/reference/data-types/datetime)

**Ejemplos**

**Ejemplo 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 │
└─────────────────────────────────────────────────────────────────┘
```

<div id="reinterpret">
  ## reinterpret
</div>

Introducido en: v1.1.0

Usa la misma secuencia de bytes en memoria de origen para el valor proporcionado `x` y la reinterpreta como el tipo de destino.

**Sintaxis**

```sql theme={null}
reinterpret(x, type)
```

**Argumentos**

* `x` — Cualquier tipo. [`Any`](/es/reference/data-types/index)
* `type` — Tipo de destino. Si es un array, el tipo de elemento del array debe ser de longitud fija. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Valor del tipo de destino. [`Any`](/es/reference/data-types/index)

**Ejemplos**

**Ejemplo 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 │
└─────────────┴──────────────┴───────────────┘
```

**Ejemplo 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]  │
└────────────────────────────┘
```

<div id="reinterpretAsDate">
  ## reinterpretAsDate
</div>

Introducido en: v1.1.0

Reinterpreta el valor de entrada como un valor Date (suponiendo un orden little endian), que representa el número de días desde el inicio de la época Unix 1970-01-01

**Sintaxis**

```sql theme={null}
reinterpretAsDate(x)
```

**Argumentos**

* `x` — Número de días desde el inicio de la época Unix. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`UUID`](/es/reference/data-types/uuid) o [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)

**Valor devuelto**

Date. [`Date`](/es/reference/data-types/date)

**Ejemplos**

**Ejemplo 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 │
└───────────────────────┴────────────────────────┘
```

<div id="reinterpretAsDateTime">
  ## reinterpretAsDateTime
</div>

Introducido en: v1.1.0

Reinterpreta el valor de entrada como un valor DateTime (suponiendo el orden little endian), que es el número de días transcurridos desde el inicio de la época Unix, 1970-01-01

**Sintaxis**

```sql theme={null}
reinterpretAsDateTime(x)
```

**Argumentos**

* `x` — Número de segundos desde el inicio de la época Unix. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`UUID`](/es/reference/data-types/uuid) o [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)

**Valor devuelto**

Fecha y hora. [`DateTime`](/es/reference/data-types/datetime)

**Ejemplos**

**Ejemplo 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 │
└───────────────────────────┴────────────────────────────┘
```

<div id="reinterpretAsFixedString">
  ## reinterpretAsFixedString
</div>

Introducido en: v1.1.0

Reinterpreta el valor de entrada como una cadena de longitud fija (asumiendo el orden little endian).
Los bytes nulos del final se ignoran; por ejemplo, para el valor UInt32 255, la función devuelve una cadena con un solo carácter.

**Sintaxis**

```sql theme={null}
reinterpretAsFixedString(x)
```

**Argumentos**

* `x` — Valor que se reinterpretará como cadena. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime)

**Valor devuelto**

Cadena fija que contiene los bytes que representan `x`. [`FixedString`](/es/reference/data-types/fixedstring)

**Ejemplos**

**Ejemplo 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                                              │
└─────────────────────────────────────────────────────────────┴────────────────────────────────────────────────┘
```

<div id="reinterpretAsFloat32">
  ## reinterpretAsFloat32
</div>

Introducido en: v1.1.0

Reinterpreta el valor de entrada como un valor de tipo Float32.
A diferencia de [`CAST`](#CAST), la función no intenta preservar el valor original; si el tipo de destino no puede representar el tipo de entrada, el resultado no está definido.

**Sintaxis**

```sql theme={null}
reinterpretAsFloat32(x)
```

**Argumentos**

* `x` — Valor para reinterpretar como Float32. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`UUID`](/es/reference/data-types/uuid) o [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)

**Valor devuelto**

Devuelve el valor reinterpretado `x`. [`Float32`](/es/reference/data-types/float)

**Ejemplos**

**Ejemplo 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 │
└────────────┴─────────────────────────┘
```

<div id="reinterpretAsFloat64">
  ## reinterpretAsFloat64
</div>

Introducida en: v1.1.0

Reinterpreta el valor de entrada como un valor de tipo Float64.
A diferencia de [`CAST`](#CAST), la función no intenta preservar el valor original; si el tipo de destino no puede representar el tipo de entrada, el resultado no está definido.

**Sintaxis**

```sql theme={null}
reinterpretAsFloat64(x)
```

**Argumentos**

* `x` — Valor para reinterpretar como Float64. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`UUID`](/es/reference/data-types/uuid) o [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)

**Valor devuelto**

Devuelve el valor reinterpretado `x`. [`Float64`](/es/reference/data-types/float)

**Ejemplos**

**Ejemplo 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 │
└─────────────────────┴─────────────────────────┘
```

<div id="reinterpretAsInt128">
  ## reinterpretAsInt128
</div>

Introducido en: v1.1.0

Reinterpreta el valor de entrada como un valor de tipo Int128.
A diferencia de [`CAST`](#CAST), la función no intenta conservar el valor original; si el tipo de destino no puede representar el tipo de entrada, el resultado no está definido.

**Sintaxis**

```sql theme={null}
reinterpretAsInt128(x)
```

**Argumentos**

* `x` — Valor que se va a reinterpretar como Int128. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`UUID`](/es/reference/data-types/uuid) o [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)

**Valor devuelto**

Devuelve el valor reinterpretado `x`. [`Int128`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo 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          │
└─────┴───────────────┴─────┴─────────────────┘
```

<div id="reinterpretAsInt16">
  ## reinterpretAsInt16
</div>

Introducido en: v1.1.0

Reinterpreta el valor de entrada como un valor de tipo Int16.
A diferencia de [`CAST`](#CAST), la función no intenta conservar el valor original; si el tipo de destino no puede representar el tipo de entrada, el resultado no está definido.

**Sintaxis**

```sql theme={null}
reinterpretAsInt16(x)
```

**Argumentos**

* `x` — Valor que se reinterpretará como Int16. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`UUID`](/es/reference/data-types/uuid) o [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)

**Valor devuelto**

Devuelve el valor reinterpretado `x`. [`Int16`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo 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           │
└───┴───────────────┴─────┴─────────────────┘
```

<div id="reinterpretAsInt256">
  ## reinterpretAsInt256
</div>

Introducido en: v1.1.0

Reinterpreta el valor de entrada como un valor de tipo Int256.
A diferencia de [`CAST`](#CAST), la función no intenta conservar el valor original; si el tipo de destino no puede representar el tipo de entrada, el resultado es indefinido.

**Sintaxis**

```sql theme={null}
reinterpretAsInt256(x)
```

**Argumentos**

* `x` — Valor que se va a reinterpretar como Int256. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`UUID`](/es/reference/data-types/uuid) o [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)

**Valor devuelto**

Devuelve el valor reinterpretado de `x`. [`Int256`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo 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          │
└─────┴───────────────┴─────┴─────────────────┘
```

<div id="reinterpretAsInt32">
  ## reinterpretAsInt32
</div>

Introducido en: v1.1.0

Reinterpreta el valor de entrada como un valor de tipo Int32.
A diferencia de [`CAST`](#CAST), la función no intenta preservar el valor original; si el tipo de destino no puede representar el tipo de entrada, el resultado no está definido.

**Sintaxis**

```sql theme={null}
reinterpretAsInt32(x)
```

**Argumentos**

* `x` — Valor que se reinterpretará como Int32. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`UUID`](/es/reference/data-types/uuid) o [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)

**Valor devuelto**

Devuelve el valor reinterpretado `x`. [`Int32`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo 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           │
└─────┴───────────────┴─────┴─────────────────┘
```

<div id="reinterpretAsInt64">
  ## reinterpretAsInt64
</div>

Introducido en: v1.1.0

Reinterpreta el valor de entrada como un valor del tipo Int64.
A diferencia de [`CAST`](#CAST), la función no intenta preservar el valor original; si el tipo de destino no puede representar el tipo de entrada, el resultado no está definido.

**Sintaxis**

```sql theme={null}
reinterpretAsInt64(x)
```

**Argumentos**

* `x` — Valor que se reinterpretará como Int64. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`UUID`](/es/reference/data-types/uuid) o [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)

**Valor devuelto**

Devuelve el valor reinterpretado `x`. [`Int64`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo 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           │
└─────┴───────────────┴─────┴─────────────────┘
```

<div id="reinterpretAsInt8">
  ## reinterpretAsInt8
</div>

Introducido en: v1.1.0

Reinterpreta el valor de entrada como un valor de tipo Int8.
A diferencia de [`CAST`](#CAST), la función no intenta conservar el valor original; si el tipo de destino no puede representar el tipo de entrada, el resultado no está definido.

**Sintaxis**

```sql theme={null}
reinterpretAsInt8(x)
```

**Argumentos**

* `x` — Valor que se va a reinterpretar como Int8. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`UUID`](/es/reference/data-types/uuid) o [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)

**Valor devuelto**

Devuelve el valor reinterpretado de `x`. [`Int8`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo 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            │
└───┴───────────────┴─────┴─────────────────┘
```

<div id="reinterpretAsString">
  ## reinterpretAsString
</div>

Introducido en: v1.1.0

Reinterpreta el valor de entrada como una cadena (suponiendo el orden de bytes little endian).
Los bytes nulos del final se ignoran; por ejemplo, para el valor UInt32 255, la función devuelve una cadena con un solo carácter.

**Sintaxis**

```sql theme={null}
reinterpretAsString(x)
```

**Argumentos**

* `x` — Valor que se reinterpretará como cadena. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime)

**Valor devuelto**

String que contiene los bytes que representan `x`. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo 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                                         │
└────────────────────────────────────────────────────────┴───────────────────────────────────────────┘
```

<div id="reinterpretAsUInt128">
  ## reinterpretAsUInt128
</div>

Introducido en: v1.1.0

Reinterpreta el valor de entrada como un valor de tipo UInt128.
A diferencia de [`CAST`](#CAST), la función no intenta preservar el valor original; si el tipo de destino no puede representar el tipo de entrada, el resultado es indefinido.

**Sintaxis**

```sql theme={null}
reinterpretAsUInt128(x)
```

**Argumentos**

* `x` — Valor que se va a reinterpretar como UInt128. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`UUID`](/es/reference/data-types/uuid) o [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)

**Valor devuelto**

Devuelve el valor reinterpretado `x`. [`UInt128`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo 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         │
└─────┴───────────────┴─────┴─────────────────┘
```

<div id="reinterpretAsUInt16">
  ## reinterpretAsUInt16
</div>

Introducido en: v1.1.0

Reinterpreta el valor de entrada como un valor de tipo UInt16.
A diferencia de [`CAST`](#CAST), la función no intenta preservar el valor original; si el tipo de destino no puede representar el tipo de entrada, el resultado no está definido.

**Sintaxis**

```sql theme={null}
reinterpretAsUInt16(x)
```

**Argumentos**

* `x` — Valor que se va a reinterpretar como UInt16. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`UUID`](/es/reference/data-types/uuid) o [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)

**Valor devuelto**

Devuelve el valor reinterpretado `x`. [`UInt16`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo 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          │
└───┴───────────────┴─────┴─────────────────┘
```

<div id="reinterpretAsUInt256">
  ## reinterpretAsUInt256
</div>

Introducido en: v1.1.0

Reinterpreta el valor de entrada como un valor de tipo UInt256.
A diferencia de [`CAST`](#CAST), la función no intenta preservar el valor original; si el tipo de destino no puede representar el tipo de entrada, el resultado es indefinido.

**Sintaxis**

```sql theme={null}
reinterpretAsUInt256(x)
```

**Argumentos**

* `x` — Valor para reinterpretar como UInt256. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`UUID`](/es/reference/data-types/uuid) o [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)

**Valor devuelto**

Devuelve el valor reinterpretado `x`. [`UInt256`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo 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         │
└─────┴───────────────┴─────┴─────────────────┘
```

<div id="reinterpretAsUInt32">
  ## reinterpretAsUInt32
</div>

Introducido en: v1.1.0

Reinterpreta el valor de entrada como un valor de tipo UInt32.
A diferencia de [`CAST`](#CAST), la función no intenta preservar el valor original; si el tipo de destino no puede representar el tipo de entrada, el resultado no está definido.

**Sintaxis**

```sql theme={null}
reinterpretAsUInt32(x)
```

**Argumentos**

* `x` — Valor que se reinterpretará como UInt32. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`UUID`](/es/reference/data-types/uuid) o [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)

**Valor devuelto**

Devuelve el valor reinterpretado `x`. [`UInt32`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo 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          │
└─────┴───────────────┴─────┴─────────────────┘
```

<div id="reinterpretAsUInt64">
  ## reinterpretAsUInt64
</div>

Introducido en: v1.1.0

Reinterpreta el valor de entrada como un valor de tipo UInt64.
A diferencia de [`CAST`](#CAST), la función no intenta conservar el valor original; si el tipo de destino no puede representar el tipo de entrada, el resultado es indefinido.

**Sintaxis**

```sql theme={null}
reinterpretAsUInt64(x)
```

**Argumentos**

* `x` — Valor que se va a reinterpretar como UInt64. [`Int*`](/es/reference/data-types/int-uint) o [`UInt*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`UUID`](/es/reference/data-types/uuid) o [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)

**Valor devuelto**

Devuelve el valor reinterpretado de `x`. [`UInt64`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo 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          │
└─────┴───────────────┴─────┴─────────────────┘
```

<div id="reinterpretAsUInt8">
  ## reinterpretAsUInt8
</div>

Introducido en: v1.1.0

Reinterpreta el valor de entrada como un valor de tipo UInt8.
A diferencia de [`CAST`](#CAST), la función no intenta preservar el valor original; si el tipo de destino no puede representar el tipo de entrada, el resultado no está definido.

**Sintaxis**

```sql theme={null}
reinterpretAsUInt8(x)
```

**Argumentos**

* `x` — Valor para reinterpretar como UInt8. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`UUID`](/es/reference/data-types/uuid) o [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)

**Valor devuelto**

Devuelve el valor reinterpretado `x`. [`UInt8`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo 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           │
└─────┴─────────────────┴─────┴─────────────────┘
```

<div id="reinterpretAsUUID">
  ## reinterpretAsUUID
</div>

Introducido en: v1.1.0

Acepta una cadena de 16 bytes y devuelve un UUID interpretando cada mitad de 8 bytes en orden de bytes little-endian. Si la cadena no tiene la longitud suficiente, la función actúa como si se rellenara al final con la cantidad necesaria de bytes nulos. Si la cadena tiene más de 16 bytes, se ignoran los bytes adicionales del final.

**Sintaxis**

```sql theme={null}
reinterpretAsUUID(fixed_string)
```

**Argumentos**

* `fixed_string` — Cadena de bytes en orden big-endian. [`FixedString`](/es/reference/data-types/fixedstring)

**Valor devuelto**

Un valor del tipo UUID. [`UUID`](/es/reference/data-types/uuid)

**Ejemplos**

**De cadena a 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 │
└───────────────────────────────────────────────────────────────────────┘
```

<div id="toBFloat16">
  ## toBFloat16
</div>

Introducido en: v1.1.0

Convierte un valor de entrada a un valor de tipo BFloat16.
Lanza una excepción en caso de error.

Véase también:

* [`toBFloat16OrZero`](#toBFloat16OrZero).
* [`toBFloat16OrNull`](#toBFloat16OrNull).

**Sintaxis**

```sql theme={null}
toBFloat16(expr)
```

**Argumentos**

* `expr` — Expresión que devuelve un número o la representación en cadena de un número. [`Expression`](/es/reference/data-types/special-data-types/expression)

**Valor devuelto**

Devuelve un valor brain-float de 16 bits. [`BFloat16`](/es/reference/data-types/float)

**Ejemplos**

**Ejemplo 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
```

<div id="toBFloat16OrNull">
  ## toBFloat16OrNull
</div>

Introducido en: v1.1.0

Convierte un valor de entrada de tipo String en un valor de tipo BFloat16.
Si la cadena no representa un valor de coma flotante, la función devuelve NULL.

Argumentos admitidos:

* Representaciones en cadena de valores numéricos.

Argumentos no admitidos (devuelven `NULL`):

* Representaciones en cadena de valores binarios y hexadecimales.
* Valores numéricos.

<Note>
  La función permite una pérdida silenciosa de precisión al convertir a partir de la representación en cadena.
</Note>

Vea también:

* [`toBFloat16`](#toBFloat16).
* [`toBFloat16OrZero`](#toBFloat16OrZero).

**Sintaxis**

```sql theme={null}
toBFloat16OrNull(x)
```

**Argumentos**

* `x` — La representación en cadena de un número. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor brain-float de 16 bits o `NULL` en caso contrario. [`BFloat16`](/es/reference/data-types/float) o [`NULL`](/es/reference/syntax#null)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT toBFloat16OrNull('0x5E'), -- argumentos no compatibles
       toBFloat16OrNull('12.3'), -- uso habitual
       toBFloat16OrNull('12.3456789') -- pérdida silenciosa de precisión
```

```response title=Response theme={null}
\N
12.25
12.3125
```

<div id="toBFloat16OrZero">
  ## toBFloat16OrZero
</div>

Introducido en: v1.1.0

Convierte un valor de entrada de tipo String en un valor de tipo BFloat16.
Si la cadena no representa un valor de coma flotante, la función devuelve cero.

Argumentos admitidos:

* Representaciones en cadena de valores numéricos.

Argumentos no admitidos (devuelven `0`):

* Representaciones en cadena de valores binarios y hexadecimales.
* Valores numéricos.

<Note>
  La función permite una pérdida de precisión silenciosa al convertir desde la representación en cadena.
</Note>

Véase también:

* [`toBFloat16`](#toBFloat16).
* [`toBFloat16OrNull`](#toBFloat16OrNull).

**Sintaxis**

```sql theme={null}
toBFloat16OrZero(x)
```

**Argumentos**

* `x` — Una representación en `String` de un número. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor brain-float de 16 bits; de lo contrario, `0`. [`BFloat16`](/es/reference/data-types/float)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT toBFloat16OrZero('0x5E'), -- argumentos no compatibles
       toBFloat16OrZero('12.3'), -- uso típico
       toBFloat16OrZero('12.3456789') -- pérdida silenciosa de precisión
```

```response title=Response theme={null}
0
12.25
12.3125
```

<div id="toBool">
  ## toBool
</div>

Introducido en: v22.2.0

Convierte un valor de entrada en un valor del tipo Bool.

**Sintaxis**

```sql theme={null}
toBool(expr)
```

**Argumentos**

* `expr` — Expresión que devuelve un número o una cadena. Para las cadenas, acepta 'true' o 'false' (sin distinguir entre mayúsculas y minúsculas). [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`String`](/es/reference/data-types/string) o [`Expression`](/es/reference/data-types/special-data-types/expression)

**Valor devuelto**

Devuelve `true` o `false` según la evaluación del argumento. [`Bool`](/es/reference/data-types/boolean)

**Ejemplos**

**Ejemplo 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
```

<div id="toDate">
  ## toDate
</div>

Introducido en: v1.1.0

Convierte un valor de entrada al tipo [`Date`](/es/reference/data-types/date).
Admite la conversión desde tipos String, FixedString, DateTime o numéricos.

**Sintaxis**

```sql theme={null}
toDate(x)
```

**Argumentos**

* `x` — Valor de entrada para convertir. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring) o [`DateTime`](/es/reference/data-types/datetime) o [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)

**Valor devuelto**

Devuelve el valor de entrada convertido. [`Date`](/es/reference/data-types/date)

**Ejemplos**

**Conversión de String a Date**

```sql title=Query theme={null}
SELECT toDate('2025-04-15')
```

```response title=Response theme={null}
2025-04-15
```

**Conversión de DateTime a Date**

```sql title=Query theme={null}
SELECT toDate(toDateTime('2025-04-15 10:30:00'))
```

```response title=Response theme={null}
2025-04-15
```

**Conversión de entero a fecha**

```sql title=Query theme={null}
SELECT toDate(20297)
```

```response title=Response theme={null}
2025-07-28
```

<div id="toDate32">
  ## toDate32
</div>

Introducido en: v21.9.0

Convierte el argumento al tipo de datos [Date32](/es/reference/data-types/date32).
Si el valor está fuera del rango, `toDate32` devuelve los valores límite admitidos por [Date32](/es/reference/data-types/date32).
Si el argumento es de tipo [`Date`](/es/reference/data-types/date), se tienen en cuenta sus límites.

**Sintaxis**

```sql theme={null}
toDate32(expr)
```

**Argumentos**

* `expr` — El valor que se va a convertir. [`String`](/es/reference/data-types/string) o [`UInt32`](/es/reference/data-types/int-uint) o [`Date`](/es/reference/data-types/date)

**Valor devuelto**

Devuelve una fecha de calendario. [`Date32`](/es/reference/data-types/date32)

**Ejemplos**

**Dentro del intervalo**

```sql title=Query theme={null}
SELECT toDate32('2025-01-01') AS value, toTypeName(value)
FORMAT Vertical
```

```response title=Response theme={null}
Fila 1:
──────
value:           2025-01-01
toTypeName(value): Date32
```

**Fuera de rango**

```sql title=Query theme={null}
SELECT toDate32('1899-01-01') AS value, toTypeName(value)
FORMAT Vertical
```

```response title=Response theme={null}
Row 1:
──────
value:           1900-01-01
toTypeName(value): Date32
```

<div id="toDate32OrDefault">
  ## toDate32OrDefault
</div>

Introducido en: v21.11.0

Convierte el argumento al tipo de dato [Date32](/es/reference/data-types/date32). Si el valor está fuera del rango, `toDate32OrDefault` devuelve el valor del límite inferior admitido por [Date32](/es/reference/data-types/date32). Si el argumento es de tipo [Date](/es/reference/data-types/date), se tienen en cuenta sus límites. Devuelve el valor predeterminado si se recibe un argumento no válido.

**Sintaxis**

```sql theme={null}
toDate32OrDefault(expr[, default])
```

**Argumentos**

* `expr` — Expresión que devuelve un número o su representación en cadena. [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
* `default` — Opcional. El valor predeterminado que se devolverá si el análisis falla. [`Date32`](/es/reference/data-types/date32)

**Valor devuelto**

Un valor de tipo Date32 si la conversión se realiza correctamente; de lo contrario, devuelve el valor predeterminado si se proporciona, o 1900-01-01 en caso contrario. [`Date32`](/es/reference/data-types/date32)

**Ejemplos**

**Conversión correcta**

```sql title=Query theme={null}
SELECT toDate32OrDefault('1930-01-01', toDate32('2020-01-01'))
```

```response title=Response theme={null}
1930-01-01
```

**Error de conversión**

```sql title=Query theme={null}
SELECT toDate32OrDefault('xx1930-01-01', toDate32('2020-01-01'))
```

```response title=Response theme={null}
2020-01-01
```

<div id="toDate32OrNull">
  ## toDate32OrNull
</div>

Introducido en: v21.9.0

Convierte un valor de entrada a un valor de tipo Date32, pero devuelve `NULL` si recibe un argumento no válido.
Igual que [`toDate32`](#toDate32), pero devuelve `NULL` si recibe un argumento no válido.

**Sintaxis**

```sql theme={null}
toDate32OrNull(x)
```

**Argumentos**

* `x` — La representación en cadena de una fecha. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor `Date32` si la conversión se realiza correctamente; de lo contrario, `NULL`. [`Date32`](/es/reference/data-types/date32) o [`NULL`](/es/reference/syntax#null)

**Ejemplos**

**Ejemplo 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 │                      ᴺᵁᴸᴸ │
└──────────────────────────────┴───────────────────────────┘
```

<div id="toDate32OrZero">
  ## toDate32OrZero
</div>

Introducido en: v21.9.0

Convierte un valor de entrada en un valor de tipo [Date32](/es/reference/data-types/date32), pero devuelve el límite inferior de [Date32](/es/reference/data-types/date32) si se recibe un argumento no válido.
Es igual que [toDate32](#toDate32), pero devuelve el límite inferior de [Date32](/es/reference/data-types/date32) si se recibe un argumento no válido.

Véase también:

* [`toDate32`](#toDate32)
* [`toDate32OrNull`](#toDate32OrNull)
* [`toDate32OrDefault`](#toDate32OrDefault)

**Sintaxis**

```sql theme={null}
toDate32OrZero(x)
```

**Argumentos**

* `x` — La representación en cadena de una fecha. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor de Date32 si la operación se realiza correctamente; en caso contrario, el límite inferior de Date32 (`1900-01-01`). [`Date32`](/es/reference/data-types/date32)

**Ejemplos**

**Ejemplo 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 │
└──────────────────────────────┴────────────────────┘
```

<div id="toDateOrDefault">
  ## toDateOrDefault
</div>

Introducido en: v21.11.0

Como [toDate](#toDate), pero si falla, devuelve un valor predeterminado, que es el segundo argumento (si se especifica) o, de lo contrario, el límite inferior de [Date](/es/reference/data-types/date).

**Sintaxis**

```sql theme={null}
toDateOrDefault(expr[, default])
```

**Argumentos**

* `expr` — Expresión que devuelve un número o una representación en cadena de un número. [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
* `default` — Opcional. El valor predeterminado que se devuelve si el análisis no se puede realizar correctamente. [`Date`](/es/reference/data-types/date)

**Valor devuelto**

Un valor de tipo Date si la conversión se realiza correctamente; en caso contrario, devuelve el valor predeterminado si se proporciona, o 1970-01-01 si no. [`Date`](/es/reference/data-types/date)

**Ejemplos**

**Conversión correcta**

```sql title=Query theme={null}
SELECT toDateOrDefault('2022-12-30')
```

```response title=Response theme={null}
2022-12-30
```

**Conversión fallida**

```sql title=Query theme={null}
SELECT toDateOrDefault('', CAST('2023-01-01', 'Date'))
```

```response title=Response theme={null}
2023-01-01
```

<div id="toDateOrNull">
  ## toDateOrNull
</div>

Introducido en: v1.1.0

Convierte un valor de entrada en un valor de tipo `Date`, pero devuelve `NULL` si recibe un argumento no válido.
Igual que [`toDate`](#toDate), pero devuelve `NULL` si recibe un argumento no válido.

**Sintaxis**

```sql theme={null}
toDateOrNull(x)
```

**Argumentos**

* `x` — Una representación en cadena de una fecha. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor `Date` si la operación se realiza correctamente; de lo contrario, `NULL`. [`Date`](/es/reference/data-types/date) o [`NULL`](/es/reference/syntax#null)

**Ejemplos**

**Ejemplo 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 │                   ᴺᵁᴸᴸ │
└────────────────────────────┴────────────────────────┘
```

<div id="toDateOrZero">
  ## toDateOrZero
</div>

Introducido en: v1.1.0

Convierte un valor de entrada en un valor de tipo [`Date`](/es/reference/data-types/date), pero devuelve el límite inferior de [`Date`](/es/reference/data-types/date) si recibe un argumento no válido.
Igual que [toDate](#toDate), pero devuelve el límite inferior de [`Date`](/es/reference/data-types/date) si recibe un argumento no válido.

Véase también:

* [`toDate`](#toDate)
* [`toDateOrNull`](#toDateOrNull)
* [`toDateOrDefault`](#toDateOrDefault)

**Sintaxis**

```sql theme={null}
toDateOrZero(x)
```

**Argumentos**

* `x` — Una representación en cadena de una fecha. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor de tipo Date si la operación se realiza correctamente; de lo contrario, devuelve el límite inferior de Date (`1970-01-01`). [`Date`](/es/reference/data-types/date)

**Ejemplos**

**Ejemplo 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 │
└────────────────────────────┴──────────────────┘
```

<div id="toDateTime">
  ## toDateTime
</div>

Introducido en: v1.1.0

Convierte un valor de entrada al tipo [DateTime](/es/reference/data-types/datetime).

<Note>
  Si `expr` es un número, se interpreta como la cantidad de segundos transcurridos desde el inicio de la época Unix (como marca temporal Unix).
  Si `expr` es una [String](/es/reference/data-types/string), puede interpretarse como una marca temporal Unix o como una representación en cadena de una fecha / fecha con hora.
  Por lo tanto, el análisis de las representaciones en cadena de números cortos (de hasta 4 dígitos) está explícitamente deshabilitado debido a la ambigüedad; por ejemplo, una cadena `'1999'` puede ser tanto un año (una representación en cadena incompleta de Date / DateTime) como una marca temporal Unix. Se permiten cadenas numéricas más largas.
</Note>

**Sintaxis**

```sql theme={null}
toDateTime(expr[, time_zone])
```

**Argumentos**

* `expr` — El valor. [`String`](/es/reference/data-types/string) o [`Int`](/es/reference/data-types/int-uint) o [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime)
* `time_zone` — Zona horaria. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve una fecha y hora. [`DateTime`](/es/reference/data-types/datetime)

**Ejemplos**

**Ejemplo 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}
Row 1:
──────
toDateTime('2025-01-01 00:00:00'): 2025-01-01 00:00:00
toDateTime(1735689600, 'UTC'):     2025-01-01 00:00:00
```

<div id="toDateTime32">
  ## toDateTime32
</div>

Introducido en: v20.9.0

Convierte un valor de entrada al tipo `DateTime`.
Admite la conversión a partir de `String`, `FixedString`, `Date`, `Date32`, `DateTime` o tipos numéricos (`(U)Int*`, `Float*`, `Decimal`).
DateTime32 proporciona un rango ampliado en comparación con `DateTime`, y admite fechas desde `1900-01-01` hasta `2299-12-31`.

**Sintaxis**

```sql theme={null}
toDateTime32(x[, timezone])
```

**Argumentos**

* `x` — Valor de entrada que se convertirá. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring) o [`UInt*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `timezone` — Opcional. Zona horaria para el valor `DateTime` devuelto. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el valor de entrada convertido. [`DateTime`](/es/reference/data-types/datetime)

**Ejemplos**

**El valor está dentro del rango**

```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 con precisión**

```sql title=Query theme={null}
SELECT toDateTime64(1735689600.000, 3) AS value, toTypeName(value);
-- sin el punto decimal, el valor se sigue interpretando como una marca temporal Unix en 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)                              │
└─────────────────────────┴────────────────────────────────────────────┘
```

**Con zona horaria**

```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')                                      │
└─────────────────────────┴─────────────────────────────────────────────────────────────────────┘
```

<div id="toDateTime64">
  ## toDateTime64
</div>

Introducido en: v20.1.0

Convierte un valor de entrada en un valor del tipo [`DateTime64`](/es/reference/data-types/datetime64).

**Sintaxis**

```sql theme={null}
toDateTime64(expr, scale[, timezone])
```

**Argumentos**

* `expr` — Expresión que devuelve un número o su representación en cadena. [`Expresión`](/es/reference/data-types/special-data-types/expression)
* `scale` — Tamaño de tick (precisión): 10^(-scale) segundos. [`UInt8`](/es/reference/data-types/int-uint)
* `timezone` — Opcional. Zona horaria del objeto `DateTime64` especificado. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve una fecha y hora del calendario, con precisión de subsegundos. [`DateTime64`](/es/reference/data-types/datetime64)

**Ejemplos**

**El valor está dentro del rango**

```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 con una precisión determinada**

```sql title=Query theme={null}
SELECT toDateTime64(1546300800.000, 3) AS value, toTypeName(value);
-- Sin el punto decimal, el valor se sigue interpretando como una marca temporal Unix en 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)                              │
└─────────────────────────┴────────────────────────────────────────────┘
```

**Con zona horaria**

```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')                                      │
└─────────────────────────┴─────────────────────────────────────────────────────────────────────┘
```

<div id="toDateTime64OrDefault">
  ## toDateTime64OrDefault
</div>

Introducido en: v21.11.0

Al igual que [toDateTime64](#toDateTime64), esta función convierte un valor de entrada en un valor del tipo [DateTime64](/es/reference/data-types/datetime64),
pero devuelve el valor predeterminado de [DateTime64](/es/reference/data-types/datetime64)
o el valor predeterminado proporcionado si recibe un argumento no válido.

**Sintaxis**

```sql theme={null}
toDateTime64OrDefault(expr, scale[, timezone, default])
```

**Argumentos**

* `expr` — Expresión que devuelve un número o una representación en cadena de un número. [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
* `scale` — Tamaño del tick (precisión): 10^-precisión segundos. [`UInt8`](/es/reference/data-types/int-uint)
* `timezone` — Opcional. Zona horaria. [`String`](/es/reference/data-types/string)
* `default` — Opcional. El valor predeterminado que se devuelve si el análisis falla. [`DateTime64`](/es/reference/data-types/datetime64)

**Valor devuelto**

Valor de tipo DateTime64 si la conversión se realiza correctamente; de lo contrario, devuelve el valor predeterminado si se proporcionó o 1970-01-01 00:00:00.000 si no. [`DateTime64`](/es/reference/data-types/datetime64)

**Ejemplos**

**Conversión exitosa**

```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
```

**Error de conversión**

```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
```

<div id="toDateTime64OrNull">
  ## toDateTime64OrNull
</div>

Introducido en: v20.1.0

Convierte un valor de entrada en un valor de tipo `DateTime64`, pero devuelve `NULL` si recibe un argumento no válido.
Es igual que `toDateTime64`, pero devuelve `NULL` si recibe un argumento no válido.

**Sintaxis**

```sql theme={null}
toDateTime64OrNull(x)
```

**Argumentos**

* `x` — Una representación en cadena de una fecha con hora y precisión de subsegundos. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor `DateTime64` si la operación se realiza correctamente; en caso contrario, `NULL`. [`DateTime64`](/es/reference/data-types/datetime64) o [`NULL`](/es/reference/syntax#null)

**Ejemplos**

**Ejemplo 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 │                          ᴺᵁᴸᴸ │
└─────────────────────────────────────────────────┴───────────────────────────────┘
```

<div id="toDateTime64OrZero">
  ## toDateTime64OrZero
</div>

Introducido en: v20.1.0

Convierte un valor de entrada en un valor del tipo [DateTime64](/es/reference/data-types/datetime64), pero devuelve el límite inferior de [DateTime64](/es/reference/data-types/datetime64) si recibe un argumento no válido.
Es igual que [toDateTime64](#toDateTime64), pero devuelve el límite inferior de [DateTime64](/es/reference/data-types/datetime64) si recibe un argumento no válido.

Véase también:

* [toDateTime64](#toDateTime64).
* [toDateTime64OrNull](#toDateTime64OrNull).
* [toDateTime64OrDefault](#toDateTime64OrDefault).

**Sintaxis**

```sql theme={null}
toDateTime64OrZero(x)
```

**Argumentos**

* `x` — Una representación en cadena de una fecha y hora con precisión de subsegundos. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor DateTime64 si la operación se realiza correctamente; de lo contrario, devuelve el límite inferior de DateTime64 (`1970-01-01 00:00:00.000`). [`DateTime64`](/es/reference/data-types/datetime64)

**Ejemplos**

**Ejemplo 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 │
└─────────────────────────────────────────────────┴─────────────────────────────────────┘
```

<div id="toDateTimeOrDefault">
  ## toDateTimeOrDefault
</div>

Introducido en: v21.11.0

Como [toDateTime](#toDateTime), pero, si falla, devuelve un valor predeterminado, que es el tercer argumento (si se especifica) o, de lo contrario, el límite inferior de [DateTime](/es/reference/data-types/datetime).

**Sintaxis**

```sql theme={null}
toDateTimeOrDefault(expr[, timezone, default])
```

**Argumentos**

* `expr` — Expresión que devuelve un número o una representación en cadena de un número. [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
* `timezone` — Opcional. Zona horaria. [`String`](/es/reference/data-types/string)
* `default` — Opcional. El valor predeterminado que se devuelve si el análisis falla. [`DateTime`](/es/reference/data-types/datetime)

**Valor devuelto**

Valor de tipo DateTime si la conversión se realiza correctamente; de lo contrario, devuelve el valor predeterminado si se proporciona, o 1970-01-01 00:00:00 si no. [`DateTime`](/es/reference/data-types/datetime)

**Ejemplos**

**Conversión correcta**

```sql title=Query theme={null}
SELECT toDateTimeOrDefault('2022-12-30 13:44:17')
```

```response title=Response theme={null}
2022-12-30 13:44:17
```

**Conversión fallida**

```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
```

<div id="toDateTimeOrNull">
  ## toDateTimeOrNull
</div>

Introducido en: v1.1.0

Convierte un valor de entrada en un valor de tipo `DateTime`, pero devuelve `NULL` si recibe un argumento no válido.
Es igual que [`toDateTime`](#toDateTime), pero devuelve `NULL` si recibe un argumento no válido.

**Sintaxis**

```sql theme={null}
toDateTimeOrNull(x)
```

**Argumentos**

* `x` — Una representación en cadena de una fecha con hora. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor `DateTime` si tiene éxito; de lo contrario, `NULL`. [`DateTime`](/es/reference/data-types/datetime) o [`NULL`](/es/reference/syntax#null)

**Ejemplos**

**Ejemplo 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 │                        ᴺᵁᴸᴸ │
└─────────────────────────────────────────┴─────────────────────────────┘
```

<div id="toDateTimeOrZero">
  ## toDateTimeOrZero
</div>

Introducido en: v1.1.0

Convierte un valor de entrada en un valor de tipo [DateTime](/es/reference/data-types/datetime), pero devuelve el límite inferior de [DateTime](/es/reference/data-types/datetime) si recibe un argumento no válido.
Es igual que [toDateTime](#toDateTime), pero devuelve el límite inferior de [DateTime](/es/reference/data-types/datetime) si recibe un argumento no válido.

**Sintaxis**

```sql theme={null}
toDateTimeOrZero(x)
```

**Argumentos**

* `x` — Una representación en cadena de una fecha con hora. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor `DateTime` si la conversión se realiza correctamente; de lo contrario, devuelve el límite inferior de `DateTime` (`1970-01-01 00:00:00`). [`DateTime`](/es/reference/data-types/datetime)

**Ejemplos**

**Ejemplo 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 │
└─────────────────────────────────────────┴─────────────────────────────┘
```

<div id="toDecimal128">
  ## toDecimal128
</div>

Introducido en: v18.12.0

Convierte un valor de entrada en un valor del tipo [`Decimal(38, S)`](/es/reference/data-types/decimal) con escala `S`.
Genera una excepción en caso de error.

Argumentos admitidos:

* Valores o representaciones en cadena del tipo (U)Int\*.
* Valores o representaciones en cadena del tipo Float\*.

Argumentos no admitidos:

* Valores o representaciones en cadena de valores Float\* `NaN` e `Inf` (sin distinguir entre mayúsculas y minúsculas).
* Representaciones en cadena de valores binarios y hexadecimales; por ejemplo, `SELECT toDecimal128('0xc0fe', 1);`.

<Note>
  Puede producirse un desbordamiento si el valor de `expr` supera los límites de `Decimal128`: `(-1*10^(38 - S), 1*10^(38 - S))`.
  Los dígitos sobrantes de la parte fraccionaria se descartan (no se redondean).
  Los dígitos sobrantes de la parte entera provocarán una excepción.
</Note>

<Warning>
  Las conversiones descartan los dígitos adicionales y pueden producir resultados inesperados al trabajar con entradas Float32/Float64, ya que las operaciones se realizan con instrucciones de coma flotante.
  Por ejemplo: `toDecimal128(1.15, 2)` es igual a `1.14` porque 1.15 \* 100 en coma flotante es 114.99.
  Puede usar una entrada de tipo String para que las operaciones utilicen el tipo entero subyacente: `toDecimal128('1.15', 2) = 1.15`
</Warning>

**Sintaxis**

```sql theme={null}
toDecimal128(expr, S)
```

**Argumentos**

* `expr` — Expresión que devuelve un número o la representación textual de un número. [`Expresión`](/es/reference/data-types/special-data-types/expression)
* `S` — Parámetro de escala entre 0 y 38, que especifica cuántos dígitos puede tener la parte fraccionaria de un número. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve un valor de tipo `Decimal(38, S)` [`Decimal128(S)`](/es/reference/data-types/decimal)

**Ejemplos**

**Ejemplo 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}
Fila 1:
──────
a:      99
type_a: Decimal(38, 1)
b:      99.67
type_b: Decimal(38, 2)
c:      99.67
type_c: Decimal(38, 3)
```

<div id="toDecimal128OrDefault">
  ## toDecimal128OrDefault
</div>

Introducido en: v21.11.0

Al igual que [`toDecimal128`](#toDecimal128), esta función convierte un valor de entrada a un valor de tipo [Decimal(38, S)](/es/reference/data-types/decimal), pero devuelve el valor predeterminado en caso de error.

**Sintaxis**

```sql theme={null}
toDecimal128OrDefault(expr, S[, default])
```

**Argumentos**

* `expr` — Una representación en forma de String de un número. [`String`](/es/reference/data-types/string)
* `S` — Parámetro de escala entre 0 y 38 que especifica cuántos dígitos puede tener la parte fraccionaria de un número. [`UInt8`](/es/reference/data-types/int-uint)
* `default` — Opcional. El valor predeterminado que se devolverá si la conversión al tipo Decimal128(S) no se realiza correctamente. [`Decimal128(S)`](/es/reference/data-types/decimal)

**Valor devuelto**

Un valor de tipo Decimal(38, S) si la conversión se realiza correctamente; de lo contrario, devuelve el valor predeterminado si se proporcionó o 0 si no. [`Decimal128(S)`](/es/reference/data-types/decimal)

**Ejemplos**

**Conversión exitosa**

```sql title=Query theme={null}
SELECT toDecimal128OrDefault(toString(1/42), 18)
```

```response title=Response theme={null}
0.023809523809523808
```

**Conversión fallida**

```sql title=Query theme={null}
SELECT toDecimal128OrDefault('Inf', 0, CAST('-1', 'Decimal128(0)'))
```

```response title=Response theme={null}
-1
```

<div id="toDecimal128OrNull">
  ## toDecimal128OrNull
</div>

Introducido en: v20.1.0

Convierte un valor de entrada en un valor del tipo [`Decimal(38, S)`](/es/reference/data-types/decimal), pero devuelve `NULL` en caso de error.
Como [`toDecimal128`](#toDecimal128), pero devuelve `NULL` en lugar de lanzar una excepción si se producen errores de conversión.

Argumentos admitidos:

* Valores o representaciones en cadena del tipo (U)Int\*.
* Valores o representaciones en cadena del tipo Float\*.

Argumentos no admitidos (devuelven `NULL`):

* Valores o representaciones en cadena de valores Float\* `NaN` e `Inf` (sin distinguir entre mayúsculas y minúsculas).
* Representaciones en cadena de valores binarios y hexadecimales.
* Valores que superan los límites de `Decimal128`:`(-1*10^(38 - S), 1*10^(38 - S))`.

Véase también:

* [`toDecimal128`](#toDecimal128).
* [`toDecimal128OrZero`](#toDecimal128OrZero).
* [`toDecimal128OrDefault`](#toDecimal128OrDefault).

**Sintaxis**

```sql theme={null}
toDecimal128OrNull(expr, S)
```

**Argumentos**

* `expr` — Expresión que devuelve un número o una representación en cadena de un número. [`Expresión`](/es/reference/data-types/special-data-types/expression)
* `S` — Parámetro de escala entre 0 y 38 que especifica cuántos dígitos puede tener la parte fraccionaria de un número. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve un valor Decimal(38, S) si tiene éxito; en caso contrario, `NULL`. [`Decimal128(S)`](/es/reference/data-types/decimal) o [`NULL`](/es/reference/syntax#null)

**Ejemplos**

**Ejemplo 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 │                             ᴺᵁᴸᴸ │
└───────────────────────────────┴──────────────────────────────────┘
```

<div id="toDecimal128OrZero">
  ## toDecimal128OrZero
</div>

Introducido en: v20.1.0

Convierte un valor de entrada en un valor del tipo [Decimal(38, S)](/es/reference/data-types/decimal), pero devuelve `0` en caso de error.
Es similar a [`toDecimal128`](#toDecimal128), pero devuelve `0` en lugar de generar una excepción cuando se producen errores de conversión.

Argumentos admitidos:

* Valores o representaciones de cadena del tipo (U)Int\*.
* Valores o representaciones de cadena del tipo Float\*.

Argumentos no admitidos (devuelven `0`):

* Valores o representaciones de cadena de valores Float\* `NaN` e `Inf` (sin distinguir entre mayúsculas y minúsculas).
* Representaciones de cadena de valores binarios y hexadecimales.

<Note>
  Si el valor de entrada supera los límites de `Decimal128`:`(-1*10^(38 - S), 1*10^(38 - S))`, la función devuelve `0`.
</Note>

**Sintaxis**

```sql theme={null}
toDecimal128OrZero(expr, S)
```

**Argumentos**

* `expr` — Expresión que devuelve un número o su representación en cadena. [`Expresión`](/es/reference/data-types/special-data-types/expression)
* `S` — Parámetro de escala entre 0 y 38 que especifica cuántos dígitos puede tener la parte fraccionaria de un número. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve un valor `Decimal(38, S)` si la operación se realiza correctamente; en caso contrario, `0`. [`Decimal128(S)`](/es/reference/data-types/decimal)

**Ejemplos**

**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 │
└───────────────────────────────┴──────────────────────────────────┘
```

<div id="toDecimal256">
  ## toDecimal256
</div>

Introducido en: v20.8.0

Convierte un valor de entrada en un valor de tipo [`Decimal(76, S)`](/es/reference/data-types/decimal) con escala `S`. Genera una excepción en caso de error.

Argumentos admitidos:

* Valores o representaciones de cadena del tipo (U)Int\*.
* Valores o representaciones de cadena del tipo Float\*.

Argumentos no admitidos:

* Valores o representaciones de cadena de valores Float\* `NaN` e `Inf` (sin distinción entre mayúsculas y minúsculas).
* Representaciones de cadena de valores binarios y hexadecimales; por ejemplo, `SELECT toDecimal256('0xc0fe', 1);`.

<Note>
  Puede producirse un desbordamiento si el valor de `expr` supera los límites de `Decimal256`:`(-1*10^(76 - S), 1*10^(76 - S))`.
  Los dígitos sobrantes de la parte fraccionaria se descartan (no se redondean).
  Los dígitos sobrantes de la parte entera provocarán una excepción.
</Note>

<Warning>
  Las conversiones descartan los dígitos adicionales y podrían comportarse de forma inesperada al trabajar con entradas Float32/Float64, ya que las operaciones se realizan mediante instrucciones de coma flotante.
  Por ejemplo: `toDecimal256(1.15, 2)` es igual a `1.14` porque 1.15 \* 100 en coma flotante es 114.99.
  Puede usar una entrada String para que las operaciones utilicen el tipo entero subyacente: `toDecimal256('1.15', 2) = 1.15`
</Warning>

**Sintaxis**

```sql theme={null}
toDecimal256(expr, S)
```

**Argumentos**

* `expr` — Expresión que devuelve un número o una representación en cadena de un número. [`Expresión`](/es/reference/data-types/special-data-types/expression)
* `S` — Parámetro de escala entre 0 y 76 que especifica cuántos dígitos puede tener la parte fraccionaria de un número. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve un valor de tipo `Decimal(76, S)`. [`Decimal256(S)`](/es/reference/data-types/decimal)

**Ejemplos**

**Ejemplo 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}
Fila 1:
──────
a:      99
type_a: Decimal(76, 1)
b:      99.67
type_b: Decimal(76, 2)
c:      99.67
type_c: Decimal(76, 3)
```

<div id="toDecimal256OrDefault">
  ## toDecimal256OrDefault
</div>

Introducido en: v21.11.0

Al igual que [`toDecimal256`](#toDecimal256), esta función convierte un valor de entrada en un valor de tipo [Decimal(76, S)](/es/reference/data-types/decimal), pero devuelve el valor predeterminado en caso de error.

**Sintaxis**

```sql theme={null}
toDecimal256OrDefault(expr, S[, default])
```

**Argumentos**

* `expr` — Una representación en cadena de un número. [`String`](/es/reference/data-types/string)
* `S` — Parámetro de escala entre 0 y 76 que especifica cuántos dígitos puede tener la parte fraccionaria de un número. [`UInt8`](/es/reference/data-types/int-uint)
* `default` — Opcional. El valor predeterminado que se devolverá si no se puede convertir al tipo Decimal256(S). [`Decimal256(S)`](/es/reference/data-types/decimal)

**Valor devuelto**

Un valor de tipo Decimal(76, S) si la conversión se realiza correctamente; de lo contrario, devuelve el valor predeterminado si se proporcionó, o 0 si no. [`Decimal256(S)`](/es/reference/data-types/decimal)

**Ejemplos**

**Conversión exitosa**

```sql title=Query theme={null}
SELECT toDecimal256OrDefault(toString(1/42), 76)
```

```response title=Response theme={null}
0.023809523809523808
```

**Error de conversión**

```sql title=Query theme={null}
SELECT toDecimal256OrDefault('Inf', 0, CAST('-1', 'Decimal256(0)'))
```

```response title=Response theme={null}
-1
```

<div id="toDecimal256OrNull">
  ## toDecimal256OrNull
</div>

Introducido en: v20.8.0

Convierte un valor de entrada a un valor de tipo [`Decimal(76, S)`](/es/reference/data-types/decimal), pero devuelve `NULL` en caso de error.
Es como [`toDecimal256`](#toDecimal256), pero devuelve `NULL` en lugar de generar una excepción cuando se producen errores de conversión.

Argumentos admitidos:

* Valores o representaciones en cadena del tipo (U)Int\*.
* Valores o representaciones en cadena del tipo Float\*.

Argumentos no admitidos (devuelven `NULL`):

* Valores o representaciones en cadena de valores Float\* `NaN` e `Inf` (sin distinguir entre mayúsculas y minúsculas).
* Representaciones en cadena de valores binarios y hexadecimales.
* Valores que superan los límites de `Decimal256`: `(-1 * 10^(76 - S), 1 * 10^(76 - S))`.

Véase también:

* [`toDecimal256`](#toDecimal256).
* [`toDecimal256OrZero`](#toDecimal256OrZero).
* [`toDecimal256OrDefault`](#toDecimal256OrDefault).

**Sintaxis**

```sql theme={null}
toDecimal256OrNull(expr, S)
```

**Argumentos**

* `expr` — Expresión que devuelve un número o su representación en forma de cadena. [`Expresión`](/es/reference/data-types/special-data-types/expression)
* `S` — Parámetro de escala entre 0 y 76 que especifica cuántos dígitos puede tener la parte fraccionaria de un número. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve un valor Decimal(76, S) si la conversión se realiza correctamente; en caso contrario, `NULL`. [`Decimal256(S)`](/es/reference/data-types/decimal) o [`NULL`](/es/reference/syntax#null)

**Ejemplos**

**Ejemplo 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 │                             ᴺᵁᴸᴸ │
└───────────────────────────────┴──────────────────────────────────┘
```

<div id="toDecimal256OrZero">
  ## toDecimal256OrZero
</div>

Introducido en: v20.8.0

Convierte un valor de entrada en un valor de tipo [Decimal(76, S)](/es/reference/data-types/decimal), pero devuelve `0` en caso de error.
Es similar a [`toDecimal256`](#toDecimal256), pero devuelve `0` en lugar de generar una excepción cuando se producen errores de conversión.

Argumentos admitidos:

* Valores o representaciones en cadena del tipo (U)Int\*.
* Valores o representaciones en cadena del tipo Float\*.

Argumentos no admitidos (devuelven `0`):

* Valores o representaciones en cadena de valores Float\* `NaN` e `Inf` (sin distinguir mayúsculas de minúsculas).
* Representaciones en cadena de valores binarios y hexadecimales.

<Note>
  Si el valor de entrada supera los límites de `Decimal256`:`(-1*10^(76 - S), 1*10^(76 - S))`, la función devuelve `0`.
</Note>

Véase también:

* [`toDecimal256`](#toDecimal256).
* [`toDecimal256OrNull`](#toDecimal256OrNull).
* [`toDecimal256OrDefault`](#toDecimal256OrDefault).

**Sintaxis**

```sql theme={null}
toDecimal256OrZero(expr, S)
```

**Argumentos**

* `expr` — Expresión que devuelve un número o la representación en cadena de un número. [`Expresión`](/es/reference/data-types/special-data-types/expression)
* `S` — Parámetro de escala entre 0 y 76 que especifica cuántos dígitos puede tener la parte fraccionaria de un número. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve un valor Decimal(76, S) si la operación se realiza correctamente; en caso contrario, `0`. [`Decimal256(S)`](/es/reference/data-types/decimal)

**Ejemplos**

**Ejemplo 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 │
└───────────────────────────────┴──────────────────────────────────┘
```

<div id="toDecimal32">
  ## toDecimal32
</div>

Introducido en: v18.12.0

Convierte un valor de entrada en un valor de tipo [`Decimal(9, S)`](/es/reference/data-types/decimal) con una escala de `S`. Lanza una excepción en caso de error.

Argumentos admitidos:

* Valores o representaciones de cadena del tipo (U)Int\*.
* Valores o representaciones de cadena del tipo Float\*.

Argumentos no admitidos:

* Valores o representaciones de cadena de valores Float\* `NaN` e `Inf` (sin distinguir entre mayúsculas y minúsculas).
* Representaciones de cadena de valores binarios y hexadecimales, por ejemplo, `SELECT toDecimal32('0xc0fe', 1);`.

<Note>
  Puede producirse un desbordamiento si el valor de `expr` supera los límites de `Decimal32`: `(-1*10^(9 - S), 1*10^(9 - S))`.
  Los dígitos sobrantes de la parte fraccionaria se descartan (no se redondean).
  Los dígitos sobrantes de la parte entera provocarán una excepción.
</Note>

<Warning>
  Las conversiones descartan los dígitos adicionales y pueden comportarse de forma inesperada al trabajar con entradas Float32/Float64, ya que las operaciones se realizan mediante instrucciones de coma flotante.
  Por ejemplo: `toDecimal32(1.15, 2)` es igual a `1.14` porque 1.15 \* 100 en coma flotante es 114.99.
  Puede usar una entrada String para que las operaciones utilicen el tipo entero subyacente: `toDecimal32('1.15', 2) = 1.15`
</Warning>

**Sintaxis**

```sql theme={null}
toDecimal32(expr, S)
```

**Argumentos**

* `expr` — Expresión que devuelve un número o una representación en cadena de un número. [`Expresión`](/es/reference/data-types/special-data-types/expression)
* `S` — Parámetro de escala entre 0 y 9 que especifica cuántos dígitos puede tener la parte fraccionaria de un número. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve un valor de tipo `Decimal(9, S)` [`Decimal32(S)`](/es/reference/data-types/decimal)

**Ejemplos**

**Ejemplo 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}
Fila 1:
──────
a:      2
type_a: Decimal(9, 1)
b:      4.2
type_b: Decimal(9, 2)
c:      4.2
type_c: Decimal(9, 3)
```

<div id="toDecimal32OrDefault">
  ## toDecimal32OrDefault
</div>

Introducido en: v21.11.0

Al igual que [`toDecimal32`](#toDecimal32), esta función convierte un valor de entrada en un valor del tipo [Decimal(9, S)](/es/reference/data-types/decimal), pero devuelve el valor predeterminado en caso de error.

**Sintaxis**

```sql theme={null}
toDecimal32OrDefault(expr, S[, default])
```

**Argumentos**

* `expr` — Una representación en `String` de un número. [`String`](/es/reference/data-types/string)
* `S` — Parámetro de escala entre 0 y 9 que especifica cuántos dígitos puede tener la parte fraccionaria de un número. [`UInt8`](/es/reference/data-types/int-uint)
* `default` — Opcional. El valor predeterminado que se devuelve si no es posible interpretar el valor como el tipo Decimal32(S). [`Decimal32(S)`](/es/reference/data-types/decimal)

**Valor devuelto**

Un valor de tipo Decimal(9, S) si la conversión se realiza correctamente; en caso contrario, devuelve el valor predeterminado si se proporcionó o 0 si no. [`Decimal32(S)`](/es/reference/data-types/decimal)

**Ejemplos**

**Conversión correcta**

```sql title=Query theme={null}
SELECT toDecimal32OrDefault(toString(0.0001), 5)
```

```response title=Response theme={null}
0.0001
```

**Error de conversión**

```sql title=Query theme={null}
SELECT toDecimal32OrDefault('Inf', 0, CAST('-1', 'Decimal32(0)'))
```

```response title=Response theme={null}
-1
```

<div id="toDecimal32OrNull">
  ## toDecimal32OrNull
</div>

Introducido en: v20.1.0

Convierte un valor de entrada en un valor de tipo [`Decimal(9, S)`](/es/reference/data-types/decimal), pero devuelve `NULL` en caso de error.
Es similar a [`toDecimal32`](#toDecimal32), pero devuelve `NULL` en lugar de lanzar una excepción en caso de errores de conversión.

Argumentos admitidos:

* Valores o representaciones en cadena del tipo (U)Int\*.
* Valores o representaciones en cadena del tipo Float\*.

Argumentos no compatibles (devuelven `NULL`):

* Valores o representaciones en cadena de valores Float\* `NaN` e `Inf` (sin distinguir entre mayúsculas y minúsculas).
* Representaciones en cadena de valores binarios y hexadecimales.
* Valores que superan los límites de `Decimal32`:`(-1*10^(9 - S), 1*10^(9 - S))`.

Véase también:

* [`toDecimal32`](#toDecimal32).
* [`toDecimal32OrZero`](#toDecimal32OrZero).
* [`toDecimal32OrDefault`](#toDecimal32OrDefault).

**Sintaxis**

```sql theme={null}
toDecimal32OrNull(expr, S)
```

**Argumentos**

* `expr` — Expresión que devuelve un número o la representación en cadena de un número. [`Expression`](/es/reference/data-types/special-data-types/expression)
* `S` — Parámetro de escala entre 0 y 9 que especifica cuántos dígitos puede tener la parte fraccionaria de un número. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve un valor Decimal(9, S) si la operación se realiza correctamente; en caso contrario, `NULL`. [`Decimal32(S)`](/es/reference/data-types/decimal) o [`NULL`](/es/reference/syntax#null)

**Ejemplos**

**Ejemplo 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 │                            ᴺᵁᴸᴸ │
└──────────────────────────────┴─────────────────────────────────┘
```

<div id="toDecimal32OrZero">
  ## toDecimal32OrZero
</div>

Introducido en: v20.1.0

Convierte un valor de entrada en un valor del tipo [Decimal(9, S)](/es/reference/data-types/decimal), pero devuelve `0` en caso de error.
Es como [`toDecimal32`](#toDecimal32), pero devuelve `0` en lugar de lanzar una excepción cuando se producen errores de conversión.

Argumentos admitidos:

* Valores o representaciones en cadena del tipo (U)Int\*.
* Valores o representaciones en cadena del tipo Float\*.

Argumentos no admitidos (devuelven `0`):

* Valores o representaciones en cadena de valores Float\* `NaN` e `Inf` (sin distinguir entre mayúsculas y minúsculas).
* Representaciones en cadena de valores binarios y hexadecimales.

<Note>
  Si el valor de entrada supera los límites de `Decimal32`:`(-1*10^(9 - S), 1*10^(9 - S))`, la función devuelve `0`.
</Note>

**Sintaxis**

```sql theme={null}
toDecimal32OrZero(expr, S)
```

**Argumentos**

* `expr` — Expresión que devuelve un número o la representación en cadena de un número. [`Expression`](/es/reference/data-types/special-data-types/expression)
* `S` — Parámetro de escala entre 0 y 9 que especifica cuántos dígitos puede tener la parte fraccionaria de un número. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve un valor Decimal(9, S) si tiene éxito; de lo contrario, `0`. [`Decimal32(S)`](/es/reference/data-types/decimal)

**Ejemplos**

**Ejemplo 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 │
└──────────────────────────────┴─────────────────────────────────┘
```

<div id="toDecimal64">
  ## toDecimal64
</div>

Introducido en: v18.12.0

Convierte un valor de entrada en un valor de tipo [`Decimal(18, S)`](/es/reference/data-types/decimal) con una escala de `S`.
Lanza una excepción en caso de error.

Argumentos admitidos:

* Valores o representaciones en cadena del tipo (U)Int\*.
* Valores o representaciones en cadena del tipo Float\*.

Argumentos no admitidos:

* Valores o representaciones en cadena de valores Float\* `NaN` e `Inf` (sin distinguir entre mayúsculas y minúsculas).
* Representaciones en cadena de valores binarios y hexadecimales; por ejemplo, `SELECT toDecimal64('0xc0fe', 1);`.

<Note>
  Puede producirse un desbordamiento si el valor de `expr` supera los límites de `Decimal64`:`(-1*10^(18 - S), 1*10^(18 - S))`.
  Los dígitos sobrantes de la fracción se descartan (no se redondean).
  Los dígitos sobrantes en la parte entera provocarán una excepción.
</Note>

<Warning>
  Las conversiones descartan los dígitos adicionales y podrían comportarse de forma inesperada al trabajar con entradas Float32/Float64, ya que las operaciones se realizan con instrucciones de coma flotante.
  Por ejemplo, `toDecimal64(1.15, 2)` es igual a `1.14` porque 1.15 \* 100 en coma flotante es 114.99.
  Puede usar una entrada de tipo String para que las operaciones usen el tipo entero subyacente: `toDecimal64('1.15', 2) = 1.15`
</Warning>

**Sintaxis**

```sql theme={null}
toDecimal64(expr, S)
```

**Argumentos**

* `expr` — Expresión que devuelve un número o la representación en cadena de un número. [`Expression`](/es/reference/data-types/special-data-types/expression)
* `S` — Parámetro de escala entre 0 y 18 que especifica cuántos dígitos puede tener la parte fraccionaria de un número. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve un valor decimal. [`Decimal(18, S)`](/es/reference/data-types/decimal)

**Ejemplos**

**Ejemplo 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}
Fila 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)
```

<div id="toDecimal64OrDefault">
  ## toDecimal64OrDefault
</div>

Introducido en: v21.11.0

Al igual que [`toDecimal64`](#toDecimal64), esta función convierte un valor de entrada a un valor del tipo [Decimal(18, S)](/es/reference/data-types/decimal), pero devuelve el valor predeterminado en caso de error.

**Sintaxis**

```sql theme={null}
toDecimal64OrDefault(expr, S[, default])
```

**Argumentos**

* `expr` — Una representación en `String` de un número. [`String`](/es/reference/data-types/string)
* `S` — Parámetro de escala entre 0 y 18 que especifica cuántos dígitos puede tener la parte fraccionaria de un número. [`UInt8`](/es/reference/data-types/int-uint)
* `default` — Opcional. El valor predeterminado que se devuelve si no se puede convertir al tipo Decimal64(S). [`Decimal64(S)`](/es/reference/data-types/decimal)

**Valor devuelto**

Un valor de tipo Decimal(18, S) si la conversión se realiza correctamente; de lo contrario, devuelve el valor predeterminado si se proporcionó, o 0 si no. [`Decimal64(S)`](/es/reference/data-types/decimal)

**Ejemplos**

**Conversión correcta**

```sql title=Query theme={null}
SELECT toDecimal64OrDefault(toString(0.0001), 18)
```

```response title=Response theme={null}
0.0001
```

**Conversión fallida**

```sql title=Query theme={null}
SELECT toDecimal64OrDefault('Inf', 0, CAST('-1', 'Decimal64(0)'))
```

```response title=Response theme={null}
-1
```

<div id="toDecimal64OrNull">
  ## toDecimal64OrNull
</div>

Introducido en: v20.1.0

Convierte un valor de entrada en un valor de tipo [Decimal(18, S)](/es/reference/data-types/decimal), pero devuelve `NULL` en caso de error.
Igual que [`toDecimal64`](#toDecimal64), pero devuelve `NULL` en lugar de lanzar una excepción cuando se producen errores de conversión.

Argumentos admitidos:

* Valores o representaciones en cadena del tipo (U)Int\*.
* Valores o representaciones en cadena del tipo Float\*.

Argumentos no admitidos (devuelven `NULL`):

* Valores o representaciones en cadena de valores Float\* `NaN` e `Inf` (sin distinguir entre mayúsculas y minúsculas).
* Representaciones en cadena de valores binarios y hexadecimales.
* Valores que superan los límites de `Decimal64`:`(-1*10^(18 - S), 1*10^(18 - S))`.

Véase también:

* [`toDecimal64`](#toDecimal64).
* [`toDecimal64OrZero`](#toDecimal64OrZero).
* [`toDecimal64OrDefault`](#toDecimal64OrDefault).

**Sintaxis**

```sql theme={null}
toDecimal64OrNull(expr, S)
```

**Argumentos**

* `expr` — Expresión que devuelve un número o una representación en cadena de un número. [`Expression`](/es/reference/data-types/special-data-types/expression)
* `S` — Parámetro de escala entre 0 y 18 que especifica cuántos dígitos puede tener la parte fraccionaria de un número. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve un valor `Decimal(18, S)` si la operación se realiza correctamente; de lo contrario, `NULL`. [`Decimal64(S)`](/es/reference/data-types/decimal) o [`NULL`](/es/reference/syntax#null)

**Ejemplos**

**Ejemplo 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 │                            ᴺᵁᴸᴸ │
└──────────────────────────────┴─────────────────────────────────┘
```

<div id="toDecimal64OrZero">
  ## toDecimal64OrZero
</div>

Introducido en: v20.1.0

Convierte un valor de entrada en un valor de tipo [Decimal(18, S)](/es/reference/data-types/decimal), pero devuelve `0` en caso de error.
Igual que [`toDecimal64`](#toDecimal64), pero devuelve `0` en lugar de lanzar una excepción si se producen errores de conversión.

Argumentos admitidos:

* Valores o representaciones en cadena del tipo (U)Int\*.
* Valores o representaciones en cadena del tipo Float\*.

Argumentos no admitidos (devuelven `0`):

* Valores o representaciones en cadena de valores Float\* `NaN` e `Inf` (sin distinguir entre mayúsculas y minúsculas).
* Representaciones en cadena de valores binarios y hexadecimales.

<Note>
  Si el valor de entrada supera los límites de `Decimal64`:`(-1*10^(18 - S), 1*10^(18 - S))`, la función devuelve `0`.
</Note>

Véase también:

* [`toDecimal64`](#toDecimal64).
* [`toDecimal64OrNull`](#toDecimal64OrNull).
* [`toDecimal64OrDefault`](#toDecimal64OrDefault).

**Sintaxis**

```sql theme={null}
toDecimal64OrZero(expr, S)
```

**Argumentos**

* `expr` — Expresión que devuelve un número o su representación en cadena. [`Expression`](/es/reference/data-types/special-data-types/expression)
* `S` — Parámetro de escala entre 0 y 18 que especifica cuántos dígitos puede tener la parte fraccionaria de un número. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve un valor `Decimal(18, S)` si la operación se realiza correctamente; de lo contrario, `0`. [`Decimal64(S)`](/es/reference/data-types/decimal)

**Ejemplos**

**Ejemplo 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 │
└──────────────────────────────┴─────────────────────────────────┘
```

<div id="toDecimalString">
  ## toDecimalString
</div>

Introducido en: v23.3.0

Convierte un valor numérico a String con el número especificado de dígitos fraccionarios.

La función redondea el valor de entrada al número especificado de posiciones decimales. Si el valor de entrada tiene menos dígitos fraccionarios
de los solicitados, el resultado se rellena con ceros hasta alcanzar el número exacto de dígitos fraccionarios especificado.

**Sintaxis**

```sql theme={null}
toDecimalString(number, scale)
```

**Argumentos**

* `number` — El valor numérico que se convertirá en una cadena. Puede ser cualquier tipo numérico (Int, UInt, Float, Decimal). [`Int8`](/es/reference/data-types/int-uint) o [`Int16`](/es/reference/data-types/int-uint) o [`Int32`](/es/reference/data-types/int-uint) o [`Int64`](/es/reference/data-types/int-uint) o [`UInt8`](/es/reference/data-types/int-uint) o [`UInt16`](/es/reference/data-types/int-uint) o [`UInt32`](/es/reference/data-types/int-uint) o [`UInt64`](/es/reference/data-types/int-uint) o [`Float32`](/es/reference/data-types/float) o [`Float64`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
* `scale` — El número de dígitos que se mostrarán en la parte fraccionaria. El resultado se redondeará si es necesario. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve una representación del número en String con exactamente el número especificado de dígitos fraccionarios. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Redondear y dar formato a un número**

```sql title=Query theme={null}
SELECT toDecimalString(2.1456, 2)
```

```response title=Response theme={null}
┌─toDecimalString(2.1456, 2)─┐
│ 2.15                       │
└────────────────────────────┘
```

**Completar con ceros**

```sql title=Query theme={null}
SELECT toDecimalString(5, 3)
```

```response title=Response theme={null}
┌─toDecimalString(5, 3)─┐
│ 5.000                 │
└───────────────────────┘
```

**Distintos 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   │
└─────────────┴───────────┘
```

<div id="toFixedString">
  ## toFixedString
</div>

Introducido en: v1.1.0

Convierte un argumento [`String`](/es/reference/data-types/string) en un tipo [`FixedString(N)`](/es/reference/data-types/fixedstring) (una cadena de longitud fija N).

Si la cadena tiene menos bytes que N, se rellena con bytes nulos a la derecha.
Si la cadena tiene más bytes que N, se lanza una excepción.

**Sintaxis**

```sql theme={null}
toFixedString(s, N)
```

**Argumentos**

* `s` — Cadena que se va a convertir. [`String`](/es/reference/data-types/string)
* `N` — Longitud del FixedString resultante. [`const UInt*`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve un FixedString de longitud N. [`FixedString(N)`](/es/reference/data-types/fixedstring)

**Ejemplos**

**Ejemplo 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 │
└───────────────┘
```

<div id="toFloat32">
  ## toFloat32
</div>

Introducido en: v1.1.0

Convierte un valor de entrada en un valor de tipo [Float32](/es/reference/data-types/float).
Lanza una excepción en caso de error.

Argumentos admitidos:

* Valores de tipo (U)Int\*.
* Representaciones de cadena de (U)Int8/16/32/128/256.
* Valores de tipo Float\*, incluidos `NaN` e `Inf`.
* Representaciones de cadena de Float\*, incluidos `NaN` e `Inf` (sin distinción entre mayúsculas y minúsculas).

Argumentos no admitidos:

* Representaciones de cadena de valores binarios y hexadecimales; por ejemplo, `SELECT toFloat32('0xc0fe');`.

Véase también:

* [`toFloat32OrZero`](#toFloat32OrZero).
* [`toFloat32OrNull`](#toFloat32OrNull).
* [`toFloat32OrDefault`](#toFloat32OrDefault).

**Sintaxis**

```sql theme={null}
toFloat32(expr)
```

**Argumentos**

* `expr` — Expresión que devuelve un número o una representación en cadena de un número. [`Expression`](/es/reference/data-types/special-data-types/expression)

**Valor devuelto**

Devuelve un valor de punto flotante de 32 bits. [`Float32`](/es/reference/data-types/float)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toFloat32(42.7),
    toFloat32('42.7'),
    toFloat32('NaN')
FORMAT Vertical
```

```response title=Response theme={null}
Row 1:
──────
toFloat32(42.7):   42.7
toFloat32('42.7'): 42.7
toFloat32('NaN'):  nan
```

<div id="toFloat32OrDefault">
  ## toFloat32OrDefault
</div>

Introducido en: v21.11.0

Al igual que [`toFloat32`](#toFloat32), esta función convierte un valor de entrada en un valor de tipo [Float32](/es/reference/data-types/float), pero devuelve el valor predeterminado en caso de error.
Si no se pasa ningún valor `default`, se devuelve `0` en caso de error.

**Sintaxis**

```sql theme={null}
toFloat32OrDefault(expr[, default])
```

**Argumentos**

* `expr` — Expresión que devuelve un número o la representación en cadena de un número. [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
* `default` — Opcional. El valor predeterminado que se devolverá si el análisis falla. [`Float32`](/es/reference/data-types/float)

**Valor devuelto**

Devuelve un valor de tipo Float32 si la conversión se realiza correctamente; de lo contrario, devuelve el valor predeterminado si se proporcionó, o 0 si no. [`Float32`](/es/reference/data-types/float)

**Ejemplos**

**Conversión correcta**

```sql title=Query theme={null}
SELECT toFloat32OrDefault('8', CAST('0', 'Float32'))
```

```response title=Response theme={null}
8
```

**Conversión fallida**

```sql title=Query theme={null}
SELECT toFloat32OrDefault('abc', CAST('0', 'Float32'))
```

```response title=Response theme={null}
0
```

<div id="toFloat32OrNull">
  ## toFloat32OrNull
</div>

Introducido en: v1.1.0

Convierte un valor de entrada en un valor de tipo [Float32](/es/reference/data-types/float), pero devuelve `NULL` en caso de error.
Como [`toFloat32`](#toFloat32), pero devuelve `NULL` en lugar de lanzar una excepción si se produce un error de conversión.

Argumentos admitidos:

* Valores de tipo (U)Int\*.
* Representaciones en cadena de (U)Int8/16/32/128/256.
* Valores de tipo Float\*, incluidos `NaN` e `Inf`.
* Representaciones en cadena de Float\*, incluidos `NaN` e `Inf` (sin distinguir entre mayúsculas y minúsculas).

Argumentos no admitidos (devuelven `NULL`):

* Representaciones en cadena de valores binarios y hexadecimales; por ejemplo, `SELECT toFloat32OrNull('0xc0fe');`.
* Formatos de cadena no válidos.

Véase también:

* [`toFloat32`](#toFloat32).
* [`toFloat32OrZero`](#toFloat32OrZero).
* [`toFloat32OrDefault`](#toFloat32OrDefault).

**Sintaxis**

```sql theme={null}
toFloat32OrNull(x)
```

**Argumentos**

* `x` — Una representación en cadena de un número. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor de coma flotante de 32 bits si la operación se realiza correctamente; de lo contrario, `NULL`. [`Float32`](/es/reference/data-types/float) o [`NULL`](/es/reference/syntax#null)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toFloat32OrNull('42.7'),
    toFloat32OrNull('NaN'),
    toFloat32OrNull('abc')
FORMAT Vertical
```

```response title=Response theme={null}
Row 1:
──────
toFloat32OrNull('42.7'): 42.7
toFloat32OrNull('NaN'):  nan
toFloat32OrNull('abc'):  \N
```

<div id="toFloat32OrZero">
  ## toFloat32OrZero
</div>

Introducido en: v1.1.0

Convierte un valor de entrada en un valor de tipo [Float32](/es/reference/data-types/float), pero devuelve `0` en caso de error.
Es como [`toFloat32`](#toFloat32), pero devuelve `0` en lugar de lanzar una excepción cuando se producen errores de conversión.

Véase también:

* [`toFloat32`](#toFloat32).
* [`toFloat32OrNull`](#toFloat32OrNull).
* [`toFloat32OrDefault`](#toFloat32OrDefault).

**Sintaxis**

```sql theme={null}
toFloat32OrZero(x)
```

**Argumentos**

* `x` — Una representación en cadena de un número. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor de coma flotante de 32 bits si la operación se realiza correctamente; en caso contrario, `0`. [`Float32`](/es/reference/data-types/float)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toFloat32OrZero('42.7'),
    toFloat32OrZero('abc')
FORMAT Vertical
```

```response title=Response theme={null}
Row 1:
──────
toFloat32OrZero('42.7'): 42.7
toFloat32OrZero('abc'):  0
```

<div id="toFloat64">
  ## toFloat64
</div>

Introducido en: v1.1.0

Convierte un valor de entrada en un valor del tipo [`Float64`](/es/reference/data-types/float).
Lanza una excepción en caso de error.

Argumentos admitidos:

* Valores de tipo (U)Int\*.
* Representaciones de cadena de (U)Int8/16/32/128/256.
* Valores de tipo Float\*, incluidos `NaN` e `Inf`.
* Representaciones de cadena del tipo Float\*, incluidos `NaN` e `Inf` (sin distinguir entre mayúsculas y minúsculas).

Argumentos no admitidos:

* Representaciones de cadena de valores binarios y hexadecimales, por ejemplo, `SELECT toFloat64('0xc0fe');`.

Véase también:

* [`toFloat64OrZero`](#toFloat64OrZero).
* [`toFloat64OrNull`](#toFloat64OrNull).
* [`toFloat64OrDefault`](#toFloat64OrDefault).

**Sintaxis**

```sql theme={null}
toFloat64(expr)
```

**Argumentos**

* `expr` — Expresión que devuelve un número o su representación en cadena. [`Expresión`](/es/reference/data-types/special-data-types/expression)

**Valor devuelto**

Devuelve un valor de punto flotante de 64 bits. [`Float64`](/es/reference/data-types/float)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toFloat64(42.7),
    toFloat64('42.7'),
    toFloat64('NaN')
FORMAT Vertical
```

```response title=Response theme={null}
Row 1:
──────
toFloat64(42.7):   42.7
toFloat64('42.7'): 42.7
toFloat64('NaN'):  nan
```

<div id="toFloat64OrDefault">
  ## toFloat64OrDefault
</div>

Introducido en: v21.11.0

Al igual que [`toFloat64`](#toFloat64), esta función convierte un valor de entrada en un valor de tipo [Float64](/es/reference/data-types/float), pero devuelve el valor por defecto en caso de error.
Si no se proporciona ningún valor `default`, se devuelve `0` en caso de error.

**Sintaxis**

```sql theme={null}
toFloat64OrDefault(expr[, default])
```

**Argumentos**

* `expr` — Expresión que devuelve un número o la representación en cadena de un número. [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
* `default` — Opcional. El valor predeterminado que se devuelve si el análisis no se realiza correctamente. [`Float64`](/es/reference/data-types/float)

**Valor devuelto**

Devuelve un valor de tipo Float64 si la operación se realiza correctamente; de lo contrario, devuelve el valor predeterminado si se proporciona, o 0 en caso contrario. [`Float64`](/es/reference/data-types/float)

**Ejemplos**

**Conversión correcta**

```sql title=Query theme={null}
SELECT toFloat64OrDefault('8', CAST('0', 'Float64'))
```

```response title=Response theme={null}
8
```

**Error de conversión**

```sql title=Query theme={null}
SELECT toFloat64OrDefault('abc', CAST('0', 'Float64'))
```

```response title=Response theme={null}
0
```

<div id="toFloat64OrNull">
  ## toFloat64OrNull
</div>

Introducido en: v1.1.0

Convierte un valor de entrada en un valor de tipo [Float64](/es/reference/data-types/float), pero devuelve `NULL` en caso de error.
Como [`toFloat64`](#toFloat64), pero devuelve `NULL` en lugar de lanzar una excepción si se producen errores de conversión.

Argumentos admitidos:

* Valores de tipo (U)Int\*.
* Representaciones de cadena de (U)Int8/16/32/128/256.
* Valores de tipo Float\*, incluidos `NaN` e `Inf`.
* Representaciones de cadena del tipo Float\*, incluidos `NaN` e `Inf` (sin distinguir entre mayúsculas y minúsculas).

Argumentos no admitidos (devuelven `NULL`):

* Representaciones de cadena de valores binarios y hexadecimales, p. ej., `SELECT toFloat64OrNull('0xc0fe');`.
* Formatos de cadena no válidos.

Véase también:

* [`toFloat64`](#toFloat64).
* [`toFloat64OrZero`](#toFloat64OrZero).
* [`toFloat64OrDefault`](#toFloat64OrDefault).

**Sintaxis**

```sql theme={null}
toFloat64OrNull(x)
```

**Argumentos**

* `x` — La representación en cadena de un número. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor de tipo Float64 si la conversión se realiza correctamente; en caso contrario, `NULL`. [`Float64`](/es/reference/data-types/float) o [`NULL`](/es/reference/syntax#null)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toFloat64OrNull('42.7'),
    toFloat64OrNull('NaN'),
    toFloat64OrNull('abc')
FORMAT Vertical
```

```response title=Response theme={null}
Row 1:
──────
toFloat64OrNull('42.7'): 42.7
toFloat64OrNull('NaN'):  nan
toFloat64OrNull('abc'):  \N
```

<div id="toFloat64OrZero">
  ## toFloat64OrZero
</div>

Introducido en: v1.1.0

Convierte un valor de entrada a un valor de tipo [Float64](/es/reference/data-types/float), pero devuelve `0` en caso de error.
Al igual que [`toFloat64`](#toFloat64), pero devuelve `0` en lugar de lanzar una excepción si se producen errores de conversión.

Vea también:

* [`toFloat64`](#toFloat64).
* [`toFloat64OrNull`](#toFloat64OrNull).
* [`toFloat64OrDefault`](#toFloat64OrDefault).

**Sintaxis**

```sql theme={null}
toFloat64OrZero(x)
```

**Argumentos**

* `x` — La representación textual de un número. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor de coma flotante de 64 bits si la operación se realiza correctamente; en caso contrario, `0`. [`Float64`](/es/reference/data-types/float)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toFloat64OrZero('42.7'),
    toFloat64OrZero('abc')
FORMAT Vertical
```

```response title=Response theme={null}
Row 1:
──────
toFloat64OrZero('42.7'): 42.7
toFloat64OrZero('abc'):  0
```

<div id="toInt128">
  ## toInt128
</div>

Introducido en: v1.1.0

Convierte un valor de entrada en un valor de tipo [Int128](/es/reference/data-types/int-uint).
Lanza una excepción si se produce un error.
La función redondea hacia cero; es decir, trunca los dígitos fraccionarios de los números.

Argumentos admitidos:

* Valores o representaciones en cadena del tipo (U)Int\*.
* Valores del tipo Float\*.

Argumentos no admitidos:

* Representaciones en cadena de valores Float\*, incluidos `NaN` e `Inf`.
* Representaciones en cadena de valores binarios y hexadecimales; por ejemplo, `SELECT toInt128('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de Int128, el resultado se desborda por arriba o por abajo.
  Esto no se considera un error.
</Note>

Véase también:

* [`toInt128OrZero`](#toInt128OrZero).
* [`toInt128OrNull`](#toInt128OrNull).
* [`toInt128OrDefault`](#toInt128OrDefault).

**Sintaxis**

```sql theme={null}
toInt128(expr)
```

**Argumentos**

* `expr` — Expresión que devuelve un número o su representación en cadena. [`Expresión`](/es/reference/data-types/special-data-types/expression)

**Valor devuelto**

Devuelve un valor entero de 128 bits. [`Int128`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toInt128(-128),
    toInt128(-128.8),
    toInt128('-128')
FORMAT Vertical
```

```response title=Response theme={null}
Row 1:
──────
toInt128(-128):   -128
toInt128(-128.8): -128
toInt128('-128'): -128
```

<div id="toInt128OrDefault">
  ## toInt128OrDefault
</div>

Introducido en: v21.11.0

Al igual que [`toInt128`](#toInt128), esta función convierte un valor de entrada en un valor de tipo [Int128](/es/reference/data-types/int-uint), pero devuelve el valor predeterminado si se produce un error.
Si no se proporciona ningún valor `default`, se devuelve `0` en caso de error.

**Sintaxis**

```sql theme={null}
toInt128OrDefault(expr[, default])
```

**Argumentos**

* `expr` — Expresión que devuelve un número o una representación en cadena de un número. [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
* `default` — Opcional. El valor predeterminado que se devuelve si el análisis falla. [`Int128`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve un valor de tipo Int128 si la operación se realiza correctamente; de lo contrario, devuelve el valor predeterminado si se proporciona, o 0 si no. [`Int128`](/es/reference/data-types/int-uint)

**Ejemplos**

**Conversión correcta**

```sql title=Query theme={null}
SELECT toInt128OrDefault('-128', CAST('-1', 'Int128'))
```

```response title=Response theme={null}
-128
```

**Conversión fallida**

```sql title=Query theme={null}
SELECT toInt128OrDefault('abc', CAST('-1', 'Int128'))
```

```response title=Response theme={null}
-1
```

<div id="toInt128OrNull">
  ## toInt128OrNull
</div>

Introducido en: v20.8.0

Al igual que [`toInt128`](#toInt128), esta función convierte un valor de entrada en un valor de tipo [Int128](/es/reference/data-types/int-uint), pero devuelve `NULL` en caso de error.

Argumentos admitidos:

* Representaciones en cadena de (U)Int\*.

Argumentos no admitidos (devuelven `NULL`):

* Representaciones en cadena de valores Float\*, incluidos `NaN` e `Inf`.
* Representaciones en cadena de valores binarios y hexadecimales; por ejemplo, `SELECT toInt128OrNull('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de [Int128](/es/reference/data-types/int-uint), se produce un desbordamiento o subdesbordamiento en el resultado.
  Esto no se considera un error.
</Note>

Véase también:

* [`toInt128`](#toInt128).
* [`toInt128OrZero`](#toInt128OrZero).
* [`toInt128OrDefault`](#toInt128OrDefault).

**Sintaxis**

```sql theme={null}
toInt128OrNull(x)
```

**Argumentos**

* `x` — Una representación en cadena de un número. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor de tipo Int128, o `NULL` si la conversión no se realiza correctamente. [`Int128`](/es/reference/data-types/int-uint) o [`NULL`](/es/reference/syntax#null)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toInt128OrNull('-128'),
    toInt128OrNull('abc')
FORMAT Vertical
```

```response title=Response theme={null}
Row 1:
──────
toInt128OrNull('-128'): -128
toInt128OrNull('abc'):  \N
```

<div id="toInt128OrZero">
  ## toInt128OrZero
</div>

Introducido en: v20.8.0

Convierte un valor de entrada al tipo [Int128](/es/reference/data-types/int-uint), pero devuelve `0` en caso de error.
Es como [`toInt128`](#toInt128), pero devuelve `0` en lugar de lanzar una excepción.

Véase también:

* [`toInt128`](#toInt128).
* [`toInt128OrNull`](#toInt128OrNull).
* [`toInt128OrDefault`](#toInt128OrDefault).

**Sintaxis**

```sql theme={null}
toInt128OrZero(x)
```

**Argumentos**

* `x` — Valor de entrada que se va a convertir. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal) o [`(U)Int*`](/es/reference/data-types/int-uint) o [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime)

**Valor devuelto**

Devuelve el valor de entrada convertido o `0` si la conversión falla. [`Int128`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT toInt128OrZero('123')
```

```response title=Response theme={null}
123
```

**Si la conversión falla, devuelve cero**

```sql title=Query theme={null}
SELECT toInt128OrZero('abc')
```

```response title=Response theme={null}
0
```

<div id="toInt16">
  ## toInt16
</div>

Introducido en: v1.1.0

Convierte un valor de entrada en un valor de tipo [`Int16`](/es/reference/data-types/int-uint).
Lanza una excepción en caso de error.

Argumentos admitidos:

* Valores o representaciones en cadena del tipo (U)Int\*.
* Valores del tipo Float\*.

Argumentos no admitidos:

* Representaciones en cadena de valores Float\*, incluidos `NaN` e `Inf`.
* Representaciones en cadena de valores binarios y hexadecimales; por ejemplo, `SELECT toInt16('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de [Int16](/es/reference/data-types/int-uint), se produce un desbordamiento o subdesbordamiento del resultado.
  Esto no se considera un error.
  Por ejemplo: `SELECT toInt16(32768) == -32768;`.
</Note>

<Note>
  La función usa [redondeo hacia cero](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), lo que significa que trunca los dígitos fraccionarios de los números.
</Note>

Véase también:

* [`toInt16OrZero`](#toInt16OrZero).
* [`toInt16OrNull`](#toInt16OrNull).
* [`toInt16OrDefault`](#toInt16OrDefault).

**Sintaxis**

```sql theme={null}
toInt16(expr)
```

**Argumentos**

* `expr` — Expresión que devuelve un número o la representación en cadena de un número. [`expresión`](/es/reference/data-types/special-data-types/expression)

**Valor devuelto**

Devuelve un valor entero de 16 bits. [`Int16`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toInt16(-16),
    toInt16(-16.16),
    toInt16('-16')
FORMAT Vertical
```

```response title=Response theme={null}
Row 1:
──────
toInt16(-16):    -16
toInt16(-16.16): -16
toInt16('-16'):  -16
```

<div id="toInt16OrDefault">
  ## toInt16OrDefault
</div>

Introducido en: v21.11.0

Al igual que [`toInt16`](#toInt16), esta función convierte un valor de entrada en un valor de tipo [Int16](/es/reference/data-types/int-uint), pero devuelve el valor por defecto en caso de error.
Si no se pasa ningún valor `default`, se devuelve `0` en caso de error.

**Sintaxis**

```sql theme={null}
toInt16OrDefault(expr[, default])
```

**Argumentos**

* `expr` — Expresión que devuelve un número o la representación en cadena de un número. [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
* `default` — Opcional. El valor predeterminado que se devuelve si el análisis no se realiza correctamente. [`Int16`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve un valor de tipo Int16 si la operación se realiza correctamente; de lo contrario, devuelve el valor predeterminado, si se proporciona, o 0 si no. [`Int16`](/es/reference/data-types/int-uint)

**Ejemplos**

**Conversión correcta**

```sql title=Query theme={null}
SELECT toInt16OrDefault('-16', CAST('-1', 'Int16'))
```

```response title=Response theme={null}
-16
```

**Conversión fallida**

```sql title=Query theme={null}
SELECT toInt16OrDefault('abc', CAST('-1', 'Int16'))
```

```response title=Response theme={null}
-1
```

<div id="toInt16OrNull">
  ## toInt16OrNull
</div>

Introducido en: v1.1.0

Al igual que [`toInt16`](#toInt16), esta función convierte un valor de entrada en un valor de tipo [Int16](/es/reference/data-types/int-uint), pero devuelve `NULL` en caso de error.

Argumentos admitidos:

* Representaciones en cadena de (U)Int\*.

Argumentos no admitidos (devuelven `NULL`):

* Representaciones en cadena de valores Float\*, incluidos `NaN` e `Inf`.
* Representaciones en cadena de valores binarios y hexadecimales; por ejemplo, `SELECT toInt16OrNull('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de [Int16](/es/reference/data-types/int-uint), se produce un desbordamiento o subdesbordamiento en el resultado.
  Esto no se considera un error.
</Note>

Véase también:

* [`toInt16`](#toInt16).
* [`toInt16OrZero`](#toInt16OrZero).
* [`toInt16OrDefault`](#toInt16OrDefault).

**Sintaxis**

```sql theme={null}
toInt16OrNull(x)
```

**Argumentos**

* `x` — Una representación en cadena de un número. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor de tipo `Int16` o `NULL` si la conversión no se realiza correctamente. [`Int16`](/es/reference/data-types/int-uint) o [`NULL`](/es/reference/syntax#null)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toInt16OrNull('-16'),
    toInt16OrNull('abc')
FORMAT Vertical
```

```response title=Response theme={null}
fila 1:
──────
toInt16OrNull('-16'): -16
toInt16OrNull('abc'): \N
```

<div id="toInt16OrZero">
  ## toInt16OrZero
</div>

Introducido en: v1.1.0

Al igual que [`toInt16`](#toInt16), esta función convierte un valor de entrada en un valor del tipo [Int16](/es/reference/data-types/int-uint), pero devuelve `0` en caso de error.

Argumentos admitidos:

* Representaciones en cadena de (U)Int\*.

Argumentos no admitidos (devuelven `0`):

* Representaciones en cadena de valores Float\*, incluidos `NaN` e `Inf`.
* Representaciones en cadena de valores binarios y hexadecimales, por ejemplo, `SELECT toInt16OrZero('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de [Int16](/es/reference/data-types/int-uint), se produce un desbordamiento o subdesbordamiento en el resultado.
  Esto no se considera un error.
</Note>

Véase también:

* [`toInt16`](#toInt16).
* [`toInt16OrNull`](#toInt16OrNull).
* [`toInt16OrDefault`](#toInt16OrDefault).

**Sintaxis**

```sql theme={null}
toInt16OrZero(x)
```

**Argumentos**

* `x` — Una representación en cadena de un número. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor de tipo Int16 o `0` si la conversión no se realiza correctamente. [`Int16`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toInt16OrZero('16'),
    toInt16OrZero('abc')
FORMAT Vertical
```

```response title=Response theme={null}
Fila 1:
──────
toInt16OrZero('16'): 16
toInt16OrZero('abc'): 0
```

<div id="toInt256">
  ## toInt256
</div>

Introducido en: v1.1.0

Convierte un valor de entrada en un valor de tipo [Int256](/es/reference/data-types/int-uint).
Lanza una excepción en caso de error.
La función usa redondeo hacia cero, es decir, trunca los dígitos fraccionarios de los números.

Argumentos admitidos:

* Valores o representaciones en cadena del tipo (U)Int\*.
* Valores de tipo Float\*.

Argumentos no admitidos:

* Representaciones en cadena de valores Float\*, incluidos `NaN` e `Inf`.
* Representaciones en cadena de valores binarios y hexadecimales, por ejemplo, `SELECT toInt256('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de Int256, el resultado puede desbordarse por exceso o por defecto.
  Esto no se considera un error.
</Note>

Véase también:

* [`toInt256OrZero`](#toInt256OrZero).
* [`toInt256OrNull`](#toInt256OrNull).
* [`toInt256OrDefault`](#toInt256OrDefault).

**Sintaxis**

```sql theme={null}
toInt256(expr)
```

**Argumentos**

* `expr` — Expresión que devuelve un número o la representación en cadena de un número. [`Expresión`](/es/reference/data-types/special-data-types/expression)

**Valor devuelto**

Devuelve un valor entero de 256 bits. [`Int256`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toInt256(-256),
    toInt256(-256.256),
    toInt256('-256')
FORMAT Vertical
```

```response title=Response theme={null}
fila 1:
──────
toInt256(-256):     -256
toInt256(-256.256): -256
toInt256('-256'):   -256
```

<div id="toInt256OrDefault">
  ## toInt256OrDefault
</div>

Introducido en: v21.11.0

Al igual que [`toInt256`](#toInt256), esta función convierte un valor de entrada en un valor de tipo [Int256](/es/reference/data-types/int-uint), pero devuelve el valor predeterminado en caso de producirse un error.
Si no se proporciona ningún valor `default`, se devuelve `0` en caso de error.

**Sintaxis**

```sql theme={null}
toInt256OrDefault(expr[, default])
```

**Argumentos**

* `expr` — Expresión que devuelve un número o la representación en cadena de un número. [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
* `default` — Opcional. El valor predeterminado que se devuelve si el análisis no se realiza correctamente. [`Int256`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve un valor de tipo Int256 si la conversión se realiza correctamente; de lo contrario, devuelve el valor predeterminado si se proporciona, o 0 si no. [`Int256`](/es/reference/data-types/int-uint)

**Ejemplos**

**Conversión correcta**

```sql title=Query theme={null}
SELECT toInt256OrDefault('-256', CAST('-1', 'Int256'))
```

```response title=Response theme={null}
-256
```

**Conversión fallida**

```sql title=Query theme={null}
SELECT toInt256OrDefault('abc', CAST('-1', 'Int256'))
```

```response title=Response theme={null}
-1
```

<div id="toInt256OrNull">
  ## toInt256OrNull
</div>

Introducido en: v20.8.0

Al igual que [`toInt256`](#toInt256), esta función convierte un valor de entrada en un valor de tipo [Int256](/es/reference/data-types/int-uint), pero devuelve `NULL` en caso de error.

Argumentos admitidos:

* Representaciones de cadena de (U)Int\*.

Argumentos no admitidos (devuelven `NULL`):

* Representaciones de cadena de valores Float\*, incluidos `NaN` e `Inf`.
* Representaciones de cadena de valores binarios y hexadecimales; por ejemplo, `SELECT toInt256OrNull('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de [Int256](/es/reference/data-types/int-uint), se produce un desbordamiento por exceso o por defecto en el resultado.
  Esto no se considera un error.
</Note>

Véase también:

* [`toInt256`](#toInt256).
* [`toInt256OrZero`](#toInt256OrZero).
* [`toInt256OrDefault`](#toInt256OrDefault).

**Sintaxis**

```sql theme={null}
toInt256OrNull(x)
```

**Argumentos**

* `x` — La representación en cadena de un número. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor de tipo Int256 o `NULL` si la conversión no se realiza correctamente. [`Int256`](/es/reference/data-types/int-uint) o [`NULL`](/es/reference/syntax#null)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toInt256OrNull('-256'),
    toInt256OrNull('abc')
FORMAT Vertical
```

```response title=Response theme={null}
Fila 1:
──────
toInt256OrNull('-256'): -256
toInt256OrNull('abc'):  \N
```

<div id="toInt256OrZero">
  ## toInt256OrZero
</div>

Introducido en: v20.8.0

Convierte un valor de entrada al tipo [Int256](/es/reference/data-types/int-uint), pero devuelve `0` en caso de error.
Igual que [`toInt256`](#toInt256), pero devuelve `0` en lugar de generar una excepción.

Véase también:

* [`toInt256`](#toInt256).
* [`toInt256OrNull`](#toInt256OrNull).
* [`toInt256OrDefault`](#toInt256OrDefault).

**Sintaxis**

```sql theme={null}
toInt256OrZero(x)
```

**Argumentos**

* `x` — Valor de entrada que se va a convertir. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal) o [`(U)Int*`](/es/reference/data-types/int-uint) o [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime)

**Valor devuelto**

Devuelve el valor de entrada convertido o `0` si la conversión falla. [`Int256`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT toInt256OrZero('123')
```

```response title=Response theme={null}
123
```

**Si falla la conversión, devuelve cero**

```sql title=Query theme={null}
SELECT toInt256OrZero('abc')
```

```response title=Response theme={null}
0
```

<div id="toInt32">
  ## toInt32
</div>

Introducido en: v1.1.0

Convierte un valor de entrada en un valor de tipo [`Int32`](/es/reference/data-types/int-uint).
Lanza una excepción en caso de error.

Argumentos admitidos:

* Valores o representaciones en cadena del tipo (U)Int\*.
* Valores del tipo Float\*.

Argumentos no admitidos:

* Representaciones en cadena de valores Float\*, incluidos `NaN` e `Inf`.
* Representaciones en cadena de valores binarios y hexadecimales, por ejemplo, `SELECT toInt32('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de [Int32](/es/reference/data-types/int-uint), se produce un desbordamiento por exceso o por defecto.
  Esto no se considera un error.
  Por ejemplo: `SELECT toInt32(2147483648) == -2147483648;`
</Note>

<Note>
  La función utiliza [redondeo hacia cero](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), lo que significa que trunca los dígitos fraccionarios de los números.
</Note>

Véase también:

* [`toInt32OrZero`](#toInt32OrZero).
* [`toInt32OrNull`](#toInt32OrNull).
* [`toInt32OrDefault`](#toInt32OrDefault).

**Sintaxis**

```sql theme={null}
toInt32(expr)
```

**Argumentos**

* `expr` — Expresión que devuelve un número o la representación en cadena de un número. [`Expresión`](/es/reference/data-types/special-data-types/expression)

**Valor devuelto**

Devuelve un valor entero de 32 bits. [`Int32`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toInt32(-32),
    toInt32(-32.32),
    toInt32('-32')
FORMAT Vertical
```

```response title=Response theme={null}
Fila 1:
──────
toInt32(-32):    -32
toInt32(-32.32): -32
toInt32('-32'):  -32
```

<div id="toInt32OrDefault">
  ## toInt32OrDefault
</div>

Introducido en: v21.11.0

Al igual que [`toInt32`](#toInt32), esta función convierte un valor de entrada en un valor de tipo [Int32](/es/reference/data-types/int-uint), pero devuelve el valor predeterminado en caso de error.
Si no se pasa ningún valor `default`, se devuelve `0` en caso de error.

**Sintaxis**

```sql theme={null}
toInt32OrDefault(expr[, default])
```

**Argumentos**

* `expr` — Expresión que devuelve un número o la representación en cadena de un número. [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
* `default` — Opcional. El valor predeterminado que se devuelve si el análisis no es correcto. [`Int32`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve un valor de tipo Int32 si la conversión se realiza correctamente; de lo contrario, devuelve el valor predeterminado si se proporciona, o 0 en caso contrario. [`Int32`](/es/reference/data-types/int-uint)

**Ejemplos**

**Conversión correcta**

```sql title=Query theme={null}
SELECT toInt32OrDefault('-32', CAST('-1', 'Int32'))
```

```response title=Response theme={null}
-32
```

**Error de conversión**

```sql title=Query theme={null}
SELECT toInt32OrDefault('abc', CAST('-1', 'Int32'))
```

```response title=Response theme={null}
-1
```

<div id="toInt32OrNull">
  ## toInt32OrNull
</div>

Introducido en: v1.1.0

Al igual que [`toInt32`](#toInt32), esta función convierte un valor de entrada en un valor de tipo [Int32](/es/reference/data-types/int-uint), pero devuelve `NULL` en caso de error.

Argumentos admitidos:

* Representaciones en cadena de (U)Int\*.

Argumentos no admitidos (devuelven `NULL`):

* Representaciones en cadena de valores Float\*, incluidos `NaN` e `Inf`.
* Representaciones en cadena de valores binarios y hexadecimales; por ejemplo, `SELECT toInt32OrNull('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de [Int32](/es/reference/data-types/int-uint), se produce un desbordamiento o subdesbordamiento en el resultado.
  Esto no se considera un error.
</Note>

Véase también:

* [`toInt32`](#toInt32).
* [`toInt32OrZero`](#toInt32OrZero).
* [`toInt32OrDefault`](#toInt32OrDefault).

**Sintaxis**

```sql theme={null}
toInt32OrNull(x)
```

**Argumentos**

* `x` — Una representación en cadena de un número. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor de tipo Int32 o `NULL` si la conversión no se realiza correctamente. [`Int32`](/es/reference/data-types/int-uint) o [`NULL`](/es/reference/syntax#null)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toInt32OrNull('-32'),
    toInt32OrNull('abc')
FORMAT Vertical
```

```response title=Response theme={null}
fila 1:
──────
toInt32OrNull('-32'): -32
toInt32OrNull('abc'): \N
```

<div id="toInt32OrZero">
  ## toInt32OrZero
</div>

Introducido en: v1.1.0

Al igual que [`toInt32`](#toInt32), esta función convierte un valor de entrada en un valor de tipo [Int32](/es/reference/data-types/int-uint), pero devuelve `0` en caso de error.

Argumentos admitidos:

* Representaciones en cadena de (U)Int\*.

Argumentos no admitidos (devuelven `0`):

* Representaciones en cadena de valores Float\*, incluidos `NaN` e `Inf`.
* Representaciones en cadena de valores binarios y hexadecimales; por ejemplo, `SELECT toInt32OrZero('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de [Int32](/es/reference/data-types/int-uint), se produce un desbordamiento o subdesbordamiento del resultado.
  Esto no se considera un error.
</Note>

Véase también:

* [`toInt32`](#toInt32).
* [`toInt32OrNull`](#toInt32OrNull).
* [`toInt32OrDefault`](#toInt32OrDefault).

**Sintaxis**

```sql theme={null}
toInt32OrZero(x)
```

**Argumentos**

* `x` — Una representación en cadena de un número. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor de tipo Int32 o `0` si la conversión no se realiza correctamente. [`Int32`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toInt32OrZero('32'),
    toInt32OrZero('abc')
FORMAT Vertical
```

```response title=Response theme={null}
fila 1:
──────
toInt32OrZero('32'): 32
toInt32OrZero('abc'): 0
```

<div id="toInt64">
  ## toInt64
</div>

Introducido en: v1.1.0

Convierte un valor de entrada en un valor de tipo [`Int64`](/es/reference/data-types/int-uint).
Lanza una excepción si se produce un error.

Argumentos admitidos:

* Valores o representaciones de cadena del tipo (U)Int\*.
* Valores del tipo Float\*.

Argumentos no admitidos:

* Representaciones de cadena de valores Float\*, incluidos `NaN` e `Inf`.
* Representaciones de cadena de valores binarios y hexadecimales, por ejemplo, `SELECT toInt64('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de [Int64](/es/reference/data-types/int-uint), el resultado se desborda por exceso o por defecto.
  Esto no se considera un error.
  Por ejemplo: `SELECT toInt64(9223372036854775808) == -9223372036854775808;`
</Note>

<Note>
  La función utiliza [redondeo hacia cero](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), lo que significa que trunca los dígitos fraccionarios de los números.
</Note>

Véase también:

* [`toInt64OrZero`](#toInt64OrZero).
* [`toInt64OrNull`](#toInt64OrNull).
* [`toInt64OrDefault`](#toInt64OrDefault).

**Sintaxis**

```sql theme={null}
toInt64(expr)
```

**Argumentos**

* `expr` — Expresión que devuelve un número o su representación en cadena. Admitido: valores o representaciones en cadena del tipo (U)Int\*, valores del tipo Float\*. No admitido: representaciones en cadena de valores Float\*, incluidos NaN e Inf, y representaciones en cadena de valores binarios y hexadecimales. [`Expresión`](/es/reference/data-types/special-data-types/expression)

**Valor devuelto**

Devuelve un valor entero de 64 bits. [`Int64`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toInt64(-64),
    toInt64(-64.64),
    toInt64('-64')
FORMAT Vertical
```

```response title=Response theme={null}
fila 1:
──────
toInt64(-64):    -64
toInt64(-64.64): -64
toInt64('-64'):  -64
```

<div id="toInt64OrDefault">
  ## toInt64OrDefault
</div>

Introducido en: v21.11.0

Al igual que [`toInt64`](#toInt64), esta función convierte un valor de entrada a un valor de tipo [Int64](/es/reference/data-types/int-uint), pero devuelve el valor predeterminado en caso de error.
Si no se pasa ningún valor `default`, se devuelve `0` en caso de error.

**Sintaxis**

```sql theme={null}
toInt64OrDefault(expr[, default])
```

**Argumentos**

* `expr` — Expresión que devuelve un número o la representación en cadena de un número. [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
* `default` — Opcional. El valor predeterminado que se devuelve si no se puede analizar. [`Int64`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve un valor de tipo Int64 si la conversión se realiza correctamente; de lo contrario, devuelve el valor predeterminado, si se proporciona, o 0 en caso contrario. [`Int64`](/es/reference/data-types/int-uint)

**Ejemplos**

**Conversión correcta**

```sql title=Query theme={null}
SELECT toInt64OrDefault('-64', CAST('-1', 'Int64'))
```

```response title=Response theme={null}
-64
```

**Conversión fallida**

```sql title=Query theme={null}
SELECT toInt64OrDefault('abc', CAST('-1', 'Int64'))
```

```response title=Response theme={null}
-1
```

<div id="toInt64OrNull">
  ## toInt64OrNull
</div>

Introducido en: v1.1.0

Al igual que [`toInt64`](#toInt64), esta función convierte un valor de entrada en un valor de tipo [Int64](/es/reference/data-types/int-uint), pero devuelve `NULL` en caso de error.

Argumentos admitidos:

* Representaciones en cadena de (U)Int\*.

Argumentos no admitidos (devuelven `NULL`):

* Representaciones en cadena de valores Float\*, incluidos `NaN` e `Inf`.
* Representaciones en cadena de valores binarios y hexadecimales, por ejemplo, `SELECT toInt64OrNull('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de [Int64](/es/reference/data-types/int-uint), se produce desbordamiento o subdesbordamiento en el resultado.
  Esto no se considera un error.
</Note>

Véase también:

* [`toInt64`](#toInt64).
* [`toInt64OrZero`](#toInt64OrZero).
* [`toInt64OrDefault`](#toInt64OrDefault).

**Sintaxis**

```sql theme={null}
toInt64OrNull(x)
```

**Argumentos**

* `x` — La representación en cadena de un número. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor de tipo Int64; en caso contrario, `NULL` si la conversión no se realiza correctamente. [`Int64`](/es/reference/data-types/int-uint) o [`NULL`](/es/reference/syntax#null)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toInt64OrNull('-64'),
    toInt64OrNull('abc')
FORMAT Vertical
```

```response title=Response theme={null}
Row 1:
──────
toInt64OrNull('-64'): -64
toInt64OrNull('abc'): \N
```

<div id="toInt64OrZero">
  ## toInt64OrZero
</div>

Introducido en: v1.1.0

Convierte un valor de entrada al tipo [Int64](/es/reference/data-types/int-uint), pero devuelve `0` si se produce un error.
Igual que [`toInt64`](#toInt64), pero devuelve `0` en lugar de lanzar una excepción.

Véase también:

* [`toInt64`](#toInt64).
* [`toInt64OrNull`](#toInt64OrNull).
* [`toInt64OrDefault`](#toInt64OrDefault).

**Sintaxis**

```sql theme={null}
toInt64OrZero(x)
```

**Argumentos**

* `x` — Valor de entrada que se va a convertir. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal) o [`(U)Int*`](/es/reference/data-types/int-uint) o [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime)

**Valor devuelto**

Devuelve el valor de entrada convertido; en caso contrario, `0` si la conversión falla. [`Int64`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT toInt64OrZero('123')
```

```response title=Response theme={null}
123
```

**Si la conversión falla, devuelve cero**

```sql title=Query theme={null}
SELECT toInt64OrZero('abc')
```

```response title=Response theme={null}
0
```

<div id="toInt8">
  ## toInt8
</div>

Introducido en: v1.1.0

Convierte un valor de entrada en un valor de tipo [`Int8`](/es/reference/data-types/int-uint).
Lanza una excepción en caso de error.

Argumentos admitidos:

* Valores o representaciones de cadena del tipo (U)Int\*.
* Valores del tipo Float\*.

Argumentos no admitidos:

* Representaciones de cadena de valores Float\*, incluidos `NaN` e `Inf`.
* Representaciones de cadena de valores en binario y hexadecimal; por ejemplo, `SELECT toInt8('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de [Int8](/es/reference/data-types/int-uint), se produce un desbordamiento por exceso o subdesbordamiento en el resultado.
  Esto no se considera un error.
  Por ejemplo: `SELECT toInt8(128) == -128;`.
</Note>

<Note>
  La función usa [rounding towards zero](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), lo que significa que trunca los dígitos fraccionarios de los números.
</Note>

Véase también:

* [`toInt8OrZero`](#toInt8OrZero).
* [`toInt8OrNull`](#toInt8OrNull).
* [`toInt8OrDefault`](#toInt8OrDefault).

**Sintaxis**

```sql theme={null}
toInt8(expr)
```

**Argumentos**

* `expr` — Expresión que devuelve un número o la representación en cadena de un número. [`Expresión`](/es/reference/data-types/special-data-types/expression)

**Valor devuelto**

Devuelve un valor entero de 8 bits. [`Int8`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toInt8(-8),
    toInt8(-8.8),
    toInt8('-8')
FORMAT Vertical
```

```response title=Response theme={null}
Fila 1:
──────
toInt8(-8):   -8
toInt8(-8.8): -8
toInt8('-8'): -8
```

<div id="toInt8OrDefault">
  ## toInt8OrDefault
</div>

Introducido en: v21.11.0

Al igual que [`toInt8`](#toInt8), esta función convierte un valor de entrada en un valor de tipo [Int8](/es/reference/data-types/int-uint), pero devuelve el valor predeterminado si se produce un error.
Si no se proporciona ningún valor `default`, se devuelve `0` en caso de error.

**Sintaxis**

```sql theme={null}
toInt8OrDefault(expr[, default])
```

**Argumentos**

* `expr` — Expresión que devuelve un número o una representación en cadena de un número. [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
* `default` — Opcional. El valor predeterminado que se devuelve si no se puede analizar. [`Int8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve un valor de tipo Int8 si la conversión se realiza correctamente; de lo contrario, devuelve el valor predeterminado si se proporcionó, o 0 si no. [`Int8`](/es/reference/data-types/int-uint)

**Ejemplos**

**Conversión correcta**

```sql title=Query theme={null}
SELECT toInt8OrDefault('-8', CAST('-1', 'Int8'))
```

```response title=Response theme={null}
-8
```

**Error de conversión**

```sql title=Query theme={null}
SELECT toInt8OrDefault('abc', CAST('-1', 'Int8'))
```

```response title=Response theme={null}
-1
```

<div id="toInt8OrNull">
  ## toInt8OrNull
</div>

Introducido en: v1.1.0

Al igual que [`toInt8`](#toInt8), esta función convierte un valor de entrada en un valor de tipo [Int8](/es/reference/data-types/int-uint), pero devuelve `NULL` en caso de error.

Argumentos admitidos:

* Representaciones en cadena de (U)Int\*.

Argumentos no admitidos (devuelven `NULL`):

* Representaciones en cadena de valores Float\*, incluidos `NaN` e `Inf`.
* Representaciones en cadena de valores binarios y hexadecimales; por ejemplo, `SELECT toInt8OrNull('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de [Int8](/es/reference/data-types/int-uint), se produce un desbordamiento o subdesbordamiento del resultado.
  Esto no se considera un error.
</Note>

Véase también:

* [`toInt8`](#toInt8).
* [`toInt8OrZero`](#toInt8OrZero).
* [`toInt8OrDefault`](#toInt8OrDefault).

**Sintaxis**

```sql theme={null}
toInt8OrNull(x)
```

**Argumentos**

* `x` — Una representación en cadena de un número. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor de tipo Int8 o `NULL` si la conversión no se realiza correctamente. [`Int8`](/es/reference/data-types/int-uint) o [`NULL`](/es/reference/syntax#null)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toInt8OrNull('-8'),
    toInt8OrNull('abc')
FORMAT Vertical
```

```response title=Response theme={null}
Fila 1:
──────
toInt8OrNull('-8'):  -8
toInt8OrNull('abc'): \N
```

<div id="toInt8OrZero">
  ## toInt8OrZero
</div>

Introducido en: v1.1.0

Al igual que [`toInt8`](#toInt8), esta función convierte un valor de entrada en un valor de tipo [Int8](/es/reference/data-types/int-uint), pero devuelve `0` en caso de error.

Argumentos admitidos:

* Representaciones de cadena de (U)Int\*.

Argumentos no admitidos (devuelven `0`):

* Representaciones de cadena de valores Float\*, incluidos `NaN` e `Inf`.
* Representaciones de cadena de valores binarios y hexadecimales; por ejemplo, `SELECT toInt8OrZero('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de [Int8](/es/reference/data-types/int-uint), se produce desbordamiento o subdesbordamiento en el resultado.
  Esto no se considera un error.
</Note>

Véase también:

* [`toInt8`](#toInt8).
* [`toInt8OrNull`](#toInt8OrNull).
* [`toInt8OrDefault`](#toInt8OrDefault).

**Sintaxis**

```sql theme={null}
toInt8OrZero(x)
```

**Argumentos**

* `x` — Una representación en cadena de un número. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor de tipo Int8; de lo contrario, `0` si la conversión falla. [`Int8`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toInt8OrZero('8'),
    toInt8OrZero('abc')
FORMAT Vertical
```

```response title=Response theme={null}
Row 1:
──────
toInt8OrZero('8'): 8
toInt8OrZero('abc'): 0
```

<div id="toInterval">
  ## toInterval
</div>

Introducido en: v25.4.0

Crea un valor de Interval a partir de un valor numérico y de una cadena que indica la unidad.

Esta función proporciona una forma unificada de crear intervalos de distintos tipos (segundos, minutos, horas, días, semanas, meses, trimestres, años)
desde una sola función, especificando la unidad como un argumento de cadena. La cadena de la unidad no distingue entre mayúsculas y minúsculas.

Esto equivale a llamar a funciones específicas de tipo como `toIntervalSecond`, `toIntervalMinute`, `toIntervalDay`, etc.,
pero permite especificar la unidad de forma dinámica como un parámetro de cadena.

**Sintaxis**

```sql theme={null}
toInterval(value, unit)
```

**Argumentos**

* `value` — El valor numérico que representa el número de unidades. Puede ser cualquier tipo numérico. [`Int8`](/es/reference/data-types/int-uint) o [`Int16`](/es/reference/data-types/int-uint) o [`Int32`](/es/reference/data-types/int-uint) o [`Int64`](/es/reference/data-types/int-uint) o [`UInt8`](/es/reference/data-types/int-uint) o [`UInt16`](/es/reference/data-types/int-uint) o [`UInt32`](/es/reference/data-types/int-uint) o [`UInt64`](/es/reference/data-types/int-uint) o [`Float32`](/es/reference/data-types/float) o [`Float64`](/es/reference/data-types/float)
* `unit` — La unidad de tiempo. Debe ser una cadena constante. Valores válidos: 'nanosecond', 'microsecond', 'millisecond', 'second', 'minute', 'hour', 'day', 'week', 'month', 'quarter', 'year'. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor Interval del tipo especificado. El tipo de resultado depende de la unidad: IntervalNanosecond, IntervalMicrosecond, IntervalMillisecond, IntervalSecond, IntervalMinute, IntervalHour, IntervalDay, IntervalWeek, IntervalMonth, IntervalQuarter o IntervalYear. [`Interval`](/es/reference/data-types/int-uint)

**Ejemplos**

**Crear intervalos con distintas 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      │
└─────────┴──────┴────────┘
```

**Usar intervalos en la aritmética de fechas**

```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 │
└──────────────────────┴─────────────────────┴─────────────────────┘
```

**Creación 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 │
└────────────┘
```

<div id="toIntervalDay">
  ## toIntervalDay
</div>

Introducido en: v1.1.0

Devuelve un intervalo de `n` días del tipo de datos [`IntervalDay`](/es/reference/data-types/special-data-types/interval).

**Sintaxis**

```sql theme={null}
toIntervalDay(n)
```

**Argumentos**

* `n` — Número de días. Números enteros o su representación en cadena, y números de coma flotante. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un intervalo de `n` días. [`Interval`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo 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 │
└────────────┘
```

<div id="toIntervalHour">
  ## toIntervalHour
</div>

Introducido en: v1.1.0

Devuelve un intervalo de `n` horas del tipo de dato [`IntervalHour`](/es/reference/data-types/special-data-types/interval).

**Sintaxis**

```sql theme={null}
toIntervalHour(n)
```

**Argumentos**

* `n` — Número de horas. Números enteros o sus representaciones en cadena, y números de coma flotante. [`Int*`](/es/reference/data-types/int-uint) o [`UInt*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un intervalo de `n` horas. [`Interval`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo 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 │
└─────────────────────┘
```

<div id="toIntervalMicrosecond">
  ## toIntervalMicrosecond
</div>

Introducido en: v22.6.0

Devuelve un intervalo de `n` microsegundos del tipo de dato [`IntervalMicrosecond`](/es/reference/data-types/special-data-types/interval).

**Sintaxis**

```sql theme={null}
toIntervalMicrosecond(n)
```

**Argumentos**

* `n` — Cantidad de microsegundos. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un intervalo de `n` microsegundos. [`Interval`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo 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 │
└────────────────────────────┘
```

<div id="toIntervalMillisecond">
  ## toIntervalMillisecond
</div>

Introducido en: v22.6.0

Devuelve un intervalo de `n` milisegundos del tipo de datos [IntervalMillisecond](/es/reference/data-types/special-data-types/interval).

**Sintaxis**

```sql theme={null}
toIntervalMillisecond(n)
```

**Argumentos**

* `n` — Número de milisegundos. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un intervalo de `n` milisegundos. [`Interval`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo 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 │
└─────────────────────────┘
```

<div id="toIntervalMinute">
  ## toIntervalMinute
</div>

Introducido en: v1.1.0

Devuelve un intervalo de `n` minutos del tipo de datos [`IntervalMinute`](/es/reference/data-types/special-data-types/interval).

**Sintaxis**

```sql theme={null}
toIntervalMinute(n)
```

**Argumentos**

* `n` — Número de minutos. Números enteros o sus representaciones en cadena, y números de punto flotante. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un intervalo de `n` minutos. [`Interval`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo 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 │
└─────────────────────┘
```

<div id="toIntervalMonth">
  ## toIntervalMonth
</div>

Introducido en: v1.1.0

Devuelve un intervalo de `n` meses del tipo de datos [`IntervalMonth`](/es/reference/data-types/special-data-types/interval).

**Sintaxis**

```sql theme={null}
toIntervalMonth(n)
```

**Argumentos**

* `n` — Número de meses. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un intervalo de `n` meses. [`Interval`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo 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 │
└────────────┘
```

<div id="toIntervalNanosecond">
  ## toIntervalNanosecond
</div>

Introducido en: v22.6.0

Devuelve un intervalo de `n` nanosegundos del tipo de dato [`IntervalNanosecond`](/es/reference/data-types/special-data-types/interval).

**Sintaxis**

```sql theme={null}
toIntervalNanosecond(n)
```

**Argumentos**

* `n` — Número de nanosegundos. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un intervalo de `n` nanosegundos. [`Interval`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo 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 │
└───────────────────────────────┘
```

<div id="toIntervalQuarter">
  ## toIntervalQuarter
</div>

Introducido en: v1.1.0

Devuelve un intervalo de `n` trimestres del tipo de dato [`IntervalQuarter`](/es/reference/data-types/special-data-types/interval).

**Sintaxis**

```sql theme={null}
toIntervalQuarter(n)
```

**Argumentos**

* `n` — Número de trimestres. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un intervalo de `n` trimestres. [`Interval`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo 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 │
└────────────┘
```

<div id="toIntervalSecond">
  ## toIntervalSecond
</div>

Introducido en: v1.1.0

Devuelve un intervalo de `n` segundos del tipo de datos [`IntervalSecond`](/es/reference/data-types/special-data-types/interval).

**Sintaxis**

```sql theme={null}
toIntervalSecond(n)
```

**Argumentos**

* `n` — Número de segundos. Números enteros o sus representaciones como cadenas, y números de coma flotante. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un intervalo de `n` segundos. [`Interval`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo 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 │
└─────────────────────┘
```

<div id="toIntervalWeek">
  ## toIntervalWeek
</div>

Introducido en: v1.1.0

Devuelve un intervalo de `n` semanas del tipo de datos [`IntervalWeek`](/es/reference/data-types/special-data-types/interval).

**Sintaxis**

```sql theme={null}
toIntervalWeek(n)
```

**Argumentos**

* `n` — Número de semanas. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un intervalo de `n` semanas. [`Interval`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo 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 │
└────────────┘
```

<div id="toIntervalYear">
  ## toIntervalYear
</div>

Introducido en: v1.1.0

Devuelve un intervalo de `n` años del tipo de dato [`IntervalYear`](/es/reference/data-types/special-data-types/interval).

**Sintaxis**

```sql theme={null}
toIntervalYear(n)
```

**Argumentos**

* `n` — Número de años. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un intervalo de `n` años. [`Interval`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo 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 │
└────────────┘
```

<div id="toLowCardinality">
  ## toLowCardinality
</div>

Introducido en: v18.12.0

Convierte el argumento de entrada en la versión [LowCardinality](/es/reference/data-types/lowcardinality) del mismo tipo de dato.

<Tip>
  Para convertir el tipo de dato `LowCardinality` en un tipo de dato normal, use la función [CAST](#CAST).
  Por ejemplo: `CAST(x AS String)`.
</Tip>

**Sintaxis**

```sql theme={null}
toLowCardinality(expr)
```

**Argumentos**

* `expr` — Expresión que da como resultado uno de los tipos de datos admitidos: [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring) o [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)

**Valor devuelto**

Devuelve el valor de entrada convertido al tipo de dato `LowCardinality`. [`LowCardinality`](/es/reference/data-types/lowcardinality)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT toLowCardinality('1')
```

```response title=Response theme={null}
┌─toLowCardinality('1')─┐
│ 1                     │
└───────────────────────┘
```

<div id="toString">
  ## toString
</div>

Introducido en: v1.1.0

Convierte valores a su representación como cadena.
Para argumentos DateTime, la función puede tomar un segundo argumento String que contenga el nombre de la zona horaria.

**Sintaxis**

```sql theme={null}
toString(value[, timezone])
```

**Argumentos**

* `value` — Valor que se convertirá en cadena. [`Any`](/es/reference/data-types/index)
* `timezone` — Opcional. Nombre de la zona horaria para convertir DateTime. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve una representación en cadena del valor de entrada. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo 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 │
└─────────────────────┴───────────────────┴─────────────────────┘
```

<div id="toStringCutToZero">
  ## toStringCutToZero
</div>

Introducida en: v1.1.0

Acepta un argumento de tipo [String](/es/reference/data-types/string) o [FixedString](/es/reference/data-types/fixedstring) y devuelve un String que contiene una copia de la cadena original truncada en el primer byte nulo.

Los bytes nulos (\0) se consideran terminadores de cadena.
Esta función resulta útil para procesar cadenas de estilo C o datos binarios en los que los bytes nulos marcan el final del contenido significativo.

**Sintaxis**

```sql theme={null}
toStringCutToZero(s)
```

**Argumentos**

* `s` — String o FixedString que se va a procesar. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)

**Valor devuelto**

Devuelve un String que contiene los caracteres anteriores al primer byte nulo. [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo 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                             │
└────────────────────────────┴───────────────────────────────────┘
```

<div id="toTime">
  ## toTime
</div>

Introducido en: v1.1.0

Convierte un valor de entrada al tipo [Time](/es/reference/data-types/time).
Admite la conversión desde String, FixedString, DateTime o tipos numéricos que representan segundos desde la medianoche.

**Sintaxis**

```sql theme={null}
toTime(x)
```

**Argumentos**

* `x` — Valor de entrada que se debe convertir. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring) o [`DateTime`](/es/reference/data-types/datetime) o [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)

**Valor devuelto**

Devuelve el valor convertido. [`Time`](/es/reference/data-types/time)

**Ejemplos**

**Conversión de String a Time**

```sql title=Query theme={null}
SELECT toTime('14:30:25')
```

```response title=Response theme={null}
14:30:25
```

**Conversión de DateTime a Time**

```sql title=Query theme={null}
SELECT toTime(toDateTime('2025-04-15 14:30:25'))
```

```response title=Response theme={null}
14:30:25
```

**Conversión de entero a Time**

```sql title=Query theme={null}
SELECT toTime(52225)
```

```response title=Response theme={null}
14:30:25
```

<div id="toTime64">
  ## toTime64
</div>

Introducido en: v25.6.0

Convierte un valor de entrada al tipo [Time64](/es/reference/data-types/time64).
Admite la conversión desde String, FixedString, DateTime64 o tipos numéricos que representan microsegundos transcurridos desde la medianoche.
Proporciona precisión de microsegundos para los valores de tiempo.

**Sintaxis**

```sql theme={null}
toTime64(x)
```

**Argumentos**

* `x` — Valor de entrada que se debe convertir. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring) o [`DateTime64`](/es/reference/data-types/datetime64) o [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)

**Valor devuelto**

Devuelve el valor de entrada convertido con precisión de microsegundos. [`Time64(6)`](/es/reference/data-types/time64)

**Ejemplos**

**Conversión de String a Time64**

```sql title=Query theme={null}
SELECT toTime64('14:30:25.123456')
```

```response title=Response theme={null}
14:30:25.123456
```

**Conversión de DateTime64 a 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
```

**Conversión de enteros a Time64**

```sql title=Query theme={null}
SELECT toTime64(52225123456)
```

```response title=Response theme={null}
14:30:25.123456
```

<div id="toTime64OrNull">
  ## toTime64OrNull
</div>

Introducido en: v25.6.0

Convierte un valor de entrada en un valor de tipo `Time64`, pero devuelve `NULL` en caso de error.
Es como [`toTime64`](#toTime64), pero devuelve `NULL` en lugar de lanzar una excepción cuando se producen errores de conversión.

Véase también:

* [`toTime64`](#toTime64)
* [`toTime64OrZero`](#toTime64OrZero)

**Sintaxis**

```sql theme={null}
toTime64OrNull(x)
```

**Argumentos**

* `x` — Una representación textual de una hora con precisión de subsegundos. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor Time64 si la conversión se realiza correctamente; de lo contrario, `NULL`. [`Time64`](/es/reference/data-types/time64) o [`NULL`](/es/reference/syntax#null)

**Ejemplos**

**Ejemplo 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 │                      ᴺᵁᴸᴸ │
└────────────────────────────────┴───────────────────────────┘
```

<div id="toTime64OrZero">
  ## toTime64OrZero
</div>

Introducido en: v25.6.0

Convierte un valor de entrada a un valor de tipo Time64, pero devuelve `00:00:00.000` en caso de error.
Al igual que [`toTime64`](#toTime64), pero devuelve `00:00:00.000` en lugar de lanzar una excepción ante errores de conversión.

**Sintaxis**

```sql theme={null}
toTime64OrZero(x)
```

**Argumentos**

* `x` — Una representación textual de una hora con precisión de fracciones de segundo. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor Time64 si la operación se realiza correctamente; de lo contrario, `00:00:00.000`. [`Time64`](/es/reference/data-types/time64)

**Ejemplos**

**Ejemplo 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 │
└────────────────────────────────┴──────────────────────────┘
```

<div id="toTimeOrNull">
  ## toTimeOrNull
</div>

Introducido en: v1.1.0

Convierte un valor de entrada en un valor de tipo Time, pero devuelve `NULL` en caso de error.
Al igual que [`toTime`](#toTime), pero devuelve `NULL` en lugar de generar una excepción si se producen errores de conversión.

Véase también:

* [`toTime`](#toTime)
* [`toTimeOrZero`](#toTimeOrZero)

**Sintaxis**

```sql theme={null}
toTimeOrNull(x)
```

**Argumentos**

* `x` — Una representación textual de una hora. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor `Time` si la operación se realiza correctamente; de lo contrario, `NULL`. [`Time`](/es/reference/data-types/time) o [`NULL`](/es/reference/syntax#null)

**Ejemplos**

**Ejemplo 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 │                    ᴺᵁᴸᴸ │
└──────────────────────────┴─────────────────────────┘
```

<div id="toTimeOrZero">
  ## toTimeOrZero
</div>

Introducido en: v1.1.0

Convierte un valor de entrada en un valor de tipo Time, pero devuelve `00:00:00` en caso de error.
Al igual que toTime, devuelve `00:00:00` en lugar de lanzar una excepción si se producen errores de conversión.

**Sintaxis**

```sql theme={null}
toTimeOrZero(x)
```

**Argumentos**

* `x` — Una representación textual de una hora. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor `Time` si la operación se realiza correctamente; de lo contrario, `00:00:00`. [`Time`](/es/reference/data-types/time)

**Ejemplos**

**Ejemplo 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 │
└──────────────────────────┴─────────────────────────┘
```

<div id="toUInt128">
  ## toUInt128
</div>

Introducido en: v1.1.0

Convierte un valor de entrada en un valor de tipo [`UInt128`](/es/reference/functions/regular-functions/type-conversion-functions#toUInt128).
Lanza una excepción en caso de error.
La función usa redondeo hacia cero, lo que significa que trunca los dígitos fraccionarios de los números.

Argumentos admitidos:

* Valores o representaciones en cadena del tipo (U)Int\*.
* Valores del tipo Float\*.

Argumentos no admitidos:

* Representaciones en cadena de valores Float\*, incluidos `NaN` e `Inf`.
* Representaciones en cadena de valores binarios y hexadecimales; por ejemplo, `SELECT toUInt128('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de UInt128, se produce un desbordamiento o subdesbordamiento.
  Esto no se considera un error.
</Note>

Véase también:

* [`toUInt128OrZero`](#toUInt128OrZero).
* [`toUInt128OrNull`](#toUInt128OrNull).
* [`toUInt128OrDefault`](#toUInt128OrDefault).

**Sintaxis**

```sql theme={null}
toUInt128(expr)
```

**Argumentos**

* `expr` — Expresión que devuelve un número o su representación en cadena. [`Expression`](/es/reference/data-types/special-data-types/expression)

**Valor devuelto**

Devuelve un entero sin signo de 128 bits. [`UInt128`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toUInt128(128),
    toUInt128(128.8),
    toUInt128('128')
FORMAT Vertical
```

```response title=Response theme={null}
Fila 1:
──────
toUInt128(128):   128
toUInt128(128.8): 128
toUInt128('128'): 128
```

<div id="toUInt128OrDefault">
  ## toUInt128OrDefault
</div>

Introducido en: v21.11.0

Al igual que [`toUInt128`](#toUInt128), esta función convierte un valor de entrada en un valor de tipo [`UInt128`](/es/reference/data-types/int-uint), pero devuelve el valor predeterminado en caso de error.
Si no se proporciona ningún valor `default`, se devuelve `0` en caso de error.

**Sintaxis**

```sql theme={null}
toUInt128OrDefault(expr[, default])
```

**Argumentos**

* `expr` — Expresión que devuelve un número o una representación en cadena de un número. [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
* `default` — Opcional. El valor predeterminado que se devuelve si el análisis no se realiza correctamente. [`UInt128`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve un valor de tipo UInt128 si la conversión se realiza correctamente; de lo contrario, devuelve el valor predeterminado, si se proporcionó, o 0 si no. [`UInt128`](/es/reference/data-types/int-uint)

**Ejemplos**

**Conversión correcta**

```sql title=Query theme={null}
SELECT toUInt128OrDefault('128', CAST('0', 'UInt128'))
```

```response title=Response theme={null}
128
```

**Conversión fallida**

```sql title=Query theme={null}
SELECT toUInt128OrDefault('abc', CAST('0', 'UInt128'))
```

```response title=Response theme={null}
0
```

<div id="toUInt128OrNull">
  ## toUInt128OrNull
</div>

Introducido en: v21.6.0

Al igual que [`toUInt128`](#toUInt128), esta función convierte un valor de entrada en un valor del tipo [`UInt128`](/es/reference/data-types/int-uint), pero devuelve `NULL` en caso de error.

Argumentos admitidos:

* Representaciones en cadena de (U)Int\*.

Argumentos no admitidos (devuelven `NULL`):

* Representaciones en cadena de valores Float\*, incluidos `NaN` e `Inf`.
* Representaciones en cadena de valores binarios y hexadecimales; por ejemplo, `SELECT toUInt128OrNull('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de [`UInt128`](/es/reference/data-types/int-uint), se produce un desbordamiento o subdesbordamiento del resultado.
  Esto no se considera un error.
</Note>

Véase también:

* [`toUInt128`](#toUInt128).
* [`toUInt128OrZero`](#toUInt128OrZero).
* [`toUInt128OrDefault`](#toUInt128OrDefault).

**Sintaxis**

```sql theme={null}
toUInt128OrNull(x)
```

**Argumentos**

* `x` — Una representación en cadena de un número. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor de tipo UInt128 o `NULL` si la conversión no se realiza correctamente. [`UInt128`](/es/reference/data-types/int-uint) o [`NULL`](/es/reference/syntax#null)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toUInt128OrNull('128'),
    toUInt128OrNull('abc')
FORMAT Vertical
```

```response title=Response theme={null}
Row 1:
──────
toUInt128OrNull('128'): 128
toUInt128OrNull('abc'): \N
```

<div id="toUInt128OrZero">
  ## toUInt128OrZero
</div>

Introducido en: v1.1.0

Al igual que [`toUInt128`](#toUInt128), esta función convierte un valor de entrada en un valor de tipo [`UInt128`](/es/reference/data-types/int-uint), pero devuelve `0` en caso de error.

Argumentos admitidos:

* Representaciones en cadena de (U)Int\*.

Argumentos no admitidos (devuelven `0`):

* Representaciones en cadena de valores Float\*, incluidos `NaN` e `Inf`.
* Representaciones en cadena de valores binarios y hexadecimales; por ejemplo, `SELECT toUInt128OrZero('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de [`UInt128`](/es/reference/data-types/int-uint), se produce desbordamiento o subdesbordamiento en el resultado.
  Esto no se considera un error.
</Note>

Véase también:

* [`toUInt128`](#toUInt128).
* [`toUInt128OrNull`](#toUInt128OrNull).
* [`toUInt128OrDefault`](#toUInt128OrDefault).

**Sintaxis**

```sql theme={null}
toUInt128OrZero(x)
```

**Argumentos**

* `x` — La representación textual de un número. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor de tipo UInt128; en caso contrario, `0` si la conversión falla. [`UInt128`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toUInt128OrZero('128'),
    toUInt128OrZero('abc')
FORMAT Vertical
```

```response title=Response theme={null}
Row 1:
──────
toUInt128OrZero('128'): 128
toUInt128OrZero('abc'): 0
```

<div id="toUInt16">
  ## toUInt16
</div>

Introducido en: v1.1.0

Convierte un valor de entrada en un valor de tipo [`UInt16`](/es/reference/data-types/int-uint).
Lanza una excepción en caso de error.

Argumentos admitidos:

* Valores o representaciones en cadena de tipo (U)Int\*.
* Valores de tipo Float\*.

Argumentos no admitidos:

* Representaciones en cadena de valores Float\*, incluidos `NaN` e `Inf`.
* Representaciones en cadena de valores binarios y hexadecimales; por ejemplo, `SELECT toUInt16('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de [`UInt16`](/es/reference/data-types/int-uint), se produce un desbordamiento o subdesbordamiento en el resultado.
  Esto no se considera un error.
  Por ejemplo: `SELECT toUInt16(65536) == 0;`.
</Note>

<Note>
  La función usa [redondeo hacia cero](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), lo que significa que trunca los dígitos fraccionarios de los números.
</Note>

Véase también:

* [`toUInt16OrZero`](#toUInt16OrZero).
* [`toUInt16OrNull`](#toUInt16OrNull).
* [`toUInt16OrDefault`](#toUInt16OrDefault).

**Sintaxis**

```sql theme={null}
toUInt16(expr)
```

**Argumentos**

* `expr` — Expresión que devuelve un número o una representación textual de un número. [`Expression`](/es/reference/data-types/special-data-types/expression)

**Valor devuelto**

Devuelve un valor entero sin signo de 16 bits. [`UInt16`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toUInt16(16),
    toUInt16(16.16),
    toUInt16('16')
FORMAT Vertical
```

```response title=Response theme={null}
Fila 1:
──────
toUInt16(16):    16
toUInt16(16.16): 16
toUInt16('16'):  16
```

<div id="toUInt16OrDefault">
  ## toUInt16OrDefault
</div>

Introducido en: v21.11.0

Al igual que [`toUInt16`](#toUInt16), esta función convierte un valor de entrada en un valor de tipo [UInt16](/es/reference/data-types/int-uint), pero devuelve el valor por defecto en caso de error.
Si no se proporciona ningún valor `default`, se devuelve `0` en caso de error.

**Sintaxis**

```sql theme={null}
toUInt16OrDefault(expr[, default])
```

**Argumentos**

* `expr` — Expresión que devuelve un número o su representación en cadena. [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
* `default` — Opcional. El valor predeterminado que se devuelve si el análisis no se realiza correctamente. [`UInt16`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve un valor de tipo UInt16 si la conversión se realiza correctamente; en caso contrario, devuelve el valor predeterminado, si se proporcionó, o 0 si no. [`UInt16`](/es/reference/data-types/int-uint)

**Ejemplos**

**Conversión correcta**

```sql title=Query theme={null}
SELECT toUInt16OrDefault('16', CAST('0', 'UInt16'))
```

```response title=Response theme={null}
16
```

**Conversión fallida**

```sql title=Query theme={null}
SELECT toUInt16OrDefault('abc', CAST('0', 'UInt16'))
```

```response title=Response theme={null}
0
```

<div id="toUInt16OrNull">
  ## toUInt16OrNull
</div>

Introducido en: v1.1.0

Al igual que [`toUInt16`](#toUInt16), esta función convierte un valor de entrada en un valor de tipo [`UInt16`](/es/reference/data-types/int-uint), pero devuelve `NULL` en caso de error.

Argumentos admitidos:

* Representaciones de cadena de (U)Int8/16/32/128/256.

Argumentos no admitidos (devuelven `NULL`):

* Representaciones de cadena de valores Float\*, incluidos `NaN` e `Inf`.
* Representaciones de cadena de valores binarios y hexadecimales; por ejemplo, `SELECT toUInt16OrNull('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de [`UInt16`](/es/reference/data-types/int-uint), se produce un desbordamiento o subdesbordamiento del resultado.
  Esto no se considera un error.
</Note>

Véase también:

* [`toUInt16`](#toUInt16).
* [`toUInt16OrZero`](#toUInt16OrZero).
* [`toUInt16OrDefault`](#toUInt16OrDefault).

**Sintaxis**

```sql theme={null}
toUInt16OrNull(x)
```

**Argumentos**

* `x` — Una representación en cadena de un número. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor de tipo `UInt16`; en caso contrario, `NULL` si la conversión no se realiza correctamente. [`UInt16`](/es/reference/data-types/int-uint) o [`NULL`](/es/reference/syntax#null)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toUInt16OrNull('16'),
    toUInt16OrNull('abc')
FORMAT Vertical
```

```response title=Response theme={null}
Row 1:
──────
toUInt16OrNull('16'):  16
toUInt16OrNull('abc'): \N
```

<div id="toUInt16OrZero">
  ## toUInt16OrZero
</div>

Introducido en: v1.1.0

Al igual que [`toUInt16`](#toUInt16), esta función convierte un valor de entrada en un valor de tipo [`UInt16`](/es/reference/data-types/int-uint), pero devuelve `0` en caso de error.

Argumentos admitidos:

* Representaciones en cadena de (U)Int8/16/32/128/256.

Argumentos no admitidos (devuelven `0`):

* Representaciones en cadena de valores Float\*, incluidos `NaN` e `Inf`.
* Representaciones en cadena de valores binarios y hexadecimales; por ejemplo, `SELECT toUInt16OrZero('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de [`UInt16`](/es/reference/data-types/int-uint), se produce desbordamiento o subdesbordamiento en el resultado.
  Esto no se considera un error.
</Note>

Véase también:

* [`toUInt16`](#toUInt16).
* [`toUInt16OrNull`](#toUInt16OrNull).
* [`toUInt16OrDefault`](#toUInt16OrDefault).

**Sintaxis**

```sql theme={null}
toUInt16OrZero(x)
```

**Argumentos**

* `x` — La representación en cadena de un número. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor de tipo UInt16; en caso contrario, `0` si la conversión no se realiza correctamente. [`UInt16`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toUInt16OrZero('16'),
    toUInt16OrZero('abc')
FORMAT Vertical
```

```response title=Response theme={null}
Row 1:
──────
toUInt16OrZero('16'):  16
toUInt16OrZero('abc'): 0
```

<div id="toUInt256">
  ## toUInt256
</div>

Introducido en: v1.1.0

Convierte un valor de entrada a un valor de tipo UInt256.
Lanza una excepción en caso de error.
La función utiliza redondeo hacia cero, lo que significa que trunca los dígitos fraccionarios de los números.

Argumentos admitidos:

* Valores o representaciones en cadena de tipo (U)Int\*.
* Valores de tipo Float\*.

Argumentos no admitidos:

* Representaciones en cadena de valores de tipo Float\*, incluidos `NaN` e `Inf`.
* Representaciones en cadena de valores binarios y hexadecimales; por ejemplo, `SELECT toUInt256('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de UInt256, el resultado produce desbordamiento o subdesbordamiento.
  Esto no se considera un error.
</Note>

Véase también:

* [`toUInt256OrZero`](#toUInt256OrZero).
* [`toUInt256OrNull`](#toUInt256OrNull).
* [`toUInt256OrDefault`](#toUInt256OrDefault).

**Sintaxis**

```sql theme={null}
toUInt256(expr)
```

**Argumentos**

* `expr` — Expresión que devuelve un número o la representación en cadena de un número. [`Expresión`](/es/reference/data-types/special-data-types/expression)

**Valor devuelto**

Devuelve un valor entero sin signo de 256 bits. [`UInt256`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toUInt256(256),
    toUInt256(256.256),
    toUInt256('256')
FORMAT Vertical
```

```response title=Response theme={null}
Row 1:
──────
toUInt256(256):     256
toUInt256(256.256): 256
toUInt256('256'):   256
```

<div id="toUInt256OrDefault">
  ## toUInt256OrDefault
</div>

Introducido en: v21.11.0

Al igual que [`toUInt256`](#toUInt256), esta función convierte un valor de entrada en un valor del tipo [UInt256](/es/reference/data-types/int-uint), pero devuelve el valor predeterminado en caso de error.
Si no se pasa ningún valor `default`, se devuelve `0` en caso de error.

**Sintaxis**

```sql theme={null}
toUInt256OrDefault(expr[, default])
```

**Argumentos**

* `expr` — Expresión que devuelve un número o la representación en cadena de un número. [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
* `default` — Opcional. El valor predeterminado que se devuelve si el análisis no se realiza correctamente. [`UInt256`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve un valor de tipo UInt256 si la conversión se realiza correctamente; de lo contrario, devuelve el valor predeterminado si se proporciona, o 0 en caso contrario. [`UInt256`](/es/reference/data-types/int-uint)

**Ejemplos**

**Conversión correcta**

```sql title=Query theme={null}
SELECT toUInt256OrDefault('-256', CAST('0', 'UInt256'))
```

```response title=Response theme={null}
0
```

**Error de conversión**

```sql title=Query theme={null}
SELECT toUInt256OrDefault('abc', CAST('0', 'UInt256'))
```

```response title=Response theme={null}
0
```

<div id="toUInt256OrNull">
  ## toUInt256OrNull
</div>

Introducido en: v20.8.0

Al igual que [`toUInt256`](#toUInt256), esta función convierte un valor de entrada en un valor de tipo [`UInt256`](/es/reference/data-types/int-uint), pero devuelve `NULL` en caso de error.

Argumentos admitidos:

* Representaciones de cadena de (U)Int\*.

Argumentos no admitidos (devuelven `NULL`):

* Representaciones de cadena de valores Float\*, incluidos `NaN` e `Inf`.
* Representaciones de cadena de valores binarios y hexadecimales; por ejemplo, `SELECT toUInt256OrNull('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de [`UInt256`](/es/reference/data-types/int-uint), se produce un desbordamiento o un subdesbordamiento del resultado.
  Esto no se considera un error.
</Note>

Véase también:

* [`toUInt256`](#toUInt256).
* [`toUInt256OrZero`](#toUInt256OrZero).
* [`toUInt256OrDefault`](#toUInt256OrDefault).

**Sintaxis**

```sql theme={null}
toUInt256OrNull(x)
```

**Argumentos**

* `x` — La representación en cadena de un número. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor de tipo UInt256 o `NULL` si la conversión no se realiza correctamente. [`UInt256`](/es/reference/data-types/int-uint) o [`NULL`](/es/reference/syntax#null)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toUInt256OrNull('256'),
    toUInt256OrNull('abc')
FORMAT Vertical
```

```response title=Response theme={null}
Row 1:
──────
toUInt256OrNull('256'): 256
toUInt256OrNull('abc'): \N
```

<div id="toUInt256OrZero">
  ## toUInt256OrZero
</div>

Introducido en: v20.8.0

Al igual que [`toUInt256`](#toUInt256), esta función convierte un valor de entrada en un valor del tipo [`UInt256`](/es/reference/data-types/int-uint), pero devuelve `0` en caso de error.

Argumentos admitidos:

* Representaciones en cadena de (U)Int\*.

Argumentos no admitidos (devuelven `0`):

* Representaciones en cadena de valores Float\*, incluidos `NaN` e `Inf`.
* Representaciones en cadena de valores binarios y hexadecimales, por ejemplo, `SELECT toUInt256OrZero('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de [`UInt256`](/es/reference/data-types/int-uint), se produce un desbordamiento o subdesbordamiento del resultado.
  Esto no se considera un error.
</Note>

Véase también:

* [`toUInt256`](#toUInt256).
* [`toUInt256OrNull`](#toUInt256OrNull).
* [`toUInt256OrDefault`](#toUInt256OrDefault).

**Sintaxis**

```sql theme={null}
toUInt256OrZero(x)
```

**Argumentos**

* `x` — La representación en cadena de un número. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor de tipo UInt256; de lo contrario, `0` si la conversión no se realiza correctamente. [`UInt256`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toUInt256OrZero('256'),
    toUInt256OrZero('abc')
FORMAT Vertical
```

```response title=Response theme={null}
Row 1:
──────
toUInt256OrZero('256'): 256
toUInt256OrZero('abc'): 0
```

<div id="toUInt32">
  ## toUInt32
</div>

Introducido en: v1.1.0

Convierte un valor de entrada en un valor de tipo [`UInt32`](/es/reference/data-types/int-uint).
Lanza una excepción en caso de error.

Argumentos admitidos:

* Valores o representaciones en cadena del tipo (U)Int\*.
* Valores del tipo Float\*.

Argumentos no admitidos:

* Representaciones en cadena de valores Float\*, incluidos `NaN` e `Inf`.
* Representaciones en cadena de valores binarios y hexadecimales; por ejemplo, `SELECT toUInt32('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de [`UInt32`](/es/reference/data-types/int-uint), el resultado produce desbordamiento o subdesbordamiento.
  Esto no se considera un error.
  Por ejemplo: `SELECT toUInt32(4294967296) == 0;`
</Note>

<Note>
  La función usa [redondeo hacia cero](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), lo que significa que trunca los dígitos fraccionarios de los números.
</Note>

Véase también:

* [`toUInt32OrZero`](#toUInt32OrZero).
* [`toUInt32OrNull`](#toUInt32OrNull).
* [`toUInt32OrDefault`](#toUInt32OrDefault).

**Sintaxis**

```sql theme={null}
toUInt32(expr)
```

**Argumentos**

* `expr` — Expresión que devuelve un número o la representación en cadena de un número. [`Expresión`](/es/reference/data-types/special-data-types/expression)

**Valor devuelto**

Devuelve un valor entero sin signo de 32 bits. [`UInt32`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toUInt32(32),
    toUInt32(32.32),
    toUInt32('32')
FORMAT Vertical
```

```response title=Response theme={null}
Fila 1:
──────
toUInt32(32):    32
toUInt32(32.32): 32
toUInt32('32'):  32
```

<div id="toUInt32OrDefault">
  ## toUInt32OrDefault
</div>

Introducido en: v21.11.0

Al igual que [`toUInt32`](#toUInt32), esta función convierte un valor de entrada en un valor del tipo [UInt32](/es/reference/data-types/int-uint), pero devuelve el valor predeterminado en caso de error.
Si no se pasa ningún valor `default`, se devuelve `0` en caso de error.

**Sintaxis**

```sql theme={null}
toUInt32OrDefault(expr[, default])
```

**Argumentos**

* `expr` — Expresión que devuelve un número o una representación en cadena de caracteres de un número. [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
* `default` — Opcional. El valor predeterminado que se devuelve si el análisis falla. [`UInt32`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve un valor de tipo UInt32 si la conversión se realiza con éxito; de lo contrario, devuelve el valor predeterminado si se proporciona, o 0 en caso contrario. [`UInt32`](/es/reference/data-types/int-uint)

**Ejemplos**

**Conversión exitosa**

```sql title=Query theme={null}
SELECT toUInt32OrDefault('32', CAST('0', 'UInt32'))
```

```response title=Response theme={null}
32
```

**Conversión fallida**

```sql title=Query theme={null}
SELECT toUInt32OrDefault('abc', CAST('0', 'UInt32'))
```

```response title=Response theme={null}
0
```

<div id="toUInt32OrNull">
  ## toUInt32OrNull
</div>

Introducido en: v1.1.0

Al igual que [`toUInt32`](#toUInt32), esta función convierte un valor de entrada en un valor de tipo [`UInt32`](/es/reference/data-types/int-uint), pero devuelve `NULL` en caso de error.

Argumentos admitidos:

* Representaciones en cadena de (U)Int8/16/32/128/256.

Argumentos no admitidos (devuelven `NULL`):

* Representaciones en cadena de valores Float\*, incluidos `NaN` e `Inf`.
* Representaciones en cadena de valores binarios y hexadecimales; por ejemplo, `SELECT toUInt32OrNull('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de [`UInt32`](/es/reference/data-types/int-uint), se produce un desbordamiento o subdesbordamiento en el resultado.
  Esto no se considera un error.
</Note>

Véase también:

* [`toUInt32`](#toUInt32).
* [`toUInt32OrZero`](#toUInt32OrZero).
* [`toUInt32OrDefault`](#toUInt32OrDefault).

**Sintaxis**

```sql theme={null}
toUInt32OrNull(x)
```

**Argumentos**

* `x` — La representación en cadena de un número. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor de tipo `UInt32` o `NULL` si la conversión no se realiza correctamente. [`UInt32`](/es/reference/data-types/int-uint) o [`NULL`](/es/reference/syntax#null)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toUInt32OrNull('32'),
    toUInt32OrNull('abc')
FORMAT Vertical
```

```response title=Response theme={null}
Row 1:
──────
toUInt32OrNull('32'):  32
toUInt32OrNull('abc'): \N
```

<div id="toUInt32OrZero">
  ## toUInt32OrZero
</div>

Introducido en: v1.1.0

Al igual que [`toUInt32`](#toUInt32), esta función convierte un valor de entrada en un valor del tipo [`UInt32`](/es/reference/data-types/int-uint), pero devuelve `0` en caso de error.

Argumentos admitidos:

* Representaciones en cadena de (U)Int8/16/32/128/256.

Argumentos no admitidos (devuelven `0`):

* Representaciones en cadena de valores Float\*, incluidos `NaN` e `Inf`.
* Representaciones en cadena de valores binarios y hexadecimales; por ejemplo, `SELECT toUInt32OrZero('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de [`UInt32`](/es/reference/data-types/int-uint), el resultado puede producir desbordamiento o subdesbordamiento.
  Esto no se considera un error.
</Note>

Véase también:

* [`toUInt32`](#toUInt32).
* [`toUInt32OrNull`](#toUInt32OrNull).
* [`toUInt32OrDefault`](#toUInt32OrDefault).

**Sintaxis**

```sql theme={null}
toUInt32OrZero(x)
```

**Argumentos**

* `x` — Una representación en cadena de un número. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor de tipo UInt32 o `0` si la conversión no se realiza correctamente. [`UInt32`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toUInt32OrZero('32'),
    toUInt32OrZero('abc')
FORMAT Vertical
```

```response title=Response theme={null}
Row 1:
──────
toUInt32OrZero('32'):  32
toUInt32OrZero('abc'): 0
```

<div id="toUInt64">
  ## toUInt64
</div>

Introducido en: v1.1.0

Convierte un valor de entrada en un valor de tipo [`UInt64`](/es/reference/data-types/int-uint).
Lanza una excepción en caso de error.

Argumentos admitidos:

* Valores o representaciones en cadena del tipo (U)Int\*.
* Valores del tipo Float\*.

Tipos no admitidos:

* Representaciones en cadena de valores Float\*, incluidos `NaN` e `Inf`.
* Representaciones en cadena de valores binarios y hexadecimales; por ejemplo, `SELECT toUInt64('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de [`UInt64`](/es/reference/data-types/int-uint), el resultado produce un desbordamiento o subdesbordamiento.
  Esto no se considera un error.
  Por ejemplo: `SELECT toUInt64(18446744073709551616) == 0;`
</Note>

<Note>
  La función usa [redondeo hacia cero](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), lo que significa que trunca los dígitos fraccionarios de los números.
</Note>

Véase también:

* [`toUInt64OrZero`](#toUInt64OrZero).
* [`toUInt64OrNull`](#toUInt64OrNull).
* [`toUInt64OrDefault`](#toUInt64OrDefault).

**Sintaxis**

```sql theme={null}
toUInt64(expr)
```

**Argumentos**

* `expr` — Expresión que devuelve un número o la representación textual de un número. [`Expresión`](/es/reference/data-types/special-data-types/expression)

**Valor devuelto**

Devuelve un valor entero sin signo de 64 bits. [`UInt64`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toUInt64(64),
    toUInt64(64.64),
    toUInt64('64')
FORMAT Vertical
```

```response title=Response theme={null}
Fila 1:
──────
toUInt64(64):    64
toUInt64(64.64): 64
toUInt64('64'):  64
```

<div id="toUInt64OrDefault">
  ## toUInt64OrDefault
</div>

Introducido en: v21.11.0

Al igual que [`toUInt64`](#toUInt64), esta función convierte un valor de entrada en un valor del tipo [UInt64](/es/reference/data-types/int-uint), pero devuelve el valor predeterminado en caso de error.
Si no se pasa ningún valor `default`, se devuelve `0` en caso de error.

**Sintaxis**

```sql theme={null}
toUInt64OrDefault(expr[, default])
```

**Argumentos**

* `expr` — Expresión que devuelve un número o una representación en cadena de un número. [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
* `default` — Opcional. El valor predeterminado que se devolverá si el análisis sintáctico no se completa correctamente. [`UInt64`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve un valor de tipo UInt64 si la conversión se realiza correctamente; en caso contrario, devuelve el valor predeterminado si se proporciona, o 0 si no. [`UInt64`](/es/reference/data-types/int-uint)

**Ejemplos**

**Conversión correcta**

```sql title=Query theme={null}
SELECT toUInt64OrDefault('64', CAST('0', 'UInt64'))
```

```response title=Response theme={null}
64
```

**Error de conversión**

```sql title=Query theme={null}
SELECT toUInt64OrDefault('abc', CAST('0', 'UInt64'))
```

```response title=Response theme={null}
0
```

<div id="toUInt64OrNull">
  ## toUInt64OrNull
</div>

Introducido en: v1.1.0

Al igual que [`toUInt64`](#toUInt64), esta función convierte un valor de entrada en un valor de tipo [`UInt64`](/es/reference/data-types/int-uint), pero devuelve `NULL` en caso de error.

Argumentos admitidos:

* Representaciones en cadena de (U)Int\*.

Argumentos no admitidos (devuelven `NULL`):

* Representaciones en cadena de valores Float\*, incluidos `NaN` e `Inf`.
* Representaciones en cadena de valores binarios y hexadecimales; por ejemplo, `SELECT toUInt64OrNull('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de [`UInt64`](/es/reference/data-types/int-uint), se produce un desbordamiento o subdesbordamiento del resultado.
  Esto no se considera un error.
</Note>

Véase también:

* [`toUInt64`](#toUInt64).
* [`toUInt64OrZero`](#toUInt64OrZero).
* [`toUInt64OrDefault`](#toUInt64OrDefault).

**Sintaxis**

```sql theme={null}
toUInt64OrNull(x)
```

**Argumentos**

* `x` — Una representación textual de un número. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor de tipo UInt64 o `NULL` si la conversión no se realiza correctamente. [`UInt64`](/es/reference/data-types/int-uint) o [`NULL`](/es/reference/syntax#null)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toUInt64OrNull('64'),
    toUInt64OrNull('abc')
FORMAT Vertical
```

```response title=Response theme={null}
Row 1:
──────
toUInt64OrNull('64'):  64
toUInt64OrNull('abc'): \N
```

<div id="toUInt64OrZero">
  ## toUInt64OrZero
</div>

Introducido en: v1.1.0

Al igual que [`toUInt64`](#toUInt64), esta función convierte un valor de entrada en un valor de tipo [`UInt64`](/es/reference/data-types/int-uint), pero devuelve `0` en caso de error.

Argumentos admitidos:

* Representaciones de cadena de (U)Int\*.

Argumentos no admitidos (devuelven `0`):

* Representaciones de cadena de valores Float\*, incluidos `NaN` e `Inf`.
* Representaciones de cadena de valores binarios y hexadecimales; por ejemplo, `SELECT toUInt64OrZero('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de [`UInt64`](/es/reference/data-types/int-uint), se produce un desbordamiento o subdesbordamiento del resultado.
  Esto no se considera un error.
</Note>

Véase también:

* [`toUInt64`](#toUInt64).
* [`toUInt64OrNull`](#toUInt64OrNull).
* [`toUInt64OrDefault`](#toUInt64OrDefault).

**Sintaxis**

```sql theme={null}
toUInt64OrZero(x)
```

**Argumentos**

* `x` — La representación en String de un número. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor de tipo UInt64 o, si la conversión falla, `0`. [`UInt64`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toUInt64OrZero('64'),
    toUInt64OrZero('abc')
FORMAT Vertical
```

```response title=Response theme={null}
Row 1:
──────
toUInt64OrZero('64'):  64
toUInt64OrZero('abc'): 0
```

<div id="toUInt8">
  ## toUInt8
</div>

Introducido en: v1.1.0

Convierte un valor de entrada a un valor de tipo [`UInt8`](/es/reference/data-types/int-uint).
Lanza una excepción en caso de error.

Argumentos admitidos:

* Valores o representaciones de cadena del tipo (U)Int\*.
* Valores del tipo Float\*.

Argumentos no admitidos:

* Representaciones de cadena de valores Float\*, incluidos `NaN` e `Inf`.
* Representaciones de cadena de valores binarios y hexadecimales; por ejemplo, `SELECT toUInt8('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de [UInt8](/es/reference/data-types/int-uint), se produce un desbordamiento o subdesbordamiento en el resultado.
  Esto no se considera un error.
  Por ejemplo: `SELECT toUInt8(256) == 0;`.
</Note>

<Note>
  La función usa [redondeo hacia cero](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), lo que significa que trunca los dígitos fraccionarios de los números.
</Note>

Véase también:

* [`toUInt8OrZero`](#toUInt8OrZero).
* [`toUInt8OrNull`](#toUInt8OrNull).
* [`toUInt8OrDefault`](#toUInt8OrDefault).

**Sintaxis**

```sql theme={null}
toUInt8(expr)
```

**Argumentos**

* `expr` — Expresión que devuelve un número o su representación textual. [`Expresión`](/es/reference/data-types/special-data-types/expression)

**Valor devuelto**

Devuelve un valor entero sin signo de 8 bits. [`UInt8`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toUInt8(8),
    toUInt8(8.8),
    toUInt8('8')
FORMAT Vertical
```

```response title=Response theme={null}
Row 1:
──────
toUInt8(8):   8
toUInt8(8.8): 8
toUInt8('8'): 8
```

<div id="toUInt8OrDefault">
  ## toUInt8OrDefault
</div>

Introducido en: v21.11.0

Al igual que [`toUInt8`](#toUInt8), esta función convierte un valor de entrada en un valor del tipo [UInt8](/es/reference/data-types/int-uint), pero devuelve el valor predeterminado en caso de que se produzca un error.
Si no se proporciona ningún valor `default`, se devuelve `0` en caso de error.

**Sintaxis**

```sql theme={null}
toUInt8OrDefault(expr[, default])
```

**Argumentos**

* `expr` — Expresión que devuelve un número o la representación en cadena de un número. [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
* `default` — Opcional. El valor predeterminado que se devuelve si el análisis no se realiza correctamente. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve un valor de tipo UInt8 si la conversión se realiza correctamente; de lo contrario, devuelve el valor predeterminado si se proporciona, o 0 si no. [`UInt8`](/es/reference/data-types/int-uint)

**Ejemplos**

**Conversión exitosa**

```sql title=Query theme={null}
SELECT toUInt8OrDefault('8', CAST('0', 'UInt8'))
```

```response title=Response theme={null}
8
```

**Error de conversión**

```sql title=Query theme={null}
SELECT toUInt8OrDefault('abc', CAST('0', 'UInt8'))
```

```response title=Response theme={null}
0
```

<div id="toUInt8OrNull">
  ## toUInt8OrNull
</div>

Introducido en: v1.1.0

Al igual que [`toUInt8`](#toUInt8), esta función convierte un valor de entrada a un valor del tipo [`UInt8`](/es/reference/data-types/int-uint), pero devuelve `NULL` en caso de error.

Argumentos admitidos:

* Representaciones de cadena de (U)Int8/16/32/128/256.

Argumentos no admitidos (devuelven `NULL`):

* Representaciones de cadena de valores Float\* normales, incluidos `NaN` e `Inf`.
* Representaciones de cadena de valores binarios y hexadecimales; por ejemplo, `SELECT toUInt8OrNull('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de [`UInt8`](/es/reference/data-types/int-uint), se produce desbordamiento o subdesbordamiento en el resultado.
  Esto no se considera un error.
</Note>

Véase también:

* [`toUInt8`](#toUInt8).
* [`toUInt8OrZero`](#toUInt8OrZero).
* [`toUInt8OrDefault`](#toUInt8OrDefault).

**Sintaxis**

```sql theme={null}
toUInt8OrNull(x)
```

**Argumentos**

* `x` — Una representación en cadena de un número. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor de tipo UInt8, o `NULL` si la conversión no se realiza correctamente. [`UInt8`](/es/reference/data-types/int-uint) o [`NULL`](/es/reference/syntax#null)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toUInt8OrNull('42'),
    toUInt8OrNull('abc')
FORMAT Vertical
```

```response title=Response theme={null}
Row 1:
──────
toUInt8OrNull('42'):  42
toUInt8OrNull('abc'): \N
```

<div id="toUInt8OrZero">
  ## toUInt8OrZero
</div>

Introducido en: v1.1.0

Al igual que [`toUInt8`](#toUInt8), esta función convierte un valor de entrada en un valor de tipo [`UInt8`](/es/reference/data-types/int-uint), pero devuelve `0` en caso de error.

Argumentos admitidos:

* Representaciones en cadena de (U)Int8/16/32/128/256.

Argumentos no admitidos (devuelve `0`):

* Representaciones en cadena de valores Float\* normales, incluidos `NaN` e `Inf`.
* Representaciones en cadena de valores binarios y hexadecimales; por ejemplo, `SELECT toUInt8OrZero('0xc0fe');`.

<Note>
  Si el valor de entrada no puede representarse dentro de los límites de [`UInt8`](/es/reference/data-types/int-uint), se produce desbordamiento o subdesbordamiento en el resultado.
  Esto no se considera un error.
</Note>

Véase también:

* [`toUInt8`](#toUInt8).
* [`toUInt8OrNull`](#toUInt8OrNull).
* [`toUInt8OrDefault`](#toUInt8OrDefault).

**Sintaxis**

```sql theme={null}
toUInt8OrZero(x)
```

**Argumentos**

* `x` — La representación en cadena de un número. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor de tipo UInt8; en caso contrario, `0` si la conversión no se realiza correctamente. [`UInt8`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    toUInt8OrZero('-8'),
    toUInt8OrZero('abc')
FORMAT Vertical
```

```response title=Response theme={null}
Row 1:
──────
toUInt8OrZero('-8'):  0
toUInt8OrZero('abc'): 0
```

<div id="toUUID">
  ## toUUID
</div>

Introducido en: v1.1.0

Convierte un valor de tipo String en un valor UUID.

**Sintaxis**

```sql theme={null}
toUUID(string)
```

**Argumentos**

* `string` — UUID como cadena. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)

**Valor devuelto**

Devuelve un UUID a partir de la representación en cadena del UUID. [`UUID`](/es/reference/data-types/uuid)

**Ejemplos**

**Ejemplo 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 │
└──────────────────────────────────────┘
```

<div id="toUUIDOrZero">
  ## toUUIDOrZero
</div>

Introducido en: v20.12.0

Convierte un valor de entrada en un valor de tipo [UUID](/es/reference/data-types/uuid), pero devuelve un UUID con ceros en caso de error.
Al igual que [`toUUID`](/es/reference/functions/regular-functions/type-conversion-functions#toUUID), pero devuelve un UUID con ceros (`00000000-0000-0000-0000-000000000000`) en lugar de generar una excepción cuando se producen errores de conversión.

Argumentos admitidos:

* Representaciones de UUID en cadena en formato estándar (8-4-4-4-12 dígitos hexadecimales).
* Representaciones de UUID en cadena sin guiones (32 dígitos hexadecimales).

Argumentos no admitidos (devuelven un UUID con ceros):

* Formatos de cadena no válidos.
* Tipos que no son cadenas.

**Sintaxis**

```sql theme={null}
toUUIDOrZero(x)
```

**Argumentos**

* `x` — Una representación textual de un UUID. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve un valor UUID si la operación se realiza correctamente; en caso contrario, un UUID con valor cero (`00000000-0000-0000-0000-000000000000`). [`UUID`](/es/reference/data-types/uuid)

**Ejemplos**

**Ejemplo 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 │
└──────────────────────────────────────┴──────────────────────────────────────┘
```

<div id="toUnixTimestamp64Micro">
  ## toUnixTimestamp64Micro
</div>

Introducido en: v20.5.0

Convierte un [`DateTime64`](/es/reference/data-types/datetime64) en un valor [`Int64`](/es/reference/data-types/int-uint) con precisión fija de microsegundos.
El valor de entrada se ajusta al alza o a la baja según corresponda, en función de su precisión.

<Note>
  El valor de salida es relativo a UTC, no a la zona horaria del valor de entrada.
</Note>

**Sintaxis**

```sql theme={null}
toUnixTimestamp64Micro(value)
```

**Argumentos**

* `value` — Valor de DateTime64 con cualquier precisión. [`DateTime64`](/es/reference/data-types/datetime64)

**Valor devuelto**

Devuelve una marca de tiempo Unix en microsegundos. [`Int64`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo 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 │
└────────────────────────────────┘
```

<div id="toUnixTimestamp64Milli">
  ## toUnixTimestamp64Milli
</div>

Introducido en: v20.5.0

Convierte un [`DateTime64`](/es/reference/data-types/datetime64) en un valor [`Int64`](/es/reference/data-types/int-uint) con precisión fija de milisegundos.
El valor de entrada se escala hacia arriba o hacia abajo según corresponda, en función de su precisión.

<Note>
  El valor de salida está referido a UTC, no a la zona horaria del valor de entrada.
</Note>

**Sintaxis**

```sql theme={null}
toUnixTimestamp64Milli(value)
```

**Argumentos**

* `value` — Valor de DateTime64 con cualquier precisión. [`DateTime64`](/es/reference/data-types/datetime64)

**Valor devuelto**

Devuelve una marca de tiempo Unix en milisegundos. [`Int64`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo 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 │
└──────────────────────────────┘
```

<div id="toUnixTimestamp64Nano">
  ## toUnixTimestamp64Nano
</div>

Introducido en: v20.5.0

Convierte un [`DateTime64`](/es/reference/data-types/datetime64) en un valor [`Int64`](/es/reference/functions/regular-functions/type-conversion-functions#toInt64) con precisión fija de nanosegundos.
El valor de entrada se escala hacia arriba o hacia abajo según corresponda, en función de su precisión.

<Note>
  El valor de salida es relativo a UTC, no a la zona horaria del valor de entrada.
</Note>

**Sintaxis**

```sql theme={null}
toUnixTimestamp64Nano(value)
```

**Argumentos**

* `value` — Valor de DateTime64 con cualquier precisión. [`DateTime64`](/es/reference/data-types/datetime64)

**Valor devuelto**

Devuelve una marca de tiempo Unix en nanosegundos. [`Int64`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo 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 │
└────────────────────────────────┘
```

<div id="toUnixTimestamp64Second">
  ## toUnixTimestamp64Second
</div>

Introducido en: v24.12.0

Convierte un [`DateTime64`](/es/reference/data-types/datetime64) en un valor [`Int64`](/es/reference/data-types/int-uint) con precisión fija de segundos.
El valor de entrada se ajusta hacia arriba o hacia abajo según corresponda, en función de su precisión.

<Note>
  El valor de salida es relativo a UTC, no a la zona horaria del valor de entrada.
</Note>

**Sintaxis**

```sql theme={null}
toUnixTimestamp64Second(value)
```

**Argumentos**

* `value` — Valor de DateTime64 con cualquier precisión. [`DateTime64`](/es/reference/data-types/datetime64)

**Valor devuelto**

Devuelve una marca de tiempo Unix en segundos. [`Int64`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo 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 │
└───────────────────────────────┘
```