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
SELECT
toDateTime('2016-06-15 23:00:00') AS time,
toDate(time) AS date_local,
toDate(time, 'Asia/Yekaterinburg') AS date_yekat,
toString(time, 'US/Samoa') AS time_samoa
┌────────────────time─┬─date_local─┬─date_yekat─┬─time_samoa──────────┐
│ 2016-06-15 23:00:00 │ 2016-06-15 │ 2016-06-16 │ 2016-06-15 09:00:00 │
└─────────────────────┴────────────┴────────────┴─────────────────────┘
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.
now('UTC'). Se añadió únicamente por compatibilidad con MySQL. Se recomienda usar now.
Sintaxis
Alias: UTC_timestamp
Argumentos
Valor devuelto
Devuelve la fecha y hora actuales en el momento del análisis de la consulta. DateTime
Ejemplos
Obtener la marca de tiempo UTC actual
┌──────UTCTimestamp()─┐
│ 2024-05-28 08:32:09 │
└─────────────────────┘
Date.
Esta función es la opuesta de la función toYYYYMMDD().
El resultado no está definido si la entrada no codifica un valor Date válido.
Sintaxis
Argumentos
Valor devuelto
Devuelve un valor de tipo Date a partir de los argumentos proporcionados Date
Ejemplos
Ejemplo
SELECT YYYYMMDDToDate(20230911);
┌─toYYYYMMDD(20230911)─┐
│ 2023-09-11 │
└──────────────────────┘
Date32.
Esta función es la opuesta de la función toYYYYMMDD().
La salida no está definida si la entrada no codifica un valor Date32 válido.
Sintaxis
YYYYMMDDToDate32(YYYYMMDD)
Date32 a partir de los argumentos proporcionados Date32
Ejemplos
Ejemplo
SELECT YYYYMMDDToDate32(20000507);
┌─YYYYMMDDToDate32(20000507)─┐
│ 2000-05-07 │
└────────────────────────────┘
DateTime.
Esta función es la opuesta de la función toYYYYMMDDhhmmss().
La salida no está definida si la entrada no codifica un valor DateTime válido.
Sintaxis
YYYYMMDDhhmmssToDateTime(YYYYMMDDhhmmss[, timezone])
YYYYMMDDhhmmss — Número que contiene el año, mes, día, hora, minuto y segundo. (U)Int* o Float* o Decimaltimezone — Nombre de la zona horaria. String
Valor devuelto
Devuelve un valor DateTime a partir de los argumentos indicados DateTime
Ejemplos
Ejemplo
SELECT YYYYMMDDToDateTime(20230911131415);
┌──────YYYYMMDDhhmmssToDateTime(20230911131415)─┐
│ 2023-09-11 13:14:15 │
└───────────────────────────────────────────────┘
YYYYMMDDhhmmssToDateTime64
DateTime64.
Esta función es lo contrario de la función toYYYYMMDDhhmmss().
La salida no está definida si la entrada no codifica un valor DateTime64 válido.
Sintaxis
YYYYMMDDhhmmssToDateTime64(YYYYMMDDhhmmss[, precision[, timezone]])
YYYYMMDDhhmmss — Número que contiene el año, el mes, el día, la hora, el minuto y el segundo. (U)Int* o Float* o Decimalprecision — Precisión de la parte fraccionaria (0-9). UInt8timezone — Nombre de la zona horaria. String
Valor devuelto
Devuelve un valor DateTime64 a partir de los argumentos proporcionados DateTime64
Ejemplos
Ejemplo
SELECT YYYYMMDDhhmmssToDateTime64(20230911131415, 3, 'Asia/Istanbul');
┌─YYYYMMDDhhmm⋯/Istanbul')─┐
│ 2023-09-11 13:14:15.000 │
└──────────────────────────┘
addDate(datetime, interval)
interval a datetime. Date or Date32 or DateTime or DateTime64
Ejemplos
Añadir un intervalo a una fecha
SELECT addDate(toDate('2018-01-01'), INTERVAL 3 YEAR)
┌─addDate(toDa⋯valYear(3))─┐
│ 2021-01-01 │
└──────────────────────────┘
datetime más num días. Date o Date32 o DateTime o DateTime64
Ejemplos
Añadir días a distintos tipos de fecha
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
┌─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 │
└────────────────────┴─────────────────────────┴────────────────────────────────┘
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 day)
┌─plus(CAST('1⋯valDay(10))─┐
│ 1998-06-26 │
└──────────────────────────┘
datetime más num horas DateTime o DateTime64(3)
Ejemplos
Añadir horas a distintos tipos de fecha
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
┌─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 │
└─────────────────────┴──────────────────────────┴─────────────────────────────────┘
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 hour)
┌─plus(CAST('1⋯alHour(10))─┐
│ 1998-06-16 10:00:00 │
└──────────────────────────┘
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).
addInterval(interval_1, interval_2)
Tuple(Interval)
Ejemplos
Sumar intervalos
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)
┌─addInterval(toIntervalDay(1), toIntervalMonth(1))─┐
│ (1,1) │
└───────────────────────────────────────────────────┘
┌─addInterval((toIntervalDay(1), toIntervalYear(1)), toIntervalMonth(1))─┐
│ (1,1,1) │
└────────────────────────────────────────────────────────────────────────┘
┌─addInterval(toIntervalDay(2), toIntervalDay(1))─┐
│ (3) │
└─────────────────────────────────────────────────┘
addMicroseconds(datetime, num)
date_time más num microsegundos DateTime64
Ejemplos
Añadir microsegundos a distintos tipos de fecha con hora
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
┌─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 │
└─────────────────────────────────┴────────────────────────────────────────┘
SELECT dateAdd('1998-06-16'::DateTime, INTERVAL 10 microsecond)
┌─plus(CAST('19⋯osecond(10))─┐
│ 1998-06-16 00:00:00.000010 │
└────────────────────────────┘
addMilliseconds(datetime, num)
datetime con num milisegundos añadidos DateTime64
Ejemplos
Añadir milisegundos a distintos tipos de fecha y hora
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
┌─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 │
└─────────────────────────────────┴────────────────────────────────────────┘
SELECT dateAdd('1998-06-16'::DateTime, INTERVAL 10 millisecond)
┌─plus(CAST('1⋯second(10))─┐
│ 1998-06-16 00:00:00.010 │
└──────────────────────────┘
addMinutes(datetime, num)
datetime más num minutos. DateTime o DateTime64(3)
Ejemplos
Añadir minutos a distintos tipos de fecha
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
┌─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 │
└───────────────────────┴────────────────────────────┴───────────────────────────────────┘
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 minute)
┌─plus(CAST('1⋯Minute(10))─┐
│ 1998-06-16 00:10:00 │
└──────────────────────────┘
datetime con num meses añadidos Date o Date32 o DateTime o DateTime64
Ejemplos
Añadir meses a distintos tipos de fecha
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
┌─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 │
└──────────────────────┴───────────────────────────┴──────────────────────────────────┘
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 month)
┌─plus(CAST('1⋯lMonth(10))─┐
│ 1999-04-16 │
└──────────────────────────┘
addNanoseconds(datetime, num)
datetime más num nanosegundos DateTime64
Ejemplos
Sumar nanosegundos a distintos tipos de fecha y hora
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
┌─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 │
└────────────────────────────────┴───────────────────────────────────────┘
SELECT dateAdd('1998-06-16'::DateTime, INTERVAL 1000 nanosecond)
┌─plus(CAST('199⋯osecond(1000))─┐
│ 1998-06-16 00:00:00.000001000 │
└───────────────────────────────┘
addQuarters(datetime, num)
datetime más num trimestres. Date o Date32 o DateTime o DateTime64
Ejemplos
Añadir trimestres a distintos tipos de fecha
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
┌─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 │
└────────────────────────┴─────────────────────────────┴────────────────────────────────────┘
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 quarter)
┌─plus(CAST('1⋯uarter(10))─┐
│ 2000-12-16 │
└──────────────────────────┘
addSeconds(datetime, num)
datetime más num segundos DateTime o DateTime64(3)
Ejemplos
Añadir segundos a distintos tipos de fecha
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
┌─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 │
└───────────────────────┴────────────────────────────┴───────────────────────────────────┘
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 second)
┌─dateAdd('1998-06-16'::Date, INTERVAL 10 second)─┐
│ 1998-06-16 00:00:10 │
└─────────────────────────────────────────────────┘
addTupleOfIntervals(datetime, intervals)
date con intervals añadidos. Date o Date32 o DateTime o DateTime64
Ejemplos
Añadir una tupla de intervalos a una fecha
WITH toDate('2018-01-01') AS date
SELECT addTupleOfIntervals(date, (INTERVAL 1 DAY, INTERVAL 1 MONTH, INTERVAL 1 YEAR))
┌─addTupleOfIntervals(date, (toIntervalDay(1), toIntervalMonth(1), toIntervalYear(1)))─┐
│ 2019-02-02 │
└──────────────────────────────────────────────────────────────────────────────────────┘
datetime más num semanas Date o Date32 o DateTime o DateTime64
Ejemplos
Añadir semanas a distintos tipos de fecha
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
┌─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 │
└─────────────────────┴──────────────────────────┴─────────────────────────────────┘
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 week)
┌─plus(CAST('1⋯alWeek(10))─┐
│ 1998-08-25 │
└──────────────────────────┘
datetime más num años. Date o Date32 o DateTime o DateTime64
Ejemplos
Añadir años a distintos tipos de fecha
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
┌─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 │
└─────────────────────┴──────────────────────────┴─────────────────────────────────┘
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 year)
┌─plus(CAST('1⋯alYear(10))─┐
│ 2008-06-16 │
└──────────────────────────┘
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.
Sintaxis
age('unit', startdate, enddate[, timezone])
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 o Date32 o DateTime o DateTime64enddate — El segundo valor temporal del que se resta (el minuendo). Date o Date32 o DateTime o DateTime64timezone — 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
Valor devuelto
Devuelve la diferencia entre enddate y startdate expresada en unit. Int32
Ejemplos
Calcular la edad en horas
SELECT age('hour', toDateTime('2018-01-01 22:30:00'), toDateTime('2018-01-02 23:00:00'))
┌─age('hour', toDateTime('2018-01-01 22:30:00'), toDateTime('2018-01-02 23:00:00'))─┐
│ 24 │
└───────────────────────────────────────────────────────────────────────────────────┘
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
┌──────────e─┬──────────s─┬─day_age─┬─month_age─┬─year_age─┐
│ 2022-01-01 │ 2021-12-29 │ 3 │ 0 │ 0 │
└────────────┴────────────┴─────────┴───────────┴──────────┘
changeDay(date_or_datetime, value)
date_or_datetime, con el componente de día modificado. Date o Date32 o DateTime o DateTime64
Ejemplos
Ejemplo de uso
SELECT changeDay('2024-01-31'::DateTime, 15)
changeHour(date_or_datetime, value)
date_or_datetime, con el componente de hora modificado. DateTime o DateTime64
Ejemplos
Ejemplo de uso
SELECT changeHour('2024-01-01 12:00:00'::DateTime, 5)
fecha o fecha y hora.
Sintaxis
changeMinute(date_or_datetime, value)
date_or_datetime, con el componente de minutos modificado. DateTime o DateTime64
Ejemplos
Ejemplo de uso
SELECT changeMinute('2024-01-01 12:30:00'::DateTime, 45)
changeMonth(date_or_datetime, value)
date_or_datetime, con el componente de mes modificado. Date o Date32 o DateTime o DateTime64
Ejemplos
Ejemplo de uso
SELECT changeMonth('2024-01-01'::DateTime, 12)
changeSecond(date_or_datetime, value)
date_or_datetime, con el componente de segundos modificado. DateTime o DateTime64
Ejemplos
Ejemplo de uso
SELECT changeSecond('2024-01-01 12:30:45'::DateTime, 15)
changeYear(date_or_datetime, value)
date_or_datetime con el componente de año modificado. Date o Date32 o DateTime o DateTime64
Ejemplos
Ejemplo de uso
SELECT changeYear('2024-01-01'::DateTime, 2023)
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), 1 mes para la unidad month (consulte toRelativeMonthNum) y 1 año para la unidad year
(consulte 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.
Sintaxis
dateDiff(unit, startdate, enddate[, timezone])
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 o Date32 o DateTime o DateTime64enddate — El segundo valor de tiempo del que se resta (el minuendo). Date o Date32 o DateTime o DateTime64timezone — 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
Valor devuelto
Devuelve la diferencia entre enddate y startdate expresada en unit. Int64
Ejemplos
Calcular la diferencia entre fechas en horas
SELECT dateDiff('hour', toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00')) AS res
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
┌──────────e─┬──────────s─┬─day_diff─┬─month_diff─┬─year_diff─┐
│ 2022-01-01 │ 2021-12-29 │ 3 │ 1 │ 1 │
└────────────┴────────────┴──────────┴────────────┴───────────┘
- ‘year’
- ‘quarter’
- ‘month’
- ‘week’
- ‘dayofyear’
- ‘day’
- ‘weekday’
- ‘hour’
- ‘minute’
- ‘second’
Sintaxis
dateName(date_part, date[, timezone])
String
Ejemplos
Extraer distintas partes de la fecha
WITH toDateTime('2021-04-14 11:22:33') AS date_value
SELECT
dateName('year', date_value),
dateName('month', date_value),
dateName('day', date_value)
┌─dateName('year', date_value)─┬─dateName('month', date_value)─┬─dateName('day', date_value)─┐
│ 2021 │ April │ 14 │
└──────────────────────────────┴───────────────────────────────┴─────────────────────────────┘
dateTrunc(unit, datetime[, timezone])
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.
Stringdatetime — Fecha y hora. Date o Date32 o DateTime o DateTime64timezone — 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
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 o Date |
| Día, Hora, Minuto, Segundo | Date32, DateTime64, Date o DateTime | DateTime64 o DateTime |
| Milisegundo, Microsegundo, | Cualquiera | DateTime64 |
| Nanosegundo | | con escala 3, 6 o 9 |
SELECT now(), dateTrunc('hour', now());
┌───────────────now()─┬─dateTrunc('hour', now())──┐
│ 2020-09-28 10:40:45 │ 2020-09-28 10:00:00 │
└─────────────────────┴───────────────────────────┘
SELECT now(), dateTrunc('hour', now(), 'Asia/Istanbul');
┌───────────────now()─┬─dateTrunc('hour', now(), 'Asia/Istanbul')──┐
│ 2020-09-28 10:46:26 │ 2020-09-28 13:00:00 │
└─────────────────────┴────────────────────────────────────────────┘
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.
La operación opuesta de esta función es 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
formatDateTime(datetime, format[, timezone])
DATE_FORMAT
Argumentos
datetime — Una fecha o una fecha y hora para formatear. Date o Date32 o DateTime o DateTime64format — Cadena de formato con campos de reemplazo. Stringtimezone — Opcional. Nombre de la zona horaria para la hora formateada. String
Valor devuelto
Devuelve valores de fecha y hora según el formato especificado. String
Ejemplos
Formatear una fecha con el marcador de posición del año
SELECT formatDateTime(toDate('2010-01-04'), '%g')
┌─formatDateTime(toDate('2010-01-04'), '%g')─┐
│ 10 │
└────────────────────────────────────────────┘
SELECT formatDateTime(toDateTime64('2010-01-04 12:34:56.123456', 7), '%f')
┌─formatDateTime(toDateTime64('2010-01-04 12:34:56.123456', 7), '%f')─┐
│ 1234560 │
└─────────────────────────────────────────────────────────────────────┘
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
┌──────────────────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 │
└─────────────────────┴───────────────────┴─────────────┘
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.
La operación opuesta de esta función es 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 | ’ |
formatDateTimeInJodaSyntax(datetime, format[, timezone])
datetime — Una fecha o una fecha y hora para formatear. DateTime o Date o Date32 o DateTime64format — Cadena de formato con campos de sustitución de estilo Joda. Stringtimezone — Opcional. Nombre de la zona horaria para la hora formateada. String
Valor devuelto
Devuelve valores de fecha y hora según el formato especificado. String
Ejemplos
Formatear datetime con sintaxis Joda
SELECT formatDateTimeInJodaSyntax(toDateTime('2010-01-04 12:34:56'), 'yyyy-MM-dd HH:mm:ss')
┌─formatDateTimeInJodaSyntax(toDateTime('2010-01-04 12:34:56'), 'yyyy-MM-dd HH:mm:ss')─┐
│ 2010-01-04 12:34:56 │
└─────────────────────────────────────────────────────────────────────────────────────────┘
FROM_DAYS() de MySQL. El resultado no está definido si no puede representarse dentro de los límites del tipo Date.
Sintaxis
fromDaysSinceYearZero(days)
FROM_DAYS
Argumentos
days — La cantidad de días transcurridos desde el año cero. UInt32
Valor devuelto
Devuelve la fecha correspondiente a la cantidad de días transcurridos desde el año cero. Date
Ejemplos
Convertir los días transcurridos desde el año cero en fechas
SELECT
fromDaysSinceYearZero(739136) AS date1,
fromDaysSinceYearZero(toDaysSinceYearZero(toDate('2023-09-08'))) AS date2
┌──────date1─┬──────date2─┐
│ 2023-09-08 │ 2023-09-08 │
└────────────┴────────────┘
FROM_DAYS() de MySQL. El resultado no está definido si no puede representarse dentro de los límites del tipo Date32.
Sintaxis
fromDaysSinceYearZero32(days)
days — El número de días transcurridos desde el año cero. UInt32
Valor devuelto
Devuelve la fecha correspondiente al número de días transcurridos desde el año cero. Date32
Ejemplos
Convertir días desde el año cero en fechas
SELECT
fromDaysSinceYearZero32(739136) AS date1,
fromDaysSinceYearZero32(toDaysSinceYearZero(toDate('2023-09-08'))) AS date2
┌──────date1─┬──────date2─┐
│ 2023-09-08 │ 2023-09-08 │
└────────────┴────────────┘
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
fromModifiedJulianDay(day)
day — número de Día Juliano Modificado. (U)Int*
Valor devuelto
Devuelve la fecha en formato de texto. String
Ejemplos
Convertir un Día Juliano Modificado en fecha
SELECT fromModifiedJulianDay(58849)
┌─fromModifiedJulianDay(58849)─┐
│ 2020-01-01 │
└──────────────────────────────┘
fromModifiedJulianDayOrNull
fromModifiedJulianDay(), pero en lugar de lanzar una excepción, devuelve NULL.
Sintaxis
fromModifiedJulianDayOrNull(day)
day — número de día juliano modificado. (U)Int*
Valor devuelto
Devuelve la fecha en formato de texto cuando el argumento day es válido; de lo contrario, null. Nullable(String)
Ejemplos
Convertir el día juliano modificado en fecha con manejo de null
SELECT fromModifiedJulianDayOrNull(58849);
SELECT fromModifiedJulianDayOrNull(60000000); -- argumento inválido, devuelve NULL
┌─fromModified⋯Null(58849)─┐
│ 2020-01-01 │
└──────────────────────────┘
┌─fromModified⋯l(60000000)─┐
│ ᴺᵁᴸᴸ │
└──────────────────────────┘
fromUTCTimestamp(datetime, time_zone)
from_utc_timestamp
Argumentos
datetime — Un valor constante de fecha o fecha con hora, o una expresión. DateTime o DateTime64time_zone — Un valor constante de tipo String o una expresión que representa la zona horaria. String
Valor devuelto
Devuelve un valor DateTime/DateTime64 en la zona horaria especificada. DateTime o DateTime64
Ejemplos
Convierte la zona horaria UTC a la zona horaria especificada
SELECT fromUTCTimestamp(toDateTime64('2023-03-16 10:00:00', 3), 'Asia/Shanghai')
┌─fromUTCTimestamp(toDateTime64('2023-03-16 10:00:00',3), 'Asia/Shanghai')─┐
│ 2023-03-16 18:00:00.000 │
└─────────────────────────────────────────────────────────────────────────┘
- Cuando se le proporciona un solo argumento de tipo
Integer, devuelve un valor de tipo DateTime, es decir, se comporta como toDateTime.
- Cuando se le proporcionan dos o tres argumentos, donde el primer argumento es un valor de tipo
Integer, Date, Date32, DateTime o 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 decir, se comporta como formatDateTime.
En este caso, se usa el estilo de formato de fecha y hora de MySQL.
Sintaxis
fromUnixTimestamp(timestamp)
fromUnixTimestamp(timestamp[, format[, timezone]])
FROM_UNIXTIME
Argumentos
timestamp — marca de tiempo Unix o valor de fecha o fecha con hora. (U)Int* o Date o Date32 o DateTime o DateTime64format — Opcional. Cadena de formato constante para dar formato a la salida. Stringtimezone — Opcional. Cadena constante de zona horaria. 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 o String
Ejemplos
Convertir una marca de tiempo Unix a DateTime
SELECT fromUnixTimestamp(423543535)
┌─fromUnixTimestamp(423543535)─┐
│ 1983-06-04 10:58:55 │
└──────────────────────────────┘
SELECT fromUnixTimestamp(1234334543, '%Y-%m-%d %R:%S') AS DateTime
┌─DateTime────────────┐
│ 2009-02-11 14:42:23 │
└─────────────────────┘
fromUnixTimestampInJodaSyntax
Integer, devuelve un valor de tipo DateTime; es decir, se comporta como toDateTime.
Cuando recibe dos o tres argumentos, donde el primero es un valor de tipo Integer, Date, Date32, DateTime o 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 decir, se comporta como formatDateTimeInJodaSyntax. En este caso, se utiliza el estilo de formato de fecha y hora de Joda.
Sintaxis
fromUnixTimestampInJodaSyntax(timestamp)
fromUnixTimestampInJodaSyntax(timestamp, format[, timezone])
timestamp — marca de tiempo Unix o valor de fecha y hora. (U)Int* o Date o Date32 o DateTime o DateTime64format — Opcional. Cadena de formato constante con sintaxis Joda para el formato de salida. Stringtimezone — Opcional. Cadena constante de zona horaria. 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 o String
Ejemplos
Convertir una marca de tiempo Unix con formato Joda
SELECT fromUnixTimestampInJodaSyntax(1234334543, 'yyyy-MM-dd HH:mm:ss', 'UTC') AS DateTime
┌─DateTime────────────┐
│ 2009-02-11 06:42:23 │
└─────────────────────┘
Date a partir de:
- un año, un mes y un día
- un año y el día del año
Sintaxis
makeDate(year, month, day)
makeDate(year, day_of_year)
Date construido a partir de los argumentos proporcionados Date
Ejemplos
Fecha a partir de un año, mes y día
SELECT makeDate(2023, 2, 28) AS date;
┌───────date─┐
│ 2023-02-28 │
└────────────┘
SELECT makeDate(2023, 42) AS date;
┌───────date─┐
│ 2023-02-11 │
└────────────┘
Date32 a partir de:
- un año, un mes y un día
- un año y el día del año
Sintaxis
makeDate32(year, month, day)
makeDate32(year, day_of_year)
Date32 construido a partir de los argumentos proporcionados Date32
Ejemplos
Date32 a partir de un año, un mes y un día
SELECT makeDate(2023, 2, 28) AS date;
┌───────date─┐
│ 2023-02-28 │
└────────────┘
SELECT makeDate(2023, 42) AS date;
┌───────date─┐
│ 2023-02-11 │
└────────────┘
DateTime a partir del año, el mes, el día, la hora, el minuto y el segundo, con una zona horaria opcional.
Sintaxis
makeDateTime(year, month, day, hour, minute, second[, timezone])
DateTime construido a partir de los argumentos proporcionados DateTime
Ejemplos
DateTime a partir de año, mes, día, hora, minuto y segundo
SELECT makeDateTime(2023, 2, 28, 17, 12, 33) AS DateTime;
┌────────────DateTime─┐
│ 2023-02-28 17:12:33 │
└─────────────────────┘
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
makeDateTime64(year, month, day, hour, minute, second[, fraction[, precision[, timezone]]])
DateTime64 construido a partir de los argumentos proporcionados DateTime64
Ejemplos
DateTime64 a partir de year, month, day, hour, minute y second
SELECT makeDateTime64(2023, 5, 15, 10, 30, 45, 779, 5);
┌─makeDateTime64(2023, 5, 15, 10, 30, 45, 779, 5)─┐
│ 2023-05-15 10:30:45.00779 │
└─────────────────────────────────────────────────┘
String
Ejemplos
Obtener el nombre del mes a partir de una fecha
WITH toDateTime('2021-04-14 11:22:33') AS date_value
SELECT monthName(date_value)
┌─monthName(date_value)─┐
│ April │
└───────────────────────┘
current_timestamp
Argumentos
timezone — Opcional. Nombre de la zona horaria del valor devuelto. String
Valor devuelto
Devuelve la fecha y hora actuales. DateTime
Ejemplos
Consulta sin zona horaria
┌───────────────now()─┐
│ 2020-10-17 07:42:09 │
└─────────────────────┘
SELECT now('Asia/Istanbul')
┌─now('Asia/Istanbul')─┐
│ 2020-10-17 10:42:23 │
└──────────────────────┘
SELECT NOW, CURRENT_TIMESTAMP
┌─────────────────NOW─┬───CURRENT_TIMESTAMP─┐
│ 2020-10-17 07:42:19 │ 2020-10-17 07:42:19 │
└─────────────────────┴─────────────────────┘
now64([scale[, timezone]])
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). UInt8timezone — Opcional. Nombre de la zona horaria del valor devuelto. String
Valor devuelto
Devuelve la fecha y hora actuales con precisión de subsegundos. DateTime64
Ejemplos
Consulta con precisión predeterminada y personalizada
SELECT now64(), now64(9, 'Asia/Istanbul')
┌─────────────────now64()─┬─────now64(9, 'Asia/Istanbul')─┐
│ 2022-08-21 19:34:26.196 │ 2022-08-21 22:34:26.196542766 │
└─────────────────────────┴───────────────────────────────┘
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
Argumentos
timezone — Opcional. Nombre de la zona horaria del valor devuelto. String
Valor devuelto
Devuelve la fecha y hora actuales en el momento de procesarse cada bloque de datos. DateTime
Ejemplos
Diferencia con la función now()
SELECT
now(),
nowInBlock(),
sleep(1)
FROM numbers(3)
SETTINGS max_block_size = 1
FORMAT PrettyCompactMonoBlock
┌───────────────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([scale[, timezone]])
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). UInt8timezone — Opcional. Nombre de la zona horaria del valor devuelto. 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
Ejemplos
Diferencia con la función now64()
SELECT
now64(),
nowInBlock64(),
sleep(1)
FROM numbers(3)
SETTINGS max_block_size = 1
FORMAT PrettyCompactMonoBlock
┌─────────────────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 │
└─────────────────────────┴─────────────────────────┴──────────┘
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
Alias: serverTimeZone
Argumentos
Valor devuelto
Devuelve la zona horaria del servidor como una String
Ejemplos
Ejemplo de uso
┌─serverTimeZone()─┐
│ UTC │
└──────────────────┘
subDate(datetime, interval)
interval a datetime. Date o Date32 o DateTime o DateTime64
Ejemplos
Restar un intervalo a una fecha
SELECT subDate(toDate('2018-01-01'), INTERVAL 3 YEAR)
┌─subDate(toDate('2018-01-01'), toIntervalYear(3))─┐
│ 2015-01-01 │
└──────────────────────────────────────────────────┘
subtractDays(datetime, num)
datetime menos num días. Date o Date32 o DateTime o DateTime64
Ejemplos
Restar días a distintos tipos de fecha
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
┌─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 │
└─────────────────────────┴──────────────────────────────┴─────────────────────────────────────┘
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 day)
┌─minus(CAST('⋯valDay(10))─┐
│ 1998-06-06 │
└──────────────────────────┘
subtractHours(datetime, num)
datetime menos num horas. DateTime o DateTime64(3)
Ejemplos
Restar horas a distintos tipos de fecha
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
┌─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 │
└──────────────────────────┴───────────────────────────────┴──────────────────────────────────────┘
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 hour)
┌─minus(CAST('⋯alHour(10))─┐
│ 1998-06-15 14:00:00 │
└──────────────────────────┘
toIntervalDay(2) y toIntervalDay(1), el resultado será (1) en lugar de (2,1).
Sintaxis
subtractInterval(interval_1, interval_2)
Tuple(T)
Ejemplos
Restar intervalos
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);
┌─subtractInterval(toIntervalDay(1), toIntervalMonth(1))─┐
│ (1,-1) │
└────────────────────────────────────────────────────────┘
┌─subtractInterval((toIntervalDay(1), toIntervalYear(1)), toIntervalMonth(1))─┐
│ (1,1,-1) │
└─────────────────────────────────────────────────────────────────────────────┘
┌─subtractInterval(toIntervalDay(2), toIntervalDay(1))─┐
│ (1) │
└──────────────────────────────────────────────────────┘
subtractMicroseconds(datetime, num)
datetime menos num microsegundos DateTime64
Ejemplos
Restar microsegundos de distintos tipos de fecha y hora
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
┌─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 │
└──────────────────────────────────────┴─────────────────────────────────────────────┘
SELECT dateSub('1998-06-16'::DateTime, INTERVAL 10 microsecond)
┌─minus(CAST('1⋯osecond(10))─┐
│ 1998-06-15 23:59:59.999990 │
└────────────────────────────┘
subtractMilliseconds(datetime, num)
datetime menos num milisegundos DateTime64
Ejemplos
Resta milisegundos de distintos tipos de fecha y hora
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
┌─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 │
└──────────────────────────────────────┴─────────────────────────────────────────────┘
SELECT dateSub('1998-06-16'::DateTime, INTERVAL 10 millisecond)
┌─minus(CAST('⋯second(10))─┐
│ 1998-06-15 23:59:59.990 │
└──────────────────────────┘
subtractMinutes(datetime, num)
datetime menos num minutos. DateTime o DateTime64(3)
Ejemplos
Restar minutos a distintos tipos de fecha
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
┌─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 │
└────────────────────────────┴─────────────────────────────────┴────────────────────────────────────────┘
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 minute)
┌─minus(CAST('⋯Minute(10))─┐
│ 1998-06-15 23:50:00 │
└──────────────────────────┘
subtractMonths(datetime, num)
datetime menos num meses Date o Date32 o DateTime o DateTime64
Ejemplos
Restar meses a distintos tipos de fecha
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
┌─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 │
└───────────────────────────┴────────────────────────────────┴───────────────────────────────────────┘
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 month)
┌─minus(CAST('⋯lMonth(10))─┐
│ 1997-08-16 │
└──────────────────────────┘
subtractNanoseconds(datetime, num)
datetime menos num nanosegundos. DateTime64
Ejemplos
Restar nanosegundos a distintos tipos de fecha con hora
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
┌─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 │
└─────────────────────────────────────┴────────────────────────────────────────────┘
SELECT dateSub('1998-06-16'::DateTime, INTERVAL 10 nanosecond)
┌─minus(CAST('19⋯anosecond(10))─┐
│ 1998-06-15 23:59:59.999999990 │
└───────────────────────────────┘
subtractQuarters(datetime, num)
datetime menos num trimestres. Date o Date32 o DateTime o DateTime64
Ejemplos
Restar trimestres a distintos tipos de fecha
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
┌─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 │
└─────────────────────────────┴──────────────────────────────────┴─────────────────────────────────────────┘
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 quarter)
┌─minus(CAST('1⋯Quarter(10))─┐
│ 1996-09-16 │
└───────────────────────────┘
subtractSeconds(datetime, num)
datetime menos num segundos. DateTime o DateTime64(3)
Ejemplos
Restar segundos a distintos tipos de fecha
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
┌─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 │
└────────────────────────────┴─────────────────────────────────┴────────────────────────────────────────┘
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 second)
┌─minus(CAST('⋯Second(10))─┐
│ 1998-06-15 23:59:50 │
└──────────────────────────┘
subtractTupleOfIntervals(datetime, intervals)
date con los intervals restados. Date o Date32 o DateTime o DateTime64
Ejemplos
Restar una tupla de intervalos a una fecha
WITH toDate('2018-01-01') AS date SELECT subtractTupleOfIntervals(date, (INTERVAL 1 DAY, INTERVAL 1 YEAR))
┌─subtractTupl⋯alYear(1)))─┐
│ 2016-12-31 │
└──────────────────────────┘
subtractWeeks(datetime, num)
datetime menos num semanas. Date o Date32 o DateTime o DateTime64
Ejemplos
Restar semanas a distintos tipos de fecha
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
┌─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 │
└──────────────────────────┴───────────────────────────────┴──────────────────────────────────────┘
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 week)
┌─minus(CAST('⋯alWeek(10))─┐
│ 1998-04-07 │
└──────────────────────────┘
subtractYears(datetime, num)
datetime menos num años. Date o Date32 o DateTime o DateTime64
Ejemplos
Restar años a distintos tipos de fecha
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
┌─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 │
└──────────────────────────┴───────────────────────────────┴──────────────────────────────────────┘
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 year)
┌─minus(CAST('⋯alYear(10))─┐
│ 1988-06-16 │
└──────────────────────────┘
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.
Sintaxis
timeDiff(startdate, enddate)
enddate y startdate, expresada en segundos. Int64
Ejemplos
Calcular la diferencia temporal en segundos
SELECT timeDiff(toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00')) AS res
┌───res─┐
│ 90000 │
└───────┘
SELECT timeDiff(toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00')) / 3600 AS hours
┌─hours─┐
│ 25 │
└───────┘
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
┌─time_diff_result─┬─date_diff_result─┐
│ 259200 │ 259200 │
└──────────────────┴──────────────────┘
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.
timeSlot(time[, time_zone])
time — Hora que se redondeará al inicio de un intervalo de media hora. DateTime o Date32 o DateTime64time_zone — Opcional. Un valor constante de tipo String o una expresión que representa la zona horaria. String
Valor devuelto
Devuelve la hora redondeada al inicio de un intervalo de media hora. DateTime
Ejemplos
Redondear la hora a un intervalo de media hora
SELECT timeSlot(toDateTime('2000-01-02 03:04:05', 'UTC'))
┌─timeSlot(toDateTime('2000-01-02 03:04:05', 'UTC'))─┐
│ 2000-01-02 03:00:00 │
└────────────────────────────────────────────────────┘
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
timeSlots(StartTime, Duration[, Size])
StartTime — Hora de inicio del intervalo. DateTime o DateTime64Duration — Duración del intervalo en segundos. UInt32 o DateTime64Size — Opcional. Tamaño de las franjas horarias en segundos. El valor predeterminado es 1800 (30 minutos). UInt32 o 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) o Array(DateTime64)
Ejemplos
Generar franjas horarias para un intervalo
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))
┌─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'] │
└───────────────────────────────────────────────────────────────────────────────────────────────────────────┘
expr al tipo DateTime64(6).
Si se proporciona un segundo argumento expr_time, suma la hora especificada al valor convertido.
Sintaxis
timestamp(expr[, expr_time])
expr — Fecha o fecha con hora. Stringexpr_time — Opcional. Hora que se añade al valor convertido. String
Valor devuelto
Devuelve el valor convertido de expr, o expr con la hora añadida, DateTime64(6)
Ejemplos
Convertir una cadena de fecha en DateTime64(6)
SELECT timestamp('2023-12-31') AS ts;
┌─────────────────────────ts─┐
│ 2023-12-31 00:00:00.000000 │
└────────────────────────────┘
SELECT timestamp('2023-12-31 12:00:00', '12:00:00.11') AS ts;
┌─────────────────────────ts─┐
│ 2024-01-01 00:00:00.110000 │
└────────────────────────────┘
timeZone
Argumentos
Valor devuelto
Devuelve el nombre canónico de la zona horaria como un String
Ejemplos
Ejemplo de uso
┌─timezone()───────┐
│ Europe/Amsterdam │
└──────────────────┘
DateTime o DateTime64.
Sintaxis
Alias: timeZoneOf
Argumentos
datetime — Un valor de tipo DateTime o DateTime64timezone — Opcional. Nombre de la zona horaria a la que convertir el valor datetime. String
Valor devuelto
Devuelve el nombre de la zona horaria de datetime. String
Ejemplos
Ejemplo de uso
SELECT timezoneOf(now());
┌─timezoneOf(now())─┐
│ Europe/Amsterdam │
└───────────────────┘
timeZoneOffset
Argumentos
datetime — valor de DateTime para obtener el desplazamiento de la zona horaria. DateTime o DateTime64
Valor devuelto
Devuelve el desplazamiento con respecto a UTC en segundos Int32
Ejemplos
Ejemplo de uso
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;
┌────────────────Time─┬─Type─────────────────────────┬─Offset_in_seconds─┬─Offset_in_hours─┐
│ 2021-04-21 10:20:30 │ DateTime('America/New_York') │ -14400 │ -4 │
└─────────────────────┴──────────────────────────────┴───────────────────┴─────────────────┘
Date o DateTime.
Sintaxis
Aliases: DAY, DAYOFMONTH
Argumentos
Valor devuelto
Devuelve el día del mes de la fecha/hora proporcionada UInt8
Ejemplos
Ejemplo de uso
SELECT toDayOfMonth(toDateTime('2023-04-21 10:20:30'))
┌─toDayOfMonth(toDateTime('2023-04-21 10:20:30'))─┐
│ 21 │
└─────────────────────────────────────────────────┘
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 |
toDayOfWeek(datetime[, mode[, timezone]])
DAYOFWEEK
Argumentos
datetime — Fecha o fecha con hora de la que se obtiene el día de la semana. Date o Date32 o DateTime o DateTime64mode — Opcional. Entero que especifica el modo de semana (0-3). Si se omite, el valor predeterminado es 0. UInt8timezone — Opcional. Zona horaria que se utilizará para la conversión. String
Valor devuelto
Devuelve el día de la semana para el Date o DateTime especificado UInt8
Ejemplos
Ejemplo de uso
-- 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)
┌─toDayOfWeek(toDateTime('2023-04-21'))─┬─toDayOfWeek(toDateTime('2023-04-21'), 1)─┐
│ 5 │ 4 │
└───────────────────────────────────────┴──────────────────────────────────────────┘
Date o DateTime.
Sintaxis
Alias: DAYOFYEAR
Argumentos
Valor devuelto
Devuelve el día del año del valor Date o DateTime dado UInt16
Ejemplos
Ejemplo de uso
SELECT toDayOfYear(toDateTime('2023-04-21 10:20:30'))
┌─toDayOfYear(toDateTime('2023-04-21 10:20:30'))─┐
│ 111 │
└────────────────────────────────────────────────┘
Date o DateTime.
El valor devuelto está en el intervalo de 28 a 31.
Sintaxis
Argumentos
Valor devuelto
Devuelve el número de días del mes correspondiente a la fecha/hora indicada. UInt8
Ejemplos
Ejemplo de uso
SELECT toDaysInMonth(toDate('2023-02-01')), toDaysInMonth(toDate('2024-02-01')), toDaysInMonth(toDate('2023-01-01'))
┌─toDaysInMonth(toDate('2023-02-01'))─┬─toDaysInMonth(toDate('2024-02-01'))─┬─toDaysInMonth(toDate('2023-01-01'))─┐
│ 28 │ 29 │ 31 │
└─────────────────────────────────────┴─────────────────────────────────────┴─────────────────────────────────────┘
TO_DAYS de MySQL.
Sintaxis
toDaysSinceYearZero(date[, time_zone])
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 o Date32 o DateTime o DateTime64time_zone — Zona horaria. String
Valor devuelto
Devuelve el número de días transcurridos desde la fecha 0000-01-01. UInt32
Ejemplos
Calcular los días desde el año cero
SELECT toDaysSinceYearZero(toDate('2023-09-08'))
┌─toDaysSinceYearZero(toDate('2023-09-08')))─┐
│ 713569 │
└────────────────────────────────────────────┘
DateTime o DateTime64.
Sintaxis
Aliases: HOUR
Argumentos
Valor devuelto
Devuelve la hora (0-23) de datetime. UInt8
Ejemplos
Ejemplo de uso
SELECT toHour(toDateTime('2023-04-21 10:20:30'))
┌─toHour(toDateTime('2023-04-21 10:20:30'))─┐
│ 10 │
└───────────────────────────────────────────┘
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
toISOWeek(datetime[, timezone])
UInt8
Ejemplos
Obtener los números de semana ISO
SELECT toDate('2016-12-27') AS date, toISOWeek(date) AS isoWeek
┌───────date─┬─isoWeek─┐
│ 2016-12-27 │ 52 │
└────────────┴─────────┘
SELECT toDate('2025-12-29') AS date, toISOWeek(date) AS isoWeek, toYear(date) AS year
┌───────date─┬─isoWeek─┬─year─┐
│ 2025-12-29 │ 1 │ 2025 │
└────────────┴─────────┴──────┘
UInt16
Ejemplos
Obtener el año ISO a partir de valores de fecha
SELECT
toISOYear(toDate('2024/10/02')) as year1,
toISOYear(toDateTime('2024-10-02 01:30:00')) as year2
┌─week1─┬─week2─┐
│ 40 │ 40 │
└───────┴───────┘
LAST_DAY
Argumentos
Valor devuelto
Devuelve la fecha correspondiente al último día del mes para la fecha o fecha con hora proporcionada. Date
Ejemplos
Redondear al último día del mes
SELECT toLastDayOfMonth(toDateTime('2023-04-21 10:20:30'))
┌─toLastDayOfMonth(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-04-30 │
└─────────────────────────────────────────────────────┘
toLastDayOfWeek(datetime[, mode[, timezone]])
datetime — Una fecha o una fecha con hora que se va a convertir. Date o DateTime o Date32 o DateTime64mode — Determina el primer día de la semana, tal como se describe en la función toWeek(). Valor predeterminado: 0. UInt8timezone — Opcional. La zona horaria que se usará para la conversión. Si no se especifica, se usa la zona horaria del servidor. 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 o Date32
Ejemplos
Redondear hacia arriba al sábado o domingo más próximo
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
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
DateTime o DateTime64.
Sintaxis
Aliases: MILLISECOND
Argumentos
Valor devuelto
Devuelve el milisegundo del minuto (0 - 59) de datetime. UInt16
Ejemplos
Ejemplo de uso
SELECT toMillisecond(toDateTime64('2023-04-21 10:20:30.456', 3));
┌──toMillisecond(toDateTime64('2023-04-21 10:20:30.456', 3))─┐
│ 456 │
└────────────────────────────────────────────────────────────┘
Date o DateTime.
Sintaxis
Alias: MINUTE
Argumentos
Valor devuelto
Devuelve el minuto de la hora (0 - 59) de datetime. UInt8
Ejemplos
Ejemplo de uso
SELECT toMinute(toDateTime('2023-04-21 10:20:30'))
┌─toMinute(toDateTime('2023-04-21 10:20:30'))─┐
│ 20 │
└─────────────────────────────────────────────┘
YYYY-MM-DD en un número de día juliano modificado 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
toModifiedJulianDay(date)
Int32
Ejemplos
Convertir la fecha a día juliano modificado
SELECT toModifiedJulianDay('2020-01-01')
┌─toModifiedJulianDay('2020-01-01')─┐
│ 58849 │
└───────────────────────────────────┘
toModifiedJulianDayOrNull
toModifiedJulianDay(), pero en lugar de lanzar una excepción devuelve NULL.
Sintaxis
toModifiedJulianDayOrNull(date)
date válido; de lo contrario, null. Nullable(Int32)
Ejemplos
Convertir una fecha a día juliano modificado con manejo de null
SELECT toModifiedJulianDayOrNull('2020-01-01');
SELECT toModifiedJulianDayOrNull('0000-00-00'); -- fecha inválida, devuelve NULL
┌─toModifiedJu⋯020-01-01')─┐
│ 58849 │
└──────────────────────────┘
┌─toModifiedJu⋯000-00-00')─┐
│ ᴺᵁᴸᴸ │
└──────────────────────────┘
Date
Ejemplos
Redondear hacia abajo hasta el lunes de la semana
SELECT
toMonday(toDateTime('2023-04-21 10:20:30')), -- Un viernes
toMonday(toDate('2023-04-24')); -- Ya es lunes
┌─toMonday(toDateTime('2023-04-21 10:20:30'))─┬─toMonday(toDate('2023-04-24'))─┐
│ 2023-04-17 │ 2023-04-24 │
└─────────────────────────────────────────────┴────────────────────────────────┘
Date o DateTime.
Sintaxis
Alias: MONTH
Argumentos
Valor devuelto
Devuelve el mes de la fecha/hora indicada UInt8
Ejemplos
Ejemplo de uso
SELECT toMonth(toDateTime('2023-04-21 10:20:30'))
┌─toMonth(toDateTime('2023-04-21 10:20:30'))─┐
│ 4 │
└────────────────────────────────────────────┘
toMonthNumSinceEpoch(date)
SELECT toMonthNumSinceEpoch(toDate('2024-10-01'))
Date o DateTime.
Sintaxis
Alias: QUARTER
Argumentos
Valor devuelto
Devuelve el trimestre del año de la fecha/hora indicada UInt8
Ejemplos
Ejemplo de uso
SELECT toQuarter(toDateTime('2023-04-21 10:20:30'))
┌─toQuarter(toDateTime('2023-04-21 10:20:30'))─┐
│ 2 │
└──────────────────────────────────────────────┘
toRelativeDayNum(dt1) - toRelativeDayNum(dt2).
Sintaxis
Argumentos
Valor devuelto
Devuelve el número de días desde un punto de referencia fijo en el pasado. UInt32
Ejemplos
Obtener números relativos de día
SELECT toRelativeDayNum(toDate('2023-04-01')) - toRelativeDayNum(toDate('2023-01-01'))
┌─minus(toRela⋯3-01-01')))─┐
│ 90 │
└──────────────────────────┘
toRelativeHourNum(dt1) - toRelativeHourNum(dt2).
Sintaxis
Argumentos
Valor devuelto
Devuelve el número de horas desde un punto de referencia fijo en el pasado. UInt32
Ejemplos
Obtener números de hora relativos
SELECT toRelativeHourNum(toDateTime('2023-01-01 12:00:00')) - toRelativeHourNum(toDateTime('2023-01-01 00:00:00')) AS hours_difference
┌─hours_difference─┐
│ 12 │
└──────────────────┘
toRelativeMinuteNum(dt1) - toRelativeMinuteNum(dt2).
Sintaxis
toRelativeMinuteNum(date)
UInt32
Ejemplos
Obtener números de minutos relativos
SELECT toRelativeMinuteNum(toDateTime('2023-01-01 00:30:00')) - toRelativeMinuteNum(toDateTime('2023-01-01 00:00:00')) AS minutes_difference
┌─minutes_difference─┐
│ 30 │
└────────────────────┘
toRelativeMonthNum(dt1) - toRelativeMonthNum(dt2).
Sintaxis
Argumentos
Valor devuelto
Devuelve el número de meses desde un punto de referencia fijo en el pasado. UInt32
Ejemplos
Obtener números relativos de meses
SELECT toRelativeMonthNum(toDate('2023-04-01')) - toRelativeMonthNum(toDate('2023-01-01')) AS months_difference
┌─months_difference─┐
│ 3 │
└───────────────────┘
toRelativeQuarterNum(dt1) - toRelativeQuarterNum(dt2).
Sintaxis
toRelativeQuarterNum(date)
UInt32
Ejemplos
Obtener números de trimestre relativos
SELECT toRelativeQuarterNum(toDate('2023-04-01')) - toRelativeQuarterNum(toDate('2023-01-01')) AS quarters_difference
┌─quarters_difference─┐
│ 1 │
└─────────────────────┘
toRelativeSecondNum(dt1) - toRelativeSecondNum(dt2).
Sintaxis
toRelativeSecondNum(date)
UInt32
Ejemplos
Obtener números de segundos relativos
SELECT toRelativeSecondNum(toDateTime('2023-01-01 00:01:00')) - toRelativeSecondNum(toDateTime('2023-01-01 00:00:00')) AS seconds_difference
┌─seconds_difference─┐
│ 60 │
└────────────────────┘
toRelativeWeekNum(dt1) - toRelativeWeekNum(dt2).
Sintaxis
Argumentos
Valor devuelto
Devuelve el número de semanas desde un punto de referencia fijo en el pasado. UInt32
Ejemplos
Obtener números de semana relativos
SELECT toRelativeWeekNum(toDate('2023-01-08')) - toRelativeWeekNum(toDate('2023-01-01')) AS weeks_difference
┌─weeks_difference─┐
│ 1 │
└──────────────────┘
toRelativeYearNum(dt1) - toRelativeYearNum(dt2).
Sintaxis
Argumentos
Valor devuelto
Devuelve el número de años desde un punto de referencia fijo en el pasado. UInt16
Ejemplos
Obtener números relativos de año
SELECT toRelativeYearNum('2010-10-01'::DateTime) - toRelativeYearNum('2000-01-01'::DateTime)
┌─minus(toRela⋯ateTime')))─┐
│ 10 │
└──────────────────────────┘
DateTime o DateTime64.
Sintaxis
Alias: SECOND
Argumentos
Valor devuelto
Devuelve el segundo del minuto (0 - 59) de datetime. UInt8
Ejemplos
Ejemplo de uso
SELECT toSecond(toDateTime('2023-04-21 10:20:30'))
┌─toSecond(toDateTime('2023-04-21 10:20:30'))─┐
│ 30 │
└─────────────────────────────────────────────┘
datetime — Una fecha o una fecha con hora que se va a redondear. Date o DateTime
Valor devuelto
Devuelve la fecha con hora redondeada hacia abajo hasta el inicio del día. DateTime o DateTime64
Ejemplos
Redondear hacia abajo hasta el inicio del día
SELECT toStartOfDay(toDateTime('2023-04-21 10:20:30'))
┌─toStartOfDay(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-04-21 00:00:00 │
└─────────────────────────────────────────────────┘
toStartOfFifteenMinutes(datetime)
DateTime o DateTime64
Ejemplos
Ejemplo
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
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(datetime)
toStartOfFiveMinute
Argumentos
Valor devuelto
Devuelve la fecha con hora redondeada al inicio del intervalo de cinco minutos más cercano. DateTime o DateTime64
Ejemplos
Ejemplo
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
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
DateTime o DateTime64
Ejemplos
Redondear hacia abajo al inicio de la hora
SELECT
toStartOfHour(toDateTime('2023-04-21 10:20:30'));
┌─────────────────res─┬─toTypeName(res)─┐
│ 2023-04-21 10:00:00 │ DateTime │
└─────────────────────┴─────────────────┘
Date
Ejemplos
Redondear al primer día del año ISO
SELECT toStartOfISOYear(toDateTime('2023-04-21 10:20:30'))
┌─toStartOfISOYear(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-01-02 │
└─────────────────────────────────────────────────────┘
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. | |
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
toStartOfInterval(value, INTERVAL x unit[, time_zone])
toStartOfInterval(value, INTERVAL x unit[, origin[, time_zone]])
time_bucket, date_bin
Argumentos
value — Valor de fecha o de fecha con hora que se redondea hacia abajo. Date o DateTime o DateTime64x — 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
Ejemplos
Redondeo básico de intervalos
SELECT toStartOfInterval(toDateTime('2023-01-15 14:30:00'), INTERVAL 1 MONTH)
┌─toStartOfInt⋯alMonth(1))─┐
│ 2023-01-01 │
└──────────────────────────┘
SELECT toStartOfInterval(toDateTime('2023-01-01 14:45:00'), INTERVAL 1 MINUTE, toDateTime('2023-01-01 14:35:30'))
┌─toStartOfInt⋯14:35:30'))─┐
│ 2023-01-01 14:44:30 │
└──────────────────────────┘
toStartOfMicrosecond(datetime[, timezone])
datetime — Fecha y hora. DateTime64timezone — Opcional. Zona horaria del valor devuelto. Si no se especifica, la función usa la zona horaria del parámetro value. String
Valor devuelto
Valor de entrada con submicrosegundos DateTime64
Ejemplos
Consulta sin zona horaria
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMicrosecond(dt64);
┌────toStartOfMicrosecond(dt64)─┐
│ 2020-01-01 10:20:30.999999000 │
└───────────────────────────────┘
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMicrosecond(dt64, 'Asia/Istanbul');
┌─toStartOfMicrosecond(dt64, 'Asia/Istanbul')─┐
│ 2020-01-01 12:20:30.999999000 │
└─────────────────────────────────────────────┘
toStartOfMillisecond(datetime[, timezone])
datetime — Fecha y hora. DateTime64timezone — Opcional. Zona horaria del valor devuelto. Si no se especifica, la función usa la zona horaria del parámetro value. String
Valor devuelto
Valor de entrada con fracciones de milisegundo. DateTime64
Ejemplos
Consulta sin zona horaria
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMillisecond(dt64);
┌────toStartOfMillisecond(dt64)─┐
│ 2020-01-01 10:20:30.999000000 │
└───────────────────────────────┘
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMillisecond(dt64, 'Asia/Istanbul');
┌─toStartOfMillisecond(dt64, 'Asia/Istanbul')─┐
│ 2020-01-01 12:20:30.999000000 │
└─────────────────────────────────────────────┘
toStartOfMinute(datetime)
DateTime o DateTime64
Ejemplos
Redondear hacia abajo al inicio del minuto
SELECT
toStartOfMinute(toDateTime('2023-04-21 10:20:30')),
toStartOfMinute(toDateTime64('2023-04-21 10:20:30.5300', 8))
FORMAT Vertical
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
Date
Ejemplos
Redondear hacia abajo hasta el primer día del mes
SELECT toStartOfMonth(toDateTime('2023-04-21 10:20:30'))
┌─toStartOfMonth(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-04-01 │
└───────────────────────────────────────────────────┘
toStartOfNanosecond(datetime[, timezone])
datetime — Fecha y hora. DateTime64timezone — Opcional. Zona horaria del valor devuelto. Si no se especifica, la función utiliza la zona horaria del parámetro value. String
Valor devuelto
Valor de entrada con nanosegundos. DateTime64
Ejemplos
Consulta sin zona horaria
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfNanosecond(dt64);
┌─────toStartOfNanosecond(dt64)─┐
│ 2020-01-01 10:20:30.999999999 │
└───────────────────────────────┘
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfNanosecond(dt64, 'Asia/Istanbul');
┌─toStartOfNanosecond(dt64, 'Asia/Istanbul')─┐
│ 2020-01-01 12:20:30.999999999 │
└────────────────────────────────────────────┘
Date
Ejemplos
Redondear al primer día del trimestre
SELECT toStartOfQuarter(toDateTime('2023-04-21 10:20:30'))
┌─toStartOfQuarter(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-04-01 │
└─────────────────────────────────────────────────────┘
toStartOfSecond(datetime[, timezone])
datetime — Fecha y hora de la que se truncarán las fracciones de segundo. DateTime64timezone — Opcional. Zona horaria del valor devuelto. Si no se especifica, la función usa la zona horaria del parámetro value. String
Valor devuelto
Devuelve el valor de entrada sin fracciones de segundo. DateTime64
Ejemplos
Consulta sin zona horaria
WITH toDateTime64('2020-01-01 10:20:30.999', 3) AS dt64
SELECT toStartOfSecond(dt64);
┌───toStartOfSecond(dt64)─┐
│ 2020-01-01 10:20:30.000 │
└─────────────────────────┘
WITH toDateTime64('2020-01-01 10:20:30.999', 3) AS dt64
SELECT toStartOfSecond(dt64, 'Asia/Istanbul');
┌─toStartOfSecond(dt64, 'Asia/Istanbul')─┐
│ 2020-01-01 13:20:30.000 │
└────────────────────────────────────────┘
toStartOfTenMinutes(datetime)
DateTime o DateTime64
Ejemplos
Ejemplo
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
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(datetime[, mode[, timezone]])
datetime — Una fecha o una fecha con hora que se va a convertir. Date o DateTime o Date32 o DateTime64mode — Determina el primer día de la semana, como se describe en la función toWeek(). El valor predeterminado es 0. UInt8timezone — La zona horaria que se usará para la conversión. Si no se especifica, se usa la zona horaria del servidor. 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 o Date32
Ejemplos
Redondear hacia abajo al domingo o lunes más cercano
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
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
Date.
Sintaxis
Argumentos
Valor devuelto
Devuelve el primer día del año de la fecha/hora proporcionada Date
Ejemplos
Redondeo a la baja al primer día del año
SELECT toStartOfYear(toDateTime('2023-04-21 10:20:30'))
┌─toStartOfYear(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-01-01 │
└──────────────────────────────────────────────────┘
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
toTimeWithFixedDate(date[, timezone])
DateTime
Ejemplos
Calcular la diferencia horaria entre dos fechas
SELECT toTimeWithFixedDate('2025-06-15 12:00:00'::DateTime) - toTimeWithFixedDate('2024-05-10 11:00:00'::DateTime) AS result, toTypeName(result)
┌─result─┬─toTypeName(result)─┐
│ 3600 │ Int32 │
└────────┴────────────────────┘
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
toTimezone(datetime, timezone)
toTimeZone
Argumentos
Valor devuelto
Devuelve la misma marca de tiempo que la de entrada, pero con la zona horaria especificada DateTime o DateTime64
Ejemplos
Ejemplo de uso
SELECT toDateTime('2019-01-01 00:00:00', 'UTC') AS time_utc,
toTypeName(time_utc) AS type_utc,
toInt32(time_utc) AS int32utc,
toTimezone(time_utc, 'Asia/Yekaterinburg') AS time_yekat,
toTypeName(time_yekat) AS type_yekat,
toInt32(time_yekat) AS int32yekat,
toTimezone(time_utc, 'US/Samoa') AS time_samoa,
toTypeName(time_samoa) AS type_samoa,
toInt32(time_samoa) AS int32samoa
FORMAT Vertical;
Row 1:
──────
time_utc: 2019-01-01 00:00:00
type_utc: DateTime('UTC')
int32utc: 1546300800
time_yekat: 2019-01-01 05:00:00
type_yekat: DateTime('Asia/Yekaterinburg')
int32yekat: 1546300800
time_samoa: 2018-12-31 13:00:00
type_samoa: DateTime('US/Samoa')
int32samoa: 1546300800
toUTCTimestamp(datetime, time_zone)
to_utc_timestamp
Argumentos
datetime — Un valor constante de tipo fecha o fecha con hora, o una expresión. DateTime o DateTime64time_zone — Un valor constante de tipo String, o una expresión que representa la zona horaria. String
Valor devuelto
Devuelve una fecha o fecha con hora en la zona horaria UTC. DateTime o DateTime64
Ejemplos
Convertir la zona horaria a UTC
SELECT toUTCTimestamp(toDateTime('2023-03-16'), 'Asia/Shanghai')
┌─toUTCTimestamp(toDateTime('2023-03-16'), 'Asia/Shanghai')─┐
│ 2023-03-15 16:00:00 │
└─────────────────────────────────────────────────────────┘
String, Date o DateTime en un timestamp Unix (segundos desde 1970-01-01 00:00:00 UTC) como un UInt32.
Sintaxis
toUnixTimestamp(date[, timezone])
date — Valor que se va a convertir. Date o Date32 o DateTime o DateTime64 o Stringtimezone — Opcional. Zona horaria que se utilizará para la conversión. Si no se especifica, se usa la zona horaria del servidor. String
Valor devuelto
Devuelve la marca de tiempo Unix. UInt32
Ejemplos
Ejemplo de uso
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;
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() 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() 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 |
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 en un formato compatible con 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
toWeek(datetime[, mode[, time_zone]])
week
Argumentos
datetime — Fecha o fecha con hora a partir de la cual se obtiene el número de semana. Date o DateTimemode — 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
Valor devuelto
Devuelve el número de semana según el modo especificado. UInt32
Ejemplos
Obtener el número de semana con diferentes modos
SELECT toDate('2016-12-27') AS date, toWeek(date) AS week0, toWeek(date,1) AS week1, toWeek(date,9) AS week9
┌───────date─┬─week0─┬─week1─┬─week9─┐
│ 2016-12-27 │ 52 │ 52 │ 1 │
└────────────┴───────┴───────┴───────┘
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
toYYYYMM(datetime[, timezone])
datetime — Una fecha o una fecha con hora para convertir. Date o Date32 o DateTime o DateTime64timezone — Opcional. Zona horaria para la conversión. Si se proporciona, la zona horaria debe ser una constante de cadena. String
Valor devuelto
Devuelve un número UInt32 que contiene el año y el número del mes (YYYY * 100 + MM). UInt32
Ejemplos
Convertir la fecha actual al formato YYYYMM
SELECT toYYYYMM(now(), 'US/Eastern')
┌─toYYYYMM(now(), 'US/Eastern')─┐
│ 202303 │
└───────────────────────────────┘
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
toYYYYMMDD(datetime[, timezone])
datetime — Una fecha o una fecha con hora que se va a convertir. Date o Date32 o DateTime o DateTime64timezone — Opcional. Zona horaria para la conversión. Si se especifica, la zona horaria debe ser una constante de cadena. String
Valor devuelto
Devuelve un valor UInt32 que contiene el año, el mes y el día (YYYY * 10000 + MM * 100 + DD). UInt32
Ejemplos
Convertir la fecha actual al formato YYYYMMDD
SELECT toYYYYMMDD(now(), 'US/Eastern')
┌─toYYYYMMDD(now(), 'US/Eastern')─┐
│ 20230302 │
└─────────────────────────────────┘
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
toYYYYMMDDhhmmss(datetime[, timezone])
datetime — Fecha o fecha con hora que se va a convertir. Date o Date32 o DateTime o DateTime64timezone — Opcional. Zona horaria para la conversión. Si se proporciona, la zona horaria debe ser una constante de cadena. 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
Ejemplos
Convertir la fecha y hora actuales al formato YYYYMMDDhhmmss
SELECT toYYYYMMDDhhmmss(now(), 'US/Eastern')
┌─toYYYYMMDDhhmmss(now(), 'US/Eastern')─┐
│ 20230302112209 │
└───────────────────────────────────────┘
Date o DateTime.
Sintaxis
Alias: YEAR
Argumentos
Valor devuelto
Devuelve el año de la Date o DateTime proporcionada UInt16
Ejemplos
Ejemplo de uso
SELECT toYear(toDateTime('2023-04-21 10:20:30'))
┌─toYear(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023 │
└───────────────────────────────────────────┘
toYearNumSinceEpoch(date)
SELECT toYearNumSinceEpoch(toDate('2024-10-01'))
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 en un formato compatible con 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
toYearWeek(datetime[, mode[, timezone]])
yearweek
Argumentos
datetime — Fecha o fecha con hora de la que se obtienen el año y la semana. Date o DateTimemode — 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
Valor devuelto
Devuelve el año y el número de semana como un único valor entero. UInt32
Ejemplos
Obtener combinaciones de año-semana con distintos modos
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
┌───────date─┬─yearWeek0─┬─yearWeek1─┬─yearWeek9─┬─prev_yearWeek─┐
│ 2016-12-27 │ 201652 │ 201652 │ 201701 │ 202152 │
└────────────┴───────────┴───────────┴───────────┴───────────────┘
toDate(now()).
Sintaxis
Alias: curdate, current_date
Argumentos
Valor devuelto
Devuelve la fecha actual Date
Ejemplos
Ejemplo de uso
SELECT today() AS today, curdate() AS curdate, current_date() AS current_date FORMAT Pretty
┏━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━┓
┃ today ┃ curdate ┃ current_date ┃
┡━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━┩
│ 2025-03-03 │ 2025-03-03 │ 2025-03-03 │
└────────────┴────────────┴──────────────┘
SELECT TODAY, CURDATE,CURRENT_DATE
┏━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━┓
┃ TODAY ┃ CURDATE ┃ CURRENT_DATE ┃
┡━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━┩
│ 2025-03-04 │ 2025-03-04 │ 2025-03-04 │
└────────────┴────────────┴──────────────┘
Date
Ejemplos
Obtener la fecha de ayer
SELECT yesterday();
SELECT today() - 1;
┌─yesterday()─┐
│ 2025-06-09 │
└─────────────┘
┌─minus(today(), 1)─┐
│ 2025-06-09 │
└───────────────────┘
