> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-fix-nav-issues.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> Documentación sobre funciones para trabajar con fechas y horas
# Funciones para trabajar con fechas y horas
La mayoría de las funciones de esta sección aceptan un argumento opcional de zona horaria, por ejemplo, `Europe/Amsterdam`. En este caso, se usa la zona horaria especificada en lugar de la local (predeterminada).
**Ejemplo**
```sql theme={null}
SELECT
toDateTime('2016-06-15 23:00:00') AS time,
toDate(time) AS date_local,
toDate(time, 'Asia/Yekaterinburg') AS date_yekat,
toString(time, 'US/Samoa') AS time_samoa
```
```text theme={null}
┌────────────────time─┬─date_local─┬─date_yekat─┬─time_samoa──────────┐
│ 2016-06-15 23:00:00 │ 2016-06-15 │ 2016-06-16 │ 2016-06-15 09:00:00 │
└─────────────────────┴────────────┴────────────┴─────────────────────┘
```
Para garantizar la compatibilidad con el estándar SQL, las siguientes funciones, `NOW`, `CURRENT_TIMESTAMP`, `TODAY` y `CURRENT_DATE`, se pueden usar sin paréntesis.
{/*AUTOGENERATED_START*/}
## UTCTimestamp
Introducido en: v22.11.0
Devuelve la fecha y hora actuales en el momento del análisis de la consulta. La función es una expresión constante.
Esta función da el mismo resultado que `now('UTC')`. Se añadió únicamente por compatibilidad con MySQL. Se recomienda usar [`now`](#now).
**Sintaxis**
```sql theme={null}
UTCTimestamp()
```
**Alias**: `UTC_timestamp`
**Argumentos**
* Ninguno.
**Valor devuelto**
Devuelve la fecha y hora actuales en el momento del análisis de la consulta. [`DateTime`](/es/reference/data-types/datetime)
**Ejemplos**
**Obtener la marca de tiempo UTC actual**
```sql title=Query theme={null}
SELECT UTCTimestamp()
```
```response title=Response theme={null}
┌──────UTCTimestamp()─┐
│ 2024-05-28 08:32:09 │
└─────────────────────┘
```
## YYYYMMDDToDate
Introducido en: v23.9.0
Convierte un número que contiene el año, el mes y el día en un `Date`.
Esta función es la opuesta de la función [`toYYYYMMDD()`](/es/reference/functions/regular-functions/date-time-functions#toYYYYMMDD).
El resultado no está definido si la entrada no codifica un valor `Date` válido.
**Sintaxis**
```sql theme={null}
YYYYMMDDToDate(YYYYMMDD)
```
**Argumentos**
* `YYYYMMDD` — Número que contiene el año, el mes y el día. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
**Valor devuelto**
Devuelve un valor de tipo `Date` a partir de los argumentos proporcionados [`Date`](/es/reference/data-types/date)
**Ejemplos**
**Ejemplo**
```sql title=Query theme={null}
SELECT YYYYMMDDToDate(20230911);
```
```response title=Response theme={null}
┌─toYYYYMMDD(20230911)─┐
│ 2023-09-11 │
└──────────────────────┘
```
## YYYYMMDDToDate32
Introducido en: v23.9.0
Convierte un número que contiene el año, el mes y el día en un `Date32`.
Esta función es la opuesta de la función [`toYYYYMMDD()`](/es/reference/functions/regular-functions/date-time-functions#toYYYYMMDD).
La salida no está definida si la entrada no codifica un valor `Date32` válido.
**Sintaxis**
```sql theme={null}
YYYYMMDDToDate32(YYYYMMDD)
```
**Argumentos**
* `YYYYMMDD` — Número que contiene el año, el mes y el día. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
**Valor devuelto**
Devuelve un valor `Date32` a partir de los argumentos proporcionados [`Date32`](/es/reference/data-types/date32)
**Ejemplos**
**Ejemplo**
```sql title=Query theme={null}
SELECT YYYYMMDDToDate32(20000507);
```
```response title=Response theme={null}
┌─YYYYMMDDToDate32(20000507)─┐
│ 2000-05-07 │
└────────────────────────────┘
```
## YYYYMMDDhhmmssToDateTime
Introducido en: v23.9.0
Convierte un número que contiene el año, el mes, el día, la hora, el minuto y el segundo en un `DateTime`.
Esta función es la opuesta de la función [`toYYYYMMDDhhmmss()`](/es/reference/functions/regular-functions/date-time-functions#toYYYYMMDDhhmmss).
La salida no está definida si la entrada no codifica un valor `DateTime` válido.
**Sintaxis**
```sql theme={null}
YYYYMMDDhhmmssToDateTime(YYYYMMDDhhmmss[, timezone])
```
**Argumentos**
* `YYYYMMDDhhmmss` — Número que contiene el año, mes, día, hora, minuto y segundo. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
* `timezone` — Nombre de la zona horaria. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve un valor `DateTime` a partir de los argumentos indicados [`DateTime`](/es/reference/data-types/datetime)
**Ejemplos**
**Ejemplo**
```sql title=Query theme={null}
SELECT YYYYMMDDToDateTime(20230911131415);
```
```response title=Response theme={null}
┌──────YYYYMMDDhhmmssToDateTime(20230911131415)─┐
│ 2023-09-11 13:14:15 │
└───────────────────────────────────────────────┘
```
## YYYYMMDDhhmmssToDateTime64
Introducido en: v23.9.0
Convierte un número que contiene el año, mes, día, hora, minuto y segundo en un `DateTime64`.
Esta función es lo contrario de la función [`toYYYYMMDDhhmmss()`](/es/reference/functions/regular-functions/date-time-functions#toYYYYMMDDhhmmss).
La salida no está definida si la entrada no codifica un valor `DateTime64` válido.
**Sintaxis**
```sql theme={null}
YYYYMMDDhhmmssToDateTime64(YYYYMMDDhhmmss[, precision[, timezone]])
```
**Argumentos**
* `YYYYMMDDhhmmss` — Número que contiene el año, el mes, el día, la hora, el minuto y el segundo. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
* `precision` — Precisión de la parte fraccionaria (0-9). [`UInt8`](/es/reference/data-types/int-uint)
* `timezone` — Nombre de la zona horaria. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve un valor `DateTime64` a partir de los argumentos proporcionados [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Ejemplo**
```sql title=Query theme={null}
SELECT YYYYMMDDhhmmssToDateTime64(20230911131415, 3, 'Asia/Istanbul');
```
```response title=Response theme={null}
┌─YYYYMMDDhhmm⋯/Istanbul')─┐
│ 2023-09-11 13:14:15.000 │
└──────────────────────────┘
```
## addDate
Introducido en: v23.9.0
Añade el intervalo de tiempo a la fecha, fecha con hora, o fecha o fecha con hora codificada como cadena proporcionada.
Si la suma da como resultado un valor fuera de los límites del tipo de dato, el resultado es indefinido.
**Sintaxis**
```sql theme={null}
addDate(datetime, interval)
```
**Argumentos**
* `datetime` — La fecha o fecha con hora a la que se suma `interval`. [`Date`](/es/reference/data-types/date) or [`Date32`](/es/reference/data-types/date32) or [`DateTime`](/es/reference/data-types/datetime) or [`DateTime64`](/es/reference/data-types/datetime64) or [`String`](/es/reference/data-types/string)
* `interval` — Intervalo que se va a sumar. [`Interval`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve la fecha o fecha con hora que se obtiene al sumar `interval` a `datetime`. [`Date`](/es/reference/data-types/date) or [`Date32`](/es/reference/data-types/date32) or [`DateTime`](/es/reference/data-types/datetime) or [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Añadir un intervalo a una fecha**
```sql title=Query theme={null}
SELECT addDate(toDate('2018-01-01'), INTERVAL 3 YEAR)
```
```response title=Response theme={null}
┌─addDate(toDa⋯valYear(3))─┐
│ 2021-01-01 │
└──────────────────────────┘
```
## addDays
Introducido en: v1.1.0
Añade un número determinado de días a una fecha, una fecha con hora o una fecha o fecha con hora codificada como cadena.
**Sintaxis**
```sql theme={null}
addDays(datetime, num)
```
**Argumentos**
* `datetime` — Fecha o fecha con hora a la que se debe sumar el número especificado de días. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64) o [`String`](/es/reference/data-types/string)
* `num` — Número de días que se deben sumar. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
**Valor devuelto**
Devuelve `datetime` más `num` días. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Añadir días a distintos tipos de fecha**
```sql title=Query theme={null}
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addDays(date, 5) AS add_days_with_date,
addDays(date_time, 5) AS add_days_with_date_time,
addDays(date_time_string, 5) AS add_days_with_date_time_string
```
```response title=Response theme={null}
┌─add_days_with_date─┬─add_days_with_date_time─┬─add_days_with_date_time_string─┐
│ 2024-01-06 │ 2024-01-06 00:00:00 │ 2024-01-06 00:00:00.000 │
└────────────────────┴─────────────────────────┴────────────────────────────────┘
```
**Uso de la sintaxis alternativa de INTERVAL**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 day)
```
```response title=Response theme={null}
┌─plus(CAST('1⋯valDay(10))─┐
│ 1998-06-26 │
└──────────────────────────┘
```
## addHours
Introducido en: v1.1.0
Añade un número determinado de horas a una fecha, una fecha con hora o una fecha o fecha con hora codificada como cadena.
**Sintaxis**
```sql theme={null}
addHours(datetime, num)
```
**Argumentos**
* `datetime` — Fecha o fecha con hora a la que se añadirá el número especificado de horas. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64) o [`String`](/es/reference/data-types/string)
* `num` — Número de horas que se añadirán. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
**Valor devuelto**
Devuelve `datetime` más `num` horas [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64(3)`](/es/reference/data-types/datetime64)
**Ejemplos**
**Añadir horas a distintos tipos de fecha**
```sql title=Query theme={null}
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addHours(date, 12) AS add_hours_with_date,
addHours(date_time, 12) AS add_hours_with_date_time,
addHours(date_time_string, 12) AS add_hours_with_date_time_string
```
```response title=Response theme={null}
┌─add_hours_with_date─┬─add_hours_with_date_time─┬─add_hours_with_date_time_string─┐
│ 2024-01-01 12:00:00 │ 2024-01-01 12:00:00 │ 2024-01-01 12:00:00.000 │
└─────────────────────┴──────────────────────────┴─────────────────────────────────┘
```
**Uso de la sintaxis alternativa de INTERVAL**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 hour)
```
```response title=Response theme={null}
┌─plus(CAST('1⋯alHour(10))─┐
│ 1998-06-16 10:00:00 │
└──────────────────────────┘
```
## addInterval
Introducido en: v22.11.0
Suma un intervalo a otro intervalo o a una tupla de intervalos.
Los intervalos del mismo tipo se combinarán en un solo intervalo. Por ejemplo, si se pasan `toIntervalDay(1)` y `toIntervalDay(2)`, el resultado será `(3)` en lugar de `(1,1)`.
**Sintaxis**
```sql theme={null}
addInterval(interval_1, interval_2)
```
**Argumentos**
* `interval_1` — Primer intervalo o tupla de intervalos. [`Interval`](/es/reference/data-types/int-uint) o [`Tuple(Interval)`](/es/reference/data-types/tuple)
* `interval_2` — Segundo intervalo que se suma. [`Interval`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve una tupla de intervalos [`Tuple(Interval)`](/es/reference/data-types/tuple)
**Ejemplos**
**Sumar intervalos**
```sql title=Query theme={null}
SELECT addInterval(INTERVAL 1 DAY, INTERVAL 1 MONTH);
SELECT addInterval((INTERVAL 1 DAY, INTERVAL 1 YEAR), INTERVAL 1 MONTH);
SELECT addInterval(INTERVAL 2 DAY, INTERVAL 1 DAY)
```
```response title=Response theme={null}
┌─addInterval(toIntervalDay(1), toIntervalMonth(1))─┐
│ (1,1) │
└───────────────────────────────────────────────────┘
┌─addInterval((toIntervalDay(1), toIntervalYear(1)), toIntervalMonth(1))─┐
│ (1,1,1) │
└────────────────────────────────────────────────────────────────────────┘
┌─addInterval(toIntervalDay(2), toIntervalDay(1))─┐
│ (3) │
└─────────────────────────────────────────────────┘
```
## addMicroseconds
Introducido en: v22.6.0
Añade un número especificado de microsegundos a una fecha y hora o a una fecha y hora codificada como cadena.
**Sintaxis**
```sql theme={null}
addMicroseconds(datetime, num)
```
**Argumentos**
* `datetime` — Fecha con hora a la que se añadirá el número especificado de microsegundos. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64) o [`String`](/es/reference/data-types/string)
* `num` — Número de microsegundos que se añadirán. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
**Valor devuelto**
Devuelve `date_time` más `num` microsegundos [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Añadir microsegundos a distintos tipos de fecha con hora**
```sql title=Query theme={null}
WITH
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addMicroseconds(date_time, 1000000) AS add_microseconds_with_date_time,
addMicroseconds(date_time_string, 1000000) AS add_microseconds_with_date_time_string
```
```response title=Response theme={null}
┌─add_microseconds_with_date_time─┬─add_microseconds_with_date_time_string─┐
│ 2024-01-01 00:00:01.000000 │ 2024-01-01 00:00:01.000000 │
└─────────────────────────────────┴────────────────────────────────────────┘
```
**Uso de la sintaxis alternativa de INTERVAL**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::DateTime, INTERVAL 10 microsecond)
```
```response title=Response theme={null}
┌─plus(CAST('19⋯osecond(10))─┐
│ 1998-06-16 00:00:00.000010 │
└────────────────────────────┘
```
## addMilliseconds
Introducido en: v22.6.0
Añade una cantidad especificada de milisegundos a una fecha con hora o a una fecha con hora codificada como cadena.
**Sintaxis**
```sql theme={null}
addMilliseconds(datetime, num)
```
**Argumentos**
* `datetime` — Fecha con hora a la que se añadirá el número especificado de milisegundos. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64) o [`String`](/es/reference/data-types/string)
* `num` — Número de milisegundos que se añadirán. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
**Valor devuelto**
Devuelve `datetime` con `num` milisegundos añadidos [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Añadir milisegundos a distintos tipos de fecha y hora**
```sql title=Query theme={null}
WITH
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addMilliseconds(date_time, 1000) AS add_milliseconds_with_date_time,
addMilliseconds(date_time_string, 1000) AS add_milliseconds_with_date_time_string
```
```response title=Response theme={null}
┌─add_milliseconds_with_date_time─┬─add_milliseconds_with_date_time_string─┐
│ 2024-01-01 00:00:01.000 │ 2024-01-01 00:00:01.000 │
└─────────────────────────────────┴────────────────────────────────────────┘
```
**Uso de la sintaxis alternativa de INTERVAL**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::DateTime, INTERVAL 10 millisecond)
```
```response title=Response theme={null}
┌─plus(CAST('1⋯second(10))─┐
│ 1998-06-16 00:00:00.010 │
└──────────────────────────┘
```
## addMinutes
Introducido en: v1.1.0
Añade un número determinado de minutos a una fecha, una fecha con hora o una fecha o fecha con hora codificada como cadena.
**Sintaxis**
```sql theme={null}
addMinutes(datetime, num)
```
**Argumentos**
* `datetime` — Fecha o fecha con hora a la que se añadirá el número especificado de minutos. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64) o [`String`](/es/reference/data-types/string)
* `num` — Número de minutos que se añadirán. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
**Valor devuelto**
Devuelve `datetime` más `num` minutos. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64(3)`](/es/reference/data-types/datetime64)
**Ejemplos**
**Añadir minutos a distintos tipos de fecha**
```sql title=Query theme={null}
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addMinutes(date, 20) AS add_minutes_with_date,
addMinutes(date_time, 20) AS add_minutes_with_date_time,
addMinutes(date_time_string, 20) AS add_minutes_with_date_time_string
```
```response title=Response theme={null}
┌─add_minutes_with_date─┬─add_minutes_with_date_time─┬─add_minutes_with_date_time_string─┐
│ 2024-01-01 00:20:00 │ 2024-01-01 00:20:00 │ 2024-01-01 00:20:00.000 │
└───────────────────────┴────────────────────────────┴───────────────────────────────────┘
```
**Uso de una sintaxis alternativa de INTERVAL**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 minute)
```
```response title=Response theme={null}
┌─plus(CAST('1⋯Minute(10))─┐
│ 1998-06-16 00:10:00 │
└──────────────────────────┘
```
## addMonths
Introducido en: v1.1.0
Añade una cantidad determinada de meses a una fecha, una fecha con hora o una fecha o fecha con hora codificada como cadena.
**Sintaxis**
```sql theme={null}
addMonths(datetime, num)
```
**Argumentos**
* `datetime` — Fecha o fecha con hora a la que se añadirá el número de meses especificado. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64) o [`String`](/es/reference/data-types/string)
* `num` — Número de meses que se añadirán. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
**Valor devuelto**
Devuelve `datetime` con `num` meses añadidos [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Añadir meses a distintos tipos de fecha**
```sql title=Query theme={null}
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addMonths(date, 6) AS add_months_with_date,
addMonths(date_time, 6) AS add_months_with_date_time,
addMonths(date_time_string, 6) AS add_months_with_date_time_string
```
```response title=Response theme={null}
┌─add_months_with_date─┬─add_months_with_date_time─┬─add_months_with_date_time_string─┐
│ 2024-07-01 │ 2024-07-01 00:00:00 │ 2024-07-01 00:00:00.000 │
└──────────────────────┴───────────────────────────┴──────────────────────────────────┘
```
**Uso de la sintaxis alternativa de INTERVAL**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 month)
```
```response title=Response theme={null}
┌─plus(CAST('1⋯lMonth(10))─┐
│ 1999-04-16 │
└──────────────────────────┘
```
## addNanoseconds
Introducido en: v22.6.0
Añade una cantidad especificada de nanosegundos a una fecha con hora o a una fecha con hora codificada como cadena.
**Sintaxis**
```sql theme={null}
addNanoseconds(datetime, num)
```
**Argumentos**
* `datetime` — Fecha con hora a la que se sumará el número especificado de nanosegundos. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64) o [`String`](/es/reference/data-types/string)
* `num` — Número de nanosegundos que se sumarán. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
**Valor devuelto**
Devuelve `datetime` más `num` nanosegundos [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Sumar nanosegundos a distintos tipos de fecha y hora**
```sql title=Query theme={null}
WITH
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addNanoseconds(date_time, 1000) AS add_nanoseconds_with_date_time,
addNanoseconds(date_time_string, 1000) AS add_nanoseconds_with_date_time_string
```
```response title=Response theme={null}
┌─add_nanoseconds_with_date_time─┬─add_nanoseconds_with_date_time_string─┐
│ 2024-01-01 00:00:00.000001000 │ 2024-01-01 00:00:00.000001000 │
└────────────────────────────────┴───────────────────────────────────────┘
```
**Uso de una sintaxis alternativa para INTERVAL**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::DateTime, INTERVAL 1000 nanosecond)
```
```response title=Response theme={null}
┌─plus(CAST('199⋯osecond(1000))─┐
│ 1998-06-16 00:00:00.000001000 │
└───────────────────────────────┘
```
## addQuarters
Introducido en: v20.1.0
Añade un número especificado de trimestres a una fecha, una fecha con hora o una fecha o fecha con hora codificada como cadena.
**Sintaxis**
```sql theme={null}
addQuarters(datetime, num)
```
**Argumentos**
* `datetime` — Fecha o fecha con hora a la que se añadirá el número especificado de trimestres. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64) o [`String`](/es/reference/data-types/string)
* `num` — Número de trimestres que se añadirán. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
**Valor devuelto**
Devuelve `datetime` más `num` trimestres. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Añadir trimestres a distintos tipos de fecha**
```sql title=Query theme={null}
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addQuarters(date, 1) AS add_quarters_with_date,
addQuarters(date_time, 1) AS add_quarters_with_date_time,
addQuarters(date_time_string, 1) AS add_quarters_with_date_time_string
```
```response title=Response theme={null}
┌─add_quarters_with_date─┬─add_quarters_with_date_time─┬─add_quarters_with_date_time_string─┐
│ 2024-04-01 │ 2024-04-01 00:00:00 │ 2024-04-01 00:00:00.000 │
└────────────────────────┴─────────────────────────────┴────────────────────────────────────┘
```
**Uso de la sintaxis alternativa de INTERVAL**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 quarter)
```
```response title=Response theme={null}
┌─plus(CAST('1⋯uarter(10))─┐
│ 2000-12-16 │
└──────────────────────────┘
```
## addSeconds
Introducido en: v1.1.0
Añade un número especificado de segundos a una fecha, una fecha con hora, o una fecha o fecha con hora codificada como cadena.
**Sintaxis**
```sql theme={null}
addSeconds(datetime, num)
```
**Argumentos**
* `datetime` — Fecha o fecha con hora a la que se añadirá el número especificado de segundos. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64) o [`String`](/es/reference/data-types/string)
* `num` — Número de segundos que se van a añadir. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
**Valor devuelto**
Devuelve `datetime` más `num` segundos [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64(3)`](/es/reference/data-types/datetime64)
**Ejemplos**
**Añadir segundos a distintos tipos de fecha**
```sql title=Query theme={null}
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addSeconds(date, 30) AS add_seconds_with_date,
addSeconds(date_time, 30) AS add_seconds_with_date_time,
addSeconds(date_time_string, 30) AS add_seconds_with_date_time_string
```
```response title=Response theme={null}
┌─add_seconds_with_date─┬─add_seconds_with_date_time─┬─add_seconds_with_date_time_string─┐
│ 2024-01-01 00:00:30 │ 2024-01-01 00:00:30 │ 2024-01-01 00:00:30.000 │
└───────────────────────┴────────────────────────────┴───────────────────────────────────┘
```
**Uso de la sintaxis alternativa de INTERVAL**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 second)
```
```response title=Response theme={null}
┌─dateAdd('1998-06-16'::Date, INTERVAL 10 second)─┐
│ 1998-06-16 00:00:10 │
└─────────────────────────────────────────────────┘
```
## addTupleOfIntervals
Introducido en: v22.11.0
Añade de forma consecutiva una tupla de intervalos a una fecha o a una fecha y hora.
**Sintaxis**
```sql theme={null}
addTupleOfIntervals(datetime, intervals)
```
**Argumentos**
* `datetime` — Fecha o fecha con hora a la que se añaden intervalos. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `intervals` — Tupla de intervalos que se añaden a `datetime`. [`Tuple(Interval)`](/es/reference/data-types/tuple)
**Valor devuelto**
Devuelve `date` con `intervals` añadidos. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Añadir una tupla de intervalos a una fecha**
```sql title=Query theme={null}
WITH toDate('2018-01-01') AS date
SELECT addTupleOfIntervals(date, (INTERVAL 1 DAY, INTERVAL 1 MONTH, INTERVAL 1 YEAR))
```
```response title=Response theme={null}
┌─addTupleOfIntervals(date, (toIntervalDay(1), toIntervalMonth(1), toIntervalYear(1)))─┐
│ 2019-02-02 │
└──────────────────────────────────────────────────────────────────────────────────────┘
```
## addWeeks
Introducido en: v1.1.0
Añade un número especificado de semanas a una fecha, una fecha con hora o una fecha o fecha con hora codificada como cadena.
**Sintaxis**
```sql theme={null}
addWeeks(datetime, num)
```
**Argumentos**
* `datetime` — Fecha o fecha con hora a la que se añade el número especificado de semanas. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64) o [`String`](/es/reference/data-types/string)
* `num` — Número de semanas que se añaden. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
**Valor devuelto**
Devuelve `datetime` más `num` semanas [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Añadir semanas a distintos tipos de fecha**
```sql title=Query theme={null}
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addWeeks(date, 5) AS add_weeks_with_date,
addWeeks(date_time, 5) AS add_weeks_with_date_time,
addWeeks(date_time_string, 5) AS add_weeks_with_date_time_string
```
```response title=Response theme={null}
┌─add_weeks_with_date─┬─add_weeks_with_date_time─┬─add_weeks_with_date_time_string─┐
│ 2024-02-05 │ 2024-02-05 00:00:00 │ 2024-02-05 00:00:00.000 │
└─────────────────────┴──────────────────────────┴─────────────────────────────────┘
```
**Uso de una sintaxis alternativa de INTERVAL**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 week)
```
```response title=Response theme={null}
┌─plus(CAST('1⋯alWeek(10))─┐
│ 1998-08-25 │
└──────────────────────────┘
```
## addYears
Introducido en: v1.1.0
Añade un número determinado de años a una fecha, una fecha con hora o una fecha o fecha con hora codificada como cadena.
**Sintaxis**
```sql theme={null}
addYears(datetime, num)
```
**Argumentos**
* `datetime` — Fecha o fecha con hora a la que se añadirá el número de años especificado. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64) o [`String`](/es/reference/data-types/string)
* `num` — Número de años que se va a añadir. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
**Valor devuelto**
Devuelve `datetime` más `num` años. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Añadir años a distintos tipos de fecha**
```sql title=Query theme={null}
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addYears(date, 1) AS add_years_with_date,
addYears(date_time, 1) AS add_years_with_date_time,
addYears(date_time_string, 1) AS add_years_with_date_time_string
```
```response title=Response theme={null}
┌─add_years_with_date─┬─add_years_with_date_time─┬─add_years_with_date_time_string─┐
│ 2025-01-01 │ 2025-01-01 00:00:00 │ 2025-01-01 00:00:00.000 │
└─────────────────────┴──────────────────────────┴─────────────────────────────────┘
```
**Uso de la sintaxis alternativa de INTERVAL**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 year)
```
```response title=Response theme={null}
┌─plus(CAST('1⋯alYear(10))─┐
│ 2008-06-16 │
└──────────────────────────┘
```
## age
Introducido en: v23.1.0
Devuelve el componente de la unidad de la diferencia entre `startdate` y `enddate`.
La diferencia se calcula con una precisión de 1 nanosegundo.
Por ejemplo, la diferencia entre 2021-12-29 y 2022-01-01 es de 3 días para la unidad de día,
0 meses para la unidad de mes y 0 años para la unidad de año.
Para ver una alternativa a age, consulte la función [`dateDiff`](#dateDiff).
**Sintaxis**
```sql theme={null}
age('unit', startdate, enddate[, timezone])
```
**Argumentos**
* `unit` — El tipo de intervalo del resultado.
| Unidad | Posibles valores |
| ----------- | ---------------------------------------- |
| nanosecond | `nanosecond`, `nanoseconds`, `ns` |
| microsecond | `microsecond`, `microseconds`, `us`, `u` |
| millisecond | `millisecond`, `milliseconds`, `ms` |
| second | `second`, `seconds`, `ss`, `s` |
| minute | `minute`, `minutes`, `mi`, `n` |
| hour | `hour`, `hours`, `hh`, `h` |
| day | `day`, `days`, `dd`, `d` |
| week | `week`, `weeks`, `wk`, `ww` |
| month | `month`, `months`, `mm`, `m` |
| quarter | `quarter`, `quarters`, `qq`, `q` |
| year | `year`, `years`, `yyyy`, `yy` |
* `startdate` — El primer valor temporal que se resta (el sustraendo). [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `enddate` — El segundo valor temporal del que se resta (el minuendo). [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `timezone` — Opcional. Nombre de la zona horaria. Si se especifica, se aplica tanto a startdate como a enddate. Si no se especifica, se usan las zonas horarias de startdate y enddate. Si no coinciden, el resultado no está definido. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve la diferencia entre enddate y startdate expresada en unit. [`Int32`](/es/reference/data-types/int-uint)
**Ejemplos**
**Calcular la edad en horas**
```sql title=Query theme={null}
SELECT age('hour', toDateTime('2018-01-01 22:30:00'), toDateTime('2018-01-02 23:00:00'))
```
```response title=Response theme={null}
┌─age('hour', toDateTime('2018-01-01 22:30:00'), toDateTime('2018-01-02 23:00:00'))─┐
│ 24 │
└───────────────────────────────────────────────────────────────────────────────────┘
```
**Calcular la edad en distintas unidades**
```sql title=Query theme={null}
SELECT
toDate('2022-01-01') AS e,
toDate('2021-12-29') AS s,
age('day', s, e) AS day_age,
age('month', s, e) AS month_age,
age('year', s, e) AS year_age
```
```response title=Response theme={null}
┌──────────e─┬──────────s─┬─day_age─┬─month_age─┬─year_age─┐
│ 2022-01-01 │ 2021-12-29 │ 3 │ 0 │ 0 │
└────────────┴────────────┴─────────┴───────────┴──────────┘
```
## changeDay
Introducido en: v24.7.0
Cambia el componente de día de una fecha o de una fecha y hora.
**Sintaxis**
```sql theme={null}
changeDay(date_or_datetime, value)
```
**Argumentos**
* `date_or_datetime` — El valor que se debe cambiar. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `value` — El valor nuevo. [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve un valor del mismo tipo que `date_or_datetime`, con el componente de día modificado. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT changeDay('2024-01-31'::DateTime, 15)
```
```response title=Response theme={null}
2024-01-15 00:00:00
```
## changeHour
Introducido en: v24.7.0
Cambia el componente de hora de una fecha o fecha y hora.
**Sintaxis**
```sql theme={null}
changeHour(date_or_datetime, value)
```
**Argumentos**
* `date_or_datetime` — El valor que se va a modificar. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `value` — El nuevo valor. [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve un valor del mismo tipo que `date_or_datetime`, con el componente de hora modificado. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT changeHour('2024-01-01 12:00:00'::DateTime, 5)
```
```response title=Response theme={null}
2024-01-01 05:00:00
```
## changeMinute
Introducido en: v24.7.0
Cambia el componente de minutos de una `fecha o fecha y hora`.
**Sintaxis**
```sql theme={null}
changeMinute(date_or_datetime, value)
```
**Argumentos**
* `date_or_datetime` — El valor que se va a modificar. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `value` — El nuevo valor. [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve un valor del mismo tipo que `date_or_datetime`, con el componente de minutos modificado. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT changeMinute('2024-01-01 12:30:00'::DateTime, 45)
```
```response title=Response theme={null}
2024-01-01 12:45:00
```
## changeMonth
Introducido en: v24.7.0
Modifica el componente de mes de una fecha o de una fecha y hora.
**Sintaxis**
```sql theme={null}
changeMonth(date_or_datetime, value)
```
**Argumentos**
* `date_or_datetime` — El valor a cambiar. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `value` — El nuevo valor. [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve un valor del mismo tipo que `date_or_datetime`, con el componente de mes modificado. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT changeMonth('2024-01-01'::DateTime, 12)
```
```response title=Response theme={null}
2024-12-01 00:00:00
```
## changeSecond
Introducido en: v24.7.0
Cambia el componente de segundos de una fecha o de una fecha y hora.
**Sintaxis**
```sql theme={null}
changeSecond(date_or_datetime, value)
```
**Argumentos**
* `date_or_datetime` — El valor que se modificará. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `value` — El nuevo valor. [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve un valor del mismo tipo que `date_or_datetime`, con el componente de segundos modificado. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT changeSecond('2024-01-01 12:30:45'::DateTime, 15)
```
```response title=Response theme={null}
2024-01-01 12:30:15
```
## changeYear
Introducido en: v24.7.0
Cambia el componente de año de una fecha o de una fecha y hora.
**Sintaxis**
```sql theme={null}
changeYear(date_or_datetime, value)
```
**Argumentos**
* `date_or_datetime` — El valor a cambiar. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `value` — El nuevo valor. [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve un valor del mismo tipo que `date_or_datetime` con el componente de año modificado. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT changeYear('2024-01-01'::DateTime, 2023)
```
```response title=Response theme={null}
2023-01-01 00:00:00
```
## dateDiff
Introducido en: v23.4.0
Devuelve la cantidad de límites de la `unit` especificada que se cruzan entre `startdate` y `enddate`.
La diferencia se calcula mediante unidades relativas. Por ejemplo, la diferencia entre 2021-12-29 y 2022-01-01 es de 3 días para la unidad day
(consulte [`toRelativeDayNum`](#toRelativeDayNum)), 1 mes para la unidad month (consulte [`toRelativeMonthNum`](#toRelativeMonthNum)) y 1 año para la unidad year
(consulte [`toRelativeYearNum`](#toRelativeYearNum)).
Si se especifica la unidad `week`, `dateDiff` asume que las semanas comienzan en lunes.
Tenga en cuenta que este comportamiento es diferente del de la función `toWeek()`, en la que las semanas comienzan de forma predeterminada en domingo.
Como alternativa a `dateDiff`, consulte la función [`age`](#age).
**Sintaxis**
```sql theme={null}
dateDiff(unit, startdate, enddate[, timezone])
```
**Alias**: `timestampDiff`, `TIMESTAMP_DIFF`, `DATE_DIFF`, `date_diff`, `timestamp_diff`
**Argumentos**
* `unit` — El tipo de intervalo del resultado.
| Unidad | Posibles valores |
| ------------ | ---------------------------------------- |
| nanosegundo | `nanosecond`, `nanoseconds`, `ns` |
| microsegundo | `microsecond`, `microseconds`, `us`, `u` |
| milisegundo | `millisecond`, `milliseconds`, `ms` |
| segundo | `second`, `seconds`, `ss`, `s` |
| minuto | `minute`, `minutes`, `mi`, `n` |
| hora | `hour`, `hours`, `hh`, `h` |
| día | `day`, `days`, `dd`, `d` |
| semana | `week`, `weeks`, `wk`, `ww` |
| mes | `month`, `months`, `mm`, `m` |
| trimestre | `quarter`, `quarters`, `qq`, `q` |
| año | `year`, `years`, `yyyy`, `yy` |
* `startdate` — El primer valor de tiempo que se resta (el sustraendo). [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `enddate` — El segundo valor de tiempo del que se resta (el minuendo). [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `timezone` — Opcional. Nombre de la zona horaria. Si se especifica, se aplica tanto a `startdate` como a `enddate`. Si no se especifica, se usan las zonas horarias de `startdate` y `enddate`. Si no coinciden, el resultado no está definido. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve la diferencia entre `enddate` y `startdate` expresada en `unit`. [`Int64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Calcular la diferencia entre fechas en horas**
```sql title=Query theme={null}
SELECT dateDiff('hour', toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00')) AS res
```
```response title=Response theme={null}
┌─res─┐
│ 25 │
└─────┘
```
**Calcular la diferencia entre fechas en distintas unidades**
```sql title=Query theme={null}
SELECT
toDate('2022-01-01') AS e,
toDate('2021-12-29') AS s,
dateDiff('day', s, e) AS day_diff,
dateDiff('month', s, e) AS month_diff,
dateDiff('year', s, e) AS year_diff
```
```response title=Response theme={null}
┌──────────e─┬──────────s─┬─day_diff─┬─month_diff─┬─year_diff─┐
│ 2022-01-01 │ 2021-12-29 │ 3 │ 1 │ 1 │
└────────────┴────────────┴──────────┴────────────┴───────────┘
```
## dateName
Introducido en: v21.7.0
Devuelve la parte especificada de una fecha.
Valores posibles:
* 'year'
* 'quarter'
* 'month'
* 'week'
* 'dayofyear'
* 'day'
* 'weekday'
* 'hour'
* 'minute'
* 'second'
**Sintaxis**
```sql theme={null}
dateName(date_part, date[, timezone])
```
**Argumentos**
* `date_part` — La parte de la fecha que desea extraer. [`String`](/es/reference/data-types/string)
* `datetime` — Un valor de fecha o de fecha con hora. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `timezone` — Opcional. Zona horaria. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve la parte especificada de la fecha. [`String`](/es/reference/data-types/string)
**Ejemplos**
**Extraer distintas partes de la fecha**
```sql title=Query theme={null}
WITH toDateTime('2021-04-14 11:22:33') AS date_value
SELECT
dateName('year', date_value),
dateName('month', date_value),
dateName('day', date_value)
```
```response title=Response theme={null}
┌─dateName('year', date_value)─┬─dateName('month', date_value)─┬─dateName('day', date_value)─┐
│ 2021 │ April │ 14 │
└──────────────────────────────┴───────────────────────────────┴─────────────────────────────┘
```
## dateTrunc
Introducido en: v20.8.0
Trunca un valor de fecha y hora según la parte de la fecha especificada.
**Sintaxis**
```sql theme={null}
dateTrunc(unit, datetime[, timezone])
```
**Alias**: `DATE_TRUNC`
**Argumentos**
* `unit` —
El tipo de intervalo al que se trunca el resultado. Valores posibles: `nanosecond` (solo DateTime64), `microsecond` (solo DateTime64), `millisecond` (solo DateTime64), `second`, `minute`, `hour`, `day`, `week`, `month`, `quarter`, `year`.
[`String`](/es/reference/data-types/string)
* `datetime` — Fecha y hora. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `timezone` — Opcional. Nombre de la zona horaria del valor `datetime` devuelto. Si no se especifica, la función usa la zona horaria del parámetro `datetime`. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve el valor de fecha y hora truncado.
| Argumento `unit` | Argumento `datetime` | Tipo de retorno |
| --------------------------- | --------------------------------------------- | ----------------------------------------------------------------------------------------------------- |
| Año, Trimestre, Mes, Semana | `Date32` o `DateTime64` o `Date` o `DateTime` | [`Date32`](/es/reference/data-types/date32) o [`Date`](/es/reference/data-types/date) |
| Día, Hora, Minuto, Segundo | `Date32`, `DateTime64`, `Date` o `DateTime` | [`DateTime64`](/es/reference/data-types/datetime64) o [`DateTime`](/es/reference/data-types/datetime) |
| Milisegundo, Microsegundo, | Cualquiera | [`DateTime64`](/es/reference/data-types/datetime64) |
| Nanosegundo | | con escala 3, 6 o 9 |
**Ejemplos**
**Truncar sin zona horaria**
```sql title=Query theme={null}
SELECT now(), dateTrunc('hour', now());
```
```response title=Response theme={null}
┌───────────────now()─┬─dateTrunc('hour', now())──┐
│ 2020-09-28 10:40:45 │ 2020-09-28 10:00:00 │
└─────────────────────┴───────────────────────────┘
```
**Truncar con la zona horaria especificada**
```sql title=Query theme={null}
SELECT now(), dateTrunc('hour', now(), 'Asia/Istanbul');
```
```response title=Response theme={null}
┌───────────────now()─┬─dateTrunc('hour', now(), 'Asia/Istanbul')──┐
│ 2020-09-28 10:46:26 │ 2020-09-28 13:00:00 │
└─────────────────────┴────────────────────────────────────────────┘
```
## formatDateTime
Introducido en: v1.1.0
Da formato a una fecha o fecha con hora según la cadena de formato especificada. `format` es una expresión constante, por lo que no puede haber varios formatos para una misma columna de resultado.
`formatDateTime` usa el estilo de formato de fecha y hora de MySQL; consulta la [documentación de MySQL](https://dev.mysql.com/doc/refman/8.0/en/date-and-time-functions.html#function_date-format).
La operación opuesta de esta función es [`parseDateTime`](/es/reference/functions/regular-functions/type-conversion-functions#parseDateTime).
Mediante campos de reemplazo, puedes definir un patrón para la cadena resultante.
La columna de ejemplo de la tabla siguiente muestra el resultado del formateo para `2018-01-02 22:33:44`.
**Campos de reemplazo:**
| Marcador de posición | Descripción | Ejemplo |
| -------------------- | --------------------------------------------------------------- | ---------- |
| %a | nombre abreviado del día de la semana (Mon-Sun) | Mon |
| %b | nombre abreviado del mes (Jan-Dec) | Jan |
| %c | mes como número entero (01-12) | 01 |
| %C | año dividido entre 100 y truncado a entero (00-99) | 20 |
| %d | día del mes, rellenado con ceros (01-31) | 02 |
| %D | fecha corta MM/DD/YY, equivalente a %m/%d/%y | 01/02/18 |
| %e | día del mes, rellenado con espacios (1-31) | 2 |
| %f | fracción de segundo | 123456 |
| %F | fecha corta YYYY-MM-DD, equivalente a %Y-%m-%d | 2018-01-02 |
| %g | formato de año de dos dígitos, alineado con ISO 8601 | 18 |
| %G | formato de año de cuatro dígitos para el número de semana ISO | 2018 |
| %h | hora en formato de 12 h (01-12) | 09 |
| %H | hora en formato de 24 h (00-23) | 22 |
| %i | minuto (00-59) | 33 |
| %I | hora en formato de 12 h (01-12) | 10 |
| %j | día del año (001-366) | 002 |
| %k | hora en formato de 24 h (00-23) | 14 |
| %l | hora en formato de 12 h (01-12) | 09 |
| %m | mes como número entero (01-12) | 01 |
| %M | nombre completo del mes (January-December) | January |
| %n | carácter de nueva línea | |
| %p | indicador AM o PM | PM |
| %Q | trimestre (1-4) | 1 |
| %r | hora en formato de 12 horas HH:MM AM/PM, equivalente a %h:%i %p | 10:30 PM |
| %R | hora en formato de 24 horas HH:MM, equivalente a %H:%i | 22:33 |
| %s | segundo (00-59) | 44 |
| %S | segundo (00-59) | 44 |
| %t | carácter de tabulación horizontal | |
| %T | formato de hora ISO 8601 (HH:MM:SS), equivalente a %H:%i:%S | 22:33:44 |
| %u | día de la semana ISO 8601 como número, con Monday como 1 (1-7) | 2 |
| %V | número de semana ISO 8601 (01-53) | 01 |
| %w | día de la semana como número entero, con Sunday como 0 (0-6) | 2 |
| %W | nombre completo del día de la semana (Monday-Sunday) | Monday |
| %y | año, dos últimos dígitos (00-99) | 18 |
| %Y | año | 2018 |
| %z | desfase horario respecto a UTC como +HHMM o -HHMM | -0500 |
| %% | un signo % | % |
* En versiones de ClickHouse anteriores a v23.4, `%f` imprime un único cero (0) si el valor formateado es un Date, Date32 o DateTime (que no tienen fracciones de segundo) o un DateTime64 con una precisión de 0.
* En versiones de ClickHouse anteriores a v25.1, `%f` imprime tantos dígitos como especifique la escala de DateTime64 en lugar de 6 dígitos fijos.
* En versiones de ClickHouse anteriores a v23.4, `%M` imprime el minuto (00-59) en lugar del nombre completo del mes (January-December).
**Sintaxis**
```sql theme={null}
formatDateTime(datetime, format[, timezone])
```
**Alias**: `DATE_FORMAT`
**Argumentos**
* `datetime` — Una fecha o una fecha y hora para formatear. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `format` — Cadena de formato con campos de reemplazo. [`String`](/es/reference/data-types/string)
* `timezone` — Opcional. Nombre de la zona horaria para la hora formateada. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve valores de fecha y hora según el formato especificado. [`String`](/es/reference/data-types/string)
**Ejemplos**
**Formatear una fecha con el marcador de posición del año**
```sql title=Query theme={null}
SELECT formatDateTime(toDate('2010-01-04'), '%g')
```
```response title=Response theme={null}
┌─formatDateTime(toDate('2010-01-04'), '%g')─┐
│ 10 │
└────────────────────────────────────────────┘
```
**Formatear DateTime64 con fracciones de segundo**
```sql title=Query theme={null}
SELECT formatDateTime(toDateTime64('2010-01-04 12:34:56.123456', 7), '%f')
```
```response title=Response theme={null}
┌─formatDateTime(toDateTime64('2010-01-04 12:34:56.123456', 7), '%f')─┐
│ 1234560 │
└─────────────────────────────────────────────────────────────────────┘
```
**Formato con zona horaria**
```sql title=Query theme={null}
SELECT
now() AS ts,
time_zone,
formatDateTime(ts, '%T', time_zone) AS str_tz_time
FROM system.time_zones
WHERE time_zone LIKE 'Europe%'
LIMIT 10
```
```response title=Response theme={null}
┌──────────────────ts─┬─time_zone─────────┬─str_tz_time─┐
│ 2023-09-08 19:13:40 │ Europe/Amsterdam │ 21:13:40 │
│ 2023-09-08 19:13:40 │ Europe/Andorra │ 21:13:40 │
│ 2023-09-08 19:13:40 │ Europe/Astrakhan │ 23:13:40 │
│ 2023-09-08 19:13:40 │ Europe/Athens │ 22:13:40 │
│ 2023-09-08 19:13:40 │ Europe/Belfast │ 20:13:40 │
│ 2023-09-08 19:13:40 │ Europe/Belgrade │ 21:13:40 │
│ 2023-09-08 19:13:40 │ Europe/Berlin │ 21:13:40 │
│ 2023-09-08 19:13:40 │ Europe/Bratislava │ 21:13:40 │
│ 2023-09-08 19:13:40 │ Europe/Brussels │ 21:13:40 │
│ 2023-09-08 19:13:40 │ Europe/Bucharest │ 22:13:40 │
└─────────────────────┴───────────────────┴─────────────┘
```
## formatDateTimeInJodaSyntax
Introducido en: v20.1.0
Es similar a `formatDateTime`, excepto que formatea la fecha y hora con el estilo de Joda en lugar del estilo de MySQL. Consulta la [documentación de Joda Time](https://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html).
La operación opuesta de esta función es [`parseDateTimeInJodaSyntax`](/es/reference/functions/regular-functions/type-conversion-functions#parseDateTimeInJodaSyntax).
Mediante campos de reemplazo, puede definir un patrón para la cadena resultante.
**Campos de reemplazo:**
| Marcador de posición | Descripción | Presentación | Ejemplos |
| -------------------- | ------------------------------------------ | ------------ | -------------------------- |
| G | era | texto | AD |
| C | siglo de la era (>=0) | número | 20 |
| Y | año de la era (>=0) | año | 1996 |
| x | año de semana (aún no admitido) | año | 1996 |
| w | semana del año de semana (aún no admitido) | número | 27 |
| e | día de la semana | número | 2 |
| E | día de la semana | texto | Tuesday; Tue |
| y | año | año | 1996 |
| D | día del año | número | 189 |
| M | mes del año | mes | July; Jul; 07 |
| d | día del mes | número | 10 |
| a | medio día | texto | PM |
| K | hora del medio día (0\~11) | número | 0 |
| h | hora de reloj del medio día (1\~12) | número | 12 |
| H | hora del día (0\~23) | número | 0 |
| k | hora de reloj del día (1\~24) | número | 24 |
| m | minuto de la hora | número | 30 |
| s | segundo del minuto | número | 55 |
| S | fracción de segundo | número | 978 |
| z | zona horaria | texto | Eastern Standard Time; EST |
| Z | desplazamiento de la zona horaria | zona | -0800; -0812 |
| ' | escape para texto | delimitador | |
| '' | comilla simple | literal | ' |
**Sintaxis**
```sql theme={null}
formatDateTimeInJodaSyntax(datetime, format[, timezone])
```
**Argumentos**
* `datetime` — Una fecha o una fecha y hora para formatear. [`DateTime`](/es/reference/data-types/datetime) o [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime64`](/es/reference/data-types/datetime64)
* `format` — Cadena de formato con campos de sustitución de estilo Joda. [`String`](/es/reference/data-types/string)
* `timezone` — Opcional. Nombre de la zona horaria para la hora formateada. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve valores de fecha y hora según el formato especificado. [`String`](/es/reference/data-types/string)
**Ejemplos**
**Formatear datetime con sintaxis Joda**
```sql title=Query theme={null}
SELECT formatDateTimeInJodaSyntax(toDateTime('2010-01-04 12:34:56'), 'yyyy-MM-dd HH:mm:ss')
```
```response title=Response theme={null}
┌─formatDateTimeInJodaSyntax(toDateTime('2010-01-04 12:34:56'), 'yyyy-MM-dd HH:mm:ss')─┐
│ 2010-01-04 12:34:56 │
└─────────────────────────────────────────────────────────────────────────────────────────┘
```
## fromDaysSinceYearZero
Introducido en: v23.11.0
Para un número determinado de días transcurridos desde el [1 de enero de 0000](https://en.wikipedia.org/wiki/Year_zero), devuelve la fecha correspondiente en el [calendario gregoriano proléptico definido por la norma ISO 8601](https://en.wikipedia.org/wiki/Gregorian_calendar#Proleptic_Gregorian_calendar).
El cálculo es el mismo que el de la función `FROM_DAYS()` de MySQL. El resultado no está definido si no puede representarse dentro de los límites del tipo [Date](/es/reference/data-types/date).
**Sintaxis**
```sql theme={null}
fromDaysSinceYearZero(days)
```
**Alias**: `FROM_DAYS`
**Argumentos**
* `days` — La cantidad de días transcurridos desde el año cero. [`UInt32`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve la fecha correspondiente a la cantidad de días transcurridos desde el año cero. [`Date`](/es/reference/data-types/date)
**Ejemplos**
**Convertir los días transcurridos desde el año cero en fechas**
```sql title=Query theme={null}
SELECT
fromDaysSinceYearZero(739136) AS date1,
fromDaysSinceYearZero(toDaysSinceYearZero(toDate('2023-09-08'))) AS date2
```
```response title=Response theme={null}
┌──────date1─┬──────date2─┐
│ 2023-09-08 │ 2023-09-08 │
└────────────┴────────────┘
```
## fromDaysSinceYearZero32
Introducido en: v23.11.0
Para un número determinado de días transcurridos desde el [1 de enero de 0000](https://en.wikipedia.org/wiki/Year_zero), devuelve la fecha correspondiente en el [calendario gregoriano proléptico definido por ISO 8601](https://en.wikipedia.org/wiki/Gregorian_calendar#Proleptic_Gregorian_calendar).
El cálculo es el mismo que el de la función `FROM_DAYS()` de MySQL. El resultado no está definido si no puede representarse dentro de los límites del tipo [`Date32`](/es/reference/data-types/date32).
**Sintaxis**
```sql theme={null}
fromDaysSinceYearZero32(days)
```
**Argumentos**
* `days` — El número de días transcurridos desde el año cero. [`UInt32`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve la fecha correspondiente al número de días transcurridos desde el año cero. [`Date32`](/es/reference/data-types/date32)
**Ejemplos**
**Convertir días desde el año cero en fechas**
```sql title=Query theme={null}
SELECT
fromDaysSinceYearZero32(739136) AS date1,
fromDaysSinceYearZero32(toDaysSinceYearZero(toDate('2023-09-08'))) AS date2
```
```response title=Response theme={null}
┌──────date1─┬──────date2─┐
│ 2023-09-08 │ 2023-09-08 │
└────────────┴────────────┘
```
## fromModifiedJulianDay
Introducido en: v21.1.0
Convierte un número de [día juliano modificado](https://en.wikipedia.org/wiki/Julian_day#Variants) en una fecha del [calendario gregoriano proléptico](https://en.wikipedia.org/wiki/Proleptic_Gregorian_calendar) en formato de texto `YYYY-MM-DD`. Esta función admite números de día entre `-678941` y `2973483` (que representan 0000-01-01 y 9999-12-31, respectivamente). Genera una excepción si el número de día está fuera del rango admitido.
**Sintaxis**
```sql theme={null}
fromModifiedJulianDay(day)
```
**Argumentos**
* `day` — número de Día Juliano Modificado. [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve la fecha en formato de texto. [`String`](/es/reference/data-types/string)
**Ejemplos**
**Convertir un Día Juliano Modificado en fecha**
```sql title=Query theme={null}
SELECT fromModifiedJulianDay(58849)
```
```response title=Response theme={null}
┌─fromModifiedJulianDay(58849)─┐
│ 2020-01-01 │
└──────────────────────────────┘
```
## fromModifiedJulianDayOrNull
Introducido en: v21.1.0
Similar a [`fromModifiedJulianDay()`](#fromModifiedJulianDay), pero en lugar de lanzar una excepción, devuelve `NULL`.
**Sintaxis**
```sql theme={null}
fromModifiedJulianDayOrNull(day)
```
**Argumentos**
* `day` — número de día juliano modificado. [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve la fecha en formato de texto cuando el argumento `day` es válido; de lo contrario, `null`. [`Nullable(String)`](/es/reference/data-types/nullable)
**Ejemplos**
**Convertir el día juliano modificado en fecha con manejo de `null`**
```sql title=Query theme={null}
SELECT fromModifiedJulianDayOrNull(58849);
SELECT fromModifiedJulianDayOrNull(60000000); -- argumento inválido, devuelve NULL
```
```response title=Response theme={null}
┌─fromModified⋯Null(58849)─┐
│ 2020-01-01 │
└──────────────────────────┘
┌─fromModified⋯l(60000000)─┐
│ ᴺᵁᴸᴸ │
└──────────────────────────┘
```
## fromUTCTimestamp
Introducido en: v22.1.0
Convierte un valor de fecha o de fecha con hora de la zona horaria UTC en un valor de fecha o de fecha con hora con la zona horaria especificada. Esta función se incluye principalmente por compatibilidad con Apache Spark y marcos de trabajo similares.
**Sintaxis**
```sql theme={null}
fromUTCTimestamp(datetime, time_zone)
```
**Alias**: `from_utc_timestamp`
**Argumentos**
* `datetime` — Un valor constante de fecha o fecha con hora, o una expresión. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `time_zone` — Un valor constante de tipo String o una expresión que representa la zona horaria. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve un valor DateTime/DateTime64 en la zona horaria especificada. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Convierte la zona horaria UTC a la zona horaria especificada**
```sql title=Query theme={null}
SELECT fromUTCTimestamp(toDateTime64('2023-03-16 10:00:00', 3), 'Asia/Shanghai')
```
```response title=Response theme={null}
┌─fromUTCTimestamp(toDateTime64('2023-03-16 10:00:00',3), 'Asia/Shanghai')─┐
│ 2023-03-16 18:00:00.000 │
└─────────────────────────────────────────────────────────────────────────┘
```
## fromUnixTimestamp
Introducido en: v20.8.0
Esta función convierte una marca de tiempo Unix en una fecha de calendario y una hora del día.
Se puede llamar de dos maneras:
* Cuando se le proporciona un solo argumento de tipo [`Integer`](/es/reference/data-types/int-uint), devuelve un valor de tipo [`DateTime`](/es/reference/data-types/datetime), es decir, se comporta como [`toDateTime`](/es/reference/functions/regular-functions/type-conversion-functions#toDateTime).
* Cuando se le proporcionan dos o tres argumentos, donde el primer argumento es un valor de tipo [`Integer`](/es/reference/data-types/int-uint), [`Date`](/es/reference/data-types/date), [`Date32`](/es/reference/data-types/date32), [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64), el segundo argumento es una cadena de formato constante y el tercer argumento es una cadena constante de zona horaria opcional, la función devuelve un valor de tipo [`String`](/es/reference/data-types/string), es decir, se comporta como [`formatDateTime`](#formatDateTime).
En este caso, se usa el [estilo de formato de fecha y hora de MySQL](https://dev.mysql.com/doc/refman/8.0/en/date-and-time-functions.html#function_date-format).
**Sintaxis**
```sql theme={null}
fromUnixTimestamp(timestamp)
fromUnixTimestamp(timestamp[, format[, timezone]])
```
**Alias**: `FROM_UNIXTIME`
**Argumentos**
* `timestamp` — marca de tiempo Unix o valor de fecha o fecha con hora. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `format` — Opcional. Cadena de formato constante para dar formato a la salida. [`String`](/es/reference/data-types/string)
* `timezone` — Opcional. Cadena constante de zona horaria. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve un `DateTime` del timestamp cuando se llama con un argumento, o un `String` cuando se llama con dos o tres argumentos. [`DateTime`](/es/reference/data-types/datetime) o [`String`](/es/reference/data-types/string)
**Ejemplos**
**Convertir una marca de tiempo Unix a DateTime**
```sql title=Query theme={null}
SELECT fromUnixTimestamp(423543535)
```
```response title=Response theme={null}
┌─fromUnixTimestamp(423543535)─┐
│ 1983-06-04 10:58:55 │
└──────────────────────────────┘
```
**Convertir una marca de tiempo Unix con un formato**
```sql title=Query theme={null}
SELECT fromUnixTimestamp(1234334543, '%Y-%m-%d %R:%S') AS DateTime
```
```response title=Response theme={null}
┌─DateTime────────────┐
│ 2009-02-11 14:42:23 │
└─────────────────────┘
```
## fromUnixTimestampInJodaSyntax
Introducido en: v23.1.0
Esta función convierte una marca de tiempo Unix en una fecha de calendario y una hora del día.
Se puede llamar de dos maneras:
Cuando recibe un único argumento de tipo [`Integer`](/es/reference/data-types/int-uint), devuelve un valor de tipo [`DateTime`](/es/reference/data-types/datetime); es decir, se comporta como [`toDateTime`](/es/reference/functions/regular-functions/type-conversion-functions#toDateTime).
Cuando recibe dos o tres argumentos, donde el primero es un valor de tipo [`Integer`](/es/reference/data-types/int-uint), [`Date`](/es/reference/data-types/date), [`Date32`](/es/reference/data-types/date32), [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64), el segundo es una cadena de formato constante y el tercero es una cadena constante opcional de zona horaria, la función devuelve un valor de tipo [`String`](/es/reference/data-types/string); es decir, se comporta como [`formatDateTimeInJodaSyntax`](#formatDateTimeInJodaSyntax). En este caso, se utiliza el [estilo de formato de fecha y hora de Joda](https://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html).
**Sintaxis**
```sql theme={null}
fromUnixTimestampInJodaSyntax(timestamp)
fromUnixTimestampInJodaSyntax(timestamp, format[, timezone])
```
**Argumentos**
* `timestamp` — marca de tiempo Unix o valor de fecha y hora. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `format` — Opcional. Cadena de formato constante con sintaxis Joda para el formato de salida. [`String`](/es/reference/data-types/string)
* `timezone` — Opcional. Cadena constante de zona horaria. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve una fecha con hora cuando se llama con un argumento, o un String cuando se llama con dos o tres argumentos.} [`DateTime`](/es/reference/data-types/datetime) o [`String`](/es/reference/data-types/string)
**Ejemplos**
**Convertir una marca de tiempo Unix con formato Joda**
```sql title=Query theme={null}
SELECT fromUnixTimestampInJodaSyntax(1234334543, 'yyyy-MM-dd HH:mm:ss', 'UTC') AS DateTime
```
```response title=Response theme={null}
┌─DateTime────────────┐
│ 2009-02-11 06:42:23 │
└─────────────────────┘
```
## makeDate
Introducido en: v22.6.0
Crea un `Date` a partir de:
* un año, un mes y un día
* un año y el día del año
**Sintaxis**
```sql theme={null}
makeDate(year, month, day)
makeDate(year, day_of_year)
```
**Argumentos**
* `year` — Número de año. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
* `month` — Número de mes (1-12). [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
* `day` — Día del mes (1-31). [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
* `day_of_year` — Día del año (1-365). [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
**Valor devuelto**
Devuelve un valor `Date` construido a partir de los argumentos proporcionados [`Date`](/es/reference/data-types/date)
**Ejemplos**
**Fecha a partir de un año, mes y día**
```sql title=Query theme={null}
SELECT makeDate(2023, 2, 28) AS date;
```
```response title=Response theme={null}
┌───────date─┐
│ 2023-02-28 │
└────────────┘
```
**Fecha a partir del año y el día del año**
```sql title=Query theme={null}
SELECT makeDate(2023, 42) AS date;
```
```response title=Response theme={null}
┌───────date─┐
│ 2023-02-11 │
└────────────┘
```
## makeDate32
Introducido en: v22.6.0
Crea un `Date32` a partir de:
* un año, un mes y un día
* un año y el día del año
**Sintaxis**
```sql theme={null}
makeDate32(year, month, day)
makeDate32(year, day_of_year)
```
**Argumentos**
* `year` — Año. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
* `month` — Número de mes (1-12). [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
* `day` — Día del mes (1-31). [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
* `day_of_year` — Día del año (1-365). [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
**Valor devuelto**
Devuelve un valor `Date32` construido a partir de los argumentos proporcionados [`Date32`](/es/reference/data-types/date32)
**Ejemplos**
**Date32 a partir de un año, un mes y un día**
```sql title=Query theme={null}
SELECT makeDate(2023, 2, 28) AS date;
```
```response title=Response theme={null}
┌───────date─┐
│ 2023-02-28 │
└────────────┘
```
**Date32 a partir del año y del día del año**
```sql title=Query theme={null}
SELECT makeDate(2023, 42) AS date;
```
```response title=Response theme={null}
┌───────date─┐
│ 2023-02-11 │
└────────────┘
```
## makeDateTime
Introducido en: v22.6.0
Crea un `DateTime` a partir del año, el mes, el día, la hora, el minuto y el segundo, con una zona horaria opcional.
**Sintaxis**
```sql theme={null}
makeDateTime(year, month, day, hour, minute, second[, timezone])
```
**Argumentos**
* `year` — Año. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
* `month` — Número de mes (1-12). [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
* `day` — Día del mes (1-31). [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
* `hour` — Hora (0-23). [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
* `minute` — Minuto (0-59). [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
* `second` — Segundo (0-59). [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
* `timezone` — Nombre de la zona horaria. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve un valor `DateTime` construido a partir de los argumentos proporcionados [`DateTime`](/es/reference/data-types/datetime)
**Ejemplos**
**DateTime a partir de año, mes, día, hora, minuto y segundo**
```sql title=Query theme={null}
SELECT makeDateTime(2023, 2, 28, 17, 12, 33) AS DateTime;
```
```response title=Response theme={null}
┌────────────DateTime─┐
│ 2023-02-28 17:12:33 │
└─────────────────────┘
```
## makeDateTime64
Introducido en: v22.6.0
Crea un `DateTime64` a partir del año, el mes, el día, la hora, el minuto y el segundo, con fracción, precisión y zona horaria opcionales.
**Sintaxis**
```sql theme={null}
makeDateTime64(year, month, day, hour, minute, second[, fraction[, precision[, timezone]]])
```
**Argumentos**
* `year` — Número de año. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
* `month` — Número de mes (1-12). [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
* `day` — Día del mes (1-31). [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
* `hour` — Hora (0-23). [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
* `minute` — Minuto (0-59). [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
* `second` — Segundo (0-59). [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
* `fraction` — Parte fraccionaria del segundo. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
* `precision` — Precisión de la parte fraccionaria (0-9). [`UInt8`](/es/reference/data-types/int-uint)
* `timezone` — Nombre de la zona horaria. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve un valor `DateTime64` construido a partir de los argumentos proporcionados [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**DateTime64 a partir de year, month, day, hour, minute y second**
```sql title=Query theme={null}
SELECT makeDateTime64(2023, 5, 15, 10, 30, 45, 779, 5);
```
```response title=Response theme={null}
┌─makeDateTime64(2023, 5, 15, 10, 30, 45, 779, 5)─┐
│ 2023-05-15 10:30:45.00779 │
└─────────────────────────────────────────────────┘
```
## monthName
Introducido en: v22.1.0
Devuelve el nombre del mes como una cadena a partir de un valor de fecha o de fecha con hora.
**Sintaxis**
```sql theme={null}
monthName(datetime)
```
**Argumentos**
* `datetime` — Fecha o fecha con componente de hora. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve el nombre del mes. [`String`](/es/reference/data-types/string)
**Ejemplos**
**Obtener el nombre del mes a partir de una fecha**
```sql title=Query theme={null}
WITH toDateTime('2021-04-14 11:22:33') AS date_value
SELECT monthName(date_value)
```
```response title=Response theme={null}
┌─monthName(date_value)─┐
│ April │
└───────────────────────┘
```
## now
Introducido en: v1.1.0
Devuelve la fecha y hora actuales en el momento del análisis de la consulta. La función es una expresión constante.
**Sintaxis**
```sql theme={null}
now([timezone])
```
**Alias**: `current_timestamp`
**Argumentos**
* `timezone` — Opcional. Nombre de la zona horaria del valor devuelto. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve la fecha y hora actuales. [`DateTime`](/es/reference/data-types/datetime)
**Ejemplos**
**Consulta sin zona horaria**
```sql title=Query theme={null}
SELECT now()
```
```response title=Response theme={null}
┌───────────────now()─┐
│ 2020-10-17 07:42:09 │
└─────────────────────┘
```
**Consulta con la zona horaria especificada**
```sql title=Query theme={null}
SELECT now('Asia/Istanbul')
```
```response title=Response theme={null}
┌─now('Asia/Istanbul')─┐
│ 2020-10-17 10:42:23 │
└──────────────────────┘
```
**Sintaxis SQL estándar sin paréntesis**
```sql title=Query theme={null}
SELECT NOW, CURRENT_TIMESTAMP
```
```response title=Response theme={null}
┌─────────────────NOW─┬───CURRENT_TIMESTAMP─┐
│ 2020-10-17 07:42:19 │ 2020-10-17 07:42:19 │
└─────────────────────┴─────────────────────┘
```
## now64
Introducido en: v20.1.0
Devuelve la fecha y hora actuales con precisión de fracciones de segundo en el momento del análisis de la consulta. La función es una expresión constante.
**Sintaxis**
```sql theme={null}
now64([scale[, timezone]])
```
**Argumentos**
* `scale` — Opcional. Tamaño del tick (precisión): 10^-precisión segundos. Rango válido: \[0 : 9]. Normalmente se usan 3 (predeterminado) (milisegundos), 6 (microsegundos) y 9 (nanosegundos). [`UInt8`](/es/reference/data-types/int-uint)
* `timezone` — Opcional. Nombre de la zona horaria del valor devuelto. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve la fecha y hora actuales con precisión de subsegundos. [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Consulta con precisión predeterminada y personalizada**
```sql title=Query theme={null}
SELECT now64(), now64(9, 'Asia/Istanbul')
```
```response title=Response theme={null}
┌─────────────────now64()─┬─────now64(9, 'Asia/Istanbul')─┐
│ 2022-08-21 19:34:26.196 │ 2022-08-21 22:34:26.196542766 │
└─────────────────────────┴───────────────────────────────┘
```
## nowInBlock
Introducido en: v22.8.0
Devuelve la fecha y hora actuales durante el procesamiento de cada bloque de datos. A diferencia de la función [`now`](#now), no es una expresión constante y el valor devuelto será diferente entre bloques en consultas de larga duración.
Conviene usar esta función para generar la hora actual en consultas `INSERT SELECT` de larga duración.
**Sintaxis**
```sql theme={null}
nowInBlock([timezone])
```
**Argumentos**
* `timezone` — Opcional. Nombre de la zona horaria del valor devuelto. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve la fecha y hora actuales en el momento de procesarse cada bloque de datos. [`DateTime`](/es/reference/data-types/datetime)
**Ejemplos**
**Diferencia con la función now()**
```sql title=Query theme={null}
SELECT
now(),
nowInBlock(),
sleep(1)
FROM numbers(3)
SETTINGS max_block_size = 1
FORMAT PrettyCompactMonoBlock
```
```response title=Response theme={null}
┌───────────────now()─┬────────nowInBlock()─┬─sleep(1)─┐
│ 2022-08-21 19:41:19 │ 2022-08-21 19:41:19 │ 0 │
│ 2022-08-21 19:41:19 │ 2022-08-21 19:41:20 │ 0 │
│ 2022-08-21 19:41:19 │ 2022-08-21 19:41:21 │ 0 │
└─────────────────────┴─────────────────────┴──────────┘
```
## nowInBlock64
Introducido en: v25.8.0
Devuelve la fecha y hora actuales en el momento en que se procesa cada bloque de datos, en milisegundos. A diferencia de la función [now64](#now64), no es una expresión constante, y el valor devuelto será diferente entre bloques en consultas de ejecución prolongada.
Tiene sentido utilizar esta función para generar la hora actual en consultas INSERT SELECT de ejecución prolongada.
**Sintaxis**
```sql theme={null}
nowInBlock64([scale[, timezone]])
```
**Argumentos**
* `scale` — Opcional. Tamaño del tick (precisión): 10^-precision segundos. Rango válido: \[0 : 9]. Normalmente se usan 3 (predeterminado) (milisegundos), 6 (microsegundos) y 9 (nanosegundos). [`UInt8`](/es/reference/data-types/int-uint)
* `timezone` — Opcional. Nombre de la zona horaria del valor devuelto. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve la fecha y hora actuales en el momento en que se procesa cada bloque de datos, con precisión de fracciones de segundo. [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Diferencia con la función now64()**
```sql title=Query theme={null}
SELECT
now64(),
nowInBlock64(),
sleep(1)
FROM numbers(3)
SETTINGS max_block_size = 1
FORMAT PrettyCompactMonoBlock
```
```response title=Response theme={null}
┌─────────────────now64()─┬──────────nowInBlock64()─┬─sleep(1)─┐
│ 2025-07-29 17:07:29.526 │ 2025-07-29 17:07:29.534 │ 0 │
│ 2025-07-29 17:07:29.526 │ 2025-07-29 17:07:30.535 │ 0 │
│ 2025-07-29 17:07:29.526 │ 2025-07-29 17:07:31.535 │ 0 │
└─────────────────────────┴─────────────────────────┴──────────┘
```
## serverTimezone
Introducido en: v23.6.0
Devuelve la zona horaria del servidor, es decir, el valor de la opción [`timezone`](/es/reference/settings/server-settings/settings#timezone).
Si la función se ejecuta en el contexto de una tabla distribuida, genera una columna normal con valores correspondientes a cada segmento. De lo contrario, produce un valor constante.
**Sintaxis**
```sql theme={null}
serverTimezone()
```
**Alias**: `serverTimeZone`
**Argumentos**
* Ninguno.
**Valor devuelto**
Devuelve la zona horaria del servidor como una [`String`](/es/reference/data-types/string)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT serverTimeZone()
```
```response title=Response theme={null}
┌─serverTimeZone()─┐
│ UTC │
└──────────────────┘
```
## subDate
Introducido en: v23.9.0
Resta el intervalo de tiempo de la fecha, fecha con hora, o fecha o fecha con hora codificada como cadena proporcionada.
Si la resta da como resultado un valor fuera de los límites del tipo de dato, el resultado es indefinido.
**Sintaxis**
```sql theme={null}
subDate(datetime, interval)
```
**Argumentos**
* `datetime` — La fecha o la fecha con hora a la que se le resta `interval`. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `interval` — Intervalo que se resta. [`Interval`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve la fecha o la fecha con hora obtenida al restar `interval` a `datetime`. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Restar un intervalo a una fecha**
```sql title=Query theme={null}
SELECT subDate(toDate('2018-01-01'), INTERVAL 3 YEAR)
```
```response title=Response theme={null}
┌─subDate(toDate('2018-01-01'), toIntervalYear(3))─┐
│ 2015-01-01 │
└──────────────────────────────────────────────────┘
```
## subtractDays
Introducido en: v1.1.0
Resta un número especificado de días a una fecha, una fecha con hora o una fecha o fecha con hora codificada como cadena.
**Sintaxis**
```sql theme={null}
subtractDays(datetime, num)
```
**Argumentos**
* `datetime` — Fecha o fecha con hora de la que se restará el número especificado de días. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64) o [`String`](/es/reference/data-types/string)
* `num` — Número de días que se restarán. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
**Valor devuelto**
Devuelve `datetime` menos `num` días. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Restar días a distintos tipos de fecha**
```sql title=Query theme={null}
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractDays(date, 31) AS subtract_days_with_date,
subtractDays(date_time, 31) AS subtract_days_with_date_time,
subtractDays(date_time_string, 31) AS subtract_days_with_date_time_string
```
```response title=Response theme={null}
┌─subtract_days_with_date─┬─subtract_days_with_date_time─┬─subtract_days_with_date_time_string─┐
│ 2023-12-01 │ 2023-12-01 00:00:00 │ 2023-12-01 00:00:00.000 │
└─────────────────────────┴──────────────────────────────┴─────────────────────────────────────┘
```
**Uso de la sintaxis alternativa de INTERVAL**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 day)
```
```response title=Response theme={null}
┌─minus(CAST('⋯valDay(10))─┐
│ 1998-06-06 │
└──────────────────────────┘
```
## subtractHours
Introducido en: v1.1.0
Resta una cantidad determinada de horas a una fecha, una fecha con hora, o una fecha o fecha con hora codificada como cadena.
**Sintaxis**
```sql theme={null}
subtractHours(datetime, num)
```
**Argumentos**
* `datetime` — Fecha o fecha con hora a la que se le debe restar el número especificado de horas. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64) o [`String`](/es/reference/data-types/string)
* `num` — Número de horas que se deben restar. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
**Valor devuelto**
Devuelve `datetime` menos `num` horas. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64(3)`](/es/reference/data-types/datetime64)
**Ejemplos**
**Restar horas a distintos tipos de fecha**
```sql title=Query theme={null}
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractHours(date, 12) AS subtract_hours_with_date,
subtractHours(date_time, 12) AS subtract_hours_with_date_time,
subtractHours(date_time_string, 12) AS subtract_hours_with_date_time_string
```
```response title=Response theme={null}
┌─subtract_hours_with_date─┬─subtract_hours_with_date_time─┬─subtract_hours_with_date_time_string─┐
│ 2023-12-31 12:00:00 │ 2023-12-31 12:00:00 │ 2023-12-31 12:00:00.000 │
└──────────────────────────┴───────────────────────────────┴──────────────────────────────────────┘
```
**Uso de la sintaxis alternativa de INTERVAL**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 hour)
```
```response title=Response theme={null}
┌─minus(CAST('⋯alHour(10))─┐
│ 1998-06-15 14:00:00 │
└──────────────────────────┘
```
## subtractInterval
Introducido en: v22.11.0
Añade un intervalo negado a otro intervalo o a una tupla de intervalos.
Nota: Los intervalos del mismo tipo se combinan en un único intervalo. Por ejemplo, si se pasan `toIntervalDay(2)` y `toIntervalDay(1)`, el resultado será `(1)` en lugar de `(2,1)`.
**Sintaxis**
```sql theme={null}
subtractInterval(interval_1, interval_2)
```
**Argumentos**
* `interval_1` — Primer intervalo o una tupla de intervalos. [`Interval`](/es/reference/data-types/int-uint) o [`Tuple(Interval)`](/es/reference/data-types/tuple)
* `interval_2` — Segundo intervalo que debe negarse. [`Interval`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve una tupla de intervalos [`Tuple(T)`](/es/reference/data-types/tuple)
**Ejemplos**
**Restar intervalos**
```sql title=Query theme={null}
SELECT subtractInterval(INTERVAL 1 DAY, INTERVAL 1 MONTH);
SELECT subtractInterval((INTERVAL 1 DAY, INTERVAL 1 YEAR), INTERVAL 1 MONTH);
SELECT subtractInterval(INTERVAL 2 DAY, INTERVAL 1 DAY);
```
```response title=Response theme={null}
┌─subtractInterval(toIntervalDay(1), toIntervalMonth(1))─┐
│ (1,-1) │
└────────────────────────────────────────────────────────┘
┌─subtractInterval((toIntervalDay(1), toIntervalYear(1)), toIntervalMonth(1))─┐
│ (1,1,-1) │
└─────────────────────────────────────────────────────────────────────────────┘
┌─subtractInterval(toIntervalDay(2), toIntervalDay(1))─┐
│ (1) │
└──────────────────────────────────────────────────────┘
```
## subtractMicroseconds
Introducido en: v22.6.0
Resta un número determinado de microsegundos de una fecha con hora o de una fecha con hora codificada como cadena.
**Sintaxis**
```sql theme={null}
subtractMicroseconds(datetime, num)
```
**Argumentos**
* `datetime` — Fecha con hora a la que se restará el número especificado de microsegundos. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64) o [`String`](/es/reference/data-types/string)
* `num` — Número de microsegundos que se restará. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
**Valor devuelto**
Devuelve `datetime` menos `num` microsegundos [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Restar microsegundos de distintos tipos de fecha y hora**
```sql title=Query theme={null}
WITH
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractMicroseconds(date_time, 1000000) AS subtract_microseconds_with_date_time,
subtractMicroseconds(date_time_string, 1000000) AS subtract_microseconds_with_date_time_string
```
```response title=Response theme={null}
┌─subtract_microseconds_with_date_time─┬─subtract_microseconds_with_date_time_string─┐
│ 2023-12-31 23:59:59.000000 │ 2023-12-31 23:59:59.000000 │
└──────────────────────────────────────┴─────────────────────────────────────────────┘
```
**Uso de la sintaxis alternativa de INTERVAL**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::DateTime, INTERVAL 10 microsecond)
```
```response title=Response theme={null}
┌─minus(CAST('1⋯osecond(10))─┐
│ 1998-06-15 23:59:59.999990 │
└────────────────────────────┘
```
## subtractMilliseconds
Introducido en: v22.6.0
Resta una cantidad determinada de milisegundos a una fecha con hora o a una fecha con hora codificada como cadena.
**Sintaxis**
```sql theme={null}
subtractMilliseconds(datetime, num)
```
**Argumentos**
* `datetime` — Fecha con hora de la que se restará el número especificado de milisegundos. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64) o [`String`](/es/reference/data-types/string)
* `num` — Número de milisegundos que se restarán. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
**Valor devuelto**
Devuelve `datetime` menos `num` milisegundos [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Resta milisegundos de distintos tipos de fecha y hora**
```sql title=Query theme={null}
WITH
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractMilliseconds(date_time, 1000) AS subtract_milliseconds_with_date_time,
subtractMilliseconds(date_time_string, 1000) AS subtract_milliseconds_with_date_time_string
```
```response title=Response theme={null}
┌─subtract_milliseconds_with_date_time─┬─subtract_milliseconds_with_date_time_string─┐
│ 2023-12-31 23:59:59.000 │ 2023-12-31 23:59:59.000 │
└──────────────────────────────────────┴─────────────────────────────────────────────┘
```
**Uso de la sintaxis alternativa de INTERVAL**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::DateTime, INTERVAL 10 millisecond)
```
```response title=Response theme={null}
┌─minus(CAST('⋯second(10))─┐
│ 1998-06-15 23:59:59.990 │
└──────────────────────────┘
```
## subtractMinutes
Introducido en: v1.1.0
Resta un número especificado de minutos a una fecha, una fecha con hora o una fecha o fecha con hora representada como cadena.
**Sintaxis**
```sql theme={null}
subtractMinutes(datetime, num)
```
**Argumentos**
* `datetime` — Fecha o fecha con hora a la que se le restará el número especificado de minutos. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64) o [`String`](/es/reference/data-types/string)
* `num` — Número de minutos que se restarán. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
**Valor devuelto**
Devuelve `datetime` menos `num` minutos. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64(3)`](/es/reference/data-types/datetime64)
**Ejemplos**
**Restar minutos a distintos tipos de fecha**
```sql title=Query theme={null}
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractMinutes(date, 30) AS subtract_minutes_with_date,
subtractMinutes(date_time, 30) AS subtract_minutes_with_date_time,
subtractMinutes(date_time_string, 30) AS subtract_minutes_with_date_time_string
```
```response title=Response theme={null}
┌─subtract_minutes_with_date─┬─subtract_minutes_with_date_time─┬─subtract_minutes_with_date_time_string─┐
│ 2023-12-31 23:30:00 │ 2023-12-31 23:30:00 │ 2023-12-31 23:30:00.000 │
└────────────────────────────┴─────────────────────────────────┴────────────────────────────────────────┘
```
**Uso de la sintaxis alternativa de INTERVAL**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 minute)
```
```response title=Response theme={null}
┌─minus(CAST('⋯Minute(10))─┐
│ 1998-06-15 23:50:00 │
└──────────────────────────┘
```
## subtractMonths
Introducido en: v1.1.0
Resta un número determinado de meses de una fecha, una fecha con hora o una fecha o fecha con hora codificada como cadena.
**Sintaxis**
```sql theme={null}
subtractMonths(datetime, num)
```
**Argumentos**
* `datetime` — Fecha o fecha con hora a la que se restará el número especificado de meses. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64) o [`String`](/es/reference/data-types/string)
* `num` — Número de meses que se restarán. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
**Valor devuelto**
Devuelve `datetime` menos `num` meses [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Restar meses a distintos tipos de fecha**
```sql title=Query theme={null}
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractMonths(date, 1) AS subtract_months_with_date,
subtractMonths(date_time, 1) AS subtract_months_with_date_time,
subtractMonths(date_time_string, 1) AS subtract_months_with_date_time_string
```
```response title=Response theme={null}
┌─subtract_months_with_date─┬─subtract_months_with_date_time─┬─subtract_months_with_date_time_string─┐
│ 2023-12-01 │ 2023-12-01 00:00:00 │ 2023-12-01 00:00:00.000 │
└───────────────────────────┴────────────────────────────────┴───────────────────────────────────────┘
```
**Uso de la sintaxis alternativa de INTERVAL**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 month)
```
```response title=Response theme={null}
┌─minus(CAST('⋯lMonth(10))─┐
│ 1997-08-16 │
└──────────────────────────┘
```
## subtractNanoseconds
Introducido en: v20.1.0
Resta un número determinado de nanosegundos a una fecha con hora o a una fecha con hora codificada como cadena.
**Sintaxis**
```sql theme={null}
subtractNanoseconds(datetime, num)
```
**Argumentos**
* `datetime` — Fecha con hora de la que se restará la cantidad especificada de nanosegundos. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64) o [`String`](/es/reference/data-types/string)
* `num` — Cantidad de nanosegundos que se restará. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
**Valor devuelto**
Devuelve `datetime` menos `num` nanosegundos. [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Restar nanosegundos a distintos tipos de fecha con hora**
```sql title=Query theme={null}
WITH
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractNanoseconds(date_time, 1000) AS subtract_nanoseconds_with_date_time,
subtractNanoseconds(date_time_string, 1000) AS subtract_nanoseconds_with_date_time_string
```
```response title=Response theme={null}
┌─subtract_nanoseconds_with_date_time─┬─subtract_nanoseconds_with_date_time_string─┐
│ 2023-12-31 23:59:59.999999000 │ 2023-12-31 23:59:59.999999000 │
└─────────────────────────────────────┴────────────────────────────────────────────┘
```
**Uso de una sintaxis alternativa de INTERVAL**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::DateTime, INTERVAL 10 nanosecond)
```
```response title=Response theme={null}
┌─minus(CAST('19⋯anosecond(10))─┐
│ 1998-06-15 23:59:59.999999990 │
└───────────────────────────────┘
```
## subtractQuarters
Introducido en: v20.1.0
Resta un número determinado de trimestres a una fecha, una fecha con hora o una fecha o fecha con hora codificada como cadena.
**Sintaxis**
```sql theme={null}
subtractQuarters(datetime, num)
```
**Argumentos**
* `datetime` — Fecha o fecha con hora a la que se restará el número especificado de trimestres. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64) o [`String`](/es/reference/data-types/string)
* `num` — Número de trimestres que se restarán. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
**Valor devuelto**
Devuelve `datetime` menos `num` trimestres. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Restar trimestres a distintos tipos de fecha**
```sql title=Query theme={null}
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractQuarters(date, 1) AS subtract_quarters_with_date,
subtractQuarters(date_time, 1) AS subtract_quarters_with_date_time,
subtractQuarters(date_time_string, 1) AS subtract_quarters_with_date_time_string
```
```response title=Response theme={null}
┌─subtract_quarters_with_date─┬─subtract_quarters_with_date_time─┬─subtract_quarters_with_date_time_string─┐
│ 2023-10-01 │ 2023-10-01 00:00:00 │ 2023-10-01 00:00:00.000 │
└─────────────────────────────┴──────────────────────────────────┴─────────────────────────────────────────┘
```
**Uso de la sintaxis alternativa de INTERVAL**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 quarter)
```
```response title=Response theme={null}
┌─minus(CAST('1⋯Quarter(10))─┐
│ 1996-09-16 │
└───────────────────────────┘
```
## subtractSeconds
Introducido en: v1.1.0
Resta un número determinado de segundos a una fecha, una fecha con hora o una fecha o fecha con hora codificada como cadena.
**Sintaxis**
```sql theme={null}
subtractSeconds(datetime, num)
```
**Argumentos**
* `datetime` — Fecha o fecha con hora a la que se restará el número especificado de segundos. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64) o [`String`](/es/reference/data-types/string)
* `num` — Número de segundos que se restarán. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
**Valor devuelto**
Devuelve `datetime` menos `num` segundos. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64(3)`](/es/reference/data-types/datetime64)
**Ejemplos**
**Restar segundos a distintos tipos de fecha**
```sql title=Query theme={null}
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractSeconds(date, 60) AS subtract_seconds_with_date,
subtractSeconds(date_time, 60) AS subtract_seconds_with_date_time,
subtractSeconds(date_time_string, 60) AS subtract_seconds_with_date_time_string
```
```response title=Response theme={null}
┌─subtract_seconds_with_date─┬─subtract_seconds_with_date_time─┬─subtract_seconds_with_date_time_string─┐
│ 2023-12-31 23:59:00 │ 2023-12-31 23:59:00 │ 2023-12-31 23:59:00.000 │
└────────────────────────────┴─────────────────────────────────┴────────────────────────────────────────┘
```
**Uso de una sintaxis alternativa de INTERVAL**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 second)
```
```response title=Response theme={null}
┌─minus(CAST('⋯Second(10))─┐
│ 1998-06-15 23:59:50 │
└──────────────────────────┘
```
## subtractTupleOfIntervals
Introducido en: v22.11.0
Resta de forma consecutiva una tupla de intervalos a una fecha o a una fecha con hora.
**Sintaxis**
```sql theme={null}
subtractTupleOfIntervals(datetime, intervals)
```
**Argumentos**
* `datetime` — Fecha o fecha con hora de la que se restarán intervalos. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `intervals` — tupla de intervalos que se restarán de `datetime`. [`Tuple(Interval)`](/es/reference/data-types/tuple)
**Valor devuelto**
Devuelve `date` con los `intervals` restados. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Restar una tupla de intervalos a una fecha**
```sql title=Query theme={null}
WITH toDate('2018-01-01') AS date SELECT subtractTupleOfIntervals(date, (INTERVAL 1 DAY, INTERVAL 1 YEAR))
```
```response title=Response theme={null}
┌─subtractTupl⋯alYear(1)))─┐
│ 2016-12-31 │
└──────────────────────────┘
```
## subtractWeeks
Introducido en: v1.1.0
Resta una cantidad determinada de semanas a una fecha, una fecha con hora o una fecha o fecha con hora codificada como cadena.
**Sintaxis**
```sql theme={null}
subtractWeeks(datetime, num)
```
**Argumentos**
* `datetime` — Fecha o fecha con hora a la que se le restará el número especificado de semanas. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64) o [`String`](/es/reference/data-types/string)
* `num` — Número de semanas que se restará. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
**Valor devuelto**
Devuelve `datetime` menos `num` semanas. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Restar semanas a distintos tipos de fecha**
```sql title=Query theme={null}
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractWeeks(date, 1) AS subtract_weeks_with_date,
subtractWeeks(date_time, 1) AS subtract_weeks_with_date_time,
subtractWeeks(date_time_string, 1) AS subtract_weeks_with_date_time_string
```
```response title=Response theme={null}
┌─subtract_weeks_with_date─┬─subtract_weeks_with_date_time─┬─subtract_weeks_with_date_time_string─┐
│ 2023-12-25 │ 2023-12-25 00:00:00 │ 2023-12-25 00:00:00.000 │
└──────────────────────────┴───────────────────────────────┴──────────────────────────────────────┘
```
**Uso de la sintaxis alternativa de INTERVAL**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 week)
```
```response title=Response theme={null}
┌─minus(CAST('⋯alWeek(10))─┐
│ 1998-04-07 │
└──────────────────────────┘
```
## subtractYears
Introducido en: v1.1.0
Resta un número determinado de años de una fecha, una fecha con hora o una fecha, o fecha con hora, codificada como cadena.
**Sintaxis**
```sql theme={null}
subtractYears(datetime, num)
```
**Argumentos**
* `datetime` — Fecha o fecha con hora a la que se le restará la cantidad especificada de años. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64) o [`String`](/es/reference/data-types/string)
* `num` — Cantidad de años que se restará. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
**Valor devuelto**
Devuelve `datetime` menos `num` años. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Restar años a distintos tipos de fecha**
```sql title=Query theme={null}
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractYears(date, 1) AS subtract_years_with_date,
subtractYears(date_time, 1) AS subtract_years_with_date_time,
subtractYears(date_time_string, 1) AS subtract_years_with_date_time_string
```
```response title=Response theme={null}
┌─subtract_years_with_date─┬─subtract_years_with_date_time─┬─subtract_years_with_date_time_string─┐
│ 2023-01-01 │ 2023-01-01 00:00:00 │ 2023-01-01 00:00:00.000 │
└──────────────────────────┴───────────────────────────────┴──────────────────────────────────────┘
```
**Uso de la sintaxis alternativa de INTERVAL**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 year)
```
```response title=Response theme={null}
┌─minus(CAST('⋯alYear(10))─┐
│ 1988-06-16 │
└──────────────────────────┘
```
## timeDiff
Introducido en: v23.4.0
Devuelve la diferencia en segundos entre dos fechas o entre dos fechas con valores de hora.
La diferencia se calcula como `enddate` - `startdate`.
Esta función es equivalente a `dateDiff('second', startdate, enddate)`.
Para calcular diferencias de tiempo en otras unidades (horas, días, meses, etc.), utilice la función [`dateDiff`](#dateDiff).
**Sintaxis**
```sql theme={null}
timeDiff(startdate, enddate)
```
**Argumentos**
* `startdate` — El primer valor temporal que se resta (el sustraendo). [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `enddate` — El segundo valor temporal del que se resta (el minuendo). [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve la diferencia entre `enddate` y `startdate`, expresada en segundos. [`Int64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Calcular la diferencia temporal en segundos**
```sql title=Query theme={null}
SELECT timeDiff(toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00')) AS res
```
```response title=Response theme={null}
┌───res─┐
│ 90000 │
└───────┘
```
**Calcular la diferencia de tiempo y convertirla en horas**
```sql title=Query theme={null}
SELECT timeDiff(toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00')) / 3600 AS hours
```
```response title=Response theme={null}
┌─hours─┐
│ 25 │
└───────┘
```
**Equivalente a dateDiff en segundos**
```sql title=Query theme={null}
SELECT
timeDiff(toDateTime('2021-12-29'), toDateTime('2022-01-01')) AS time_diff_result,
dateDiff('second', toDateTime('2021-12-29'), toDateTime('2022-01-01')) AS date_diff_result
```
```response title=Response theme={null}
┌─time_diff_result─┬─date_diff_result─┐
│ 259200 │ 259200 │
└──────────────────┴──────────────────┘
```
## timeSlot
Introducido en: v1.1.0
Redondea la hora al inicio de un intervalo de media hora.
Aunque esta función puede aceptar valores de los tipos extendidos `Date32` y `DateTime64` como argumento,
si se le pasa una hora fuera del rango normal (del año 1970 a 2149 para `Date` / 2106 para `DateTime`), producirá resultados incorrectos.
**Sintaxis**
```sql theme={null}
timeSlot(time[, time_zone])
```
**Argumentos**
* `time` — Hora que se redondeará al inicio de un intervalo de media hora. [`DateTime`](/es/reference/data-types/datetime) o [`Date32`](/es/reference/data-types/date32) o [`DateTime64`](/es/reference/data-types/datetime64)
* `time_zone` — Opcional. Un valor constante de tipo String o una expresión que representa la zona horaria. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve la hora redondeada al inicio de un intervalo de media hora. [`DateTime`](/es/reference/data-types/datetime)
**Ejemplos**
**Redondear la hora a un intervalo de media hora**
```sql title=Query theme={null}
SELECT timeSlot(toDateTime('2000-01-02 03:04:05', 'UTC'))
```
```response title=Response theme={null}
┌─timeSlot(toDateTime('2000-01-02 03:04:05', 'UTC'))─┐
│ 2000-01-02 03:00:00 │
└────────────────────────────────────────────────────┘
```
## timeSlots
Introducido en: v1.1.0
Para un intervalo de tiempo que comienza en `StartTime` y se extiende durante `Duration` segundos, devuelve un array de instantes, formado por puntos de este intervalo redondeados hacia abajo a `Size` segundos. `Size` es un parámetro opcional cuyo valor predeterminado es 1800 (30 minutos).
Esto es necesario, por ejemplo, al buscar vistas de página en la sesión correspondiente.
Para `DateTime64`, la escala del valor devuelto puede diferir de la escala de `StartTime`. Se toma la escala más alta de todos los argumentos proporcionados.
**Sintaxis**
```sql theme={null}
timeSlots(StartTime, Duration[, Size])
```
**Argumentos**
* `StartTime` — Hora de inicio del intervalo. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `Duration` — Duración del intervalo en segundos. [`UInt32`](/es/reference/data-types/int-uint) o [`DateTime64`](/es/reference/data-types/datetime64)
* `Size` — Opcional. Tamaño de las franjas horarias en segundos. El valor predeterminado es 1800 (30 minutos). [`UInt32`](/es/reference/data-types/int-uint) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve un Array de DateTime/DateTime64 (el tipo de retorno coincide con el tipo de `StartTime`). En el caso de DateTime64, la escala del valor devuelto puede diferir de la escala de `StartTime`: se toma la escala más alta de todos los argumentos proporcionados. [`Array(DateTime)`](/es/reference/data-types/array) o [`Array(DateTime64)`](/es/reference/data-types/array)
**Ejemplos**
**Generar franjas horarias para un intervalo**
```sql title=Query theme={null}
SELECT timeSlots(toDateTime('2012-01-01 12:20:00'), toUInt32(600));
SELECT timeSlots(toDateTime('1980-12-12 21:01:02', 'UTC'), toUInt32(600), 299);
SELECT timeSlots(toDateTime64('1980-12-12 21:01:02.1234', 4, 'UTC'), toDecimal64(600.1, 1), toDecimal64(299, 0))
```
```response title=Response theme={null}
┌─timeSlots(toDateTime('2012-01-01 12:20:00'), toUInt32(600))─┐
│ ['2012-01-01 12:00:00','2012-01-01 12:30:00'] │
└─────────────────────────────────────────────────────────────┘
┌─timeSlots(toDateTime('1980-12-12 21:01:02', 'UTC'), toUInt32(600), 299)─┐
│ ['1980-12-12 20:56:13','1980-12-12 21:01:12','1980-12-12 21:06:11'] │
└─────────────────────────────────────────────────────────────────────────┘
┌─timeSlots(toDateTime64('1980-12-12 21:01:02.1234', 4, 'UTC'), toDecimal64(600.1, 1), toDecimal64(299, 0))─┐
│ ['1980-12-12 20:56:13.0000','1980-12-12 21:01:12.0000','1980-12-12 21:06:11.0000'] │
└───────────────────────────────────────────────────────────────────────────────────────────────────────────┘
```
## timestamp
Introducido en: v23.9.0
Convierte el primer argumento `expr` al tipo [`DateTime64(6)`](/es/reference/data-types/datetime64).
Si se proporciona un segundo argumento `expr_time`, suma la hora especificada al valor convertido.
**Sintaxis**
```sql theme={null}
timestamp(expr[, expr_time])
```
**Argumentos**
* `expr` — Fecha o fecha con hora. [`String`](/es/reference/data-types/string)
* `expr_time` — Opcional. Hora que se añade al valor convertido. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve el valor convertido de `expr`, o `expr` con la hora añadida, [`DateTime64(6)`](/es/reference/data-types/datetime64)
**Ejemplos**
**Convertir una cadena de fecha en DateTime64(6)**
```sql title=Query theme={null}
SELECT timestamp('2023-12-31') AS ts;
```
```response title=Response theme={null}
┌─────────────────────────ts─┐
│ 2023-12-31 00:00:00.000000 │
└────────────────────────────┘
```
**Agregar una hora a una cadena de fecha**
```sql title=Query theme={null}
SELECT timestamp('2023-12-31 12:00:00', '12:00:00.11') AS ts;
```
```response title=Response theme={null}
┌─────────────────────────ts─┐
│ 2024-01-01 00:00:00.110000 │
└────────────────────────────┘
```
## timezone
Introducido en: v21.4.0
Devuelve el nombre de la zona horaria de la sesión actual o convierte un desplazamiento o un nombre de zona horaria en un nombre canónico de zona horaria.
**Sintaxis**
```sql theme={null}
timezone()
```
**Alias**: `timeZone`
**Argumentos**
* Ninguno.
**Valor devuelto**
Devuelve el nombre canónico de la zona horaria como un [`String`](/es/reference/data-types/string)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT timezone()
```
```response title=Response theme={null}
┌─timezone()───────┐
│ Europe/Amsterdam │
└──────────────────┘
```
## timezoneOf
Introducido en: v21.4.0
Devuelve el nombre de la zona horaria de un valor [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64).
**Sintaxis**
```sql theme={null}
timezoneOf(datetime)
```
**Alias**: `timeZoneOf`
**Argumentos**
* `datetime` — Un valor de tipo [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `timezone` — Opcional. Nombre de la zona horaria a la que convertir el valor `datetime`. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve el nombre de la zona horaria de `datetime`. [`String`](/es/reference/data-types/string)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT timezoneOf(now());
```
```response title=Response theme={null}
┌─timezoneOf(now())─┐
│ Europe/Amsterdam │
└───────────────────┘
```
## timezoneOffset
Introducido en: v21.6.0
Devuelve el desfase horario en segundos con respecto a [UTC](https://en.wikipedia.org/wiki/Coordinated_Universal_Time).
La función tiene en cuenta el horario de verano y los cambios históricos de la zona horaria en la fecha y hora especificadas.
**Sintaxis**
```sql theme={null}
timezoneOffset(datetime)
```
**Alias**: `timeZoneOffset`
**Argumentos**
* `datetime` — valor de `DateTime` para obtener el desplazamiento de la zona horaria. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve el desplazamiento con respecto a UTC en segundos [`Int32`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT toDateTime('2021-04-21 10:20:30', 'America/New_York') AS Time,
toTypeName(Time) AS Type,
timezoneOffset(Time) AS Offset_in_seconds,
(Offset_in_seconds / 3600) AS Offset_in_hours;
```
```response title=Response theme={null}
┌────────────────Time─┬─Type─────────────────────────┬─Offset_in_seconds─┬─Offset_in_hours─┐
│ 2021-04-21 10:20:30 │ DateTime('America/New_York') │ -14400 │ -4 │
└─────────────────────┴──────────────────────────────┴───────────────────┴─────────────────┘
```
## toDayOfMonth
Introducido en: v1.1.0
Devuelve el día del mes (1-31) de un valor `Date` o `DateTime`.
**Sintaxis**
```sql theme={null}
toDayOfMonth(datetime)
```
**Aliases**: `DAY`, `DAYOFMONTH`
**Argumentos**
* `datetime` — Fecha o fecha con hora de la que se obtiene el día del mes. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve el día del mes de la fecha/hora proporcionada [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT toDayOfMonth(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toDayOfMonth(toDateTime('2023-04-21 10:20:30'))─┐
│ 21 │
└─────────────────────────────────────────────────┘
```
## toDayOfWeek
Introducido en: v1.1.0
Devuelve el número correspondiente al día de la semana de un valor `Date` o `DateTime`.
La variante de dos argumentos de `toDayOfWeek()` le permite especificar si la semana comienza en lunes o en domingo,
y si el valor devuelto debe estar en el rango de 0 a 6 o de 1 a 7.
| Modo | Primer día de la semana | Rango |
| ---- | ----------------------- | -------------------------------------------- |
| 0 | Lunes | 1-7: Lunes = 1, Martes = 2, ..., Domingo = 7 |
| 1 | Lunes | 0-6: Lunes = 0, Martes = 1, ..., Domingo = 6 |
| 2 | Domingo | 0-6: Domingo = 0, Lunes = 1, ..., Sábado = 6 |
| 3 | Domingo | 1-7: Domingo = 1, Lunes = 2, ..., Sábado = 7 |
**Sintaxis**
```sql theme={null}
toDayOfWeek(datetime[, mode[, timezone]])
```
**Alias**: `DAYOFWEEK`
**Argumentos**
* `datetime` — Fecha o fecha con hora de la que se obtiene el día de la semana. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `mode` — Opcional. Entero que especifica el modo de semana (0-3). Si se omite, el valor predeterminado es 0. [`UInt8`](/es/reference/data-types/int-uint)
* `timezone` — Opcional. Zona horaria que se utilizará para la conversión. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve el día de la semana para el `Date` o `DateTime` especificado [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
-- La siguiente fecha es el 21 de abril de 2023, que fue un viernes:
SELECT
toDayOfWeek(toDateTime('2023-04-21')),
toDayOfWeek(toDateTime('2023-04-21'), 1)
```
```response title=Response theme={null}
┌─toDayOfWeek(toDateTime('2023-04-21'))─┬─toDayOfWeek(toDateTime('2023-04-21'), 1)─┐
│ 5 │ 4 │
└───────────────────────────────────────┴──────────────────────────────────────────┘
```
## toDayOfYear
Introducido en: v18.4.0
Devuelve el número de día dentro del año (1-366) de un valor `Date` o `DateTime`.
**Sintaxis**
```sql theme={null}
toDayOfYear(datetime)
```
**Alias**: `DAYOFYEAR`
**Argumentos**
* `datetime` — Fecha o fecha con hora de la que se obtiene el día del año. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve el día del año del valor Date o DateTime dado [`UInt16`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT toDayOfYear(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toDayOfYear(toDateTime('2023-04-21 10:20:30'))─┐
│ 111 │
└────────────────────────────────────────────────┘
```
## toDaysInMonth
Introducido en: v26.3.0
Devuelve el número de días del mes correspondiente a un `Date` o `DateTime`.
El valor devuelto está en el intervalo de 28 a 31.
**Sintaxis**
```sql theme={null}
toDaysInMonth(datetime)
```
**Argumentos**
* `datetime` — Fecha o fecha con hora a partir de la cual se obtiene el número de días del mes. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve el número de días del mes correspondiente a la fecha/hora indicada. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT toDaysInMonth(toDate('2023-02-01')), toDaysInMonth(toDate('2024-02-01')), toDaysInMonth(toDate('2023-01-01'))
```
```response title=Response theme={null}
┌─toDaysInMonth(toDate('2023-02-01'))─┬─toDaysInMonth(toDate('2024-02-01'))─┬─toDaysInMonth(toDate('2023-01-01'))─┐
│ 28 │ 29 │ 31 │
└─────────────────────────────────────┴─────────────────────────────────────┴─────────────────────────────────────┘
```
## toDaysSinceYearZero
Introducido en: v23.9.0
Para una fecha determinada, devuelve el número de días transcurridos desde el [1 de enero de 0000](https://en.wikipedia.org/wiki/Year_zero) en el
[calendario gregoriano proléptico definido por ISO 8601](https://en.wikipedia.org/wiki/Gregorian_calendar#Proleptic_Gregorian_calendar).
El cálculo es el mismo que en la función [`TO_DAYS`](https://dev.mysql.com/doc/refman/8.0/en/date-and-time-functions.html#function_to-days) de MySQL.
**Sintaxis**
```sql theme={null}
toDaysSinceYearZero(date[, time_zone])
```
**Alias**: `TO_DAYS`
**Argumentos**
* `date` — La fecha o fecha con hora para la que se calcula el número de días transcurridos desde el año cero. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `time_zone` — Zona horaria. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve el número de días transcurridos desde la fecha `0000-01-01`. [`UInt32`](/es/reference/data-types/int-uint)
**Ejemplos**
**Calcular los días desde el año cero**
```sql title=Query theme={null}
SELECT toDaysSinceYearZero(toDate('2023-09-08'))
```
```response title=Response theme={null}
┌─toDaysSinceYearZero(toDate('2023-09-08')))─┐
│ 713569 │
└────────────────────────────────────────────┘
```
## toHour
Introducido en: v1.1.0
Devuelve el componente horario (0-23) de un valor `DateTime` o `DateTime64`.
**Sintaxis**
```sql theme={null}
toHour(datetime)
```
**Aliases**: `HOUR`
**Argumentos**
* `datetime` — Fecha y hora de la que se extrae la hora. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve la hora (0-23) de `datetime`. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT toHour(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toHour(toDateTime('2023-04-21 10:20:30'))─┐
│ 10 │
└───────────────────────────────────────────┘
```
## toISOWeek
Introducido en: v20.1.0
Devuelve el número de semana ISO de una fecha o una fecha con hora.
Esta es una función de compatibilidad equivalente a `toWeek(date, 3)`.
Las semanas ISO comienzan en lunes y la primera semana del año contiene el 4 de enero.
Según la norma ISO 8601, los números de semana están comprendidos entre 1 y 53.
Tenga en cuenta que las fechas cercanas al inicio o al final de un año pueden devolver un número de semana del año anterior o del siguiente. Por ejemplo,
el 29 de diciembre de 2025 devuelve la semana 1 porque cae en la primera semana que contiene el 4 de enero de 2026.
**Sintaxis**
```sql theme={null}
toISOWeek(datetime[, timezone])
```
**Argumentos**
* `datetime` — Fecha o fecha con hora de la que se obtiene el número de semana ISO. [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`Date32`](/es/reference/data-types/date32) o [`DateTime64`](/es/reference/data-types/datetime64)
* `timezone` — Opcional. Zona horaria. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve el número de semana ISO según el estándar ISO 8601. Devuelve un número entre 1 y 53. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Obtener los números de semana ISO**
```sql title=Query theme={null}
SELECT toDate('2016-12-27') AS date, toISOWeek(date) AS isoWeek
```
```response title=Response theme={null}
┌───────date─┬─isoWeek─┐
│ 2016-12-27 │ 52 │
└────────────┴─────────┘
```
**La semana ISO puede pertenecer a un año distinto**
```sql title=Query theme={null}
SELECT toDate('2025-12-29') AS date, toISOWeek(date) AS isoWeek, toYear(date) AS year
```
```response title=Response theme={null}
┌───────date─┬─isoWeek─┬─year─┐
│ 2025-12-29 │ 1 │ 2025 │
└────────────┴─────────┴──────┘
```
## toISOYear
Introducido en: v18.4.0
Convierte una fecha o una fecha y hora en el número de año según ISO.
**Sintaxis**
```sql theme={null}
toISOYear(datetime)
```
**Argumentos**
* `datetime` — El valor con fecha o fecha y hora. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve el valor de entrada convertido en un número de año ISO. [`UInt16`](/es/reference/data-types/int-uint)
**Ejemplos**
**Obtener el año ISO a partir de valores de fecha**
```sql title=Query theme={null}
SELECT
toISOYear(toDate('2024/10/02')) as year1,
toISOYear(toDateTime('2024-10-02 01:30:00')) as year2
```
```response title=Response theme={null}
┌─week1─┬─week2─┐
│ 40 │ 40 │
└───────┴───────┘
```
## toLastDayOfMonth
Introducido en: v1.1.0
Redondea una fecha o una fecha con hora al último día del mes.
El tipo de retorno puede configurarse mediante [`enable_extended_results_for_datetime_functions`](/es/reference/settings/session-settings#enable_extended_results_for_datetime_functions).
**Sintaxis**
```sql theme={null}
toLastDayOfMonth(value)
```
**Alias**: `LAST_DAY`
**Argumentos**
* `value` — La fecha o fecha con hora que se debe redondear al último día del mes. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve la fecha correspondiente al último día del mes para la fecha o fecha con hora proporcionada. [`Date`](/es/reference/data-types/date)
**Ejemplos**
**Redondear al último día del mes**
```sql title=Query theme={null}
SELECT toLastDayOfMonth(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toLastDayOfMonth(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-04-30 │
└─────────────────────────────────────────────────────┘
```
## toLastDayOfWeek
Introducido en: v23.5.0
Redondea una fecha o fecha con hora hacia arriba, hasta el sábado o domingo más cercano.
El tipo de valor devuelto puede configurarse mediante [`enable_extended_results_for_datetime_functions`](/es/reference/settings/session-settings#enable_extended_results_for_datetime_functions).
**Sintaxis**
```sql theme={null}
toLastDayOfWeek(datetime[, mode[, timezone]])
```
**Argumentos**
* `datetime` — Una fecha o una fecha con hora que se va a convertir. [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`Date32`](/es/reference/data-types/date32) o [`DateTime64`](/es/reference/data-types/datetime64)
* `mode` — Determina el primer día de la semana, tal como se describe en la función `toWeek()`. Valor predeterminado: `0`. [`UInt8`](/es/reference/data-types/int-uint)
* `timezone` — Opcional. La zona horaria que se usará para la conversión. Si no se especifica, se usa la zona horaria del servidor. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve la fecha del sábado o domingo más próximo, en esa fecha o después de ella, según el modo. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32)
**Ejemplos**
**Redondear hacia arriba al sábado o domingo más próximo**
```sql title=Query theme={null}
SELECT
toLastDayOfWeek(toDateTime('2023-04-21 10:20:30')), /* un viernes */
toLastDayOfWeek(toDateTime('2023-04-21 10:20:30'), 1), /* un viernes */
toLastDayOfWeek(toDate('2023-04-23')), /* un domingo */
toLastDayOfWeek(toDate('2023-04-23'), 1) /* un domingo */
FORMAT Vertical
```
```response title=Response theme={null}
Fila 1:
──────
toLastDayOfWeek(toDateTime('2023-04-21 10:20:30')): 2023-04-23
toLastDayOfWeek(toDateTime('2023-04-21 10:20:30'), 1): 2023-04-22
toLastDayOfWeek(toDate('2023-04-23')): 2023-04-23
toLastDayOfWeek(toDate('2023-04-23'), 1): 2023-04-23
```
## toMillisecond
Introducido en: v24.2.0
Devuelve el componente de milisegundo (0-999) de un valor `DateTime` o `DateTime64`.
**Sintaxis**
```sql theme={null}
toMillisecond(datetime)
```
**Aliases**: `MILLISECOND`
**Argumentos**
* `datetime` — Fecha y hora de la que se obtiene el milisegundo. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve el milisegundo del minuto (0 - 59) de `datetime`. [`UInt16`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT toMillisecond(toDateTime64('2023-04-21 10:20:30.456', 3));
```
```response title=Response theme={null}
┌──toMillisecond(toDateTime64('2023-04-21 10:20:30.456', 3))─┐
│ 456 │
└────────────────────────────────────────────────────────────┘
```
## toMinute
Introducido en: v1.1.0
Devuelve el componente de minuto (0-59) de un valor `Date` o `DateTime`.
**Sintaxis**
```sql theme={null}
toMinute(datetime)
```
**Alias**: `MINUTE`
**Argumentos**
* `datetime` — Fecha y hora de la que se extrae el minuto. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve el minuto de la hora (0 - 59) de `datetime`. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT toMinute(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toMinute(toDateTime('2023-04-21 10:20:30'))─┐
│ 20 │
└─────────────────────────────────────────────┘
```
## toModifiedJulianDay
Introducido en: v21.1.0
Convierte una fecha del [calendario gregoriano proléptico](https://en.wikipedia.org/wiki/Proleptic_Gregorian_calendar) en formato de texto `YYYY-MM-DD` en un número de [día juliano modificado](https://en.wikipedia.org/wiki/Julian_day#Variants) de tipo `Int32`. Esta función admite fechas desde `0000-01-01` hasta `9999-12-31`. Genera una excepción si el argumento no puede interpretarse como una fecha o si la fecha no es válida.
**Sintaxis**
```sql theme={null}
toModifiedJulianDay(date)
```
**Argumentos**
* `date` — La fecha en formato de cadena. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)
**Valor devuelto**
Devuelve el número de día juliano modificado. [`Int32`](/es/reference/data-types/int-uint)
**Ejemplos**
**Convertir la fecha a día juliano modificado**
```sql title=Query theme={null}
SELECT toModifiedJulianDay('2020-01-01')
```
```response title=Response theme={null}
┌─toModifiedJulianDay('2020-01-01')─┐
│ 58849 │
└───────────────────────────────────┘
```
## toModifiedJulianDayOrNull
Introducida en: v21.1.0
Similar a [`toModifiedJulianDay()`](#toModifiedJulianDay), pero en lugar de lanzar una excepción devuelve `NULL`.
**Sintaxis**
```sql theme={null}
toModifiedJulianDayOrNull(date)
```
**Argumentos**
* `date` — Fecha en formato de texto. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)
**Valor devuelto**
Devuelve el número de día juliano modificado para un `date` válido; de lo contrario, `null`. [`Nullable(Int32)`](/es/reference/data-types/nullable)
**Ejemplos**
**Convertir una fecha a día juliano modificado con manejo de `null`**
```sql title=Query theme={null}
SELECT toModifiedJulianDayOrNull('2020-01-01');
SELECT toModifiedJulianDayOrNull('0000-00-00'); -- fecha inválida, devuelve NULL
```
```response title=Response theme={null}
┌─toModifiedJu⋯020-01-01')─┐
│ 58849 │
└──────────────────────────┘
┌─toModifiedJu⋯000-00-00')─┐
│ ᴺᵁᴸᴸ │
└──────────────────────────┘
```
## toMonday
Introducido en: v1.1.0
Redondea una fecha o fecha con hora hacia abajo hasta el lunes de la misma semana. Devuelve la fecha.
El tipo de dato devuelto se puede configurar mediante la opción [`enable_extended_results_for_datetime_functions`](/es/reference/settings/session-settings#enable_extended_results_for_datetime_functions).
**Sintaxis**
```sql theme={null}
toMonday(value)
```
**Argumentos**
* `value` — Fecha o fecha con hora que se redondea hacia abajo hasta el lunes de esa semana. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve la fecha del lunes de la misma semana correspondiente a la fecha o fecha con hora proporcionada. [`Date`](/es/reference/data-types/date)
**Ejemplos**
**Redondear hacia abajo hasta el lunes de la semana**
```sql title=Query theme={null}
SELECT
toMonday(toDateTime('2023-04-21 10:20:30')), -- Un viernes
toMonday(toDate('2023-04-24')); -- Ya es lunes
```
```response title=Response theme={null}
┌─toMonday(toDateTime('2023-04-21 10:20:30'))─┬─toMonday(toDate('2023-04-24'))─┐
│ 2023-04-17 │ 2023-04-24 │
└─────────────────────────────────────────────┴────────────────────────────────┘
```
## toMonth
Introducido en: v1.1.0
Devuelve el componente mes (1-12) de un valor `Date` o `DateTime`.
**Sintaxis**
```sql theme={null}
toMonth(datetime)
```
**Alias**: `MONTH`
**Argumentos**
* `datetime` — Fecha o fecha con hora de la que se extrae el mes. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve el mes de la fecha/hora indicada [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT toMonth(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toMonth(toDateTime('2023-04-21 10:20:30'))─┐
│ 4 │
└────────────────────────────────────────────┘
```
## toMonthNumSinceEpoch
Introducido en: v25.3.0
Devuelve el número de meses transcurridos desde el año 1970
**Sintaxis**
```sql theme={null}
toMonthNumSinceEpoch(date)
```
**Argumentos**
* `date` — Una fecha o una fecha con hora. [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Entero positivo
**Ejemplos**
**Ejemplo**
```sql title=Query theme={null}
SELECT toMonthNumSinceEpoch(toDate('2024-10-01'))
```
```response title=Response theme={null}
657
```
## toQuarter
Introducido en: v1.1.0
Devuelve el trimestre del año (1-4) correspondiente a un valor `Date` o `DateTime`.
**Sintaxis**
```sql theme={null}
toQuarter(datetime)
```
**Alias**: `QUARTER`
**Argumentos**
* `datetime` — Fecha o fecha con hora de la que se obtiene el trimestre del año. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve el trimestre del año de la fecha/hora indicada [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT toQuarter(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toQuarter(toDateTime('2023-04-21 10:20:30'))─┐
│ 2 │
└──────────────────────────────────────────────┘
```
## toRelativeDayNum
Introducido en: v1.1.0
Convierte una fecha o una fecha con hora en el número de días transcurridos desde un punto fijo determinado en el pasado.
El momento exacto es un detalle de implementación y, por lo tanto, esta función no está pensada para usarse por sí sola.
El propósito principal de la función es calcular la diferencia en días entre dos fechas o fechas con hora; por ejemplo, `toRelativeDayNum(dt1) - toRelativeDayNum(dt2)`.
**Sintaxis**
```sql theme={null}
toRelativeDayNum(date)
```
**Argumentos**
* `date` — Fecha o fecha con hora. [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve el número de días desde un punto de referencia fijo en el pasado. [`UInt32`](/es/reference/data-types/int-uint)
**Ejemplos**
**Obtener números relativos de día**
```sql title=Query theme={null}
SELECT toRelativeDayNum(toDate('2023-04-01')) - toRelativeDayNum(toDate('2023-01-01'))
```
```response title=Response theme={null}
┌─minus(toRela⋯3-01-01')))─┐
│ 90 │
└──────────────────────────┘
```
## toRelativeHourNum
Introducido en: v1.1.0
Convierte una fecha o una fecha con hora en el número de horas transcurridas desde un determinado punto fijo en el pasado.
El momento exacto es un detalle de implementación, por lo que esta función no está pensada para usarse de forma independiente.
El propósito principal de esta función es calcular la diferencia en horas entre dos fechas o fechas con hora; por ejemplo, `toRelativeHourNum(dt1) - toRelativeHourNum(dt2)`.
**Sintaxis**
```sql theme={null}
toRelativeHourNum(date)
```
**Argumentos**
* `date` — Fecha o fecha con hora. [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve el número de horas desde un punto de referencia fijo en el pasado. [`UInt32`](/es/reference/data-types/int-uint)
**Ejemplos**
**Obtener números de hora relativos**
```sql title=Query theme={null}
SELECT toRelativeHourNum(toDateTime('2023-01-01 12:00:00')) - toRelativeHourNum(toDateTime('2023-01-01 00:00:00')) AS hours_difference
```
```response title=Response theme={null}
┌─hours_difference─┐
│ 12 │
└──────────────────┘
```
## toRelativeMinuteNum
Introducido en: v1.1.0
Convierte una fecha o una fecha con hora en el número de minutos transcurridos desde un momento fijo determinado en el pasado.
El momento exacto es un detalle de implementación y, por lo tanto, esta función no está pensada para usarse de forma independiente.
El propósito principal de la función es calcular la diferencia en minutos entre dos fechas o fechas con hora; por ejemplo, `toRelativeMinuteNum(dt1) - toRelativeMinuteNum(dt2)`.
**Sintaxis**
```sql theme={null}
toRelativeMinuteNum(date)
```
**Argumentos**
* `date` — Fecha o fecha con hora. [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve el número de minutos desde un punto de referencia fijo en el pasado. [`UInt32`](/es/reference/data-types/int-uint)
**Ejemplos**
**Obtener números de minutos relativos**
```sql title=Query theme={null}
SELECT toRelativeMinuteNum(toDateTime('2023-01-01 00:30:00')) - toRelativeMinuteNum(toDateTime('2023-01-01 00:00:00')) AS minutes_difference
```
```response title=Response theme={null}
┌─minutes_difference─┐
│ 30 │
└────────────────────┘
```
## toRelativeMonthNum
Introducido en: v1.1.0
Convierte una fecha o una fecha con hora en el número de meses transcurridos desde un determinado punto fijo del pasado.
El momento exacto es un detalle de implementación y, por lo tanto, esta función no está pensada para usarse por sí sola.
El propósito principal de la función es calcular la diferencia en meses entre dos fechas o fechas con hora; por ejemplo, `toRelativeMonthNum(dt1) - toRelativeMonthNum(dt2)`.
**Sintaxis**
```sql theme={null}
toRelativeMonthNum(date)
```
**Argumentos**
* `date` — Fecha o fecha con hora. [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve el número de meses desde un punto de referencia fijo en el pasado. [`UInt32`](/es/reference/data-types/int-uint)
**Ejemplos**
**Obtener números relativos de meses**
```sql title=Query theme={null}
SELECT toRelativeMonthNum(toDate('2023-04-01')) - toRelativeMonthNum(toDate('2023-01-01')) AS months_difference
```
```response title=Response theme={null}
┌─months_difference─┐
│ 3 │
└───────────────────┘
```
## toRelativeQuarterNum
Introducido en: v1.1.0
Convierte una fecha o una fecha con hora en el número de trimestres transcurridos desde un determinado punto fijo del pasado.
El momento exacto es un detalle de implementación y, por lo tanto, esta función no está pensada para usarse de forma independiente.
El propósito principal de la función es calcular la diferencia en trimestres entre dos fechas o fechas con hora; por ejemplo, `toRelativeQuarterNum(dt1) - toRelativeQuarterNum(dt2)`.
**Sintaxis**
```sql theme={null}
toRelativeQuarterNum(date)
```
**Argumentos**
* `date` — Fecha o fecha con hora. [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve el número de trimestres desde un punto de referencia fijo en el pasado. [`UInt32`](/es/reference/data-types/int-uint)
**Ejemplos**
**Obtener números de trimestre relativos**
```sql title=Query theme={null}
SELECT toRelativeQuarterNum(toDate('2023-04-01')) - toRelativeQuarterNum(toDate('2023-01-01')) AS quarters_difference
```
```response title=Response theme={null}
┌─quarters_difference─┐
│ 1 │
└─────────────────────┘
```
## toRelativeSecondNum
Introducido en: v1.1.0
Convierte una fecha o una fecha con hora en el número de segundos transcurridos desde un determinado punto fijo del pasado.
El punto exacto en el tiempo es un detalle de implementación y, por lo tanto, esta función no está pensada para usarse por sí sola.
La finalidad principal de la función es calcular la diferencia en segundos entre dos fechas o fechas con hora; por ejemplo, `toRelativeSecondNum(dt1) - toRelativeSecondNum(dt2)`.
**Sintaxis**
```sql theme={null}
toRelativeSecondNum(date)
```
**Argumentos**
* `date` — Fecha o fecha y hora. [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve el número de segundos desde un punto de referencia fijo en el pasado. [`UInt32`](/es/reference/data-types/int-uint)
**Ejemplos**
**Obtener números de segundos relativos**
```sql title=Query theme={null}
SELECT toRelativeSecondNum(toDateTime('2023-01-01 00:01:00')) - toRelativeSecondNum(toDateTime('2023-01-01 00:00:00')) AS seconds_difference
```
```response title=Response theme={null}
┌─seconds_difference─┐
│ 60 │
└────────────────────┘
```
## toRelativeWeekNum
Introducido en: v1.1.0
Convierte una fecha o una fecha con hora en el número de semanas transcurridas desde un determinado punto fijo del pasado.
El momento exacto es un detalle de implementación y, por lo tanto, esta función no está pensada para usarse de forma independiente.
La finalidad principal de esta función es calcular la diferencia en semanas entre dos fechas o fechas con hora; por ejemplo, `toRelativeWeekNum(dt1) - toRelativeWeekNum(dt2)`.
**Sintaxis**
```sql theme={null}
toRelativeWeekNum(date)
```
**Argumentos**
* `date` — Fecha o fecha con hora. [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve el número de semanas desde un punto de referencia fijo en el pasado. [`UInt32`](/es/reference/data-types/int-uint)
**Ejemplos**
**Obtener números de semana relativos**
```sql title=Query theme={null}
SELECT toRelativeWeekNum(toDate('2023-01-08')) - toRelativeWeekNum(toDate('2023-01-01')) AS weeks_difference
```
```response title=Response theme={null}
┌─weeks_difference─┐
│ 1 │
└──────────────────┘
```
## toRelativeYearNum
Introducido en: v1.1.0
Convierte una fecha o una fecha con hora en el número de años transcurridos desde un punto fijo determinado en el pasado.
El momento exacto es un detalle de implementación y, por lo tanto, esta función no está pensada para usarse
por sí sola. El propósito principal de la función es calcular la diferencia en años entre dos fechas o fechas con hora, por ejemplo, `toRelativeYearNum(dt1) - toRelativeYearNum(dt2)`.
**Sintaxis**
```sql theme={null}
toRelativeYearNum(date)
```
**Argumentos**
* `date` — Fecha o fecha con hora. [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve el número de años desde un punto de referencia fijo en el pasado. [`UInt16`](/es/reference/data-types/int-uint)
**Ejemplos**
**Obtener números relativos de año**
```sql title=Query theme={null}
SELECT toRelativeYearNum('2010-10-01'::DateTime) - toRelativeYearNum('2000-01-01'::DateTime)
```
```response title=Response theme={null}
┌─minus(toRela⋯ateTime')))─┐
│ 10 │
└──────────────────────────┘
```
## toSecond
Introducido en: v1.1.0
Devuelve el componente de segundo (0-59) de un valor `DateTime` o `DateTime64`.
**Sintaxis**
```sql theme={null}
toSecond(datetime)
```
**Alias**: `SECOND`
**Argumentos**
* `datetime` — Fecha con hora de la que se obtiene el segundo. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve el segundo del minuto (0 - 59) de `datetime`. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT toSecond(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toSecond(toDateTime('2023-04-21 10:20:30'))─┐
│ 30 │
└─────────────────────────────────────────────┘
```
## toStartOfDay
Introducido en: v1.1.0
Redondea una fecha con hora hacia abajo hasta el inicio del día.
El tipo de retorno se puede configurar mediante la opción [`enable_extended_results_for_datetime_functions`](/es/reference/settings/session-settings#enable_extended_results_for_datetime_functions).
**Sintaxis**
```sql theme={null}
toStartOfDay(datetime)
```
**Argumentos**
* `datetime` — Una fecha o una fecha con hora que se va a redondear. [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime)
**Valor devuelto**
Devuelve la fecha con hora redondeada hacia abajo hasta el inicio del día. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Redondear hacia abajo hasta el inicio del día**
```sql title=Query theme={null}
SELECT toStartOfDay(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toStartOfDay(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-04-21 00:00:00 │
└─────────────────────────────────────────────────┘
```
## toStartOfFifteenMinutes
Introducido en: v1.1.0
Redondea la fecha con hora hacia abajo hasta el inicio del intervalo de quince minutos.
El tipo de retorno puede configurarse mediante la opción [`enable_extended_results_for_datetime_functions`](/es/reference/settings/session-settings#enable_extended_results_for_datetime_functions).
**Sintaxis**
```sql theme={null}
toStartOfFifteenMinutes(datetime)
```
**Argumentos**
* `datetime` — Una fecha o una fecha con hora para redondear. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve la fecha con hora redondeada al inicio del intervalo de quince minutos más cercano. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Ejemplo**
```sql title=Query theme={null}
SELECT
toStartOfFifteenMinutes(toDateTime('2023-04-21 10:17:00')),
toStartOfFifteenMinutes(toDateTime('2023-04-21 10:20:00')),
toStartOfFifteenMinutes(toDateTime('2023-04-21 10:23:00'))
FORMAT Vertical
```
```response title=Response theme={null}
Fila 1:
──────
toStartOfFifteenMinutes(toDateTime('2023-04-21 10:17:00')): 2023-04-21 10:15:00
toStartOfFifteenMinutes(toDateTime('2023-04-21 10:20:00')): 2023-04-21 10:15:00
toStartOfFifteenMinutes(toDateTime('2023-04-21 10:23:00')): 2023-04-21 10:15:00
```
## toStartOfFiveMinutes
Introducido en: v22.6.0
Redondea hacia abajo una fecha con hora al inicio del intervalo de cinco minutos más cercano.
El tipo de retorno se puede configurar mediante la opción [`enable_extended_results_for_datetime_functions`](/es/reference/settings/session-settings#enable_extended_results_for_datetime_functions).
**Sintaxis**
```sql theme={null}
toStartOfFiveMinutes(datetime)
```
**Alias**: `toStartOfFiveMinute`
**Argumentos**
* `datetime` — Una fecha con hora que se va a redondear. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve la fecha con hora redondeada al inicio del intervalo de cinco minutos más cercano. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Ejemplo**
```sql title=Query theme={null}
SELECT
toStartOfFiveMinutes(toDateTime('2023-04-21 10:17:00')),
toStartOfFiveMinutes(toDateTime('2023-04-21 10:20:00')),
toStartOfFiveMinutes(toDateTime('2023-04-21 10:23:00'))
FORMAT Vertical
```
```response title=Response theme={null}
Fila 1:
──────
toStartOfFiveMinutes(toDateTime('2023-04-21 10:17:00')): 2023-04-21 10:15:00
toStartOfFiveMinutes(toDateTime('2023-04-21 10:20:00')): 2023-04-21 10:20:00
toStartOfFiveMinutes(toDateTime('2023-04-21 10:23:00')): 2023-04-21 10:20:00
```
## toStartOfHour
Introducido en: v1.1.0
Redondea una fecha con hora hacia abajo hasta el inicio de la hora.
El tipo de retorno se puede configurar con la opción [`enable_extended_results_for_datetime_functions`](/es/reference/settings/session-settings#enable_extended_results_for_datetime_functions).
**Sintaxis**
```sql theme={null}
toStartOfHour(datetime)
```
**Argumentos**
* `datetime` — Una fecha con hora que se va a redondear. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve la fecha con hora redondeada hacia abajo al inicio de la hora. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Redondear hacia abajo al inicio de la hora**
```sql title=Query theme={null}
SELECT
toStartOfHour(toDateTime('2023-04-21 10:20:30'));
```
```response title=Response theme={null}
┌─────────────────res─┬─toTypeName(res)─┐
│ 2023-04-21 10:00:00 │ DateTime │
└─────────────────────┴─────────────────┘
```
## toStartOfISOYear
Introducido en: v1.1.0
Redondea hacia abajo una fecha o fecha con hora hasta el primer día del año ISO, que puede diferir de un año natural normal. Consulte la [fecha de semana ISO](https://en.wikipedia.org/wiki/ISO_week_date).
El tipo de retorno se puede configurar mediante la opción [`enable_extended_results_for_datetime_functions`](/es/reference/settings/session-settings#enable_extended_results_for_datetime_functions).
**Sintaxis**
```sql theme={null}
toStartOfISOYear(value)
```
**Argumentos**
* `value` — La fecha o fecha con hora que se debe redondear al primer día del año ISO. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve el primer día del año ISO correspondiente a la fecha o fecha con hora proporcionada. [`Date`](/es/reference/data-types/date)
**Ejemplos**
**Redondear al primer día del año ISO**
```sql title=Query theme={null}
SELECT toStartOfISOYear(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toStartOfISOYear(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-01-02 │
└─────────────────────────────────────────────────────┘
```
## toStartOfInterval
Introducido en: v20.1.0
Esta función generaliza otras funciones `toStartOf*()` mediante la sintaxis `toStartOfInterval(date_or_date_with_time, INTERVAL x unit [, time_zone])`.
Por ejemplo:
* `toStartOfInterval(t, INTERVAL 1 YEAR)` devuelve lo mismo que `toStartOfYear(t)`,
* `toStartOfInterval(t, INTERVAL 1 MONTH)` devuelve lo mismo que `toStartOfMonth(t)`,
* `toStartOfInterval(t, INTERVAL 1 DAY)` devuelve lo mismo que `toStartOfDay(t)`,
* `toStartOfInterval(t, INTERVAL 15 MINUTE)` devuelve lo mismo que `toStartOfFifteenMinutes(t)`.
El cálculo se realiza con respecto a momentos concretos:
| Intervalo | Inicio |
| -------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------ |
| YEAR | año 0 |
| QUARTER | 1900 T1 |
| MONTH | enero de 1900 |
| WEEK | 1970, 1.ª semana (01-05) |
| DAY | 1970-01-01 |
| HOUR | (\*) |
| MINUTE | 1970-01-01 00:00:00 |
| SECOND | 1970-01-01 00:00:00 |
| MILLISECOND | 1970-01-01 00:00:00 |
| MICROSECOND | 1970-01-01 00:00:00 |
| NANOSECOND | 1970-01-01 00:00:00 |
| (\*) los intervalos de horas son especiales: el cálculo siempre se realiza con respecto a las 00:00:00 (medianoche) del día actual. Como resultado, solo | |
| los valores de hora entre 1 y 23 son útiles. | |
Si se especifica la unidad `WEEK`, `toStartOfInterval` asume que las semanas empiezan en lunes. Tenga en cuenta que este comportamiento es distinto del de la función `toStartOfWeek`, en la que las semanas empiezan en domingo de forma predeterminada.
La segunda sobrecarga emula la función `time_bucket()` de TimescaleDB y, de forma equivalente, la función `date_bin()` de PostgreSQL.
**Sintaxis**
```sql theme={null}
toStartOfInterval(value, INTERVAL x unit[, time_zone])
toStartOfInterval(value, INTERVAL x unit[, origin[, time_zone]])
```
**Alias**: `time_bucket`, `date_bin`
**Argumentos**
* `value` — Valor de fecha o de fecha con hora que se redondea hacia abajo. [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `x` — Longitud numérica del intervalo. - `unit` — Unidad de intervalo: YEAR, QUARTER, MONTH, WEEK, DAY, HOUR, MINUTE, SECOND, MILLISECOND, MICROSECOND, NANOSECOND. - `time_zone` — Opcional. Nombre de la zona horaria como cadena. - `origin` — Opcional. Punto de origen para el cálculo (solo en la segunda sobrecarga).
**Valor devuelto**
Devuelve el inicio del intervalo que contiene el valor de entrada. [`DateTime`](/es/reference/data-types/datetime)
**Ejemplos**
**Redondeo básico de intervalos**
```sql title=Query theme={null}
SELECT toStartOfInterval(toDateTime('2023-01-15 14:30:00'), INTERVAL 1 MONTH)
```
```response title=Response theme={null}
┌─toStartOfInt⋯alMonth(1))─┐
│ 2023-01-01 │
└──────────────────────────┘
```
**Uso del punto de origen**
```sql title=Query theme={null}
SELECT toStartOfInterval(toDateTime('2023-01-01 14:45:00'), INTERVAL 1 MINUTE, toDateTime('2023-01-01 14:35:30'))
```
```response title=Response theme={null}
┌─toStartOfInt⋯14:35:30'))─┐
│ 2023-01-01 14:44:30 │
└──────────────────────────┘
```
## toStartOfMicrosecond
Introducido en: v22.6.0
Redondea hacia abajo una fecha con hora al inicio del microsegundo.
**Sintaxis**
```sql theme={null}
toStartOfMicrosecond(datetime[, timezone])
```
**Argumentos**
* `datetime` — Fecha y hora. [`DateTime64`](/es/reference/data-types/datetime64)
* `timezone` — Opcional. Zona horaria del valor devuelto. Si no se especifica, la función usa la zona horaria del parámetro `value`. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Valor de entrada con submicrosegundos [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Consulta sin zona horaria**
```sql title=Query theme={null}
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMicrosecond(dt64);
```
```response title=Response theme={null}
┌────toStartOfMicrosecond(dt64)─┐
│ 2020-01-01 10:20:30.999999000 │
└───────────────────────────────┘
```
**Consulta con zona horaria**
```sql title=Query theme={null}
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMicrosecond(dt64, 'Asia/Istanbul');
```
```response title=Response theme={null}
┌─toStartOfMicrosecond(dt64, 'Asia/Istanbul')─┐
│ 2020-01-01 12:20:30.999999000 │
└─────────────────────────────────────────────┘
```
## toStartOfMillisecond
Introducido en: v22.6.0
Redondea hacia abajo una fecha con hora hasta el inicio del milisegundo.
**Sintaxis**
```sql theme={null}
toStartOfMillisecond(datetime[, timezone])
```
**Argumentos**
* `datetime` — Fecha y hora. [`DateTime64`](/es/reference/data-types/datetime64)
* `timezone` — Opcional. Zona horaria del valor devuelto. Si no se especifica, la función usa la zona horaria del parámetro `value`. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Valor de entrada con fracciones de milisegundo. [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Consulta sin zona horaria**
```sql title=Query theme={null}
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMillisecond(dt64);
```
```response title=Response theme={null}
┌────toStartOfMillisecond(dt64)─┐
│ 2020-01-01 10:20:30.999000000 │
└───────────────────────────────┘
```
**Consulta con zona horaria**
```sql title=Query theme={null}
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMillisecond(dt64, 'Asia/Istanbul');
```
```response title=Response theme={null}
┌─toStartOfMillisecond(dt64, 'Asia/Istanbul')─┐
│ 2020-01-01 12:20:30.999000000 │
└─────────────────────────────────────────────┘
```
## toStartOfMinute
Introducido en: v1.1.0
Redondea hacia abajo una fecha con hora al inicio del minuto.
El tipo de retorno se puede configurar mediante el ajuste [`enable_extended_results_for_datetime_functions`](/es/reference/settings/session-settings#enable_extended_results_for_datetime_functions).
**Sintaxis**
```sql theme={null}
toStartOfMinute(datetime)
```
**Argumentos**
* `datetime` — Una fecha con hora que se va a redondear. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve la fecha con hora redondeada hacia abajo al inicio del minuto. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Redondear hacia abajo al inicio del minuto**
```sql title=Query theme={null}
SELECT
toStartOfMinute(toDateTime('2023-04-21 10:20:30')),
toStartOfMinute(toDateTime64('2023-04-21 10:20:30.5300', 8))
FORMAT Vertical
```
```response title=Response theme={null}
Fila 1:
──────
toStartOfMinute(toDateTime('2023-04-21 10:20:30')): 2023-04-21 10:20:00
toStartOfMinute(toDateTime64('2023-04-21 10:20:30.5300', 8)): 2023-04-21 10:20:00
```
## toStartOfMonth
Introducido en: v1.1.0
Redondea una fecha o una fecha con hora al primer día del mes.
El tipo de retorno se puede configurar mediante [`enable_extended_results_for_datetime_functions`](/es/reference/settings/session-settings#enable_extended_results_for_datetime_functions).
**Sintaxis**
```sql theme={null}
toStartOfMonth(value)
```
**Argumentos**
* `value` — La fecha o fecha con hora que se redondea hacia abajo hasta el primer día del mes. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve el primer día del mes correspondiente a la fecha o fecha con hora dada. [`Date`](/es/reference/data-types/date)
**Ejemplos**
**Redondear hacia abajo hasta el primer día del mes**
```sql title=Query theme={null}
SELECT toStartOfMonth(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toStartOfMonth(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-04-01 │
└───────────────────────────────────────────────────┘
```
## toStartOfNanosecond
Introducido en: v22.6.0
Redondea hacia abajo una fecha con hora hasta el inicio del nanosegundo.
**Sintaxis**
```sql theme={null}
toStartOfNanosecond(datetime[, timezone])
```
**Argumentos**
* `datetime` — Fecha y hora. [`DateTime64`](/es/reference/data-types/datetime64)
* `timezone` — Opcional. Zona horaria del valor devuelto. Si no se especifica, la función utiliza la zona horaria del parámetro `value`. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Valor de entrada con nanosegundos. [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Consulta sin zona horaria**
```sql title=Query theme={null}
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfNanosecond(dt64);
```
```response title=Response theme={null}
┌─────toStartOfNanosecond(dt64)─┐
│ 2020-01-01 10:20:30.999999999 │
└───────────────────────────────┘
```
**Consulta con zona horaria**
```sql title=Query theme={null}
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfNanosecond(dt64, 'Asia/Istanbul');
```
```response title=Response theme={null}
┌─toStartOfNanosecond(dt64, 'Asia/Istanbul')─┐
│ 2020-01-01 12:20:30.999999999 │
└────────────────────────────────────────────┘
```
## toStartOfQuarter
Introducido en: v1.1.0
Redondea una fecha o fecha con hora hacia abajo hasta el primer día del trimestre. El primer día del trimestre es el 1 de enero, el 1 de abril, el 1 de julio o el 1 de octubre.
El tipo de retorno se puede configurar mediante el ajuste [`enable_extended_results_for_datetime_functions`](/es/reference/settings/session-settings#enable_extended_results_for_datetime_functions).
**Sintaxis**
```sql theme={null}
toStartOfQuarter(value)
```
**Argumentos**
* `value` — La fecha o fecha con hora que se redondeará al primer día del trimestre. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve el primer día del trimestre para la fecha o fecha con hora proporcionada. [`Date`](/es/reference/data-types/date)
**Ejemplos**
**Redondear al primer día del trimestre**
```sql title=Query theme={null}
SELECT toStartOfQuarter(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toStartOfQuarter(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-04-01 │
└─────────────────────────────────────────────────────┘
```
## toStartOfSecond
Introducido en: v20.5.0
Redondea hacia abajo una fecha con hora al inicio del segundo.
**Sintaxis**
```sql theme={null}
toStartOfSecond(datetime[, timezone])
```
**Argumentos**
* `datetime` — Fecha y hora de la que se truncarán las fracciones de segundo. [`DateTime64`](/es/reference/data-types/datetime64)
* `timezone` — Opcional. Zona horaria del valor devuelto. Si no se especifica, la función usa la zona horaria del parámetro `value`. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve el valor de entrada sin fracciones de segundo. [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Consulta sin zona horaria**
```sql title=Query theme={null}
WITH toDateTime64('2020-01-01 10:20:30.999', 3) AS dt64
SELECT toStartOfSecond(dt64);
```
```response title=Response theme={null}
┌───toStartOfSecond(dt64)─┐
│ 2020-01-01 10:20:30.000 │
└─────────────────────────┘
```
**Consulta con zona horaria**
```sql title=Query theme={null}
WITH toDateTime64('2020-01-01 10:20:30.999', 3) AS dt64
SELECT toStartOfSecond(dt64, 'Asia/Istanbul');
```
```response title=Response theme={null}
┌─toStartOfSecond(dt64, 'Asia/Istanbul')─┐
│ 2020-01-01 13:20:30.000 │
└────────────────────────────────────────┘
```
## toStartOfTenMinutes
Introducido en: v20.1.0
Redondea una fecha con hora hacia abajo hasta el inicio del intervalo de diez minutos más cercano.
El tipo de retorno se puede configurar mediante [`enable_extended_results_for_datetime_functions`](/es/reference/settings/session-settings#enable_extended_results_for_datetime_functions).
**Sintaxis**
```sql theme={null}
toStartOfTenMinutes(datetime)
```
**Argumentos**
* `datetime` — Una fecha con hora. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve la fecha con hora redondeadas al inicio del intervalo de diez minutos más cercano. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Ejemplo**
```sql title=Query theme={null}
SELECT
toStartOfTenMinutes(toDateTime('2023-04-21 10:17:00')),
toStartOfTenMinutes(toDateTime('2023-04-21 10:20:00')),
toStartOfTenMinutes(toDateTime('2023-04-21 10:23:00'))
FORMAT Vertical
```
```response title=Response theme={null}
Fila 1:
──────
toStartOfTenMinutes(toDateTime('2023-04-21 10:17:00')): 2023-04-21 10:10:00
toStartOfTenMinutes(toDateTime('2023-04-21 10:20:00')): 2023-04-21 10:20:00
toStartOfTenMinutes(toDateTime('2023-04-21 10:23:00')): 2023-04-21 10:20:00
```
## toStartOfWeek
Introducido en: v20.1.0
Redondea una fecha o una fecha con hora al domingo o lunes más cercano anterior.
El tipo de retorno se puede configurar mediante el ajuste [`enable_extended_results_for_datetime_functions`](/es/reference/settings/session-settings#enable_extended_results_for_datetime_functions).
**Sintaxis**
```sql theme={null}
toStartOfWeek(datetime[, mode[, timezone]])
```
**Argumentos**
* `datetime` — Una fecha o una fecha con hora que se va a convertir. [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`Date32`](/es/reference/data-types/date32) o [`DateTime64`](/es/reference/data-types/datetime64)
* `mode` — Determina el primer día de la semana, como se describe en la función `toWeek()`. El valor predeterminado es `0`. [`UInt8`](/es/reference/data-types/int-uint)
* `timezone` — La zona horaria que se usará para la conversión. Si no se especifica, se usa la zona horaria del servidor. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve la fecha del domingo o lunes más cercano que coincida con la fecha dada o la preceda, según el modo. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32)
**Ejemplos**
**Redondear hacia abajo al domingo o lunes más cercano**
```sql title=Query theme={null}
SELECT
toStartOfWeek(toDateTime('2023-04-21 10:20:30')), /* un viernes */
toStartOfWeek(toDateTime('2023-04-21 10:20:30'), 1), /* un viernes */
toStartOfWeek(toDate('2023-04-24')), /* un lunes */
toStartOfWeek(toDate('2023-04-24'), 1) /* un lunes */
FORMAT Vertical
```
```response title=Response theme={null}
Fila 1:
──────
toStartOfWeek(toDateTime('2023-04-21 10:20:30')): 2023-04-17
toStartOfWeek(toDateTime('2023-04-21 10:20:30'), 1): 2023-04-17
toStartOfWeek(toDate('2023-04-24')): 2023-04-24
toStartOfWeek(toDate('2023-04-24'), 1): 2023-04-24
```
## toStartOfYear
Introducido en: v1.1.0
Redondea hacia abajo una fecha o una fecha con hora hasta el primer día del año. Devuelve la fecha como un objeto `Date`.
El tipo de retorno se puede configurar mediante [`enable_extended_results_for_datetime_functions`](/es/reference/settings/session-settings#enable_extended_results_for_datetime_functions).
**Sintaxis**
```sql theme={null}
toStartOfYear(value)
```
**Argumentos**
* `value` — La fecha o fecha con hora que se redondea a la baja. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve el primer día del año de la fecha/hora proporcionada [`Date`](/es/reference/data-types/date)
**Ejemplos**
**Redondeo a la baja al primer día del año**
```sql title=Query theme={null}
SELECT toStartOfYear(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toStartOfYear(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-01-01 │
└──────────────────────────────────────────────────┘
```
## toTimeWithFixedDate
Introducido en: v1.1.0
Extrae el componente horario de una fecha o de una fecha con hora.
El resultado devuelto es un desplazamiento con respecto a un punto fijo en el tiempo, actualmente `1970-01-02`,
pero el punto exacto en el tiempo es un detalle de implementación que podría cambiar en el futuro.
Por lo tanto, `toTime` no debe usarse de forma aislada.
El propósito principal de la función es calcular la diferencia de tiempo entre dos fechas o fechas con hora; por ejemplo, `toTime(dt1) - toTime(dt2)`.
**Sintaxis**
```sql theme={null}
toTimeWithFixedDate(date[, timezone])
```
**Argumentos**
* `date` — Fecha que se convertirá en una hora. [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `timezone` — Opcional. Zona horaria del valor devuelto. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve el componente de hora de una fecha o fecha con hora como un desplazamiento respecto a un punto fijo en el tiempo (actualmente, 1970-01-02). [`DateTime`](/es/reference/data-types/datetime)
**Ejemplos**
**Calcular la diferencia horaria entre dos fechas**
```sql title=Query theme={null}
SELECT toTimeWithFixedDate('2025-06-15 12:00:00'::DateTime) - toTimeWithFixedDate('2024-05-10 11:00:00'::DateTime) AS result, toTypeName(result)
```
```response title=Response theme={null}
┌─result─┬─toTypeName(result)─┐
│ 3600 │ Int32 │
└────────┴────────────────────┘
```
## toTimezone
Introducido en: v1.1.0
Convierte un `DateTime` o `DateTime64` a la zona horaria especificada.
El valor interno (número de segundos de Unix) del dato no cambia.
Solo cambian el atributo de zona horaria del valor y su representación en cadena.
**Sintaxis**
```sql theme={null}
toTimezone(datetime, timezone)
```
**Aliases**: `toTimeZone`
**Argumentos**
* `date` — El valor que se convertirá. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `timezone` — El nombre de la zona horaria de destino. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve la misma marca de tiempo que la de entrada, pero con la zona horaria especificada [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT toDateTime('2019-01-01 00:00:00', 'UTC') AS time_utc,
toTypeName(time_utc) AS type_utc,
toInt32(time_utc) AS int32utc,
toTimezone(time_utc, 'Asia/Yekaterinburg') AS time_yekat,
toTypeName(time_yekat) AS type_yekat,
toInt32(time_yekat) AS int32yekat,
toTimezone(time_utc, 'US/Samoa') AS time_samoa,
toTypeName(time_samoa) AS type_samoa,
toInt32(time_samoa) AS int32samoa
FORMAT Vertical;
```
```response title=Response theme={null}
Row 1:
──────
time_utc: 2019-01-01 00:00:00
type_utc: DateTime('UTC')
int32utc: 1546300800
time_yekat: 2019-01-01 05:00:00
type_yekat: DateTime('Asia/Yekaterinburg')
int32yekat: 1546300800
time_samoa: 2018-12-31 13:00:00
type_samoa: DateTime('US/Samoa')
int32samoa: 1546300800
```
## toUTCTimestamp
Introducido en: v23.8.0
Convierte un valor de fecha o de fecha con hora de una zona horaria a una marca temporal UTC. Esta función se incluye principalmente por compatibilidad con Apache Spark y frameworks similares.
**Sintaxis**
```sql theme={null}
toUTCTimestamp(datetime, time_zone)
```
**Alias**: `to_utc_timestamp`
**Argumentos**
* `datetime` — Un valor constante de tipo fecha o fecha con hora, o una expresión. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `time_zone` — Un valor constante de tipo String, o una expresión que representa la zona horaria. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve una fecha o fecha con hora en la zona horaria UTC. [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Ejemplos**
**Convertir la zona horaria a UTC**
```sql title=Query theme={null}
SELECT toUTCTimestamp(toDateTime('2023-03-16'), 'Asia/Shanghai')
```
```response title=Response theme={null}
┌─toUTCTimestamp(toDateTime('2023-03-16'), 'Asia/Shanghai')─┐
│ 2023-03-15 16:00:00 │
└─────────────────────────────────────────────────────────┘
```
## toUnixTimestamp
Introducido en: v1.1.0
Convierte un `String`, `Date` o `DateTime` en un timestamp Unix (segundos desde `1970-01-01 00:00:00 UTC`) como un `UInt32`.
**Sintaxis**
```sql theme={null}
toUnixTimestamp(date[, timezone])
```
**Argumentos**
* `date` — Valor que se va a convertir. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64) o [`String`](/es/reference/data-types/string)
* `timezone` — Opcional. Zona horaria que se utilizará para la conversión. Si no se especifica, se usa la zona horaria del servidor. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve la marca de tiempo Unix. [`UInt32`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT
'2017-11-05 08:07:47' AS dt_str,
toUnixTimestamp(dt_str) AS from_str,
toUnixTimestamp(dt_str, 'Asia/Tokyo') AS from_str_tokyo,
toUnixTimestamp(toDateTime(dt_str)) AS from_datetime,
toUnixTimestamp(toDateTime64(dt_str, 0)) AS from_datetime64,
toUnixTimestamp(toDate(dt_str)) AS from_date,
toUnixTimestamp(toDate32(dt_str)) AS from_date32
FORMAT Vertical;
```
```response title=Response theme={null}
Fila 1:
──────
dt_str: 2017-11-05 08:07:47
from_str: 1509869267
from_str_tokyo: 1509836867
from_datetime: 1509869267
from_datetime64: 1509869267
from_date: 1509840000
from_date32: 1509840000
```
## toWeek
Introducido en: v20.1.0
Esta función devuelve el número de semana de una fecha o fecha con hora. La forma de dos argumentos de `toWeek()` permite especificar si la semana comienza
en domingo o lunes y si el valor devuelto debe estar en el rango de `0` a `53` o de `1` a `53`.
[`toISOWeek()`](#toWeek) es una función de compatibilidad equivalente a `toWeek(date,3)`.
La siguiente tabla describe cómo funciona el argumento `mode`.
| Mode | First day of week | Range | Week 1 is the first week ... |
| ---- | ----------------- | ----- | ----------------------------- |
| 0 | Sunday | 0-53 | with a Sunday in this year |
| 1 | Monday | 0-53 | with 4 or more days this year |
| 2 | Sunday | 1-53 | with a Sunday in this year |
| 3 | Monday | 1-53 | with 4 or more days this year |
| 4 | Sunday | 0-53 | with 4 or more days this year |
| 5 | Monday | 0-53 | with a Monday in this year |
| 6 | Sunday | 1-53 | with 4 or more days this year |
| 7 | Monday | 1-53 | with a Monday in this year |
| 8 | Sunday | 1-53 | contains January 1 |
| 9 | Monday | 1-53 | contains January 1 |
Para los valores de `mode` con el significado de "con 4 o más días en este año", las semanas se numeran según ISO 8601:1988:
* Si la semana que contiene el 1 de enero tiene 4 o más días en el nuevo año, es la semana 1.
* En caso contrario, es la última semana del año anterior, y la semana siguiente es la semana 1.
Para los valores de `mode` con el significado de "contiene el 1 de enero", la semana que contiene el 1 de enero es la semana 1.
No importa cuántos días del nuevo año contenga esa semana, aunque contenga solo un día.
Es decir, si la última semana de diciembre contiene el 1 de enero del año siguiente, será la semana 1 del año siguiente.
El primer argumento también puede especificarse como [`String`](/es/reference/data-types/string) en un formato compatible con [`parseDateTime64BestEffort()`](/es/reference/functions/regular-functions/type-conversion-functions#parseDateTime64BestEffort). La compatibilidad con argumentos de tipo cadena existe solo por motivos de compatibilidad con MySQL, ya que ciertas herramientas de 3rd party la requieren. Como la compatibilidad con argumentos de tipo cadena puede pasar a depender en el futuro de nuevas configuraciones de compatibilidad con MySQL y, además, el análisis de cadenas suele ser lento, se recomienda no usarla.
**Sintaxis**
```sql theme={null}
toWeek(datetime[, mode[, time_zone]])
```
**Alias**: `week`
**Argumentos**
* `datetime` — Fecha o fecha con hora a partir de la cual se obtiene el número de semana. [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime)
* `mode` — Opcional. Un valor de `0` a `9` determina el primer día de la semana y el rango del número de semana. Valor predeterminado: `0`. - `time_zone` — Opcional. Zona horaria. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve el número de semana según el modo especificado. [`UInt32`](/es/reference/data-types/int-uint)
**Ejemplos**
**Obtener el número de semana con diferentes modos**
```sql title=Query theme={null}
SELECT toDate('2016-12-27') AS date, toWeek(date) AS week0, toWeek(date,1) AS week1, toWeek(date,9) AS week9
```
```response title=Response theme={null}
┌───────date─┬─week0─┬─week1─┬─week9─┐
│ 2016-12-27 │ 52 │ 52 │ 1 │
└────────────┴───────┴───────┴───────┘
```
## toYYYYMM
Introducido en: v1.1.0
Convierte una fecha o una fecha con hora en un número `UInt32` que contiene el año y el número del mes (YYYY \* 100 + MM).
Acepta un segundo argumento opcional de zona horaria. Si se especifica, la zona horaria debe ser una constante de cadena.
Esta función es la inversa de la función `YYYYMMDDToDate()`.
**Sintaxis**
```sql theme={null}
toYYYYMM(datetime[, timezone])
```
**Argumentos**
* `datetime` — Una fecha o una fecha con hora para convertir. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `timezone` — Opcional. Zona horaria para la conversión. Si se proporciona, la zona horaria debe ser una constante de cadena. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve un número UInt32 que contiene el año y el número del mes (YYYY \* 100 + MM). [`UInt32`](/es/reference/data-types/int-uint)
**Ejemplos**
**Convertir la fecha actual al formato YYYYMM**
```sql title=Query theme={null}
SELECT toYYYYMM(now(), 'US/Eastern')
```
```response title=Response theme={null}
┌─toYYYYMM(now(), 'US/Eastern')─┐
│ 202303 │
└───────────────────────────────┘
```
## toYYYYMMDD
Introducido en: v1.1.0
Convierte una fecha o una fecha con hora en un número `UInt32` que contiene el año, el mes y el día (YYYY \* 10000 + MM \* 100 + DD). Acepta un segundo argumento opcional de zona horaria. Si se proporciona, la zona horaria debe ser una constante de cadena.
**Sintaxis**
```sql theme={null}
toYYYYMMDD(datetime[, timezone])
```
**Argumentos**
* `datetime` — Una fecha o una fecha con hora que se va a convertir. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `timezone` — Opcional. Zona horaria para la conversión. Si se especifica, la zona horaria debe ser una constante de cadena. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve un valor `UInt32` que contiene el año, el mes y el día (YYYY \* 10000 + MM \* 100 + DD). [`UInt32`](/es/reference/data-types/int-uint)
**Ejemplos**
**Convertir la fecha actual al formato YYYYMMDD**
```sql title=Query theme={null}
SELECT toYYYYMMDD(now(), 'US/Eastern')
```
```response title=Response theme={null}
┌─toYYYYMMDD(now(), 'US/Eastern')─┐
│ 20230302 │
└─────────────────────────────────┘
```
## toYYYYMMDDhhmmss
Introducido en: v1.1.0
Convierte una fecha o una fecha con hora en un número `UInt64` que contiene el año, el mes y el día (YYYY \* 10000000000 + MM \* 100000000 + DD \* 1000000 + hh \* 10000 + mm \* 100 + ss).
Acepta un segundo argumento opcional de zona horaria. Si se proporciona, la zona horaria debe ser una constante de cadena.
**Sintaxis**
```sql theme={null}
toYYYYMMDDhhmmss(datetime[, timezone])
```
**Argumentos**
* `datetime` — Fecha o fecha con hora que se va a convertir. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `timezone` — Opcional. Zona horaria para la conversión. Si se proporciona, la zona horaria debe ser una constante de cadena. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve un número `UInt64` que contiene el año, el mes, el día, la hora, el minuto y el segundo (YYYY \* 10000000000 + MM \* 100000000 + DD \* 1000000 + hh \* 10000 + mm \* 100 + ss). [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Convertir la fecha y hora actuales al formato YYYYMMDDhhmmss**
```sql title=Query theme={null}
SELECT toYYYYMMDDhhmmss(now(), 'US/Eastern')
```
```response title=Response theme={null}
┌─toYYYYMMDDhhmmss(now(), 'US/Eastern')─┐
│ 20230302112209 │
└───────────────────────────────────────┘
```
## toYear
Introducido en: v1.1.0
Devuelve el componente de año (d. C.) de un valor `Date` o `DateTime`.
**Sintaxis**
```sql theme={null}
toYear(datetime)
```
**Alias**: `YEAR`
**Argumentos**
* `datetime` — Fecha o fecha con hora de la que se obtiene el año. [`Date`](/es/reference/data-types/date) o [`Date32`](/es/reference/data-types/date32) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve el año de la `Date` o `DateTime` proporcionada [`UInt16`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT toYear(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toYear(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023 │
└───────────────────────────────────────────┘
```
## toYearNumSinceEpoch
Introducido en: v25.3.0
Devuelve el número de años transcurridos desde 1970
**Sintaxis**
```sql theme={null}
toYearNumSinceEpoch(date)
```
**Argumentos**
* `date` — Una fecha o una fecha con hora que se va a convertir. [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Entero positivo
**Ejemplos**
**Ejemplo**
```sql title=Query theme={null}
SELECT toYearNumSinceEpoch(toDate('2024-10-01'))
```
```response title=Response theme={null}
54
```
## toYearWeek
Introduced in: v20.1.0
Devuelve el año y la semana de una fecha. El año del resultado puede ser distinto del año del argumento de fecha en la primera y la última semana del año.
El argumento mode funciona igual que el argumento mode de [`toWeek()`](/es/reference/functions/regular-functions/date-time-functions#toWeek).
Advertencia: El número de semana que devuelve `toYearWeek()` puede ser diferente del que devuelve `toWeek()`. `toWeek()` siempre devuelve el número de semana en el contexto del año indicado y, si `toWeek()` devuelve `0`, `toYearWeek()` devuelve el valor correspondiente a la última semana del año anterior. Consulte `prev_yearWeek` en el ejemplo siguiente.
El primer argumento también puede especificarse como [`String`](/es/reference/data-types/string) en un formato compatible con [`parseDateTime64BestEffort()`](/es/reference/functions/regular-functions/type-conversion-functions#parseDateTime64BestEffort). La compatibilidad con argumentos de cadena existe solo por motivos de compatibilidad con MySQL, ya que determinadas herramientas de 3rd party la requieren. Como en el futuro la compatibilidad con argumentos de cadena podría pasar a depender de nuevas configuraciones de compatibilidad con MySQL y, además, el análisis de cadenas suele ser lento, se recomienda no usarla.
**Sintaxis**
```sql theme={null}
toYearWeek(datetime[, mode[, timezone]])
```
**Alias**: `yearweek`
**Argumentos**
* `datetime` — Fecha o fecha con hora de la que se obtienen el año y la semana. [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime)
* `mode` — Opcional. Un valor de `0` a `9` que determina el primer día de la semana y el rango del número de semana. El valor predeterminado es `0`. - `timezone` — Opcional. Zona horaria. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve el año y el número de semana como un único valor entero. [`UInt32`](/es/reference/data-types/int-uint)
**Ejemplos**
**Obtener combinaciones de año-semana con distintos modos**
```sql title=Query theme={null}
SELECT toDate('2016-12-27') AS date, toYearWeek(date) AS yearWeek0, toYearWeek(date,1) AS yearWeek1, toYearWeek(date,9) AS yearWeek9, toYearWeek(toDate('2022-01-01')) AS prev_yearWeek
```
```response title=Response theme={null}
┌───────date─┬─yearWeek0─┬─yearWeek1─┬─yearWeek9─┬─prev_yearWeek─┐
│ 2016-12-27 │ 201652 │ 201652 │ 201701 │ 202152 │
└────────────┴───────────┴───────────┴───────────┴───────────────┘
```
## today
Introducido en: v1.1.0
Devuelve la fecha actual en el momento del análisis de la consulta. Igual que `toDate(now())`.
**Sintaxis**
```sql theme={null}
today()
```
**Alias**: `curdate`, `current_date`
**Argumentos**
* Ninguno.
**Valor devuelto**
Devuelve la fecha actual [`Date`](/es/reference/data-types/date)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT today() AS today, curdate() AS curdate, current_date() AS current_date FORMAT Pretty
```
```response title=Response theme={null}
┏━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━┓
┃ today ┃ curdate ┃ current_date ┃
┡━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━┩
│ 2025-03-03 │ 2025-03-03 │ 2025-03-03 │
└────────────┴────────────┴──────────────┘
```
**Sintaxis SQL estándar sin paréntesis**
```sql title=Query theme={null}
SELECT TODAY, CURDATE,CURRENT_DATE
```
```response title=Response theme={null}
┏━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━┓
┃ TODAY ┃ CURDATE ┃ CURRENT_DATE ┃
┡━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━┩
│ 2025-03-04 │ 2025-03-04 │ 2025-03-04 │
└────────────┴────────────┴──────────────┘
```
## yesterday
Introducido en: v1.1.0
No acepta argumentos y devuelve la fecha de ayer en uno de los puntos del análisis de la consulta.
**Sintaxis**
```sql theme={null}
yesterday()
```
**Argumentos**
* Ninguno.
**Valor devuelto**
Devuelve la fecha de ayer. [`Date`](/es/reference/data-types/date)
**Ejemplos**
**Obtener la fecha de ayer**
```sql title=Query theme={null}
SELECT yesterday();
SELECT today() - 1;
```
```response title=Response theme={null}
┌─yesterday()─┐
│ 2025-06-09 │
└─────────────┘
┌─minus(today(), 1)─┐
│ 2025-06-09 │
└───────────────────┘
```