Amazon Redshift dejará de admitir la creación de nuevas UDF de Python a partir del parche 198. Las UDF de Python existentes seguirán funcionando hasta el 30 de junio de 2026. Para obtener más información, consulte la [publicación del blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
# Funciones de fecha y hora
En esta sección, puede encontrar información acerca de las funciones escalares de fecha y hora compatibles con Amazon Redshift.
**Topics**
+ [Resumen de las funciones de fecha y hora](#date-functions-summary)
+ [Funciones de fecha y hora en transacciones](#date-functions-transactions)
+ [Funciones específicas del nodo principal obsoletas](#date-functions-deprecated)
+ [\$1 Operador (concatenación)](r_DATE-CONCATENATE_function.md)
+ [Función ADD\$1MONTHS](r_ADD_MONTHS.md)
+ [Función AT TIME ZONE](r_AT_TIME_ZONE.md)
+ [Función CONVERT\$1TIMEZONE](CONVERT_TIMEZONE.md)
+ [Función CURRENT\$1DATE](r_CURRENT_DATE_function.md)
+ [Función DATE\$1CMP](r_DATE_CMP.md)
+ [Función DATE\$1CMP\$1TIMESTAMP](r_DATE_CMP_TIMESTAMP.md)
+ [Función DATE\$1CMP\$1TIMESTAMPTZ](r_DATE_CMP_TIMESTAMPTZ.md)
+ [Función DATEADD](r_DATEADD_function.md)
+ [Función DATEDIFF](r_DATEDIFF_function.md)
+ [Función DATE\$1PART](r_DATE_PART_function.md)
+ [Función DATE\$1PART\$1YEAR](r_DATE_PART_YEAR.md)
+ [Función DATE\$1TRUNC](r_DATE_TRUNC.md)
+ [Función EXTRACT](r_EXTRACT_function.md)
+ [Función GETDATE](r_GETDATE.md)
+ [Función INTERVAL\$1CMP](r_INTERVAL_CMP.md)
+ [Función LAST\$1DAY](r_LAST_DAY.md)
+ [Función MONTHS\$1BETWEEN](r_MONTHS_BETWEEN_function.md)
+ [Función NEXT\$1DAY](r_NEXT_DAY.md)
+ [Función SYSDATE](r_SYSDATE.md)
+ [Función TIMEOFDAY](r_TIMEOFDAY_function.md)
+ [Función TIMESTAMP\$1CMP](r_TIMESTAMP_CMP.md)
+ [Función TIMESTAMP\$1CMP\$1DATE](r_TIMESTAMP_CMP_DATE.md)
+ [Función TIMESTAMP\$1CMP\$1TIMESTAMPTZ](r_TIMESTAMP_CMP_TIMESTAMPTZ.md)
+ [Función TIMESTAMPTZ\$1CMP](r_TIMESTAMPTZ_CMP.md)
+ [Función TIMESTAMPTZ\$1CMP\$1DATE](r_TIMESTAMPTZ_CMP_DATE.md)
+ [Función TIMESTAMPTZ\$1CMP\$1TIMESTAMP](r_TIMESTAMPTZ_CMP_TIMESTAMP.md)
+ [Función TIMEZONE](r_TIMEZONE.md)
+ [Función TO\$1TIMESTAMP](r_TO_TIMESTAMP.md)
+ [Función TRUNC](r_TRUNC_date.md)
+ [Partes de fecha para funciones de fecha o marca temporal](r_Dateparts_for_datetime_functions.md)
## Resumen de las funciones de fecha y hora
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/Date_functions_header.html)
**nota**
Los segundos de salto no se consideran en los cálculos de tiempo transcurrido.
## Funciones de fecha y hora en transacciones
Cuando se ejecutan las siguientes funciones dentro de un bloque de transacción (BEGIN ... END), la función devuelve la fecha u hora de inicio de la transacción actual, no de la instrucción actual.
+ SYSDATE
+ TIMESTAMP
+ CURRENT\$1DATE
Las siguientes funciones siempre devuelven la fecha u hora de comienzo de la instrucción actual, incluso cuando se encuentran dentro de un bloque de transacción.
+ GETDATE
+ TIMEOFDAY
## Funciones específicas del nodo principal obsoletas
Las siguientes funciones de fecha quedan obsoletas porque se ejecutan únicamente en el nodo principal. Para obtener más información, consulte [Funciones específicas del nodo principal](c_SQL_functions_leader_node_only.md).
+ AGE. En su lugar, use [Función DATEDIFF](r_DATEDIFF_function.md).
+ CURRENT\$1TIME. En su lugar, use [Función GETDATE](r_GETDATE.md) o [SYSDATE](r_SYSDATE.md).
+ CURRENT\$1TIMESTAMP. En su lugar, use [Función GETDATE](r_GETDATE.md) o [SYSDATE](r_SYSDATE.md).
+ LOCALTIME. En su lugar, use [Función GETDATE](r_GETDATE.md) o [SYSDATE](r_SYSDATE.md).
+ LOCALTIMESTAMP. En su lugar, use [Función GETDATE](r_GETDATE.md) o [SYSDATE](r_SYSDATE.md).
+ ISFINITE
+ NOW. En su lugar, use [Función GETDATE](r_GETDATE.md) o [SYSDATE](r_SYSDATE.md). Si utiliza la función NOW en una vista materializada, se establece en la marca de tiempo de la creación de la vista materializada y no en la marca de tiempo actual.
# \$1 Operador (concatenación)
Concatena una DATE a una TIME o TIMETZ a ambos lados del símbolo \$1 y devuelve una TIMESTAMP o TIMESTAMPTZ.
## Sintaxis
```
date + {time | timetz}
```
El orden de los argumentos se puede invertir. Por ejemplo, *time* \$1 *date*.
## Argumentos
*date*
Una columna de tipo de datos `DATE` o una expresión que toma implícitamente el valor de un tipo `DATE`.
*hora*
Una columna de tipo de datos `TIME` o una expresión que toma implícitamente el valor de un tipo `TIME`.
*timetz*
Una columna de tipo de datos `TIMETZ` o una expresión que toma implícitamente el valor de un tipo `TIMETZ`.
## Tipo de retorno
TIMESTAMP si la entrada es *date* \$1 *time*.
TIMESTAMPTZ si la entrada es *date* \$1 *timetz*.
## Ejemplos
### Configuración de ejemplo
Para configurar las tablas TIME\$1TEST y TIMETZ\$1TEST utilizadas en los ejemplos, use el siguiente comando.
```
create table time_test(time_val time);
insert into time_test values
('20:00:00'),
('00:00:00.5550'),
('00:58:00');
create table timetz_test(timetz_val timetz);
insert into timetz_test values
('04:00:00+00'),
('00:00:00.5550+00'),
('05:58:00+00');
```
### Ejemplos con una columna TIME
La siguiente tabla de ejemplo, TIME\$1TEST, tiene una columna TIME\$1VAL (tipo TIME) con tres valores insertados.
```
select time_val from time_test;
time_val
---------------------
20:00:00
00:00:00.5550
00:58:00
```
En el siguiente ejemplo, se concatena un literal de fecha y una columna TIME\$1VAL.
```
select date '2000-01-02' + time_val as ts from time_test;
ts
---------------------
2000-01-02 20:00:00
2000-01-02 00:00:00.5550
2000-01-02 00:58:00
```
En el siguiente ejemplo, se concatena un literal de fecha y un literal de hora.
```
select date '2000-01-01' + time '20:00:00' as ts;
ts
---------------------
2000-01-01 20:00:00
```
En el siguiente ejemplo se concatenan un literal de hora y un literal de fecha.
```
select time '20:00:00' + date '2000-01-01' as ts;
ts
---------------------
2000-01-01 20:00:00
```
### Ejemplos con una columna TIMETZ
La siguiente tabla de ejemplo, TIMETZ\$1TEST, tiene una columna TIMETZ\$1VAL (tipo TIMETZ) con tres valores insertados.
```
select timetz_val from timetz_test;
timetz_val
------------------
04:00:00+00
00:00:00.5550+00
05:58:00+00
```
En el siguiente ejemplo, se concatena un literal de fecha y una columna TIMETZ\$1VAL.
```
select date '2000-01-01' + timetz_val as ts from timetz_test;
ts
---------------------
2000-01-01 04:00:00+00
2000-01-01 00:00:00.5550+00
2000-01-01 05:58:00+00
```
En el siguiente ejemplo se concatenan una columna TIMETZ\$1VAL y un literal de fecha.
```
select timetz_val + date '2000-01-01' as ts from timetz_test;
ts
---------------------
2000-01-01 04:00:00+00
2000-01-01 00:00:00.5550+00
2000-01-01 05:58:00+00
```
En el siguiente ejemplo, se concatena un literal de DATE y un literal de TIMETZ. El ejemplo devuelve un TIMESTAMPTZ que está en la zona horaria UTC de forma predeterminada. UTC está 8 horas por delante de PST, por lo que el resultado está 8 horas por delante de la hora de entrada.
```
select date '2000-01-01' + timetz '20:00:00 PST' as ts;
ts
------------------------
2000-01-02 04:00:00+00
```
# Función ADD\$1MONTHS
ADD\$1MONTHS agrega la cantidad de meses especificada a una expresión o un valor de fecha o marca temporal. La función [DATEADD](r_DATEADD_function.md) ofrece una funcionalidad similar.
## Sintaxis
```
ADD_MONTHS( {date | timestamp}, integer)
```
## Argumentos
*date* \$1 *timestamp*
Una columna de tipo de datos `DATE` o `TIMESTAMP`, o una expresión que toma implícitamente el valor de un tipo `DATE` o `TIMESTAMP`. Si la fecha es el último día del mes, o si el mes resultante es más corto, la función devuelve el último día del mes en el resultado. Para otras fechas, el resultado tiene el mismo número de día que la expresión de fecha.
*entero*
Un valor de tipo de datos `INTEGER`. Use un número negativo para restar meses de las fechas.
## Tipo de retorno
TIMESTAMP
## Ejemplos
La siguiente consulta utiliza la función ADD\$1MONTHS dentro de una función TRUNC. La función TRUNC quita la hora del día del resultado de ADD\$1MONTHS. La función ADD\$1MONTHS agrega 12 meses a cada valor de la columna CALDATE. Los valores de la columna CALDATE son fechas.
```
select distinct trunc(add_months(caldate, 12)) as calplus12,
trunc(caldate) as cal
from date
order by 1 asc;
calplus12 | cal
------------+------------
2009-01-01 | 2008-01-01
2009-01-02 | 2008-01-02
2009-01-03 | 2008-01-03
...
(365 rows)
```
En el siguiente ejemplo se utiliza la función ADD\$1MONTHS para sumar 1 mes a un valor *timestamp*.
```
select add_months('2008-01-01 05:07:30', 1);
add_months
---------------------
2008-02-01 05:07:30
```
En los ejemplos a continuación, se demuestra el comportamiento resultante cuando la función ADD\$1MONTHS opera sobre fechas con meses que tienen diferente cantidad de días. En este ejemplo se muestra cómo la función controla sumar 1 mes al 31 de marzo y sumar 1 mes al 30 de abril. Abril tiene 30 días, por lo que sumar 1 mes al 31 de marzo da como resultado el 30 de abril. Mayo tiene 31 días, por lo que sumar 1 mes al 30 de abril da como resultado el 31 de mayo.
```
select add_months('2008-03-31',1);
add_months
---------------------
2008-04-30 00:00:00
select add_months('2008-04-30',1);
add_months
---------------------
2008-05-31 00:00:00
```
# Función AT TIME ZONE
AT TIME ZONE especifica la zona horaria que debe usarse con una expresión TIMESTAMP o TIMESTAMPTZ.
## Sintaxis
```
AT TIME ZONE 'timezone'
```
## Argumentos
*timezone*
La `TIMEZONE` para el valor devuelto. La zona horaria puede especificarse como un nombre (por ejemplo, **'Africa/Kampala'** o **'Singapore'**) o como una abreviatura (por ejemplo, **'UTC'** o **'PDT'**).
Para ver una lista de los nombres de zonas horarias compatibles, ejecute el siguiente comando.
```
select pg_timezone_names();
```
Para ver una lista de las abreviaturas de zonas horarias compatibles, ejecute el siguiente comando.
```
select pg_timezone_abbrevs();
```
Para obtener más información y ejemplos, consulte [Notas de uso de la zona horaria](CONVERT_TIMEZONE.md#CONVERT_TIMEZONE-usage-notes).
## Tipo de retorno
TIMESTAMPTZ, cuando se usa con una expresión TIMESTAMP. TIMESTAMP, cuando se usa con una expresión TIMESTAMPTZ.
## Ejemplos
En el siguiente ejemplo, se convierte un valor de marca temporal sin zona horaria y se interpreta como hora MST (UTC\$17 en POSIX). En el ejemplo se devuelve un valor del tipo de datos TIMESTAMPTZ para la zona horaria UTC. Si configura su zona horaria predeterminada en una zona horaria distinta de UTC, es posible que vea un resultado diferente.
```
SELECT TIMESTAMP '2001-02-16 20:38:40' AT TIME ZONE 'MST';
timezone
------------------------
2001-02-17 03:38:40+00
```
En el siguiente ejemplo, se toma una marca temporal de entrada con un valor de zona horaria cuya zona horaria especificada es EST (UTC\$15 en POSIX) y se lo convierte a MST (UTC\$17 en POSIX). En el ejemplo se devuelve un valor de tipo de datos TIMESTAMP.
```
SELECT TIMESTAMPTZ '2001-02-16 20:38:40-05' AT TIME ZONE 'MST';
timezone
------------------------
2001-02-16 18:38:40
```
# Función CONVERT\$1TIMEZONE
CONVERT\$1TIMEZONE convierte una marca temporal de una zona horaria a otra. La función se ajusta automáticamente al horario de verano.
## Sintaxis
```
CONVERT_TIMEZONE( ['source_timezone',] 'target_timezone', 'timestamp')
```
## Argumentos
*source\$1timezone*
(Opcional) La zona horaria de la marca temporal actual. El valor predeterminado es UTC. Para obtener más información, consulte [Notas de uso de la zona horaria](#CONVERT_TIMEZONE-usage-notes).
*target\$1timezone*
La zona horaria para la marca temporal nueva. Para obtener más información, consulte [Notas de uso de la zona horaria](#CONVERT_TIMEZONE-usage-notes).
*timestamp*
Una columna de marca temporal o una expresión que, implícitamente, se convierte en una marca temporal.
## Tipo de retorno
TIMESTAMP
## Notas de uso de la zona horaria
Tanto *source\$1timezone* como *target\$1timezone* pueden especificarse como un nombre de zona horaria (por ejemplo, “África/Kampala” o “Singapur”) o como una abreviatura de zona horaria (por ejemplo, “UTC” o “PDT”). No es necesario convertir los nombres de las zonas horarias en nombres ni las abreviaturas en abreviaturas. Por ejemplo, puede elegir una marca de tiempo en el nombre de zona horaria de origen “Singapur” y convertirla en una marca de tiempo en la abreviatura de zona horaria “PDT”.
**nota**
Los resultados de usar un nombre de zona horaria o una abreviatura de zona horaria pueden ser diferentes debido a la hora estacional local (por ejemplo, el horario de verano).
### Uso de un nombre de zona horaria
Para ver una lista actualizada y completa de los nombres de zonas horarias, ejecute el siguiente comando.
```
select pg_timezone_names();
```
Cada fila contiene una cadena separada por comas con el nombre de la zona horaria, la abreviatura, el desfase respecto de UTC y el indicador de si la zona horaria sigue el horario de verano (`t` o `f`). Por ejemplo, en el siguiente fragmento se muestran dos filas resultantes. La primera fila es la zona horaria `Antarctica/South Pole`, la abreviatura `NZDT`, con un desfase de `13:00:00` respecto de UTC y `f` para indicar que no sigue el horario de verano. La segunda fila es la zona horaria `Europe/Paris`, la abreviatura `CET`, con un desfase de `01:00:00` respecto de UTC y `f` para indicar que sigue el horario de verano.
```
pg_timezone_names
------------------
(Antarctica/South_Pole,NZDT,13:00:00,t)
(Europe/Paris,CET,01:00:00,f)
```
Ejecute la instrucción SQL para obtener la lista completa y buscar un nombre de zona horaria. Se devuelven aproximadamente 600 filas. Aunque algunos de los nombres de zonas horarias devueltos son siglas o acrónimos en mayúsculas (por ejemplo: GB, PRC, ROK), la función CONVERT\$1TIMEZONE los trata como nombres de zonas horarias, no abreviaturas de zonas horarias.
Si especifica una zona horaria mediante un nombre de zona horaria, CONVERT\$1TIMEZONE se ajusta automáticamente al horario de verano (DST) o a cualquier otro protocolo de temporada local, como el horario de verano, el horario estándar o el horario de invierno, que esté vigente en esa zona horaria durante la fecha y hora especificadas por “*timestamp*”. Por ejemplo, “Europa/Londres” representa UTC en invierno y suma una hora en verano. Tenga en cuenta que Amazon Redshift utiliza la [Base de datos de zonas horarias de IANA](https://www.iana.org/time-zones) como fuente autorizada de especificación de zonas horarias.
### Uso de una abreviatura de zona horaria
Para ver una lista actualizada y completa de las abreviaturas de zona horaria, ejecute el siguiente comando.
```
select pg_timezone_abbrevs();
```
Los resultados contienen una cadena separada por comas con la abreviatura de la zona horaria, el desfase con respecto de UTC y un indicador de si la zona horaria sigue el horario de verano (`t` o `f`). Por ejemplo, en el siguiente fragmento se muestran dos filas resultantes. La primera fila contiene la abreviatura del horario de verano del Pacífico `PDT`, con un desfase de `-07:00:00` con respecto de UTC y `t` para indicar que sigue el horario de verano. La segunda fila contiene la abreviatura de hora estándar del Pacífico `PST`, con un desfase de `-08:00:00` con respecto de UTC y `f` para indicar que no sigue el horario de verano.
```
pg_timezone_abbrevs
--------------------
(PDT,-07:00:00,t)
(PST,-08:00:00,f)
```
Ejecute la instrucción SQL para obtener la lista completa y buscar una abreviatura basada en el indicador de desfase y horario de verano. Se devuelven aproximadamente 200 filas.
Las abreviaturas de zona horaria representan un desfase fijo a partir de UTC. Si especifica una zona horaria mediante una abreviatura de zona horaria, CONVERT\$1TIMEZONE usa el desfase fijo con respecto a UTC para cualquier protocolo de temporada local.
### Uso del formato estilo POSIX
Una especificación de zona horaria de estilo POSIX toma la forma *STDoffset* o *STDoffsetDST*, donde *STD* es la abreviatura de la zona horaria, *offset* es el ajuste numérico en horas hacia el oeste desde UTC y *DST* es la abreviatura opcional del horario de verano de la zona. Se supone que el horario de verano adelanta una hora, en función del desfase dado.
Los formatos de zona horaria estilo POSIX usan desfases positivos al oeste de Greenwich, al contrario que la convención de la norma ISO 8601, que usa desfases positivos al este de Greenwich.
A continuación, se muestran algunos ejemplos de zonas horarias estilo POSIX:
+ PST8
+ PST8PDT
+ EST5
+ EST5EDT
**nota**
Amazon Redshift no valida las especificaciones de zona horaria con estilo POSIX, por lo que es posible establecer la zona horaria en un valor no válido. Por ejemplo, el siguiente comando no devuelve un mensaje de error, a pesar de que establece la zona horaria en un valor no válido.
```
set timezone to ‘xxx36’;
```
## Ejemplos
En muchos ejemplos se utiliza el conjunto de datos de muestra TICKIT. Para obtener más información, consulte [Base de datos de muestra](https://docs.aws.amazon.com/redshift/latest/dg/c_sampledb.html).
En el siguiente ejemplo, se convierte el valor de la marca temporal de la zona horaria UTC predeterminada a la zona horaria PST.
```
select convert_timezone('PST', '2008-08-21 07:23:54');
convert_timezone
------------------------
2008-08-20 23:23:54
```
En el siguiente ejemplo, el valor de la marca temporal que aparece en la columna LISTTIME se convierte de la zona horaria UTC predeterminada a la zona horaria PST. Aunque la marca temporal se encuentra dentro del periodo de horario de verano, se convierte a horario estándar porque la zona horaria objetivo se especifica como una abreviatura (PST).
```
select listtime, convert_timezone('PST', listtime) from listing
where listid = 16;
listtime | convert_timezone
--------------------+-------------------
2008-08-24 09:36:12 2008-08-24 01:36:12
```
En el siguiente ejemplo, la marca temporal que aparece en la columna LISTTIME se convierte de la zona horaria predeterminada UTC a la zona horaria US/Pacific. La zona horaria objetivo usa un nombre de zona horaria y la marca temporal se encuentra dentro del periodo de horario de verano, por lo que la función devuelve el horario de verano.
```
select listtime, convert_timezone('US/Pacific', listtime) from listing
where listid = 16;
listtime | convert_timezone
--------------------+---------------------
2008-08-24 09:36:12 | 2008-08-24 02:36:12
```
En el siguiente ejemplo, se convierte una cadena de marca temporal de EST a PST:
```
select convert_timezone('EST', 'PST', '20080305 12:25:29');
convert_timezone
-------------------
2008-03-05 09:25:29
```
En el siguiente ejemplo, se convierte una marca temporal al horario del este de Estados Unidos estándar porque la zona horaria objetivo usa un nombre de zona horaria (America/New\$1York) y la marca temporal se encuentra dentro del periodo estándar.
```
select convert_timezone('America/New_York', '2013-02-01 08:00:00');
convert_timezone
---------------------
2013-02-01 03:00:00
(1 row)
```
En el siguiente ejemplo, se convierte la marca temporal al horario de verano del este de Estados Unidos porque la zona horaria objetivo usa un nombre de zona horaria (America/New\$1York) y la marca temporal se encuentra dentro del periodo de horario de verano.
```
select convert_timezone('America/New_York', '2013-06-01 08:00:00');
convert_timezone
---------------------
2013-06-01 04:00:00
(1 row)
```
En el siguiente ejemplo, se demuestra el uso de desplazamientos.
```
SELECT CONVERT_TIMEZONE('GMT','NEWZONE +2','2014-05-17 12:00:00') as newzone_plus_2,
CONVERT_TIMEZONE('GMT','NEWZONE-2:15','2014-05-17 12:00:00') as newzone_minus_2_15,
CONVERT_TIMEZONE('GMT','America/Los_Angeles+2','2014-05-17 12:00:00') as la_plus_2,
CONVERT_TIMEZONE('GMT','GMT+2','2014-05-17 12:00:00') as gmt_plus_2;
newzone_plus_2 | newzone_minus_2_15 | la_plus_2 | gmt_plus_2
---------------------+---------------------+---------------------+---------------------
2014-05-17 10:00:00 | 2014-05-17 14:15:00 | 2014-05-17 10:00:00 | 2014-05-17 10:00:00
(1 row)
```
# Función CURRENT\$1DATE
CURRENT\$1DATE devuelve una fecha en la zona horaria de la sesión actual (que es UTC de manera predeterminada) en el formato predeterminado: AAAA-MM-DD.
**nota**
CURRENT\$1DATE devuelve la fecha de comienzo de la transacción actual, no de la instrucción actual. Pensemos en el escenario en el que se inicia una transacción con varias instrucciones el 10/01/08 a las 23:59 y la instrucción que contiene CURRENT\$1DATE se ejecuta el 10/02/08 a las 00:00. CURRENT\$1DATE devuelve `10/01/08`, no `10/02/08`.
## Sintaxis
```
CURRENT_DATE
```
## Tipo de retorno
DATE
## Ejemplos
En el siguiente ejemplo, se devuelve la fecha actual (en las Región de AWS donde se ejecuta la función).
```
select current_date;
date
------------
2008-10-01
```
En el ejemplo siguiente se crea una tabla, se inserta una fila en la que el valor predeterminado de la columna `todays_date` es CURRENT\$1DATE y, a continuación, se seleccionan todas las filas de la tabla.
```
CREATE TABLE insert_dates(
label varchar(128) NOT NULL,
todays_date DATE DEFAULT CURRENT_DATE);
INSERT INTO insert_dates(label)
VALUES('Date row inserted');
SELECT * FROM insert_dates;
label | todays_date
------------------+-------------
Date row inserted | 2023-05-10
```
# Función DATE\$1CMP
DATE\$1CMP compara dos fechas. La función devuelve `0` si las fechas son idénticas, `1` si *date1* es posterior y `-1` si *date2* es posterior.
## Sintaxis
```
DATE_CMP(date1, date2)
```
## Argumentos
*date1*
Una columna de tipo de datos `DATE` o una expresión que toma el valor de un tipo `DATE`.
*date2*
Una columna de tipo de datos `DATE` o una expresión que toma el valor de un tipo `DATE`.
## Tipo de retorno
INTEGER
## Ejemplos
La siguiente consulta compara los valores DATE de la columna CALDATE con la fecha 4 de enero del 2008 y devuelve si el valor en CALDATE es anterior (`-1`), igual (`0`) o posterior (`1`) al 4 de enero del 2008:
```
select caldate, '2008-01-04',
date_cmp(caldate,'2008-01-04')
from date
order by dateid
limit 10;
caldate | ?column? | date_cmp
-----------+------------+----------
2008-01-01 | 2008-01-04 | -1
2008-01-02 | 2008-01-04 | -1
2008-01-03 | 2008-01-04 | -1
2008-01-04 | 2008-01-04 | 0
2008-01-05 | 2008-01-04 | 1
2008-01-06 | 2008-01-04 | 1
2008-01-07 | 2008-01-04 | 1
2008-01-08 | 2008-01-04 | 1
2008-01-09 | 2008-01-04 | 1
2008-01-10 | 2008-01-04 | 1
(10 rows)
```
# Función DATE\$1CMP\$1TIMESTAMP
DATE\$1CMP\$1TIMESTAMP compara una fecha con una marca temporal y devuelve `0` si los valores son idénticos, `1` si *date* es posterior cronológicamente y `-1` si *timestamp* es posterior.
## Sintaxis
```
DATE_CMP_TIMESTAMP(date, timestamp)
```
## Argumentos
*date*
Una columna de tipo de datos `DATE` o una expresión que toma el valor de un tipo `DATE`.
*timestamp*
Una columna de tipo de datos `TIMESTAMP` o una expresión que toma el valor de un tipo `TIMESTAMP`.
## Tipo de retorno
INTEGER
## Ejemplos
En el siguiente ejemplo, se compara la fecha `2008-06-18` con LISTTIME. Los valores de la columna LISTTIME son marcas temporales. Las listas hechas antes de esa fecha devuelven `1`; las hechas después de ella, `-1`.
```
select listid, '2008-06-18', listtime,
date_cmp_timestamp('2008-06-18', listtime)
from listing
order by 1, 2, 3, 4
limit 10;
listid | ?column? | listtime | date_cmp_timestamp
--------+------------+---------------------+--------------------
1 | 2008-06-18 | 2008-01-24 06:43:29 | 1
2 | 2008-06-18 | 2008-03-05 12:25:29 | 1
3 | 2008-06-18 | 2008-11-01 07:35:33 | -1
4 | 2008-06-18 | 2008-05-24 01:18:37 | 1
5 | 2008-06-18 | 2008-05-17 02:29:11 | 1
6 | 2008-06-18 | 2008-08-15 02:08:13 | -1
7 | 2008-06-18 | 2008-11-15 09:38:15 | -1
8 | 2008-06-18 | 2008-11-09 05:07:30 | -1
9 | 2008-06-18 | 2008-09-09 08:03:36 | -1
10 | 2008-06-18 | 2008-06-17 09:44:54 | 1
(10 rows)
```
# Función DATE\$1CMP\$1TIMESTAMPTZ
DATE\$1CMP\$1TIMESTAMPTZ compara una fecha con una marca temporal con zona horaria y devuelve `0` si los valores son idénticos, `1` si *date* es posterior cronológicamente y `-1` si *timestamptz* es posterior.
## Sintaxis
```
DATE_CMP_TIMESTAMPTZ(date, timestamptz)
```
## Argumentos
*date*
Una columna de tipo de datos `DATE` o una expresión que toma implícitamente el valor de un tipo `DATE`.
*timestamptz*
Una columna de tipo de datos `TIMESTAMPTZ` o una expresión que toma implícitamente el valor de un tipo `TIMESTAMPTZ`.
## Tipo de retorno
INTEGER
## Ejemplos
En el siguiente ejemplo, se compara la fecha `2008-06-18` con LISTTIME. Las listas hechas antes de esa fecha devuelven `1`; las hechas después de ella, `-1`.
```
select listid, '2008-06-18', CAST(listtime AS timestamptz),
date_cmp_timestamptz('2008-06-18', CAST(listtime AS timestamptz))
from listing
order by 1, 2, 3, 4
limit 10;
listid | ?column? | timestamptz | date_cmp_timestamptz
--------+------------+------------------------+----------------------
1 | 2008-06-18 | 2008-01-24 06:43:29+00 | 1
2 | 2008-06-18 | 2008-03-05 12:25:29+00 | 1
3 | 2008-06-18 | 2008-11-01 07:35:33+00 | -1
4 | 2008-06-18 | 2008-05-24 01:18:37+00 | 1
5 | 2008-06-18 | 2008-05-17 02:29:11+00 | 1
6 | 2008-06-18 | 2008-08-15 02:08:13+00 | -1
7 | 2008-06-18 | 2008-11-15 09:38:15+00 | -1
8 | 2008-06-18 | 2008-11-09 05:07:30+00 | -1
9 | 2008-06-18 | 2008-09-09 08:03:36+00 | -1
10 | 2008-06-18 | 2008-06-17 09:44:54+00 | 1
(10 rows)
```
# Función DATEADD
Aumenta un valor de DATE, TIME, TIMETZ o TIMESTAMP según un intervalo especificado.
## Sintaxis
```
DATEADD( datepart, interval, {date|time|timetz|timestamp} )
```
## Argumentos
*datepart*
La parte de la fecha (año, mes, día u hora, por ejemplo) sobre la que opera la función. Para obtener más información, consulte [Partes de fecha para funciones de fecha o marca temporal](r_Dateparts_for_datetime_functions.md).
*intervalo*
Un número entero que especifica el intervalo (cantidad de días, por ejemplo) por agregar a la expresión objetivo. Un número entero negativo resta al intervalo.
*date*\$1*time*\$1*timetz*\$1*timestamp*
Una columna DATE, TIME, TIMETZ o TIMESTAMP o una expresión que, de forma implícita, se convierte a una DATE, TIME, TIMETZ o TIMESTAMP. La expresión de DATE, TIME, TIMETZ o TIMESTAMP debe contener la parte de fecha especificada.
## Tipo de retorno
TIMESTAMP, TIME o TIMETZ según el tipo de datos de entrada.
## Ejemplos con una columna DATE
En el siguiente ejemplo, se agregan 30 días a cada fecha en noviembre que se encuentra en la tabla de DATE.
```
select dateadd(day,30,caldate) as novplus30
from date
where month='NOV'
order by dateid;
novplus30
---------------------
2008-12-01 00:00:00
2008-12-02 00:00:00
2008-12-03 00:00:00
...
(30 rows)
```
En el siguiente ejemplo, se agregan 18 meses a un valor de fecha literal.
```
select dateadd(month,18,'2008-02-28');
date_add
---------------------
2009-08-28 00:00:00
(1 row)
```
El nombre predeterminado de la columna para una función DATEADD es DATE\$1ADD. La marca temporal predeterminada para un valor de fecha es `00:00:00`.
En el siguiente ejemplo, se agregan 30 minutos a un valor de fecha que no especifica una marca temporal.
```
select dateadd(m,30,'2008-02-28');
date_add
---------------------
2008-02-28 00:30:00
(1 row)
```
Puede nombrar las partes de la fecha de manera completa o abreviada. En este caso, *m* representa a los minutos y no a lo meses.
## Ejemplos con una columna TIME
La siguiente tabla de ejemplo, TIME\$1TEST, tiene una columna TIME\$1VAL (tipo TIME) con tres valores insertados.
```
select time_val from time_test;
time_val
---------------------
20:00:00
00:00:00.5550
00:58:00
```
En el siguiente ejemplo, se agregan 5 minutos a cada TIME\$1VAL de la tabla TIME\$1TEST.
```
select dateadd(minute,5,time_val) as minplus5 from time_test;
minplus5
---------------
20:05:00
00:05:00.5550
01:03:00
```
En el siguiente ejemplo, se agregan 8 horas a un valor de fecha literal.
```
select dateadd(hour, 8, time '13:24:55');
date_add
---------------
21:24:55
```
El siguiente ejemplo muestra cuando una hora supera las 24:00:00 o cuando es antes de las 00:00:00.
```
select dateadd(hour, 12, time '13:24:55');
date_add
---------------
01:24:55
```
## Ejemplos con una columna TIMETZ
Los valores de salida en estos ejemplos están en formato UTC, que es la zona horaria predeterminada.
La siguiente tabla de ejemplo, TIMETZ\$1TEST, tiene una columna TIMETZ\$1VAL (tipo TIMETZ) con tres valores insertados.
```
select timetz_val from timetz_test;
timetz_val
------------------
04:00:00+00
00:00:00.5550+00
05:58:00+00
```
En el siguiente ejemplo, se agregan 5 minutos a cada TIMETZ\$1VAL de la tabla TIMETZ\$1TEST.
```
select dateadd(minute,5,timetz_val) as minplus5_tz from timetz_test;
minplus5_tz
---------------
04:05:00+00
00:05:00.5550+00
06:03:00+00
```
En el siguiente ejemplo, se agregan 2 horas a un valor de timetz literal.
```
select dateadd(hour, 2, timetz '13:24:55 PST');
date_add
---------------
23:24:55+00
```
## Ejemplos con una columna TIMESTAMP
Los valores de salida en estos ejemplos están en formato UTC, que es la zona horaria predeterminada.
La siguiente tabla de ejemplo, TIMESTAMP\$1TEST tiene una columna TIMESTAMP\$1VAL (tipo TIMESTAMP) con tres valores insertados.
```
SELECT timestamp_val FROM timestamp_test;
timestamp_val
------------------
1988-05-15 10:23:31
2021-03-18 17:20:41
2023-06-02 18:11:12
```
El siguiente ejemplo agrega 20 años solo a los valores TIMESTAMP\$1VAL en TIMESTAMP\$1TEST anteriores al año 2000.
```
SELECT dateadd(year,20,timestamp_val)
FROM timestamp_test
WHERE timestamp_val < to_timestamp('2000-01-01 00:00:00', 'YYYY-MM-DD HH:MI:SS');
date_add
---------------
2008-05-15 10:23:31
```
En el siguiente ejemplo se agregan 5 segundos a un valor de marca temporal literal escrito sin un indicador de segundos.
```
SELECT dateadd(second, 5, timestamp '2001-06-06');
date_add
---------------
2001-06-06 00:00:05
```
## Notas de uso
Las funciones DATEADD(month, ...) y ADD\$1MONTHS administran las fechas que caen en fin de mes de manera diferente:
+ ADD\$1MONTHS: si la fecha que se agrega es el último día del mes, el resultado es siempre el último día del mes en el resultado, sin importar su longitud. Por ejemplo, 30 de abril \$1 1 mes es 31 de mayo.
```
select add_months('2008-04-30',1);
add_months
---------------------
2008-05-31 00:00:00
(1 row)
```
+ DATEADD: si en la fecha que se agrega hay menos días que en el mes del resultado, el resultado será el día correspondiente del mes del resultado, no el último día de ese mes. Por ejemplo, 30 de abril \$1 1 mes es 30 de mayo.
```
select dateadd(month,1,'2008-04-30');
date_add
---------------------
2008-05-30 00:00:00
(1 row)
```
La función DATEADD administra la fecha 02-29 de año bisiesto de manera diferente con dateadd (month, 12,…) o dateadd (year, 1, …).
```
select dateadd(month,12,'2016-02-29');
date_add
---------------------
2017-02-28 00:00:00
select dateadd(year, 1, '2016-02-29');
date_add
---------------------
2017-03-01 00:00:00
```
# Función DATEDIFF
DATEDIFF devuelve la diferencia entre las partes de fecha de dos expresiones de fecha u hora.
## Sintaxis
```
DATEDIFF( datepart, {date|time|timetz|timestamp}, {date|time|timetz|timestamp} )
```
## Argumentos
*datepart*
La parte específica del valor de fecha u hora (año, mes o día; hora, minuto, segundo, milisegundo o microsegundo) sobre la que opera la función. Para obtener más información, consulte [Partes de fecha para funciones de fecha o marca temporal](r_Dateparts_for_datetime_functions.md).
En concreto, DATEDIFF determina la cantidad de límites de la parte de fecha que se cruzan entre las dos expresiones. Suponga, por ejemplo, que calcula la diferencia en años entre dos fechas, `12-31-2008` y `01-01-2009`. En este caso, la función devuelve 1 año a pesar de que estas fechas solo tienen un día de diferencia. Si busca la diferencia en horas entre dos marcas temporales, `01-01-2009 8:30:00` y `01-01-2009 10:00:00`, el resultado es 2 horas. Si busca la diferencia en horas entre dos marcas temporales, `8:30:00` y `10:00:00`, el resultado es 2 horas.
*date*\$1*time*\$1*timetz*\$1*timestamp*
Una columna o expresiones de DATE, TIME, TIMETZ o TIMESTAMP que se convierten de forma implícita en DATE, TIME, TIMETZ o TIMESTAMP. Ambas expresiones deben contener la parte de fecha u hora especificada. Si la segunda fecha u hora es posterior a la primera, el resultado es positivo. Si la segunda fecha u hora es anterior a la primera, el resultado es negativo.
## Tipo de retorno
BIGINT
## Ejemplos con una columna DATE
En el siguiente ejemplo, se encuentra la diferencia, en cantidad de semanas, entre dos valores de fecha literales.
```
select datediff(week,'2009-01-01','2009-12-31') as numweeks;
numweeks
----------
52
(1 row)
```
En el siguiente ejemplo, se encuentra la diferencia, en horas, entre dos valores de fecha literales. Cuando no se proporciona el valor de la hora para una fecha, de forma predeterminada es 00:00:00.
```
select datediff(hour, '2023-01-01', '2023-01-03 05:04:03');
date_diff
----------
53
(1 row)
```
En el siguiente ejemplo se encuentra la diferencia, en días, entre dos valores TIMESTAMETZ literales.
```
Select datediff(days, 'Jun 1,2008 09:59:59 EST', 'Jul 4,2008 09:59:59 EST')
date_diff
----------
33
```
En el siguiente ejemplo, se encuentra la diferencia, en días, entre dos fechas de la misma fila de una tabla.
```
select * from date_table;
start_date | end_date
-----------+-----------
2009-01-01 | 2009-03-23
2023-01-04 | 2024-05-04
(2 rows)
select datediff(day, start_date, end_date) as duration from date_table;
duration
---------
81
486
(2 rows)
```
En el siguiente ejemplo, se encuentra la diferencia, en cantidad de trimestres, entre un valor literal del pasado y la fecha de hoy. En este ejemplo, se asume que la fecha actual es 5 de junio del 2008. Puede nombrar las partes de la fecha de manera completa o abreviada. El nombre predeterminado de la columna para la función DATEDIFF es DATE\$1DIFF.
```
select datediff(qtr, '1998-07-01', current_date);
date_diff
-----------
40
(1 row)
```
En este ejemplo, se unen las tablas SALES y LISTING para calcular cuántos días después de indicarse se vendieron los tickets de los listados 1000 a 1005. La espera más prolongada para la venta de estos listados fue de 15 días, y la más corta, de menos de 1 día (0 días).
```
select priceperticket,
datediff(day, listtime, saletime) as wait
from sales, listing where sales.listid = listing.listid
and sales.listid between 1000 and 1005
order by wait desc, priceperticket desc;
priceperticket | wait
---------------+------
96.00 | 15
123.00 | 11
131.00 | 9
123.00 | 6
129.00 | 4
96.00 | 4
96.00 | 0
(7 rows)
```
En este ejemplo, se calculan las horas promedio esperadas por los vendedores para todas las ventas de tickets.
```
select avg(datediff(hours, listtime, saletime)) as avgwait
from sales, listing
where sales.listid = listing.listid;
avgwait
---------
465
(1 row)
```
## Ejemplos con una columna TIME
La siguiente tabla de ejemplo, TIME\$1TEST, tiene una columna TIME\$1VAL (tipo TIME) con tres valores insertados.
```
select time_val from time_test;
time_val
---------------------
20:00:00
00:00:00.5550
00:58:00
```
En el siguiente ejemplo, se encuentra la diferencia en cantidad de horas entre la columna TIME\$1VAL y un literal de tiempo.
```
select datediff(hour, time_val, time '15:24:45') from time_test;
date_diff
-----------
-5
15
15
```
En el siguiente ejemplo, se encuentra la diferencia en cantidad de minutos entre dos valores de tiempo literales.
```
select datediff(minute, time '20:00:00', time '21:00:00') as nummins;
nummins
----------
60
```
## Ejemplos con una columna TIMETZ
La siguiente tabla de ejemplo, TIMETZ\$1TEST, tiene una columna TIMETZ\$1VAL (tipo TIMETZ) con tres valores insertados.
```
select timetz_val from timetz_test;
timetz_val
------------------
04:00:00+00
00:00:00.5550+00
05:58:00+00
```
En el siguiente ejemplo, se encuentran las diferencias en la cantidad de horas, entre un literal TIMETZ y timetz\$1val.
```
select datediff(hours, timetz '20:00:00 PST', timetz_val) as numhours from timetz_test;
numhours
----------
0
-4
1
```
En el siguiente ejemplo, se encuentra la diferencia en cantidad de horas entre dos valores TIMETZ literales.
```
select datediff(hours, timetz '20:00:00 PST', timetz '00:58:00 EST') as numhours;
numhours
----------
1
```
# Función DATE\$1PART
DATE\$1PART extrae los valores de parte de fecha a partir de una expresión. DATE\$1PART es sinónimo de la función PGDATE\$1PART.
## Sintaxis
```
DATE_PART(datepart, {date|timestamp})
```
## Argumentos
*datepart*
Un literal o cadena de identificación de la parte específica del valor de la fecha (por ejemplo, año, mes o día) en la que actúa la función. Para obtener más información, consulte [Partes de fecha para funciones de fecha o marca temporal](r_Dateparts_for_datetime_functions.md).
\$1*date*\$1*timestamp*\$1
Una columna de fecha, una columna de marca de tiempo o una expresión que se convierte implícitamente en una fecha o una marca de tiempo. La columna o expresión en *fecha* o *marca de tiempo* debe contener la parte de fecha especificada en *parte de fecha*.
## Tipo de retorno
DOUBLE
## Ejemplos
El nombre predeterminado de la columna para la función DATE\$1PART es `pgdate_part`.
Para obtener más información acerca de los datos utilizados en algunos de estos ejemplos, consulte [Base de datos de muestra](c_sampledb.md).
En el ejemplo siguiente se encuentra el minuto de un literal de marca temporal.
```
SELECT DATE_PART(minute, timestamp '20230104 04:05:06.789');
pgdate_part
-----------
5
```
En el ejemplo siguiente, se encuentra el número de semana de un literal de marca temporal. El cálculo del número de semana sigue el estándar ISO 8601. Para obtener más información, consulte [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) en Wikipedia.
```
SELECT DATE_PART(week, timestamp '20220502 04:05:06.789');
pgdate_part
-----------
18
```
En el ejemplo siguiente se encuentra el día del mes de un literal de marca temporal.
```
SELECT DATE_PART(day, timestamp '20220502 04:05:06.789');
pgdate_part
-----------
2
```
En el ejemplo siguiente se encuentra el día de la semana de un literal de marca temporal. El cálculo del número del día de la semana es un número entero de 0 a 6, que empieza el domingo.
```
SELECT DATE_PART(dayofweek, timestamp '20220502 04:05:06.789');
pgdate_part
-----------
1
```
En el ejemplo siguiente se encuentra el siglo de un literal de marca temporal. El cálculo del siglo sigue el estándar ISO 8601. Para obtener más información, consulte [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) en Wikipedia.
```
SELECT DATE_PART(century, timestamp '20220502 04:05:06.789');
pgdate_part
-----------
21
```
En el ejemplo siguiente, se encuentra el milenio de un literal de marca de tiempo. El cálculo del milenio sigue el estándar ISO 8601. Para obtener más información, consulte [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) en Wikipedia.
```
SELECT DATE_PART(millennium, timestamp '20220502 04:05:06.789');
pgdate_part
-----------
3
```
En el ejemplo siguiente, se encuentran los microsegundos de un literal de marca de tiempo. El cálculo de los microsegundos sigue el estándar ISO 8601. Para obtener más información, consulte [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) en Wikipedia.
```
SELECT DATE_PART(microsecond, timestamp '20220502 04:05:06.789');
pgdate_part
-----------
789000
```
En el ejemplo siguiente se encuentra el mes de un literal de fecha.
```
SELECT DATE_PART(month, date '20220502');
pgdate_part
-----------
5
```
En el siguiente ejemplo, se aplica la función DATE\$1PART a una columna de una tabla.
```
SELECT date_part(w, listtime) AS weeks, listtime
FROM listing
WHERE listid=10
weeks | listtime
------+---------------------
25 | 2008-06-17 09:44:54
(1 row)
```
Puede especificar las partes de fecha utilizando su nombre completo o una abreviatura; en este caso, *w* quiere decir semanas.
La parte de fecha de día de la semana devuelve un número entero de 0 a 6, comenzando por domingo. Use DATE\$1PART con dow (DAYOFWEEK) para visualizar los eventos que se llevan a cabo un sábado.
```
SELECT date_part(dow, starttime) AS dow, starttime
FROM event
WHERE date_part(dow, starttime)=6
ORDER BY 2,1;
dow | starttime
-----+---------------------
6 | 2008-01-05 14:00:00
6 | 2008-01-05 14:00:00
6 | 2008-01-05 14:00:00
6 | 2008-01-05 14:00:00
...
(1147 rows)
```
# Función DATE\$1PART\$1YEAR
La función DATE\$1PART\$1YEAR extrae el año de una fecha.
## Sintaxis
```
DATE_PART_YEAR(date)
```
## Argumento
*date*
Una columna de tipo de datos `DATE` o una expresión que toma implícitamente el valor de un tipo `DATE`.
## Tipo de retorno
INTEGER
## Ejemplos
En el ejemplo siguiente se encuentra el año de un literal de fecha.
```
SELECT DATE_PART_YEAR(date '20220502 04:05:06.789');
date_part_year
---------------
2022
```
En el siguiente ejemplo, se extrae el año de la columna CALDATE. Los valores de la columna CALDATE son fechas. Para obtener más información sobre los datos que se utilizan en este ejemplo, consulte [Base de datos de muestra](c_sampledb.md).
```
select caldate, date_part_year(caldate)
from date
order by
dateid limit 10;
caldate | date_part_year
-----------+----------------
2008-01-01 | 2008
2008-01-02 | 2008
2008-01-03 | 2008
2008-01-04 | 2008
2008-01-05 | 2008
2008-01-06 | 2008
2008-01-07 | 2008
2008-01-08 | 2008
2008-01-09 | 2008
2008-01-10 | 2008
(10 rows)
```
# Función DATE\$1TRUNC
La función DATE\$1TRUNC trunca todo literal o expresión de marca temporal basado en la parte de fecha especificada, como la hora, la semana o el mes.
## Sintaxis
```
DATE_TRUNC('datepart', timestamp)
```
## Argumentos
*datepart*
La parte de fecha que trunca el valor de una marca temporal. La *timestamp* de entrada se trunca en la precisión de la entrada *datepart*. Por ejemplo, `month` se trunca en el primer día del mes. Los formatos válidos son los siguientes:
+ microsegundo, microsegundos
+ milisegundo, milisegundos
+ segundo, segundos
+ minuto, minutos
+ hora, horas
+ día, días
+ semana, semanas
+ mes, meses
+ trimestre, trimestres
+ año, años
+ década, décadas
+ siglo, siglos
+ milenio, milenios
Para obtener más información sobre las abreviaturas de algunos formatos, consulte . [Partes de fecha para funciones de fecha o marca temporal](r_Dateparts_for_datetime_functions.md)
*timestamp*
Una columna de marca temporal o una expresión que, implícitamente, se convierte en una marca temporal.
## Tipo de retorno
TIMESTAMP
## Ejemplos
Trunque la marca temporal de entrada en el segundo.
```
SELECT DATE_TRUNC('second', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-04-30 04:05:06
```
Trunque la marca temporal de entrada al minuto.
```
SELECT DATE_TRUNC('minute', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-04-30 04:05:00
```
Trunque la marca temporal de entrada a la hora.
```
SELECT DATE_TRUNC('hour', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-04-30 04:00:00
```
Trunque la marca temporal de entrada al día.
```
SELECT DATE_TRUNC('day', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-04-30 00:00:00
```
Trunque la marca temporal de entrada al primer día de un mes.
```
SELECT DATE_TRUNC('month', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-04-01 00:00:00
```
Trunque la marca temporal de entrada al primer día de un trimestre.
```
SELECT DATE_TRUNC('quarter', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-04-01 00:00:00
```
Trunque la marca temporal de entrada al primer día de un año.
```
SELECT DATE_TRUNC('year', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-01-01 00:00:00
```
Trunque la marca temporal de entrada al primer día de un siglo.
```
SELECT DATE_TRUNC('millennium', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2001-01-01 00:00:00
```
Trunque la marca temporal de entrada al lunes de un mes.
```
select date_trunc('week', TIMESTAMP '20220430 04:05:06.789');
date_trunc
2022-04-25 00:00:00
```
En el siguiente ejemplo, la función DATE\$1TRUNC usa la parte de fecha “week” (semana) para devolver la fecha del lunes de cada semana.
```
select date_trunc('week', saletime), sum(pricepaid) from sales where
saletime like '2008-09%' group by date_trunc('week', saletime) order by 1;
date_trunc | sum
------------+-------------
2008-09-01 | 2474899
2008-09-08 | 2412354
2008-09-15 | 2364707
2008-09-22 | 2359351
2008-09-29 | 705249
```
# Función EXTRACT
La función EXTRACT devuelve una parte de fecha u hora de un valor TIMESTAMP, TIMESTAMPTZ, TIME, TIMETZ, INTERVAL YEAR TO MONTH o INTERVAL DAY TO SECOND. Algunos ejemplos son día, mes, año, hora, minuto, segundo, milisegundo o microsegundo de una marca de tiempo.
## Sintaxis
```
EXTRACT(datepart FROM source)
```
## Argumentos
*datepart*
El subcampo de una fecha u hora que se va a extraer, como día, mes, año, hora, minuto, segundo, milisegundo o microsegundo. Para obtener los valores posibles, consulte [Partes de fecha para funciones de fecha o marca temporal](r_Dateparts_for_datetime_functions.md).
*origen*
Una columna o una expresión que se evalúa como un tipo de datos de TIMESTAMP, TIMESTAMPTZ, TIME, TIMETZ, INTERVAL YEAR TO MONTH o INTERVAL DAY TO SECOND.
## Tipo de retorno
INTEGER si el valor de *origen* se evalúa como tipo de datos TIMESTAMP, TIME, TIMETZ, INTERVAL YEAR TO MONTH o INTERVAL DAY TO SECOND.
DOUBLE PRECISION si el valor de *origen* se evalúa como el tipo de datos TIMESTAMPTZ.
## Ejemplos con TIMESTAMP
En el siguiente ejemplo, se determinan los números de las semanas para las ventas en las que el precio pagado fue 10 000 USD o más. En este ejemplo, se utilizan los datos de TICKIT. Para obtener más información, consulte [Base de datos de muestra](c_sampledb.md).
```
select salesid, extract(week from saletime) as weeknum
from sales
where pricepaid > 9999
order by 2;
salesid | weeknum
--------+---------
159073 | 6
160318 | 8
161723 | 26
```
En el siguiente ejemplo, se devuelve el valor de minutos de un valor de marca temporal literal.
```
select extract(minute from timestamp '2009-09-09 12:08:43');
date_part
-----------
8
```
En el siguiente ejemplo, se devuelve el valor de milisegundos de un valor timestamp literal.
```
select extract(ms from timestamp '2009-09-09 12:08:43.101');
date_part
-----------
101
```
## Ejemplos con TIMESTAMPTZ
En el siguiente ejemplo, se devuelve el valor de año de un valor timestamptz literal.
```
select extract(year from timestamptz '1.12.1997 07:37:16.00 PST');
date_part
-----------
1997
```
## Ejemplos con TIME
La siguiente tabla de ejemplo, TIME\$1TEST, tiene una columna TIME\$1VAL (tipo TIME) con tres valores insertados.
```
select time_val from time_test;
time_val
---------------------
20:00:00
00:00:00.5550
00:58:00
```
En el siguiente ejemplo, se extraen los minutos de cada time\$1val.
```
select extract(minute from time_val) as minutes from time_test;
minutes
-----------
0
0
58
```
En el siguiente ejemplo, se extraen las horas de cada time\$1val.
```
select extract(hour from time_val) as hours from time_test;
hours
-----------
20
0
0
```
En el siguiente ejemplo, se extraen los milisegundos de un valor literal.
```
select extract(ms from time '18:25:33.123456');
date_part
-----------
123
```
## Ejemplos con TIMETZ
La siguiente tabla de ejemplo, TIMETZ\$1TEST, tiene una columna TIMETZ\$1VAL (tipo TIMETZ) con tres valores insertados.
```
select timetz_val from timetz_test;
timetz_val
------------------
04:00:00+00
00:00:00.5550+00
05:58:00+00
```
En el siguiente ejemplo, se extraen las horas de cada timetz\$1val.
```
select extract(hour from timetz_val) as hours from time_test;
hours
-----------
4
0
5
```
En el siguiente ejemplo, se extraen los milisegundos de un valor literal. Los literales no se convierten a UTC antes de que se procese la extracción.
```
select extract(ms from timetz '18:25:33.123456 EST');
date_part
-----------
123
```
En el siguiente ejemplo, se devuelve la hora de desfase horario respecto a UTC a partir de un valor timetz literal.
```
select extract(timezone_hour from timetz '1.12.1997 07:37:16.00 PDT');
date_part
-----------
-7
```
## Ejemplos con INTERVAL YEAR TO MONTH e INTERVAL DAY TO SECOND
En el siguiente ejemplo, se extrae la parte del día de `1` del INTERVAL DAY TO SECOND que define 36 horas, es decir, 1 día y 12 horas.
```
select EXTRACT('days' from INTERVAL '36 hours' DAY TO SECOND)
date_part
------------------
1
```
En el siguiente ejemplo, se extrae la parte del mes de `3` del YEAR TO MONTH que define 15 meses, es decir, 1 año y 3 meses.
```
select EXTRACT('month' from INTERVAL '15 months' YEAR TO MONTH)
date_part
------------------
3
```
En el siguiente ejemplo, se extrae la parte del mes de `6` de 30 meses que es 2 años y 6 meses.
```
select EXTRACT('month' from INTERVAL '30' MONTH)
date_part
------------------
6
```
En el siguiente ejemplo, se extrae la parte de la hora de `2` de 50 horas que es 2 días y 2 horas.
```
select EXTRACT('hours' from INTERVAL '50' HOUR)
date_part
------------------
2
```
En el siguiente ejemplo, se extrae la parte de minutos de `11` de 1 hora, 11 minutos y 11 123 segundos.
```
select EXTRACT('minute' from INTERVAL '70 minutes 70.123 seconds' MINUTE TO SECOND)
date_part
------------------
11
```
En el siguiente ejemplo, se extrae la parte de segundos de `1.11` de 1 día, 1 hora, 1 minuto y 1,11 segundos.
```
select EXTRACT('seconds' from INTERVAL '1 day 1:1:1.11' DAY TO SECOND)
date_part
------------------
1.11
```
En el siguiente ejemplo, se extrae el número total de horas de un INTERVAL. Cada parte se extrae y se agrega a un total.
```
select EXTRACT('days' from INTERVAL '50' HOUR) * 24 + EXTRACT('hours' from INTERVAL '50' HOUR)
?column?
------------------
50
```
En el siguiente ejemplo, se extrae el número total de segundos de un INTERVALO. Cada parte se extrae y se agrega a un total.
```
select EXTRACT('days' from INTERVAL '1 day 1:1:1.11' DAY TO SECOND) * 86400 +
EXTRACT('hours' from INTERVAL '1 day 1:1:1.11' DAY TO SECOND) * 3600 +
EXTRACT('minutes' from INTERVAL '1 day 1:1:1.11' DAY TO SECOND) * 60 +
EXTRACT('seconds' from INTERVAL '1 day 1:1:1.11' DAY TO SECOND)
?column?
------------------
90061.11
```
# Función GETDATE
GETDATE devuelve la fecha y hora actual en la zona horaria de la sesión actual (que es UTC de manera predeterminada). Devuelve la fecha u hora de inicio de la instrucción actual, incluso cuando se encuentra dentro de un bloque de transacciones.
## Sintaxis
```
GETDATE()
```
Los paréntesis son obligatorios.
## Tipo de retorno
TIMESTAMP
## Ejemplos
En el siguiente ejemplo, se usa la función GETDATE para devolver la marca temporal completa para la fecha actual.
```
select getdate();
timestamp
---------------------
2008-12-04 16:10:43
```
En el siguiente ejemplo, se usa la función GETDATE dentro de la función TRUNC para devolver la fecha actual sin la hora.
```
select trunc(getdate());
trunc
------------
2008-12-04
```
# Función INTERVAL\$1CMP
INTERVAL\$1CMP compara dos intervalos y devuelve `1` si el primer intervalo es mayor, `-1` si el segundo intervalo es mayor y `0` si los intervalos son iguales. Para obtener más información, consulte [Ejemplos de literales de intervalo sin sintaxis de calificador](r_interval_literals.md).
## Sintaxis
```
INTERVAL_CMP(interval1, interval2)
```
## Argumentos
*interval1*
Un valor literal de intervalo.
*interval2*
Un valor literal de intervalo.
## Tipo de retorno
INTEGER
## Ejemplos
En el siguiente ejemplo, se compara el valor de `3 days` con `1 year`.
```
select interval_cmp('3 days','1 year');
interval_cmp
--------------
-1
```
En este ejemplo se compara el valor `7 days` con `1 week`.
```
select interval_cmp('7 days','1 week');
interval_cmp
--------------
0
```
En el siguiente ejemplo, se compara el valor de `1 year` con `3 days`.
```
select interval_cmp('1 year','3 days');
interval_cmp
--------------
1
```
# Función LAST\$1DAY
LAST\$1DAY devuelve la fecha del último día del mes que contiene el valor de *date (fecha)*. El tipo de valor devuelto siempre es DATE, sin importar el tipo de datos del argumento *date (fecha)*.
Para obtener más información sobre la recuperación de partes de fecha específicas, consulte [Función DATE\$1TRUNC](r_DATE_TRUNC.md).
## Sintaxis
```
LAST_DAY( { date | timestamp } )
```
## Argumentos
*date* \$1 *timestamp*
Una columna de tipo de datos `DATE` o `TIMESTAMP`, o una expresión que toma implícitamente el valor de un tipo `DATE` o `TIMESTAMP`.
## Tipo de retorno
DATE
## Ejemplos
En el siguiente ejemplo, se devuelve la fecha del último día del mes actual.
```
select last_day(sysdate);
last_day
------------
2014-01-31
```
En el siguiente ejemplo, se devuelve la cantidad de tickets vendidos para cada uno de los últimos 7 días del mes. Los valores de la columna SALETIME son marcas temporales.
```
select datediff(day, saletime, last_day(saletime)) as "Days Remaining", sum(qtysold)
from sales
where datediff(day, saletime, last_day(saletime)) < 7
group by 1
order by 1;
days remaining | sum
---------------+-------
0 | 10140
1 | 11187
2 | 11515
3 | 11217
4 | 11446
5 | 11708
6 | 10988
(7 rows)
```
# Función MONTHS\$1BETWEEN
MONTHS\$1BETWEEN determina la cantidad de meses que hay entre dos fechas.
Si la primera fecha es posterior a la segunda, el resultado es positivo; de lo contrario, el resultado es negativo.
Si alguno de los argumentos es nulo, el resultado es NULL.
## Sintaxis
```
MONTHS_BETWEEN( date1, date2 )
```
## Argumentos
*date1*
Una columna de tipo de datos `DATE` o una expresión que toma implícitamente el valor de un tipo `DATE`.
*date2*
Una columna de tipo de datos `DATE` o una expresión que toma implícitamente el valor de un tipo `DATE`.
## Tipo de retorno
FLOAT8
La porción de número entero del resultado se basa en la diferencia entre los valores de mes y año de las fechas. La porción de fracción del resultado se calcula a partir de los valores de día y marca temporal de las fechas y supone un mes de 31 días.
Si tanto *date1 (fecha1)* como *date2 (fecha2)* tienen el mismo día del mes (por ejemplo, 15/01/14 y 15/02/14) o el último día el mes (por ejemplo, 31/08/14 y 30/09/14), el resultado será un número entero basado en los valores de mes y año de las fechas, sin importar si la porción de marca temporal (en caso de estar presente) coincide.
## Ejemplos
En el siguiente ejemplo, se devuelven los meses entre 18/01/1969 y 18/03/1969.
```
select months_between('1969-01-18', '1969-03-18')
as months;
months
----------
-2
```
En el siguiente ejemplo, se devuelven los meses entre 18/01/1969 y 18/01/1969.
```
select months_between('1969-01-18', '1969-01-18')
as months;
months
----------
0
```
En el siguiente ejemplo, se devuelven los meses entre la primera y la última muestra de un evento.
```
select eventname,
min(starttime) as first_show,
max(starttime) as last_show,
months_between(max(starttime),min(starttime)) as month_diff
from event
group by eventname
order by eventname
limit 5;
eventname first_show last_show month_diff
---------------------------------------------------------------------------
.38 Special 2008-01-21 19:30:00.0 2008-12-25 15:00:00.0 11.12
3 Doors Down 2008-01-03 15:00:00.0 2008-12-01 19:30:00.0 10.94
70s Soul Jam 2008-01-16 19:30:00.0 2008-12-07 14:00:00.0 10.7
A Bronx Tale 2008-01-21 19:00:00.0 2008-12-15 15:00:00.0 10.8
A Catered Affair 2008-01-08 19:30:00.0 2008-12-19 19:00:00.0 11.35
```
# Función NEXT\$1DAY
NEXT\$1DAY devuelve la fecha de la primera instancia del día especificado que es posterior a la fecha proporcionada.
Si el valor de *day* es el mismo día de la semana que la fecha especificada, se devuelve la siguiente instancia de ese día.
## Sintaxis
```
NEXT_DAY( { date | timestamp }, day )
```
## Argumentos
*date* \$1 *timestamp*
Una columna de tipo de datos `DATE` o `TIMESTAMP`, o una expresión que toma implícitamente el valor de un tipo `DATE` o `TIMESTAMP`.
*day*
Una cadena que tiene el nombre de cualquier día. El uso de mayúsculas no se tiene en cuenta.
Los valores válidos son los siguientes:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_NEXT_DAY.html)
## Tipo de retorno
DATE
## Ejemplos
En el siguiente ejemplo, se devuelve la fecha del primer martes después del 20/08/2014.
```
select next_day('2014-08-20','Tuesday');
next_day
-----------
2014-08-26
```
En el siguiente ejemplo se devuelve la fecha del primer martes después del 01/01/2008 a las 5:54:44.
```
select listtime, next_day(listtime, 'Tue') from listing limit 1;
listtime | next_day
--------------------+-----------
2008-01-01 05:54:44 | 2008-01-08
```
En el siguiente ejemplo, se obtienen las fechas de marketing objetivo para el tercer trimestre.
```
select username, (firstname ||' '|| lastname) as name,
eventname, caldate, next_day (caldate, 'Monday') as marketing_target
from sales, date, users, event
where sales.buyerid = users.userid
and sales.eventid = event.eventid
and event.dateid = date.dateid
and date.qtr = 3
order by marketing_target, eventname, name;
username | name | eventname | caldate | marketing_target
----------+-------------------+----------------------+--------------+-------------------
MBO26QSG | Callum Atkinson | .38 Special | 2008-07-06 | 2008-07-07
WCR50YIU | Erasmus Alvarez | A Doll's House | 2008-07-03 | 2008-07-07
CKT70OIE | Hadassah Adkins | Ana Gabriel | 2008-07-06 | 2008-07-07
VVG07OUO | Nathan Abbott | Armando Manzanero | 2008-07-04 | 2008-07-07
GEW77SII | Scarlet Avila | August: Osage County | 2008-07-06 | 2008-07-07
ECR71CVS | Caryn Adkins | Ben Folds | 2008-07-03 | 2008-07-07
KUW82CYU | Kaden Aguilar | Bette Midler | 2008-07-01 | 2008-07-07
WZE78DJZ | Kay Avila | Bette Midler | 2008-07-01 | 2008-07-07
HXY04NVE | Dante Austin | Britney Spears | 2008-07-02 | 2008-07-07
URY81YWF | Wilma Anthony | Britney Spears | 2008-07-02 | 2008-07-07
```
# Función SYSDATE
SYSDATE devuelve la fecha y hora actual en la zona horaria de la sesión actual (que es UTC de manera predeterminada).
**nota**
SYSDATE devuelve la fecha y hora de comienzo de la transacción actual, no de la instrucción actual.
## Sintaxis
```
SYSDATE
```
Esta función no requiere argumentos.
## Tipo de retorno
TIMESTAMP
## Ejemplos
En el siguiente ejemplo, se usa la función SYSDATE para devolver la marca temporal completa para la fecha actual.
```
select sysdate;
timestamp
----------------------------
2008-12-04 16:10:43.976353
```
En el siguiente ejemplo, se usa la función SYSDATE dentro de la función TRUNC para devolver la fecha actual sin la hora.
```
select trunc(sysdate);
trunc
------------
2008-12-04
```
La siguiente consulta devuelve la información de ventas correspondiente a las fechas comprendidas entre la fecha en que se emite la consulta y la fecha que caiga 120 días antes.
```
select salesid, pricepaid, trunc(saletime) as saletime, trunc(sysdate) as now
from sales
where saletime between trunc(sysdate)-120 and trunc(sysdate)
order by saletime asc;
salesid | pricepaid | saletime | now
---------+-----------+------------+------------
91535 | 670.00 | 2008-08-07 | 2008-12-05
91635 | 365.00 | 2008-08-07 | 2008-12-05
91901 | 1002.00 | 2008-08-07 | 2008-12-05
...
```
# Función TIMEOFDAY
TIMEOFDAY es un alias especial que se usa para devolver el día, la fecha y la hora como un valor de cadena. Devuelve la cadena de hora del día para la instrucción actual, incluso cuando se encuentra dentro de un bloque de transacciones.
## Sintaxis
```
TIMEOFDAY()
```
## Tipo de retorno
VARCHAR
## Ejemplos
En el siguiente ejemplo, se devuelve la fecha y la hora actual mediante el uso de la función TIMEOFDAY.
```
select timeofday();
timeofday
------------
Thu Sep 19 22:53:50.333525 2013 UTC
```
# Función TIMESTAMP\$1CMP
Compara el valor de dos marcas temporales y devuelve un número entero. Si las marcas temporales son idénticas, la función devuelve `0`. Si la primera marca temporal es mayor, la función devuelve `1`. Si la segunda marca temporal es mayor, la función devuelve `-1`.
## Sintaxis
```
TIMESTAMP_CMP(timestamp1, timestamp2)
```
## Argumentos
*timestamp1*
Una columna de tipo de datos `TIMESTAMP` o una expresión que toma implícitamente el valor de un tipo `TIMESTAMP`.
*timestamp2*
Una columna de tipo de datos `TIMESTAMP` o una expresión que toma implícitamente el valor de un tipo `TIMESTAMP`.
## Tipo de retorno
INTEGER
## Ejemplos
En el siguiente ejemplo se comparan las marcas temporales y se muestran los resultados de la comparación.
```
SELECT TIMESTAMP_CMP('2008-01-24 06:43:29', '2008-01-24 06:43:29'), TIMESTAMP_CMP('2008-01-24 06:43:29', '2008-02-18 02:36:48'), TIMESTAMP_CMP('2008-02-18 02:36:48', '2008-01-24 06:43:29');
timestamp_cmp | timestamp_cmp | timestamp_cmp
---------------+---------------+---------------
0 | -1 | 1
```
En el siguiente ejemplo, se compara LISTTIME y SALETIME para una lista. El valor de TIMESTAMP\$1CMP es `-1` para todos los listados porque la marca temporal para la venta es posterior a la marca temporal para el listado.
```
select listing.listid, listing.listtime,
sales.saletime, timestamp_cmp(listing.listtime, sales.saletime)
from listing, sales
where listing.listid=sales.listid
order by 1, 2, 3, 4
limit 10;
listid | listtime | saletime | timestamp_cmp
--------+---------------------+---------------------+---------------
1 | 2008-01-24 06:43:29 | 2008-02-18 02:36:48 | -1
4 | 2008-05-24 01:18:37 | 2008-06-06 05:00:16 | -1
5 | 2008-05-17 02:29:11 | 2008-06-06 08:26:17 | -1
5 | 2008-05-17 02:29:11 | 2008-06-09 08:38:52 | -1
6 | 2008-08-15 02:08:13 | 2008-08-31 09:17:02 | -1
10 | 2008-06-17 09:44:54 | 2008-06-26 12:56:06 | -1
10 | 2008-06-17 09:44:54 | 2008-07-10 02:12:36 | -1
10 | 2008-06-17 09:44:54 | 2008-07-16 11:59:24 | -1
10 | 2008-06-17 09:44:54 | 2008-07-22 02:23:17 | -1
12 | 2008-07-25 01:45:49 | 2008-08-04 03:06:36 | -1
(10 rows)
```
En este ejemplo, se muestra que TIMESTAMP\$1CMP devuelve 0 en caso de marcas temporales idénticas:
```
select listid, timestamp_cmp(listtime, listtime)
from listing
order by 1 , 2
limit 10;
listid | timestamp_cmp
--------+---------------
1 | 0
2 | 0
3 | 0
4 | 0
5 | 0
6 | 0
7 | 0
8 | 0
9 | 0
10 | 0
(10 rows)
```
# Función TIMESTAMP\$1CMP\$1DATE
TIMESTAMP\$1CMP\$1DATE compara el valor de una marca temporal y una fecha. Si los valores de marca temporal y fecha son idénticos, la función devuelve `0`. Si la primera marca temporal es mayor, la función devuelve `1`. Si la fecha es mayor, la función devuelve `-1`.
## Sintaxis
```
TIMESTAMP_CMP_DATE(timestamp, date)
```
## Argumentos
*timestamp*
Una columna de tipo de datos `TIMESTAMP` o una expresión que toma implícitamente el valor de un tipo `TIMESTAMP`.
*date*
Una columna de tipo de datos `DATE` o una expresión que toma implícitamente el valor de un tipo `DATE`.
## Tipo de retorno
INTEGER
## Ejemplos
En el siguiente ejemplo, se compara LISTTIME con la fecha `2008-06-18`. Las listas hechas después de esa fecha devuelven `1`; las hechas antes de ella, `-1`. Los valores LISTTIME son marcas temporales.
```
select listid, listtime,
timestamp_cmp_date(listtime, '2008-06-18')
from listing
order by 1, 2, 3
limit 10;
listid | listtime | timestamp_cmp_date
--------+---------------------+--------------------
1 | 2008-01-24 06:43:29 | -1
2 | 2008-03-05 12:25:29 | -1
3 | 2008-11-01 07:35:33 | 1
4 | 2008-05-24 01:18:37 | -1
5 | 2008-05-17 02:29:11 | -1
6 | 2008-08-15 02:08:13 | 1
7 | 2008-11-15 09:38:15 | 1
8 | 2008-11-09 05:07:30 | 1
9 | 2008-09-09 08:03:36 | 1
10 | 2008-06-17 09:44:54 | -1
(10 rows)
```
# Función TIMESTAMP\$1CMP\$1TIMESTAMPTZ
TIMESTAMP\$1CMP\$1TIMESTAMPTZ compara el valor de una expresión de marca temporal con una expresión de marca temporal con zona horaria. Si los valores de marca temporal y marca temporal con zona horaria son idénticos, la función devuelve `0`. Si la primera marca temporal es mayor, la función devuelve `1`. Si la marca temporal con zona horaria es mayor, la función devuelve `–1`.
## Sintaxis
```
TIMESTAMP_CMP_TIMESTAMPTZ(timestamp, timestamptz)
```
## Argumentos
*timestamp*
Una columna de tipo de datos `TIMESTAMP` o una expresión que toma implícitamente el valor de un tipo `TIMESTAMP`.
*timestamptz*
Una columna de tipo de datos `TIMESTAMPTZ` o una expresión que toma implícitamente el valor de un tipo `TIMESTAMPTZ`.
## Tipo de retorno
INTEGER
## Ejemplos
En el siguiente ejemplo se comparan las marcas temporales con las marcas temporales con zona horaria y se muestran los resultados de la comparación.
```
SELECT TIMESTAMP_CMP_TIMESTAMPTZ('2008-01-24 06:43:29', '2008-01-24 06:43:29+00'), TIMESTAMP_CMP_TIMESTAMPTZ('2008-01-24 06:43:29', '2008-02-18 02:36:48+00'), TIMESTAMP_CMP_TIMESTAMPTZ('2008-02-18 02:36:48', '2008-01-24 06:43:29+00');
timestamp_cmp_timestamptz | timestamp_cmp_timestamptz | timestamp_cmp_timestamptz
---------------------------+---------------------------+--------------------------
0 | -1 | 1
```
# Función TIMESTAMPTZ\$1CMP
TIMESTAMPTZ\$1CMP compara el valor de dos valores de marca temporal con zona horaria y devuelve un número entero. Si las marcas temporales son idénticas, la función devuelve `0`. Si la primera marca temporal es mayor cronológicamente, la función devuelve `1`. Si la segunda marca temporal es mayor, la función devuelve `–1`.
## Sintaxis
```
TIMESTAMPTZ_CMP(timestamptz1, timestamptz2)
```
## Argumentos
*timestamptz1*
Una columna de tipo de datos `TIMESTAMPTZ` o una expresión que toma implícitamente el valor de un tipo `TIMESTAMPTZ`.
*timestamptz2*
Una columna de tipo de datos `TIMESTAMPTZ` o una expresión que toma implícitamente el valor de un tipo `TIMESTAMPTZ`.
## Tipo de retorno
INTEGER
## Ejemplos
En el siguiente ejemplo se comparan las marcas temporales con zonas horarias y se muestran los resultados de la comparación.
```
SELECT TIMESTAMPTZ_CMP('2008-01-24 06:43:29+00', '2008-01-24 06:43:29+00'), TIMESTAMPTZ_CMP('2008-01-24 06:43:29+00', '2008-02-18 02:36:48+00'), TIMESTAMPTZ_CMP('2008-02-18 02:36:48+00', '2008-01-24 06:43:29+00');
timestamptz_cmp | timestamptz_cmp | timestamptz_cmp
-----------------+-----------------+----------------
0 | -1 | 1
```
# Función TIMESTAMPTZ\$1CMP\$1DATE
TIMESTAMPTZ\$1CMP\$1DATE compara el valor de una marca temporal y una fecha. Si los valores de marca temporal y fecha son idénticos, la función devuelve `0`. Si la primera marca temporal es mayor, la función devuelve `1`. Si la fecha es mayor, la función devuelve `–1`.
## Sintaxis
```
TIMESTAMPTZ_CMP_DATE(timestamptz, date)
```
## Argumentos
*timestamptz*
Una columna de tipo de datos `TIMESTAMPTZ` o una expresión que toma implícitamente el valor de un tipo `TIMESTAMPTZ`.
*date*
Una columna de tipo de datos `DATE` o una expresión que toma implícitamente el valor de un tipo `DATE`.
## Tipo de retorno
INTEGER
## Ejemplos
En el siguiente ejemplo se compara LISTTIME como marca temporal con zona horaria con la fecha `2008-06-18`. Las listas hechas después de esa fecha devuelven `1`; las hechas antes de ella, `-1`.
```
select listid, CAST(listtime as timestamptz) as tstz,
timestamp_cmp_date(tstz, '2008-06-18')
from listing
order by 1, 2, 3
limit 10;
listid | tstz | timestamptz_cmp_date
--------+------------------------+----------------------
1 | 2008-01-24 06:43:29+00 | -1
2 | 2008-03-05 12:25:29+00 | -1
3 | 2008-11-01 07:35:33+00 | 1
4 | 2008-05-24 01:18:37+00 | -1
5 | 2008-05-17 02:29:11+00 | -1
6 | 2008-08-15 02:08:13+00 | 1
7 | 2008-11-15 09:38:15+00 | 1
8 | 2008-11-09 05:07:30+00 | 1
9 | 2008-09-09 08:03:36+00 | 1
10 | 2008-06-17 09:44:54+00 | -1
(10 rows)
```
# Función TIMESTAMPTZ\$1CMP\$1TIMESTAMP
TIMESTAMPTZ\$1CMP\$1TIMESTAMP compara el valor de una expresión de marca temporal con zona horaria con una expresión de marca temporal. Si los valores de marca temporal y marca temporal con zona horaria son idénticos, la función devuelve `0`. Si la marca temporal con zona horaria es mayor cronológicamente, la función devuelve `1`. Si la marca temporal es mayor, la función devuelve `–1`.
## Sintaxis
```
TIMESTAMPTZ_CMP_TIMESTAMP(timestamptz, timestamp)
```
## Argumentos
*timestamptz*
Una columna de tipo de datos `TIMESTAMPTZ` o una expresión que toma implícitamente el valor de un tipo `TIMESTAMPTZ`.
*timestamp*
Una columna de tipo de datos `TIMESTAMP` o una expresión que toma implícitamente el valor de un tipo `TIMESTAMP`.
## Tipo de retorno
INTEGER
## Ejemplos
En el siguiente ejemplo se comparan las marcas temporales con zonas horarias con las marcas temporales y se muestran los resultados de la comparación.
```
SELECT TIMESTAMPTZ_CMP_TIMESTAMP('2008-01-24 06:43:29+00', '2008-01-24 06:43:29'), TIMESTAMPTZ_CMP_TIMESTAMP('2008-01-24 06:43:29+00', '2008-02-18 02:36:48'), TIMESTAMPTZ_CMP_TIMESTAMP('2008-02-18 02:36:48+00', '2008-01-24 06:43:29');
timestamptz_cmp_timestamp | timestamptz_cmp_timestamp | timestamptz_cmp_timestamp
---------------------------+---------------------------+---------------------------
0 | -1 | 1
```
# Función TIMEZONE
TIMEZONE devuelve una marca temporal para el valor de marca temporal y zona horaria especificados.
Para obtener información y ejemplos acerca de cómo establecer la zona horaria, consulte [timezone](r_timezone_config.md).
Para obtener información y ejemplos acerca de cómo convertir la zona horaria, consulte [CONVERT\$1TIMEZONE](CONVERT_TIMEZONE.md).
## Sintaxis
```
TIMEZONE('timezone', { timestamp | timestamptz })
```
## Argumentos
*timezone*
La zona horaria para el valor de retorno. La zona horaria puede especificarse como un nombre (por ejemplo, **'Africa/Kampala'** o **'Singapore'**) o como una abreviatura (por ejemplo, **'UTC'** o **'PDT'**). Para ver una lista de los nombres de zonas horarias compatibles, ejecute el siguiente comando.
```
select pg_timezone_names();
```
Para ver una lista de las abreviaturas de zonas horarias compatibles, ejecute el siguiente comando.
```
select pg_timezone_abbrevs();
```
Tenga en cuenta que Amazon Redshift utiliza la [Base de datos de zonas horarias de IANA](https://www.iana.org/time-zones) como fuente autorizada de especificación de zonas horarias. Para obtener más información y ejemplos, consulte [Notas de uso de la zona horaria](CONVERT_TIMEZONE.md#CONVERT_TIMEZONE-usage-notes).
*timestamp* \$1 *timestamptz*
Una expresión que da como resultado un valor de tipo TIMESTAMP o TIMESTAMPTZ o un valor que pueda convertirse implícitamente a una marca temporal o a una marca temporal con zona horaria.
## Tipo de retorno
TIMESTAMPTZ, cuando se usa con una expresión TIMESTAMP.
TIMESTAMP, cuando se usa con una expresión TIMESTAMPTZ.
## Ejemplos
Lo siguiente devuelve una marca temporal para la zona horaria UTC mediante la marca temporal `2008-06-17 09:44:54` de la zona horaria PST.
```
SELECT TIMEZONE('PST', '2008-06-17 09:44:54');
timezone
-----------------------
2008-06-17 17:44:54+00
```
Lo siguiente devuelve una marca temporal para la zona horaria PST mediante la marca temporal con zona horaria UTC `2008-06-17 09:44:54+00`.
```
SELECT TIMEZONE('PST', timestamptz('2008-06-17 09:44:54+00'));
timezone
-----------------------
2008-06-17 01:44:54
```
# Función TO\$1TIMESTAMP
TO\$1TIMESTAMP convierte una cadena TIMESTAMP en TIMESTAMPTZ. Para obtener una lista de las funciones de fecha y hora adicionales de Amazon Redshift, consulte [Funciones de fecha y hora](Date_functions_header.md).
## Sintaxis
```
to_timestamp(timestamp, format)
```
```
to_timestamp (timestamp, format, is_strict)
```
## Argumentos
*timestamp*
Una cadena que representa un valor de marca temporal en el formato especificado por *format*. Si este argumento se deja vacío, el valor predeterminado de la marca de tiempo es `0001-01-01 00:00:00`.
*format*
Un literal de cadena que define el formato del valor de *timestamp*. Los formatos que incluyen una zona horaria (**TZ**, **tz** u **OF**) no son compatibles como entrada. Para obtener los formatos de marca temporal válidos, consulte [Cadenas de formatos de fecha y hora](r_FORMAT_strings.md).
*is\$1strict*
Un valor booleano opcional que especifica si se devuelve un error si un valor de marca temporal de entrada se encuentra fuera de rango. Cuando *is\$1strict* se configura como TRUE, se devuelve un error si hay un valor fuera de rango. Si *is\$1strict* se configura como FALSE, que es el valor predeterminado, se aceptan valores de desbordamiento.
## Tipo de retorno
TIMESTAMPTZ
## Ejemplos
En el siguiente ejemplo, se muestra cómo se usa la función TO\$1TIMESTAMP para convertir una cadena TIMESTAMP en TIMESTAMPTZ.
```
select sysdate, to_timestamp(sysdate, 'YYYY-MM-DD HH24:MI:SS') as second;
timestamp | second
-------------------------- ----------------------
2021-04-05 19:27:53.281812 | 2021-04-05 19:27:53+00
```
Es posible pasar a TO\$1TIMESTAMP parte de una fecha. Las partes de fecha restantes se establecen a los valores predeterminados. La hora se incluye en el resultado:
```
SELECT TO_TIMESTAMP('2017','YYYY');
to_timestamp
--------------------------
2017-01-01 00:00:00+00
```
La siguiente instrucción SQL convierte la cadena “2011-12-18 24:38:15” en un valor TIMESTAMPTZ. El resultado es un valor TIMESTAMPTZ que se establece al día siguiente porque el número de horas es superior a 24 horas:
```
SELECT TO_TIMESTAMP('2011-12-18 24:38:15', 'YYYY-MM-DD HH24:MI:SS');
to_timestamp
----------------------
2011-12-19 00:38:15+00
```
La siguiente instrucción SQL convierte la cadena “2011-12-18 24:38:15” en un valor TIMESTAMPTZ. El resultado es un error porque el valor de tiempo en la marca de tiempo es superior a 24 horas:
```
SELECT TO_TIMESTAMP('2011-12-18 24:38:15', 'YYYY-MM-DD HH24:MI:SS', TRUE);
ERROR: date/time field time value out of range: 24:38:15.0
```
# Función TRUNC
Trunca un valor `TIMESTAMP` y devuelve un valor `DATE`.
Esta función también puede truncar un número. Para obtener más información, consulte [Función TRUNC](r_TRUNC.md).
## Sintaxis
```
TRUNC(timestamp)
```
## Argumentos
*timestamp*
Una columna de tipo de datos `TIMESTAMP` o una expresión que toma implícitamente el valor de un tipo `TIMESTAMP`.
Para devolver un valor de marca temporal con `00:00:00` como la hora, convierta el resultado de la función en `TIMESTAMP`.
## Tipo de retorno
DATE
## Ejemplos
En el siguiente ejemplo, se devuelve la parte de la fecha del resultado de la función SYSDATE (que devuelve una marca temporal).
```
SELECT SYSDATE;
+----------------------------+
| timestamp |
+----------------------------+
| 2011-07-21 10:32:38.248109 |
+----------------------------+
SELECT TRUNC(SYSDATE);
+------------+
| trunc |
+------------+
| 2011-07-21 |
+------------+
```
En el siguiente ejemplo, se aplica la función TRUNC a una columna `TIMESTAMP`. El tipo de retorno es una fecha.
```
SELECT TRUNC(starttime) FROM event
ORDER BY eventid LIMIT 1;
+------------+
| trunc |
+------------+
| 2008-01-25 |
+------------+
```
En el siguiente ejemplo se devuelve un valor de marca temporal con `00:00:00` como la hora mediante la conversión del resultado de la función TRUNC en `TIMESTAMP`.
```
SELECT CAST((TRUNC(SYSDATE)) AS TIMESTAMP);
+---------------------+
| trunc |
+---------------------+
| 2011-07-21 00:00:00 |
+---------------------+
```
# Partes de fecha para funciones de fecha o marca temporal
En la siguiente tabla, se identifican los nombres y las abreviaturas de partes de fecha y de hora que se aceptan como argumentos para las siguientes funciones:
+ DATEADD
+ DATEDIFF
+ DATE\$1PART
+ EXTRACT
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_Dateparts_for_datetime_functions.html)
## Variaciones en resultados con segundos, milisegundos y microsegundos
Cuando diferentes funciones de fechas especifican segundos, milisegundos o microsegundos como partes de fecha, se generan diferencias mínimas en los resultados de las consultas:
+ La función EXTRACT devuelve números enteros solo para la parte de fecha especificada e ignora partes de fecha de niveles mayores y menores. Si la parte de fecha especificada es segundos, los milisegundos y los microsegundos no se incluyen en el resultado. Si la parte de fecha especificada es milisegundos, los segundos y los microsegundos no se incluyen. Si la parte de fecha especificada es microsegundos, los segundos y los milisegundos no se incluyen.
+ La función DATE\$1PART devuelve la parte de segundos de la marca temporal completa, sin importar la parte de fecha especificada, por lo que devuelve un valor decimal o un número entero según se requiera.
Por ejemplo, compare los resultados de las siguientes consultas:
```
create table seconds(micro timestamp);
insert into seconds values('2009-09-21 11:10:03.189717');
select extract(sec from micro) from seconds;
date_part
-----------
3
select date_part(sec, micro) from seconds;
pgdate_part
-------------
3.189717
```
## Notas acerca de CENTURY, EPOCH, DECADE y MIL
CENTURY o CENTURIES
Amazon Redshift interpreta que CENTURY comienza en el año *\$1\$1\$11* y termina en el año `###0`:
```
select extract (century from timestamp '2000-12-16 12:21:13');
date_part
-----------
20
select extract (century from timestamp '2001-12-16 12:21:13');
date_part
-----------
21
```
EPOCH
La implementación de EPOCH en Amazon Redshift está asociada a 1970-01-01 00:00:00.000000, sin importar la zona horaria donde resida el clúster. Podría ser necesario desplazar los resultados de la diferencia en horas según la zona horaria donde se encuentre el clúster.
En el siguiente ejemplo, se muestra lo siguiente:
1. Crea una tabla denominada EVENT\$1EXAMPLE basada en la tabla EVENT. Este comando CREATE AS usa la función DATE\$1PART para crear una columna de fecha (denominada PGDATE\$1PART de manera predeterminada) para almacenar el valor de fecha de inicio de cada evento.
1. Selecciona la columna y el tipo de dato de EVENT\$1EXAMPLE de PG\$1TABLE\$1DEF.
1. Selecciona EVENTNAME, STARTTIME y PGDATE\$1PART de la tabla EVENT\$1EXAMPLE para visualizar los diferentes formatos de fecha y hora.
1. Selecciona EVENTNAME y STARTTIME de EVENT EXAMPLE como están. Convierte los valores de fecha de inicio en PGDATE\$1PART mediante el uso de un intervalo de 1 segundo a una marca temporal sin zona horaria y devuelve los resultados en una columna denominada CONVERTED\$1TIMESTAMP.
```
create table event_example
as select eventname, starttime, date_part(epoch, starttime) from event;
select "column", type from pg_table_def where tablename='event_example';
column | type
---------------+-----------------------------
eventname | character varying(200)
starttime | timestamp without time zone
pgdate_part | double precision
(3 rows)
```
```
select eventname, starttime, pgdate_part from event_example;
eventname | starttime | pgdate_part
----------------------+---------------------+-------------
Mamma Mia! | 2008-01-01 20:00:00 | 1199217600
Spring Awakening | 2008-01-01 15:00:00 | 1199199600
Nas | 2008-01-01 14:30:00 | 1199197800
Hannah Montana | 2008-01-01 19:30:00 | 1199215800
K.D. Lang | 2008-01-01 15:00:00 | 1199199600
Spamalot | 2008-01-02 20:00:00 | 1199304000
Macbeth | 2008-01-02 15:00:00 | 1199286000
The Cherry Orchard | 2008-01-02 14:30:00 | 1199284200
Macbeth | 2008-01-02 19:30:00 | 1199302200
Demi Lovato | 2008-01-02 19:30:00 | 1199302200
select eventname,
starttime,
timestamp with time zone 'epoch' + pgdate_part * interval '1 second' AS converted_timestamp
from event_example;
eventname | starttime | converted_timestamp
----------------------+---------------------+---------------------
Mamma Mia! | 2008-01-01 20:00:00 | 2008-01-01 20:00:00
Spring Awakening | 2008-01-01 15:00:00 | 2008-01-01 15:00:00
Nas | 2008-01-01 14:30:00 | 2008-01-01 14:30:00
Hannah Montana | 2008-01-01 19:30:00 | 2008-01-01 19:30:00
K.D. Lang | 2008-01-01 15:00:00 | 2008-01-01 15:00:00
Spamalot | 2008-01-02 20:00:00 | 2008-01-02 20:00:00
Macbeth | 2008-01-02 15:00:00 | 2008-01-02 15:00:00
The Cherry Orchard | 2008-01-02 14:30:00 | 2008-01-02 14:30:00
Macbeth | 2008-01-02 19:30:00 | 2008-01-02 19:30:00
Demi Lovato | 2008-01-02 19:30:00 | 2008-01-02 19:30:00
...
```
DECADE o DECADES
Amazon Redshift interpreta DECADE o DECADES DATEPART en función del calendario común. Por ejemplo, debido a que el calendario común comienza a partir del año 1, la primera década (década 1) es de 0001-01-01 a 0009-12-31 y la segunda década (década 2) es de 0010-01-01 a 0019-12-31. Por ejemplo, la década 201 se extiende de 01/01/2001 a 31/12/2009:
```
select extract(decade from timestamp '1999-02-16 20:38:40');
date_part
-----------
200
select extract(decade from timestamp '2000-02-16 20:38:40');
date_part
-----------
201
select extract(decade from timestamp '2010-02-16 20:38:40');
date_part
-----------
202
```
MIL o MILS
Amazon Redshift interpreta que MIL comienza el primer día del año *\$1001* y termina el último día del año `#000`:
```
select extract (mil from timestamp '2000-12-16 12:21:13');
date_part
-----------
2
select extract (mil from timestamp '2001-12-16 12:21:13');
date_part
-----------
3
```