Amazon Redshift non supporterà più la creazione di nuovi Python UDFs a partire dalla Patch 198. Python esistente UDFs continuerà a funzionare fino al 30 giugno 2026. Per ulteriori informazioni, consulta il [post del blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Funzioni di data e ora
In questa sezione, sono riportate le informazioni sulle funzioni scalari di data e ora supportate da Amazon Redshift.
**Topics**
+ [Riepilogo delle funzioni di data e ora](#date-functions-summary)
+ [Funzioni di data e ora nelle transazioni](#date-functions-transactions)
+ [Funzioni solo sul nodo principale obsolete](#date-functions-deprecated)
+ [Operatore \$1 (concatenamento)](r_DATE-CONCATENATE_function.md)
+ [Funzione ADD\$1MONTHS](r_ADD_MONTHS.md)
+ [Funzione AT TIME ZONE](r_AT_TIME_ZONE.md)
+ [Funzione CONVERT\$1TIMEZONE](CONVERT_TIMEZONE.md)
+ [Funzione CURRENT\$1DATE](r_CURRENT_DATE_function.md)
+ [Funzione DATE\$1CMP](r_DATE_CMP.md)
+ [Funzione DATE\$1CMP\$1TIMESTAMP](r_DATE_CMP_TIMESTAMP.md)
+ [Funzione DATE\$1CMP\$1TIMESTAMPTZ](r_DATE_CMP_TIMESTAMPTZ.md)
+ [Funzione DATEADD](r_DATEADD_function.md)
+ [Funzione DATEDIFF](r_DATEDIFF_function.md)
+ [Funzione DATE\$1PART](r_DATE_PART_function.md)
+ [Funzione DATE\$1PART\$1YEAR](r_DATE_PART_YEAR.md)
+ [Funzione DATE\$1TRUNC](r_DATE_TRUNC.md)
+ [Funzione EXTRACT](r_EXTRACT_function.md)
+ [Funzione GETDATE](r_GETDATE.md)
+ [Funzione INTERVAL\$1CMP](r_INTERVAL_CMP.md)
+ [Funzione LAST\$1DAY](r_LAST_DAY.md)
+ [Funzione MONTHS\$1BETWEEN](r_MONTHS_BETWEEN_function.md)
+ [Funzione NEXT\$1DAY](r_NEXT_DAY.md)
+ [Funzione SYSDATE](r_SYSDATE.md)
+ [Funzione TIMEOFDAY](r_TIMEOFDAY_function.md)
+ [Funzione TIMESTAMP\$1CMP](r_TIMESTAMP_CMP.md)
+ [Funzione TIMESTAMP\$1CMP\$1DATE](r_TIMESTAMP_CMP_DATE.md)
+ [Funzione TIMESTAMP\$1CMP\$1TIMESTAMPTZ](r_TIMESTAMP_CMP_TIMESTAMPTZ.md)
+ [Funzione TIMESTAMPTZ\$1CMP](r_TIMESTAMPTZ_CMP.md)
+ [Funzione TIMESTAMPTZ\$1CMP\$1DATE](r_TIMESTAMPTZ_CMP_DATE.md)
+ [Funzione TIMESTAMPTZ\$1CMP\$1TIMESTAMP](r_TIMESTAMPTZ_CMP_TIMESTAMP.md)
+ [Funzione TIMEZONE](r_TIMEZONE.md)
+ [Funzione TO\$1TIMESTAMP](r_TO_TIMESTAMP.md)
+ [Funzione TRUNC](r_TRUNC_date.md)
+ [Parti di data per funzioni di data e timestamp](r_Dateparts_for_datetime_functions.md)
## Riepilogo delle funzioni di data e ora
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/Date_functions_header.html)
**Nota**
I secondi intercalari non vengono presi in considerazione nei calcoli del tempo trascorso.
## Funzioni di data e ora nelle transazioni
Quando esegui le funzioni seguenti in un blocco di transazione (BEGIN … END), la funzione restituisce la data o l'ora di inizio della transazione corrente e non dell'istruzione corrente.
+ SYSDATE
+ TIMESTAMP
+ CURRENT\$1DATE
Le funzioni seguenti restituiscono sempre la data e l'ora di inizio dell'istruzione corrente, anche quando sono in un blocco di transazione.
+ GETDATE
+ TIMEOFDAY
## Funzioni solo sul nodo principale obsolete
Le funzioni di data seguenti sono obsolete in quanto vengono eseguite solo sul nodo principale. Per ulteriori informazioni, consulta [Nodo principale: solo funzioni](c_SQL_functions_leader_node_only.md).
+ AGE. Usare invece [Funzione DATEDIFF](r_DATEDIFF_function.md).
+ CURRENT\$1TIME. Utilizza invece [Funzione GETDATE](r_GETDATE.md) o [SYSDATE](r_SYSDATE.md).
+ CURRENT\$1TIMESTAMP. Utilizza invece [Funzione GETDATE](r_GETDATE.md) o [SYSDATE](r_SYSDATE.md).
+ LOCALTIME. Utilizza invece [Funzione GETDATE](r_GETDATE.md) o [SYSDATE](r_SYSDATE.md).
+ LOCALTIMESTAMP. Utilizza invece [Funzione GETDATE](r_GETDATE.md) o [SYSDATE](r_SYSDATE.md).
+ ISFINITE
+ NOW. Utilizza invece [Funzione GETDATE](r_GETDATE.md) o [SYSDATE](r_SYSDATE.md). Se utilizzi la funzione NOW all’interno di una vista materializzata, viene impostato il timestamp della creazione della vista materializzata, anziché il timestamp corrente.
# Operatore \$1 (concatenamento)
Concatena una DATA a un TIME o TIMETZ su entrambi i lati del simbolo \$1 e restituisce un TIMESTAMPT o TIMESTAMPTZ.
## Sintassi
```
date + {time | timetz}
```
L'ordine degli argomenti può essere invertito. Ad esempio, *tempo* \$1 *data*.
## Arguments (Argomenti)
*data*
Una colonna di tipo di dati `DATE` o un'espressione che restituisce un tipo `DATE`.
*time*
Una colonna di tipo di dati `TIME` o un'espressione che restituisce un tipo `TIME`.
*timetz*
Una colonna di tipo di dati `TIMETZ` o un'espressione che restituisce un tipo `TIMETZ`.
## Tipo restituito
TIMESTAMP se l'input è *date* \$1 *time*.
TIMESTAMPTZ se l'input è *date* \$1 *timetz*.
## Esempi
### Configurazione di esempio
Per impostare le tabelle TIME\$1TEST e TIMETZ\$1TEST utilizzate negli esempi, utilizzare il comando seguente.
```
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');
```
### Esempi con una colonna TIME
La tabella di esempio seguente TIME\$1TEST contiene una colonna TIME\$1VAL (tipo TIME) con tre valori inseriti.
```
select time_val from time_test;
time_val
---------------------
20:00:00
00:00:00.5550
00:58:00
```
Nell'esempio seguente vengono concatenati una data letterale e una colonna 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
```
Nell'esempio seguente vengono concatenati un valore letterale di data e un valore letterale di ora.
```
select date '2000-01-01' + time '20:00:00' as ts;
ts
---------------------
2000-01-01 20:00:00
```
Nell'esempio seguente vengono concatenati un valore letterale di data e un valore letterale di ora.
```
select time '20:00:00' + date '2000-01-01' as ts;
ts
---------------------
2000-01-01 20:00:00
```
### Esempi con una colonna TIMETZ
La tabella di esempio seguente TIMETZ\$1TEST contiene una colonna TIMETZ\$1VAL (tipo TIMETZ) con tre valori inseriti.
```
select timetz_val from timetz_test;
timetz_val
------------------
04:00:00+00
00:00:00.5550+00
05:58:00+00
```
Nell'esempio seguente vengono concatenati un valore letterale di data e una colonna 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
```
Nell'esempio seguente vengono concatenati un valore letterale di data e una colonna TIMETZ\$1VAL.
```
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
```
Nell'esempio seguente vengono concatenati un valore letterale di DATE e un valore letterale TIMETZ. L'esempio restituisce un TIMESTAMPTZ che si trova nel fuso orario UTC per impostazione predefinita. L'UTC è 8 ore avanti rispetto al PST, quindi il risultato è in anticipo di 8 ore rispetto all'ora di immissione.
```
select date '2000-01-01' + timetz '20:00:00 PST' as ts;
ts
------------------------
2000-01-02 04:00:00+00
```
# Funzione ADD\$1MONTHS
ADD\$1MONTHS aggiunge il numero di mesi specificato a un valore o espressione di data o timestamp. La funzione [DATEADD](r_DATEADD_function.md) fornisce una funzionalità simile.
## Sintassi
```
ADD_MONTHS( {date | timestamp}, integer)
```
## Arguments (Argomenti)
*date* \$1 *timestamp*
Una colonna di tipo di dati `DATE` o `TIMESTAMP` o un'espressione che implicitamente valuta un tipo `DATE` o `TIMESTAMP`. Se la data è l'ultimo giorno del mese o se il mese risultante è più corto, la funzione restituisce l'ultimo giorno del mese nel risultato. Per le altre date, il risultato contiene lo stesso numero di giorni dell'espressione di data.
*integer*
Un valore di tipo `INTEGER`. Utilizza un numero negativo per sottrarre mesi dalle date.
## Tipo restituito
TIMESTAMP
## Esempi
La query seguente utilizza la funzione ADD\$1MONTHS in una funzione TRUNC. La funzione TRUNC rimuove l'ora del giorno dal risultato di ADD\$1MONTHS. La funzione ADD\$1MONTHS aggiunge 12 mesi a ogni valore della colonna CALDATE. I valori nella colonna CALDATE sono date.
```
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)
```
L'esempio seguente utilizza la funzione ADD\$1MONTHS per aggiungere 1 mese a un *timestamp*.
```
select add_months('2008-01-01 05:07:30', 1);
add_months
---------------------
2008-02-01 05:07:30
```
Gli esempi seguenti illustrano il comportamento quando la funzione ADD\$1MONTHS opera su date con mesi che hanno un numero di giorni differente. Questo esempio mostra come la funzione gestisce l'aggiunta di 1 mese al 31 marzo e l'aggiunta di 1 mese al 30 aprile. Aprile ha 30 giorni, quindi aggiungendo 1 mese al 31 marzo si ottiene il 30 aprile. Maggio ha 31 giorni, quindi aggiungendo 1 mese al 30 aprile si ottiene il 31 maggio.
```
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
```
# Funzione AT TIME ZONE
AT TIME ZONE specifica quale fuso orario utilizzare con un'espressione TIMESTAMP o TIMESTAMPTZ.
## Sintassi
```
AT TIME ZONE 'timezone'
```
## Arguments (Argomenti)
*timezone*
`TIMEZONE` per il valore restituito. Il fuso orario può essere specificato come nome di fuso orario (ad esempio, **'Africa/Kampala'** o **'Singapore'**) oppure come abbreviazione di fuso orario (ad esempio, **'UTC'** o **'PDT'**).
Per visualizzare un elenco dei nomi di fuso orario supportati, utilizzare il comando seguente.
```
select pg_timezone_names();
```
Per visualizzare un elenco delle abbreviazioni di fuso orario supportate, utilizzare il comando seguente.
```
select pg_timezone_abbrevs();
```
Per maggiori informazioni ed esempi, consulta [Note sull'utilizzo dei fusi orari](CONVERT_TIMEZONE.md#CONVERT_TIMEZONE-usage-notes).
## Tipo restituito
TIMESTAMPTZ quando utilizzato con un'espressione TIMESTAMP. TIMESTAMP quando utilizzato con un'espressione TIMESTAMPTZ.
## Esempi
L'esempio seguente converte un valore di timestamp senza fuso orario e lo interpreta come orario MST (UTC\$17 in POSIX). L'esempio restituisce un valore di tipo di dati TIMESTAMPTZ per il fuso orario UTC. Se configuri il fuso orario predefinito su un valore diverso da UTC, potresti vedere un risultato diverso.
```
SELECT TIMESTAMP '2001-02-16 20:38:40' AT TIME ZONE 'MST';
timezone
------------------------
2001-02-17 03:38:40+00
```
Nell'esempio seguente, un timestamp di input con un valore di fuso orario EST (UTC\$15 in POSIX) viene convertito in MST (UTC\$17 in POSIX). L'esempio restituisce un valore di tipo di dati TIMESTAMP.
```
SELECT TIMESTAMPTZ '2001-02-16 20:38:40-05' AT TIME ZONE 'MST';
timezone
------------------------
2001-02-16 18:38:40
```
# Funzione CONVERT\$1TIMEZONE
CONVERT\$1TIMEZONE converte un timestamp da un fuso orario a un altro. La funzione si regola automaticamente in base all’ora legale.
## Sintassi
```
CONVERT_TIMEZONE( ['source_timezone',] 'target_timezone', 'timestamp')
```
## Arguments (Argomenti)
*source\$1timezone*
(Facoltativo) Il fuso orario del timestamp corrente. Il valore predefinito è UTC. Per ulteriori informazioni, consultare [Note sull'utilizzo dei fusi orari](#CONVERT_TIMEZONE-usage-notes).
*target\$1timezone*
Il fuso orario del nuovo timestamp. Per ulteriori informazioni, consultare [Note sull'utilizzo dei fusi orari](#CONVERT_TIMEZONE-usage-notes).
*timestamp*
Una colonna timestamp o un'espressione che viene implicitamente convertita in un timestamp.
## Tipo restituito
TIMESTAMP
## Note sull'utilizzo dei fusi orari
È possibile specificare *source\$1timezone* o *target\$1timezone* come nome di fuso orario (ad esempio, “Africa/Kampala” o “Singapore”) oppure come abbreviazione di fuso orario (ad esempio, “UTC” o “PDT”). Non devi convertire i nomi dei fusi orari in nomi o le abbreviazioni in abbreviazioni. Ad esempio, puoi scegliere un timestamp dal nome del fuso orario di origine “Singapore” e convertirlo in un timestamp con l’abbreviazione del fuso orario “PDT”.
**Nota**
I risultati dell’utilizzo del nome di un fuso orario o dell’abbreviazione di un fuso orario possono variare in base all’ora stagionale locale, ad esempio l’ora legale.
### Utilizzo di un nome di fuso orario
Per visualizzare un elenco completo e aggiornato dei nomi dei fusi orari, esegui il comando seguente.
```
select pg_timezone_names();
```
Ogni riga contiene una stringa separata da virgole con il nome del fuso orario, l’abbreviazione, l’offset UTC e l’indicatore se il fuso orario osserva l’ora legale (`t` o `f`). Ad esempio, il frammento seguente mostra come risultati due righe. La prima riga contiene il fuso orario di `Antarctica/South Pole`, l’abbreviazione `NZDT`, con l’offset `13:00:00` rispetto a UTC e `f` per indicare che non osserva l’ora legale. La seconda riga contiene il fuso orario di `Europe/Paris`, l’abbreviazione `CET`, con l’offset `01:00:00` rispetto a UTC e `f` per indicare che non osserva l’ora legale.
```
pg_timezone_names
------------------
(Antarctica/South_Pole,NZDT,13:00:00,t)
(Europe/Paris,CET,01:00:00,f)
```
Esegui l'istruzione SQL per ottenere l'elenco completo e trovare il nome di un fuso orario. Vengono restituite circa 600 righe. Sebbene alcuni nomi di fusi orari restituiti siano acronimi o sigle maiuscole composte dalle lettere inziali (ad esempio, GB, PRC, ROK), la funzione CONVERT\$1TIMEZONE li tratta come nomi, non abbreviazioni, di fusi orari.
Se specifichi un fuso orario utilizzando un nome di fuso orario, CONVERT\$1TIMEZONE esegue automaticamente il passaggio all’ora legale (DST) o a qualsiasi altro protocollo stagionale locale, come l’ora solare o l’ora legale, in vigore per quel fuso orario durante la data e l’ora specificate da “*timestamp*”. Ad esempio, "Europe/London" rappresenta UTC in inverno e aggiunge un'ora in estate. Tieni presente che Amazon Redshift utilizza il [database dei fusi orari di IANA](https://www.iana.org/time-zones) come fonte autorevole per la specifica del fuso orario.
### Utilizzo di un'abbreviazione di fuso orario
Per visualizzare un elenco completo e aggiornato delle abbreviazioni dei fusi orari, esegui il comando seguente.
```
select pg_timezone_abbrevs();
```
I risultati contengono una stringa separata da virgole con l’abbreviazione del fuso orario, l’offset UTC e l’indicatore che mostra se il fuso orario osserva l’ora legale (`t` o `f`). Ad esempio, il frammento seguente mostra come risultati due righe. La prima riga contiene l’abbreviazione dell’ora legale del Pacifico `PDT`, con l’offset `-07:00:00` rispetto a UTC e `t` per indicare che osserva l’ora legale. La seconda riga contiene l’abbreviazione di Pacific Standard Time `PST`, con l’offset `-08:00:00` rispetto a UTC e `f` per indicare che non osserva l’ora legale.
```
pg_timezone_abbrevs
--------------------
(PDT,-07:00:00,t)
(PST,-08:00:00,f)
```
Esegui l’istruzione SQL per ottenere l’elenco intero e trovare un’abbreviazione basata sull’offset e sull’indicatore relativo all’ora legale. Vengono restituite circa 200 righe.
Le abbreviazioni di fuso orario rappresentano un offset fisso rispetto a UTC. Se specifichi un fuso orario con un’abbreviazione di fuso orario, CONVERT\$1TIMEZONE utilizza l’offset fisso rispetto a UTC e non esegue il passaggio ad alcun protocollo stagionale locale.
### Utilizzo del formato in stile POSIX
*Una specifica del fuso orario in stile POSIX è nella forma *STDoffset*o *STDoffsetDST*, dove *STD* è un'abbreviazione del fuso orario, *offset è l'offset* numerico in ore a ovest dall'UTC e DST è un'abbreviazione opzionale del fuso orario.* L’ora legale viene considerata come un’ora avanti rispetto all’offset specificato.
I formati di fuso orario in stile POSIX utilizzano offset positivi a ovest di Greenwich, contrariamente alla convenzione ISO-8601, che utilizza offset positivi a est di Greenwich.
Di seguito sono riportati alcuni esempi di fusi orari in stile POSIX:
+ PST8
+ PST8PDT
+ EST5
+ EST5EDT
**Nota**
Amazon Redshift non convalida le specifiche di fuso orario in stile POSIX, di conseguenza è possibile impostare il fuso orario su un valore non valido. Ad esempio, il comando seguente non restituisce un errore, anche se si imposta il fuso orario su un valore non valido.
```
set timezone to ‘xxx36’;
```
## Esempi
La maggior parte degli esempi usa il set di dati TICKIT di esempio. Per ulteriori informazioni, consulta [Database di esempio](https://docs.aws.amazon.com/redshift/latest/dg/c_sampledb.html).
L'esempio seguente converte il valore di timestamp dal fuso orario UTC predefinito in PST.
```
select convert_timezone('PST', '2008-08-21 07:23:54');
convert_timezone
------------------------
2008-08-20 23:23:54
```
L'esempio seguente converte il valore di timestamp nella colonna LISTTIME dal fuso orario UTC predefinito in PST. Anche se il timestamp rientra nel periodo dell'ora legale, viene convertito nell'ora standard in quanto il fuso orario di destinazione è specificato come abbreviazione (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
```
L'esempio seguente converte una colonna LISTTIME con timestamp dal fuso orario UTC predefinito al fuso orario. US/Pacific Il fuso orario di destinazione utilizza un nome di fuso orario e il timestamp è nel periodo dell'ora legale, di conseguenza la funzione restituisce l'ora legale.
```
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
```
L'esempio seguente converte una stringa di timestamp da EST a PST:
```
select convert_timezone('EST', 'PST', '20080305 12:25:29');
convert_timezone
-------------------
2008-03-05 09:25:29
```
L'esempio seguente converte un timestamp all'ora standard degli Stati Uniti orientali in quanto il fuso orario di destinazione utilizza un nome di fuso orario (America/New\$1York) e il timestamp si trova nel periodo dell'ora standard.
```
select convert_timezone('America/New_York', '2013-02-01 08:00:00');
convert_timezone
---------------------
2013-02-01 03:00:00
(1 row)
```
L'esempio seguente converte il timestamp nell'ora legale dell'est degli Stati Uniti in quanto il fuso orario target utilizza un nome di fuso orario (America/New\$1York) e il timestamp si trova nel periodo dell'ora legale.
```
select convert_timezone('America/New_York', '2013-06-01 08:00:00');
convert_timezone
---------------------
2013-06-01 04:00:00
(1 row)
```
L'esempio seguente illustra l'utilizzo di offset.
```
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)
```
# Funzione CURRENT\$1DATE
CURRENT\$1DATE restituisce una data nel fuso orario della sessione corrente (UTC per impostazione predefinita) nel formato predefinito:. YYYY-MM-DD
**Nota**
CURRENT\$1DATE restituisce la data di inizio della transazione corrente e non dell'istruzione corrente. Considera lo scenario quando avvii una transazione contenente più istruzioni alle 23:59 del giorno 01/10/08 e l'istruzione contenente CURRENT\$1DATE viene eseguita alle 00:00 del 02/10/08. CURRENT\$1DATE restituisce `10/01/08`, non `10/02/08`.
## Sintassi
```
CURRENT_DATE
```
## Tipo restituito
DATE
## Esempi
L'esempio seguente restituisce la data corrente (nel punto in Regione AWS cui viene eseguita la funzione).
```
select current_date;
date
------------
2008-10-01
```
L'esempio seguente crea una tabella, inserisce una riga in cui l'impostazione predefinita della colonna `todays_date` è CURRENT\$1DATE, quindi seleziona tutte le righe della tabella.
```
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
```
# Funzione DATE\$1CMP
DATE\$1CMP confronta due date. La funzione restituisce `0` se le date sono identiche, `1` se *date1* è maggiore e `-1` se *date2* è maggiore.
## Sintassi
```
DATE_CMP(date1, date2)
```
## Arguments (Argomenti)
*date1*
Una colonna di tipo di dati `DATE` o un'espressione che restituisce un tipo `DATE`.
*date2*
Una colonna di tipo di dati `DATE` o un'espressione che restituisce un tipo `DATE`.
## Tipo restituito
INTEGER
## Esempi
La query seguente confronta i valori DATE nella colonna CALDATE alla data del 4 gennaio 2008 e indica se il valore in CALDATE è anteriore (`-1`), uguale (`0`) o posteriore (`1`) al 4 gennaio 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)
```
# Funzione DATE\$1CMP\$1TIMESTAMP
DATE\$1CMP\$1TIMESTAMP confronta una data con un timestamp e restituisce `0` se i valori sono identici, `1` se *date* è maggiore cronologicamente e `-1` se *timestamp* è maggiore.
## Sintassi
```
DATE_CMP_TIMESTAMP(date, timestamp)
```
## Arguments (Argomenti)
*data*
Una colonna di tipo di dati `DATE` o un'espressione che restituisce un tipo `DATE`.
*timestamp*
Una colonna di tipo di dati `TIMESTAMP` o un'espressione che restituisce un tipo `TIMESTAMP`.
## Tipo restituito
INTEGER
## Esempi
L'esempio seguente confronta la data `2008-06-18` a LISTTIME. I valori della colonna LISTTIME sono timestamp. Gli elenchi generati prima di questa data restituiscono `1`; quelli creati dopo questa data restituiscono `-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)
```
# Funzione DATE\$1CMP\$1TIMESTAMPTZ
DATE\$1CMP\$1TIMESTAMPTZ confronta una data con un timestamp con fuso orario e restituisce `0` se i valori sono identici, `1` se *date* è maggiore cronologicamente e `-1` se *timestamptz* è maggiore.
## Sintassi
```
DATE_CMP_TIMESTAMPTZ(date, timestamptz)
```
## Arguments (Argomenti)
*data*
Una colonna di tipo di dati `DATE` o un'espressione che restituisce un tipo `DATE`.
*timestamptz*
Una colonna di tipo di dati `TIMESTAMPTZ` o un'espressione che restituisce un tipo `TIMESTAMPTZ`.
## Tipo restituito
INTEGER
## Esempi
L'esempio seguente confronta la data `2008-06-18` a LISTTIME. Gli elenchi generati prima di questa data restituiscono `1`; quelli creati dopo questa data restituiscono `-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)
```
# Funzione DATEADD
Incrementa un valore di DATE, TIME, TIMETZ o TIMESTAMP dell'intervallo specificato.
## Sintassi
```
DATEADD( datepart, interval, {date|time|timetz|timestamp} )
```
## Arguments (Argomenti)
*datepart*
La parte di data (ad esempio, anno, mese o giorno) su cui la funzione opera. Per ulteriori informazioni, consultare [Parti di data per funzioni di data e timestamp](r_Dateparts_for_datetime_functions.md).
*intervallo*
Un intero che specifica l'intervallo (ad esempio, il numero di giorni) da aggiungere all'espressione target. Un intero negativo sottrae l'intervallo.
*date*\$1*time*\$1*timetz*\$1*timestamp*
Una colonna o un'espressione DATE, TIME, TIMETZ, or TIMESTAMP che viene implicitamente convertita in un DATE, TIME, TIMETZ o TIMESTAMP. L'espressione DATE, TIME, TIMETZ o TIMESTAMP deve contenere la parte di data specificata.
## Tipo restituito
TIMESTAMP o TIME o TIMETZ a seconda del tipo di dati di input.
## Esempi con una colonna DATE
Nel seguente esempio vengono aggiunti 30 giorni a ogni data di novembre presente nella tabella 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)
```
L'esempio seguente aggiunge 18 mesi a un valore di data letterale.
```
select dateadd(month,18,'2008-02-28');
date_add
---------------------
2009-08-28 00:00:00
(1 row)
```
Il nome di colonna predefinito per una funzione DATEADD è DATE\$1ADD. Il timestamp predefinito per un valore di data è `00:00:00`.
Nell'esempio seguente vengono aggiunti 30 minuti a un valore di data che non specifica un timestamp.
```
select dateadd(m,30,'2008-02-28');
date_add
---------------------
2008-02-28 00:30:00
(1 row)
```
È possibile assegnare un nome completo o abbreviato alle parti di data. In questo caso, *m* sta per minuti, non mesi.
## Esempi con una colonna TIME
La tabella di esempio seguente TIME\$1TEST contiene una colonna TIME\$1VAL (tipo TIME) con tre valori inseriti.
```
select time_val from time_test;
time_val
---------------------
20:00:00
00:00:00.5550
00:58:00
```
Nell'esempio seguente vengono aggiunti 5 minuti a ogni TIME\$1VAL della tabella TIME\$1TEST.
```
select dateadd(minute,5,time_val) as minplus5 from time_test;
minplus5
---------------
20:05:00
00:05:00.5550
01:03:00
```
Nell'esempio seguente vengono aggiunte 8 ore a un valore di tempo letterale.
```
select dateadd(hour, 8, time '13:24:55');
date_add
---------------
21:24:55
```
L'esempio seguente mostra quando un tempo va oltre 24:00:00 o è precedente a 00:00:00.
```
select dateadd(hour, 12, time '13:24:55');
date_add
---------------
01:24:55
```
## Esempi con una colonna TIMETZ
I valori di output in questi esempi sono in UTC che è il fuso orario predefinito.
La tabella di esempio seguente TIMETZ\$1TEST contiene una colonna TIMETZ\$1VAL (tipo TIMETZ) con tre valori inseriti.
```
select timetz_val from timetz_test;
timetz_val
------------------
04:00:00+00
00:00:00.5550+00
05:58:00+00
```
Nell'esempio seguente vengono aggiunti 5 minuti a ogni TIMETZ\$1VAL nella tabella 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
```
Nell'esempio seguente vengono aggiunte 2 ore a un valore timetz letterale.
```
select dateadd(hour, 2, timetz '13:24:55 PST');
date_add
---------------
23:24:55+00
```
## Esempi con una colonna TIMESTAMP
I valori di output in questi esempi sono in UTC che è il fuso orario predefinito.
La tabella di esempio seguente TIMESTAMP\$1TEST ha una colonna TIMESTAMP\$1VAL (tipo TIMESTAMP) con tre valori inseriti.
```
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
```
L'esempio seguente aggiunge solo 20 anni ai valori TIMESTAMP\$1VAL in TIMESTAMP\$1TEST prima del 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
```
L'esempio seguente aggiunge 5 secondi a un valore di timestamp letterale scritto senza un indicatore dei secondi.
```
SELECT dateadd(second, 5, timestamp '2001-06-06');
date_add
---------------
2001-06-06 00:00:05
```
## Note per l'utilizzo
Le funzioni DATEADD(month, ...) e ADD\$1MONTHS gestiscono differentemente le date che cadono alla fine del mese.
+ ADD\$1MONTHS: se la data che stai aggiungendo è l'ultimo giorno del mese, il risultato è sempre l'ultimo giorno del mese risultante, indipendentemente dalla lunghezza del mese. Ad esempio, 30 aprile \$1 1 mese è il 31 maggio.
```
select add_months('2008-04-30',1);
add_months
---------------------
2008-05-31 00:00:00
(1 row)
```
+ DATEADD: se vi sono meno giorni nella data che stai aggiungendo rispetto al mese del risultato, il risultato sarà il giorno corrispondente del mese risultante, non l'ultimo giorno di quel mese. Ad esempio, 30 aprile \$1 1 mese è il 30 maggio.
```
select dateadd(month,1,'2008-04-30');
date_add
---------------------
2008-05-30 00:00:00
(1 row)
```
La funzione DATEADD gestisce la data 29/02 dell'anno bisestile differentemente a seconda se si utilizza 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
```
# Funzione DATEDIFF
DATEDIFF restituisce la differenza tra le parti di data di due espressioni di data o di ora.
## Sintassi
```
DATEDIFF( datepart, {date|time|timetz|timestamp}, {date|time|timetz|timestamp} )
```
## Arguments (Argomenti)
*datepart*
La parte specifica del valore di data o ora (anno, mese o giorno, ora, minuto, secondo, millisecondo o microsecondo) su cui la funzione opera. Per ulteriori informazioni, consultare [Parti di data per funzioni di data e timestamp](r_Dateparts_for_datetime_functions.md).
Più precisamente, DATEDIFF determina il numero di limiti di parte di data tra due espressioni. Ad esempio, si supponga di calcolare la differenza in anni tra due date, `12-31-2008` e `01-01-2009`. In questo caso, la funzione restituisce 1 anno nonostante il fatto che queste date siano separate solo da un giorno. Se cerchi la differenza in ore tra due timestamp, `01-01-2009 8:30:00` e `01-01-2009 10:00:00`, il risultato è 2 ore. Se cerchi la differenza in ore tra due timestamp, `8:30:00` e `10:00:00`, il risultato è 2 ore.
*date*\$1*time*\$1*timetz*\$1*timestamp*
Una colonna o le espressioni DATE, TIME, TIMETZ, or TIMESTAMP che viene implicitamente convertita in un DATE, TIME, TIMETZ o TIMESTAMP. Le espressioni devono entrambe contenere la parte di data o di ora specificata. Se la seconda data o ora è posteriore alla prima, il risultato è positivo. Se la seconda data o ora è anteriore alla prima, il risultato è negativo.
## Tipo restituito
BIGINT
## Esempi con una colonna DATE
Nell'esempio seguente viene rilevata la differenza in numero di settimane tra due valori di data letterali.
```
select datediff(week,'2009-01-01','2009-12-31') as numweeks;
numweeks
----------
52
(1 row)
```
Nell'esempio seguente viene rilevata la differenza in ore tra due valori di data letterali. Quando non si fornisce il valore dell'ora per una data, il valore predefinito è 00:00:00.
```
select datediff(hour, '2023-01-01', '2023-01-03 05:04:03');
date_diff
----------
53
(1 row)
```
Nell'esempio seguente viene rilevata la differenza in giorni tra due valori TIMESTAMETZ letterali.
```
Select datediff(days, 'Jun 1,2008 09:59:59 EST', 'Jul 4,2008 09:59:59 EST')
date_diff
----------
33
```
Nell'esempio seguente viene rilevata la differenza, in giorni, tra due date nella stessa riga di una tabella.
```
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)
```
Nel seguente esempio viene trovata la differenza, in numero di trimestri, tra un valore letterale nel passato e la data odierna. Questo esempio presuppone che la data corrente è il 5 giugno 2008. È possibile assegnare un nome completo o abbreviato alle parti di data. Il nome di colonna predefinito per la funzione DATEDIFF è DATE\$1DIFF.
```
select datediff(qtr, '1998-07-01', current_date);
date_diff
-----------
40
(1 row)
```
In questo esempio viene eseguito il join delle tabelle SALES e LISTING per calcolare quanti giorni dopo la pubblicazione sono stati venduti i biglietti per i risultati da 1000 a 1005. L'attesa più lunga per la vendita di questi elenchi è di 15 giorni e quella più breve è inferiore a 1 giorno (0 giorni).
```
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)
```
Questo esempio calcola il numero medio di ore di attesa dei venditori per tutte le vendite di biglietti.
```
select avg(datediff(hours, listtime, saletime)) as avgwait
from sales, listing
where sales.listid = listing.listid;
avgwait
---------
465
(1 row)
```
## Esempi con una colonna TIME
La tabella di esempio seguente TIME\$1TEST contiene una colonna TIME\$1VAL (tipo TIME) con tre valori inseriti.
```
select time_val from time_test;
time_val
---------------------
20:00:00
00:00:00.5550
00:58:00
```
Nell'esempio seguente viene rilevata la differenza di numero di ore tra la colonna TIME\$1VAL e un valore letterale temporale.
```
select datediff(hour, time_val, time '15:24:45') from time_test;
date_diff
-----------
-5
15
15
```
Nell'esempio seguente viene rilevata la differenza in numero di minuti tra due valori letterali temporali.
```
select datediff(minute, time '20:00:00', time '21:00:00') as nummins;
nummins
----------
60
```
## Esempi con una colonna TIMETZ
La tabella di esempio seguente TIMETZ\$1TEST contiene una colonna TIMETZ\$1VAL (tipo TIMETZ) con tre valori inseriti.
```
select timetz_val from timetz_test;
timetz_val
------------------
04:00:00+00
00:00:00.5550+00
05:58:00+00
```
Nell'esempio seguente vengono individuate le differenze nel numero di ore, tra un letterale TIMETZ e timetz\$1val.
```
select datediff(hours, timetz '20:00:00 PST', timetz_val) as numhours from timetz_test;
numhours
----------
0
-4
1
```
Nell'esempio seguente viene rilevata la differenza in numero di ore tra due valori TIMETZ letterali.
```
select datediff(hours, timetz '20:00:00 PST', timetz '00:58:00 EST') as numhours;
numhours
----------
1
```
# Funzione DATE\$1PART
DATE\$1PART estrae valori di parte di data da un'espressione. DATE\$1PART è un sinonimo della funzione PGDATE\$1PART.
## Sintassi
```
DATE_PART(datepart, {date|timestamp})
```
## Arguments (Argomenti)
*datepart*
Un identificatore letterale o una stringa della parte specifica del valore di data (ad esempio, anno, mese o giorno) su cui la funzione opera. Per ulteriori informazioni, consulta [Parti di data per funzioni di data e timestamp](r_Dateparts_for_datetime_functions.md).
\$1*date*\$1*timestamp*\$1
Una colonna di data o timestamp o un'espressione che viene implicitamente convertita in una data o un timestamp. La colonna o l'espressione in *data* o *timestamp* deve contenere la parte di data specificata in *datepart*.
## Tipo restituito
DOUBLE
## Esempi
Il nome di colonna predefinito per la funzione DATE\$1PART è `pgdate_part`.
Per ulteriori informazioni sui dati utilizzati in alcuni degli esempi seguenti, consulta [Database di esempio](c_sampledb.md).
L'esempio seguente restituisce il valore di minuti da un valore di timestamp letterale.
```
SELECT DATE_PART(minute, timestamp '20230104 04:05:06.789');
pgdate_part
-----------
5
```
Nell'esempio seguente viene rilevato il numero della settimana da un valore di timestamp letterale. Il calcolo del numero della settimana segue lo standard ISO 8601. Per ulteriori informazioni, consulta [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) in Wikipedia.
```
SELECT DATE_PART(week, timestamp '20220502 04:05:06.789');
pgdate_part
-----------
18
```
Nell'esempio seguente viene rilevato il giorno del mese da un valore di timestamp letterale.
```
SELECT DATE_PART(day, timestamp '20220502 04:05:06.789');
pgdate_part
-----------
2
```
Nell'esempio seguente viene rilevato il giorno della settimana da un timestamp letterale. Il numero del giorno della settimana è un numero intero compreso tra 0 e 6, iniziando da domenica.
```
SELECT DATE_PART(dayofweek, timestamp '20220502 04:05:06.789');
pgdate_part
-----------
1
```
Nell'esempio seguente viene rilevato il secolo da un timestamp letterale. Il calcolo del secolo segue lo standard ISO 8601. Per ulteriori informazioni, consulta [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) in Wikipedia.
```
SELECT DATE_PART(century, timestamp '20220502 04:05:06.789');
pgdate_part
-----------
21
```
L'esempio seguente restituisce il valore del millennio da un valore di timestamp letterale. Il calcolo del millennio segue lo standard ISO 8601. Per ulteriori informazioni, consulta [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) in Wikipedia.
```
SELECT DATE_PART(millennium, timestamp '20220502 04:05:06.789');
pgdate_part
-----------
3
```
L'esempio seguente restituisce il valore di microsecondi da un valore di timestamp letterale. Il calcolo dei microsecondi segue lo standard ISO 8601. Per ulteriori informazioni, consulta [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) in Wikipedia.
```
SELECT DATE_PART(microsecond, timestamp '20220502 04:05:06.789');
pgdate_part
-----------
789000
```
Nell'esempio seguente viene rilevato il mese da una data letterale.
```
SELECT DATE_PART(month, date '20220502');
pgdate_part
-----------
5
```
L'esempio seguente applica la funzione DATE\$1PART a una colonna di una tabella.
```
SELECT date_part(w, listtime) AS weeks, listtime
FROM listing
WHERE listid=10
weeks | listtime
------+---------------------
25 | 2008-06-17 09:44:54
(1 row)
```
È possibile assegnare un nome completo o abbreviato alle parti di data; in questo caso, *w* indica settimane.
La parte di data giorno della settimana restituisce un intero da 0 a 6, partendo da domenica. Utilizza DATE\$1PART con dow (DAYOFWEEK) per visualizzare gli eventi di un sabato.
```
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)
```
# Funzione DATE\$1PART\$1YEAR
La funzione DATE\$1PART\$1YEAR estrae l'anno da una data.
## Sintassi
```
DATE_PART_YEAR(date)
```
## Argomento
*data*
Una colonna di tipo di dati `DATE` o un'espressione che restituisce un tipo `DATE`.
## Tipo restituito
INTEGER
## Esempi
Nell'esempio seguente viene rilevato l'anno da una data letterale.
```
SELECT DATE_PART_YEAR(date '20220502 04:05:06.789');
date_part_year
---------------
2022
```
L'esempio seguente estrae l'anno dalla colonna CALDATE: I valori nella colonna CALDATE sono date. Per ulteriori informazioni sui dati utilizzati in questo esempio, consulta [Database di esempio](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)
```
# Funzione DATE\$1TRUNC
La funzione DATE\$1TRUNC tronca un'espressione di timestamp o letterale in base alla parte di data specificata, ad esempio ora, settimana o mese.
## Sintassi
```
DATE_TRUNC('datepart', timestamp)
```
## Arguments (Argomenti)
*datepart*
La parte di data in corrispondenza della quale troncare il valore di timestamp. L'input *timestamp* viene troncato alla precisione dell'input *datepart*. Ad esempio, `month` viene troncato al primo giorno del mese. I formati validi sono:
+ microsecond, microseconds
+ millisecond, milliseconds
+ second, seconds
+ minute, minutes
+ hour, hours
+ day, days
+ week, weeks
+ month, months
+ quarter, quarters
+ year, years
+ decade, decades
+ century, centuries
+ millennium, millennia
Per ulteriori informazioni sulle abbreviazioni di alcuni formati, consulta [Parti di data per funzioni di data e timestamp](r_Dateparts_for_datetime_functions.md)
*timestamp*
Una colonna timestamp o un'espressione che viene implicitamente convertita in un timestamp.
## Tipo restituito
TIMESTAMP
## Esempi
Tronca il timestamp di input al secondo.
```
SELECT DATE_TRUNC('second', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-04-30 04:05:06
```
Tronca il timestamp di input al minuto.
```
SELECT DATE_TRUNC('minute', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-04-30 04:05:00
```
Tronca il timestamp di input all'ora.
```
SELECT DATE_TRUNC('hour', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-04-30 04:00:00
```
Tronca il timestamp di input al giorno.
```
SELECT DATE_TRUNC('day', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-04-30 00:00:00
```
Tronca il timestamp di input al primo giorno di un mese.
```
SELECT DATE_TRUNC('month', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-04-01 00:00:00
```
Tronca il timestamp di input al primo giorno di un trimestre.
```
SELECT DATE_TRUNC('quarter', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-04-01 00:00:00
```
Tronca il timestamp di input al primo giorno di un anno.
```
SELECT DATE_TRUNC('year', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2020-01-01 00:00:00
```
Tronca il timestamp di input al primo giorno di un secolo.
```
SELECT DATE_TRUNC('millennium', TIMESTAMP '20200430 04:05:06.789');
date_trunc
2001-01-01 00:00:00
```
Tronca il timestamp di input al lunedì di una settimana.
```
select date_trunc('week', TIMESTAMP '20220430 04:05:06.789');
date_trunc
2022-04-25 00:00:00
```
Nell'esempio seguente, la funzione DATE\$1TRUNC utilizza la parte di data "week" per restituire la data del lunedì di ogni settimana.
```
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
```
# Funzione EXTRACT
La funzione EXTRACT restituisce una parte di data o di ora da un valore TIMESTAMP, TIMESTAMPTZ, TIME, TIMETZ, INTERVAL YEAR TO MONTH o INTERVAL DAY TO SECOND. Gli esempi includono un giorno, mese, ora, minuto, secondo, millisecondo o microsecondo da un timestamp.
## Sintassi
```
EXTRACT(datepart FROM source)
```
## Arguments (Argomenti)
*datepart*
Il sottocampo di una data o ora da estrarre, ad esempio un giorno, un mese, un anno, un'ora, un minuto, un secondo, un millisecondo o un microsecondo. Per un elenco dei valori possibili, consultare [Parti di data per funzioni di data e timestamp](r_Dateparts_for_datetime_functions.md).
*source (origine)*
Una colonna o un’espressione che restituisce un tipo di dati TIMESTAMP, TIMESTAMPTZ, TIME, TIMETZ, INTERVAL YEAR TO MONTH o INTERVAL DAY TO SECOND.
## Tipo restituito
INTEGER se il valore di *origine* restituisce un tipo di dati TIMESTAMP, TIME, TIMETZ, INTERVAL YEAR TO MONTH o INTERVAL DAY TO SECOND.
DOUBLE PRECISION se il valore di *origine* restituisce il tipo di dati TIMESTAMPTZ.
## Esempi con TIMESTAMP
Nel seguente esempio viene determinato il numero di settimane per le vendite il cui prezzo pagato è stato uguale o superiore a 10.000 USD. Questo esempio utilizza i dati TICKIT. Per ulteriori informazioni, consulta [Database di esempio](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
```
L'esempio seguente restituisce il valore di minuti da un valore di timestamp letterale.
```
select extract(minute from timestamp '2009-09-09 12:08:43');
date_part
-----------
8
```
L'esempio seguente restituisce il valore in millisecondi da un valore di timestamp letterale.
```
select extract(ms from timestamp '2009-09-09 12:08:43.101');
date_part
-----------
101
```
## Esempi con TIMESTAMPTZ
L'esempio seguente restituisce il valore di anno da un valore di timestamp letterale.
```
select extract(year from timestamptz '1.12.1997 07:37:16.00 PST');
date_part
-----------
1997
```
## Esempi con TIME
La tabella di esempio seguente TIME\$1TEST ha una colonna TIME\$1VAL (tipo TIME) con tre valori inseriti.
```
select time_val from time_test;
time_val
---------------------
20:00:00
00:00:00.5550
00:58:00
```
Nell'esempio seguente vengono estratti i minuti da ogni timetz\$1val.
```
select extract(minute from time_val) as minutes from time_test;
minutes
-----------
0
0
58
```
Nell'esempio seguente vengono estratte le ore da ogni time\$1val.
```
select extract(hour from time_val) as hours from time_test;
hours
-----------
20
0
0
```
Nell'esempio seguente vengono estratti i millisecondi da un valore letterale.
```
select extract(ms from time '18:25:33.123456');
date_part
-----------
123
```
## Esempi con TIMETZ
La tabella di esempio seguente TIMETZ\$1TEST ha una colonna TIMETZ\$1VAL (tipo TIMETZ) con tre valori inseriti.
```
select timetz_val from timetz_test;
timetz_val
------------------
04:00:00+00
00:00:00.5550+00
05:58:00+00
```
Nell'esempio seguente vengono estratte le ore da ogni timez\$1val.
```
select extract(hour from timetz_val) as hours from time_test;
hours
-----------
4
0
5
```
Nell'esempio seguente vengono estratti i millisecondi da un valore letterale. I valori letterali non vengono convertiti in UTC prima dell'elaborazione dell'estrazione.
```
select extract(ms from timetz '18:25:33.123456 EST');
date_part
-----------
123
```
L'esempio seguente restituisce l'ora dell'offset del fuso orario, da UTC da un valore timetz letterale.
```
select extract(timezone_hour from timetz '1.12.1997 07:37:16.00 PDT');
date_part
-----------
-7
```
## Esempi con INTERVAL YEAR TO MONTH e INTERVAL DAY TO SECOND
L’esempio seguente estrae la parte relativa ai giorni `1` da INTERVAL DAY TO SECOND che definisce 36 ore, ovvero 1 giorno e 12 ore.
```
select EXTRACT('days' from INTERVAL '36 hours' DAY TO SECOND)
date_part
------------------
1
```
L’esempio seguente estrae la parte relativa ai mesi `3` da YEAR TO MONTH che definisce 15 mesi, ovvero 1 anno e 3 mesi.
```
select EXTRACT('month' from INTERVAL '15 months' YEAR TO MONTH)
date_part
------------------
3
```
L’esempio seguente estrae la parte relativa ai mesi `6` da 30 mesi, ovvero 2 anni e 6 mesi.
```
select EXTRACT('month' from INTERVAL '30' MONTH)
date_part
------------------
6
```
L’esempio seguente estrae la parte relativa alle ore `2` da 50 ore, ovvero 2 giorni e 2 ore.
```
select EXTRACT('hours' from INTERVAL '50' HOUR)
date_part
------------------
2
```
L’esempio seguente estrae la parte relativa ai minuti `11` da 1 ora, 11 minuti e 11.123 secondi.
```
select EXTRACT('minute' from INTERVAL '70 minutes 70.123 seconds' MINUTE TO SECOND)
date_part
------------------
11
```
L’esempio seguente estrae la parte relativa ai secondi `1.11` da 1 giorno, 1 ora, 1 minuto e 1,11 secondi.
```
select EXTRACT('seconds' from INTERVAL '1 day 1:1:1.11' DAY TO SECOND)
date_part
------------------
1.11
```
L’esempio seguente estrae il numero totale di ore in un INTERVALLO. Ogni parte viene estratta e aggiunta a un totale.
```
select EXTRACT('days' from INTERVAL '50' HOUR) * 24 + EXTRACT('hours' from INTERVAL '50' HOUR)
?column?
------------------
50
```
L’esempio seguente estrae il numero totale di secondi in un INTERVALLO. Ogni parte viene estratta e aggiunta a un totale.
```
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
```
# Funzione GETDATE
GETDATE restituisce la data e l'ora correnti nel fuso orario della sessione corrente (UTC per impostazione predefinita). Restituisce la data o l'ora di inizio dell'istruzione corrente, anche quando si trova all'interno di un blocco di transazione.
## Sintassi
```
GETDATE()
```
Le parentesi sono obbligatorie.
## Tipo restituito
TIMESTAMP
## Esempi
L'esempio seguente utilizza la funzione GETDATE per restituire il timestamp completo della data odierna
```
select getdate();
timestamp
---------------------
2008-12-04 16:10:43
```
L'esempio seguente utilizza la funzione GETDATE nella funzione TRUNC per restituire la data odierna senza l'ora:
```
select trunc(getdate());
trunc
------------
2008-12-04
```
# Funzione INTERVAL\$1CMP
INTERVAL\$1CMP confronta due intervalli e restituisce `1` se il primo intervallo è più grande, `-1` se il secondo intervallo è più grande e `0` se gli intervalli sono uguali. Per ulteriori informazioni, consultare [Esempi di valori letterali relativi agli intervalli senza sintassi dei qualificatori](r_interval_literals.md).
## Sintassi
```
INTERVAL_CMP(interval1, interval2)
```
## Arguments (Argomenti)
*interval1*
Un valore di intervallo letterale.
*interval2*
Un valore di intervallo letterale.
## Tipo restituito
INTEGER
## Esempi
L'esempio seguente confronta il valore di `3 days` con `1 year`.
```
select interval_cmp('3 days','1 year');
interval_cmp
--------------
-1
```
Questo esempio confronta il valore`7 days` con `1 week`.
```
select interval_cmp('7 days','1 week');
interval_cmp
--------------
0
```
L'esempio seguente confronta il valore di `1 year` con `3 days`.
```
select interval_cmp('1 year','3 days');
interval_cmp
--------------
1
```
# Funzione LAST\$1DAY
LAST\$1DAY restituisce la data dell'ultimo giorno del mese che contiene *date*. Il tipo di valore restituito è sempre DATE, indipendentemente dal tipo di dati dell'argomento *date*.
Per ulteriori informazioni sul recupero di parti di data specifiche, consulta [Funzione DATE\$1TRUNC](r_DATE_TRUNC.md).
## Sintassi
```
LAST_DAY( { date | timestamp } )
```
## Arguments (Argomenti)
*date* \$1 *timestamp*
Una colonna di tipo di dati `DATE` o `TIMESTAMP` o un'espressione che implicitamente valuta un tipo `DATE` o `TIMESTAMP`.
## Tipo restituito
DATE
## Esempi
L'esempio seguente restituisce la data dell'ultimo giorno del mese corrente:
```
select last_day(sysdate);
last_day
------------
2014-01-31
```
L'esempio seguente restituisce il numero di biglietti venduti per ognuno degli ultimi 7 giorni del mese: I valori della colonna SALETIME sono timestamp.
```
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)
```
# Funzione MONTHS\$1BETWEEN
MONTHS\$1BETWEEN determina il numero di mesi tra due date.
Se la prima data è posteriore alla seconda, il risultato è positivo, altrimenti è negativo.
Se uno degli argomenti è null, il risultato è NULL.
## Sintassi
```
MONTHS_BETWEEN( date1, date2 )
```
## Arguments (Argomenti)
*date1*
Una colonna di tipo di dati `DATE` o un'espressione che restituisce un tipo `DATE`.
*date2*
Una colonna di tipo di dati `DATE` o un'espressione che restituisce un tipo `DATE`.
## Tipo restituito
FLOAT8
La parte del numero intero del risultato è basata sulla differenza tra i valori di anno e di mese delle date. La parte frazionaria del risultato viene calcolata a partire dai valori di giorno e timestamp delle date e presuppone un mese di 31 giorni.
Se *date1* e *date2* contengono la stessa data in un mese (ad esempio, 15/01/14 e 15/02/14) o l'ultimo giorno del mese (ad esempio, 31/08/14 e 30/09/14), il risultato è un numero intero basato sui valori di anno e mese delle date, indipendentemente dalla corrispondenza o meno dell'eventuale parte di timestamp.
## Esempi
L'esempio seguente restituisce i mesi tra il 18/01/1969 e il 18/03/1969:
```
select months_between('1969-01-18', '1969-03-18')
as months;
months
----------
-2
```
L'esempio seguente restituisce i mesi tra il 18/01/1969 e il 18/01/1969:
```
select months_between('1969-01-18', '1969-01-18')
as months;
months
----------
0
```
L'esempio seguente restituisce i mesi tra la prima e l'ultima proiezione di 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
```
# Funzione NEXT\$1DAY
La funzione NEXT\$1DAY restituisce la data della prima istanza del giorno specificato che è posteriore alla data fornita.
Se il valore *day* è lo stesso giorno della settimana della data considerata, viene restituita l'occorrenza successiva di quel giorno.
## Sintassi
```
NEXT_DAY( { date | timestamp }, day )
```
## Arguments (Argomenti)
*date* \$1 *timestamp*
Una colonna di tipo di dati `DATE` o `TIMESTAMP` o un'espressione che implicitamente valuta un tipo `DATE` o `TIMESTAMP`.
*giorno*
Una stringa che include il nome di qualsiasi giorno. La capitalizzazione non è importante.
I valori validi sono:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/r_NEXT_DAY.html)
## Tipo restituito
DATE
## Esempi
L'esempio seguente restituisce la data del primo martedì dopo il 20/08/2014.
```
select next_day('2014-08-20','Tuesday');
next_day
-----------
2014-08-26
```
L'esempio seguente restituisce la data del primo martedì dopo l'1/1/2008 alle 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
```
L'esempio seguente ottiene le date marketing target per il terzo 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
```
# Funzione SYSDATE
SYSDATE restituisce la data e l'ora correnti nel fuso orario della sessione corrente (UTC per impostazione predefinita).
**Nota**
SYSDATE restituisce la data e l'ora di inizio della transazione corrente e non dell'istruzione corrente.
## Sintassi
```
SYSDATE
```
Questa funzione non richiede argomenti.
## Tipo restituito
TIMESTAMP
## Esempi
L'esempio seguente utilizza la funzione SYSDATE per restituire il timestamp completo della data odierna.
```
select sysdate;
timestamp
----------------------------
2008-12-04 16:10:43.976353
```
L'esempio seguente utilizza la funzione SYSDATE nella funzione TRUNC per restituire la data odierna senza l'ora:
```
select trunc(sysdate);
trunc
------------
2008-12-04
```
La query seguente restituisce informazioni sulle vendite per le date comprese in un periodo a ritroso di 120 giorni a partire dalla data di esecuzione della query:
```
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
...
```
# Funzione TIMEOFDAY
TIMEOFDAY è un alias speciale utilizzato per restituire giorno della settimana, data e ora come valore di stringa. Restituisce la stringa dell'ora del giorno per l'istruzione corrente, anche quando si trova all'interno di un blocco di transazione.
## Sintassi
```
TIMEOFDAY()
```
## Tipo restituito
VARCHAR
## Esempi
Nell'esempio seguente viene restituita la data e l'ora correnti mediante la funzione TIMEOFDAY.
```
select timeofday();
timeofday
------------
Thu Sep 19 22:53:50.333525 2013 UTC
```
# Funzione TIMESTAMP\$1CMP
Confronta il valore di due timestamp e restituisce un intero. Se i timestamp sono identici, la funzione restituisce `0`. Se il primo timestamp è maggiore, la funzione restituisce `1`. Se il secondo timestamp è maggiore, la funzione restituisce `-1`.
## Sintassi
```
TIMESTAMP_CMP(timestamp1, timestamp2)
```
## Arguments (Argomenti)
*timestamp1*
Una colonna di tipo di dati `TIMESTAMP` o un'espressione che restituisce un tipo `TIMESTAMP`.
*timestamp2*
Una colonna di tipo di dati `TIMESTAMP` o un'espressione che restituisce un tipo `TIMESTAMP`.
## Tipo restituito
INTEGER
## Esempi
Gli esempi seguenti confrontano i timestamp e mostrano i risultati del confronto.
```
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
```
L'esempio seguente confronta LISTTIME e SALETIME per un elenco. Il valore di TIMESTAMP\$1CMP è `-1` per tutti i risultati in quanto il timestamp della vendita è successivo al timestamp del risultato:
```
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)
```
Questo esempio mostra che TIMESTAMP\$1CMP restituisce 0 per timestamp identici:
```
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)
```
# Funzione TIMESTAMP\$1CMP\$1DATE
TIMESTAMP\$1CMP\$1DATE confronta il valore di un timestamp e di una data. Se i valori di timestamp e data sono identici, la funzione restituisce `0`. Se il primo timestamp è maggiore cronologicamente, la funzione restituisce `1`. Se la data è posteriore, la funzione restituisce `-1`.
## Sintassi
```
TIMESTAMP_CMP_DATE(timestamp, date)
```
## Arguments (Argomenti)
*timestamp*
Una colonna di tipo di dati `TIMESTAMP` o un'espressione che restituisce un tipo `TIMESTAMP`.
*data*
Una colonna di tipo di dati `DATE` o un'espressione che restituisce un tipo `DATE`.
## Tipo restituito
INTEGER
## Esempi
L'esempio seguente confronta LISTTIME e la data `2008-06-18`. Gli elenchi generati dopo questa data restituiscono `1`; quelli creati prima di questa data restituiscono `-1`. I valori LISTTIME sono timestamp.
```
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)
```
# Funzione TIMESTAMP\$1CMP\$1TIMESTAMPTZ
TIMESTAMP\$1CMP\$1TIMESTAMPTZ confronta il valore di un'espressione di timestamp con quello di un'espressione di timestamp con fuso orario. Se i valori di timestamp e timestamp con fuso orario sono identici, la funzione restituisce `0`. Se il primo timestamp è maggiore cronologicamente, la funzione restituisce `1`. Se il timestamp con fuso orario è maggiore, la funzione restituisce `–1`.
## Sintassi
```
TIMESTAMP_CMP_TIMESTAMPTZ(timestamp, timestamptz)
```
## Arguments (Argomenti)
*timestamp*
Una colonna di tipo di dati `TIMESTAMP` o un'espressione che restituisce un tipo `TIMESTAMP`.
*timestamptz*
Una colonna di tipo di dati `TIMESTAMPTZ` o un'espressione che restituisce un tipo `TIMESTAMPTZ`.
## Tipo restituito
INTEGER
## Esempi
Gli esempi seguenti confrontano i timestamp con i fusi orari e mostrano i risultati del confronto.
```
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
```
# Funzione TIMESTAMPTZ\$1CMP
TIMESTAMPTZ\$1CMP confronta il valore di due timestamp con fuso orario e restituisce un intero. Se i timestamp sono identici, la funzione restituisce `0`. Se il primo timestamp è maggiore cronologicamente, la funzione restituisce `1`. Se il secondo timestamp è maggiore, la funzione restituisce `–1`.
## Sintassi
```
TIMESTAMPTZ_CMP(timestamptz1, timestamptz2)
```
## Arguments (Argomenti)
*timestamptz1*
Una colonna di tipo di dati `TIMESTAMPTZ` o un'espressione che restituisce un tipo `TIMESTAMPTZ`.
*timestamptz2*
Una colonna di tipo di dati `TIMESTAMPTZ` o un'espressione che restituisce un tipo `TIMESTAMPTZ`.
## Tipo restituito
INTEGER
## Esempi
Gli esempi seguenti confrontano i timestamp con i fusi orari e mostrano i risultati del confronto.
```
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
```
# Funzione TIMESTAMPTZ\$1CMP\$1DATE
TIMESTAMPTZ\$1CMP\$1DATE confronta il valore di un timestamp e di una data. Se i valori di timestamp e data sono identici, la funzione restituisce `0`. Se il primo timestamp è maggiore cronologicamente, la funzione restituisce `1`. Se la data è posteriore, la funzione restituisce `–1`.
## Sintassi
```
TIMESTAMPTZ_CMP_DATE(timestamptz, date)
```
## Arguments (Argomenti)
*timestamptz*
Una colonna di tipo di dati `TIMESTAMPTZ` o un'espressione che restituisce un tipo `TIMESTAMPTZ`.
*data*
Una colonna di tipo di dati `DATE` o un'espressione che restituisce un tipo `DATE`.
## Tipo restituito
INTEGER
## Esempi
L'esempio seguente confronta LISTTIME come timestamp con fuso orario con la data `2008-06-18`. Gli elenchi generati dopo questa data restituiscono `1`; quelli creati prima di questa data restituiscono `-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)
```
# Funzione TIMESTAMPTZ\$1CMP\$1TIMESTAMP
TIMESTAMPTZ\$1CMP\$1TIMESTAMP confronta il valore di un'espressione di timestamp con fuso orario con quello di un'espressione di timestamp. Se i valori di timestamp con fuso orario e timestamp sono identici, la funzione restituisce `0`. Se il primo timestamp con fuso orario è maggiore cronologicamente, la funzione restituisce `1`. Se il timestamp è maggiore, la funzione restituisce `–1`.
## Sintassi
```
TIMESTAMPTZ_CMP_TIMESTAMP(timestamptz, timestamp)
```
## Arguments (Argomenti)
*timestamptz*
Una colonna di tipo di dati `TIMESTAMPTZ` o un'espressione che restituisce un tipo `TIMESTAMPTZ`.
*timestamp*
Una colonna di tipo di dati `TIMESTAMP` o un'espressione che restituisce un tipo `TIMESTAMP`.
## Tipo restituito
INTEGER
## Esempi
Gli esempi seguenti confrontano i timestamp con i fusi orari e mostrano i risultati del confronto.
```
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
```
# Funzione TIMEZONE
TIMEZONE restituisce un timestamp per il fuso orario e il valore di timestamp specificati.
Per informazioni ed esempi su come impostare il fuso orario, consultare [timezone](r_timezone_config.md).
Per informazioni ed esempi su come convertire il fuso orario, consultare [CONVERT\$1TIMEZONE](CONVERT_TIMEZONE.md).
## Sintassi
```
TIMEZONE('timezone', { timestamp | timestamptz })
```
## Arguments (Argomenti)
*timezone*
Il fuso orario del valore restituito. Il fuso orario può essere specificato come nome di fuso orario (ad esempio, **'Africa/Kampala'** o **'Singapore'**) oppure come abbreviazione di fuso orario (ad esempio, **'UTC'** o **'PDT'**). Per visualizzare un elenco dei nomi di fuso orario supportati, utilizzare il comando seguente.
```
select pg_timezone_names();
```
Per visualizzare un elenco delle abbreviazioni di fuso orario supportate, utilizzare il comando seguente.
```
select pg_timezone_abbrevs();
```
Tieni presente che Amazon Redshift utilizza il [database dei fusi orari di IANA](https://www.iana.org/time-zones) come fonte autorevole per la specifica del fuso orario. Per maggiori informazioni ed esempi, consulta [Note sull'utilizzo dei fusi orari](CONVERT_TIMEZONE.md#CONVERT_TIMEZONE-usage-notes).
*timestamp* \$1 *timestamptz*
Un'espressione che restituisce un tipo TIMESTAMP o TIMESTAMPTZ o un valore che può essere implicitamente convertito in un timestamp o in un timestamp con fuso orario.
## Tipo restituito
TIMESTAMPTZ quando utilizzato con un'espressione TIMESTAMP.
TIMESTAMP quando utilizzato con un'espressione TIMESTAMPTZ.
## Esempi
Quanto segue restituisce un timestamp per il fuso orario UTC utilizzando il timestamp `2008-06-17 09:44:54` dal fuso orario PST.
```
SELECT TIMEZONE('PST', '2008-06-17 09:44:54');
timezone
-----------------------
2008-06-17 17:44:54+00
```
Quanto segue restituisce un timestamp per il fuso orario PST utilizzando il timestamp `2008-06-17 09:44:54+00` dal fuso orario UTC.
```
SELECT TIMEZONE('PST', timestamptz('2008-06-17 09:44:54+00'));
timezone
-----------------------
2008-06-17 01:44:54
```
# Funzione TO\$1TIMESTAMP
TO\$1TIMESTAMP converte una stringa TIMESTAMP in TIMESTAMPTZ. Per un elenco di funzioni aggiuntive di data e ora per Amazon Redshift, consulta [Funzioni di data e ora](Date_functions_header.md).
## Sintassi
```
to_timestamp(timestamp, format)
```
```
to_timestamp (timestamp, format, is_strict)
```
## Arguments (Argomenti)
*timestamp*
Una stringa che rappresenta un valore timestamp nel formato specificato da *format*. Se questo argomento viene lasciato vuoto, il valore del timestamp predefinito è `0001-01-01 00:00:00`.
*format*
Una letterale di stringa che definisce il formato del valore *timestamp*. I formati che includono un fuso orario (**TZ**, **tz** o **OF**) non sono supportati come input. Per i formati di timestamp validi, consultare [Stringhe di formato datetime](r_FORMAT_strings.md).
*is\$1strict*
Un valore booleano facoltativo che specifica se viene restituito un errore se un valore timestamp di input non è compreso nell'intervallo. Quando *is\$1strict* è impostato su TRUE, viene restituito un errore se esiste un valore fuori intervallo. Quando *is\$1strict* è impostato su FALSE, che è il valore di default, allora i valori di overflow sono accettati.
## Tipo restituito
TIMESTAMPTZ
## Esempi
L'esempio seguente mostra l'utilizzo della funzione TO\$1TIMESTAMP per convertire una stringa TIMESTAMP in 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
```
È possibile passare a TO\$1TIMESTAMP parte di una data. Le parti rimanenti della data sono impostate sui valori predefiniti. L'orario è incluso nell'output:
```
SELECT TO_TIMESTAMP('2017','YYYY');
to_timestamp
--------------------------
2017-01-01 00:00:00+00
```
L'istruzione SQL seguente converte la stringa '2011-12-18 24:38:15' in un TIMESTAMPTZ. Il risultato è un TIMESTAMPTZ che cade il giorno successivo perché il numero di ore è superiore a 24 ore:
```
SELECT TO_TIMESTAMP('2011-12-18 24:38:15', 'YYYY-MM-DD HH24:MI:SS');
to_timestamp
----------------------
2011-12-19 00:38:15+00
```
L'istruzione SQL seguente converte la stringa '2011-12-18 24:38:15' in un TIMESTAMPTZ. Il risultato è un errore perché il valore dell'ora nel timestamp è superiore a 24 ore:
```
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
```
# Funzione TRUNC
Tronca un `TIMESTAMP` e restituisce `DATE`.
Questa funzione può anche troncare un numero. Per ulteriori informazioni, consulta [Funzione TRUNC](r_TRUNC.md).
## Sintassi
```
TRUNC(timestamp)
```
## Arguments (Argomenti)
*timestamp*
Una colonna di tipo di dati `TIMESTAMP` o un'espressione che restituisce un tipo `TIMESTAMP`.
Per restituire un valore di timestamp con come ora, eseguire il casting del risultato della funzione su `TIMESTAMP`.
## Tipo restituito
DATE
## Esempi
Nel seguente esempio viene restituita la parte di data dal risultato della funzione SYSDATE (che restituisce un timestamp).
```
SELECT SYSDATE;
+----------------------------+
| timestamp |
+----------------------------+
| 2011-07-21 10:32:38.248109 |
+----------------------------+
SELECT TRUNC(SYSDATE);
+------------+
| trunc |
+------------+
| 2011-07-21 |
+------------+
```
Nell'esempio seguente viene applicata la funzione TRUNC a una colonna `TIMESTAMP`. Il tipo restituito è una data.
```
SELECT TRUNC(starttime) FROM event
ORDER BY eventid LIMIT 1;
+------------+
| trunc |
+------------+
| 2008-01-25 |
+------------+
```
L'esempio seguente restituisce un valore di timestamp con `00:00:00` come ora trasmessa dal risultato della funzione TRUNC su `TIMESTAMP`.
```
SELECT CAST((TRUNC(SYSDATE)) AS TIMESTAMP);
+---------------------+
| trunc |
+---------------------+
| 2011-07-21 00:00:00 |
+---------------------+
```
# Parti di data per funzioni di data e timestamp
La tabella seguente identifica i nomi e le abbreviazioni di parti di data e parti di ora accettati come argomenti per le seguenti funzioni:
+ DATEADD
+ DATEDIFF
+ DATE\$1PART
+ EXTRACT
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/r_Dateparts_for_datetime_functions.html)
## Variazioni nei risultati con secondi, millisecondi e microsecondi
Differenze minori nei risultati delle query si hanno quando funzioni di data differenti specificano secondi, millisecondi o microsecondi come parti di data:
+ La funzione EXTRACT restituisce interi solo per la parte di data specificata, ignorando parti di dati di livello superiore e inferiore. Se la parte di data specificata è secondi, millisecondi e microsecondi non sono inclusi nel risultato. Se la parte di data specificata è millisecondi, secondi e microsecondi non sono inclusi nel risultato. Se la parte di data specificata è microsecondi, secondi e millisecondi non sono inclusi nel risultato.
+ La funzione DATE\$1PART restituisce la parte di secondi completa del timestamp, indipendentemente dalla parte di data specificata, restituendo un valore decimale o un intero in base alle necessità.
Ad esempio, confronta i risultati delle seguenti query:
```
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
```
## Note su CENTURY, EPOCH, DECADE e MIL
CENTURY o CENTURIES
Amazon Redshift interpreta CENTURY con inizio nell'anno *\$1\$1\$11* e fine nell'anno `###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
```
EPOCA
L'implementazione di EPOCH in Amazon Redshift è relativa a 1970-01-01 00:00:00.000000 indipendentemente del fuso orario in cui si trova il cluster. È possibile che sia necessario compensare i risultati della differenza in ore a seconda del fuso orario in cui si trova il cluster.
L'esempio seguente mostra quanto segue:
1. Crea una tabella denominata EVENT\$1EXAMPLE in funzione della tabella EVENT. Questo comando CREATE AS utilizza la funzione DATE\$1PART per creare una colonna data (denominata PGDATE\$1PART per impostazione predefinita) e archiviare il valore epoch per ogni evento.
1. Seleziona la colonna e il tipo di dati di EVENT\$1EXAMPLE da PG\$1TABLE\$1DEF.
1. Seleziona EVENTNAME, STARTTIME e PGDATE\$1PART dalla tabella EVENT\$1EXAMPLE per visualizzare i differenti formati di data e ora.
1. Seleziona EVENTNAME e STARTTIME da EVENT EXAMPLE così com'è. Converte i valori epoch in PGDATE\$1PART utilizzando un intervallo di un secondo per un timestamp senza fuso orario e restituisce i risultati in una colonna denominata 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 in base al calendario comune. Ad esempio, poiché il calendario comune inizia dall'anno 1, il primo decennio (decennio 1) va da 0001-01-01 a 0009-12-31 e il secondo decennio (decennio 2) va da 0010-01-01 a 0019-12-31. Ad esempio, il decennio 201 va da 2000-01-01 a 2009-12-31:
```
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 MIL con inizio il primo giorno dell'anno *\$1001* e fine l'ultimo giorno dell'anno `#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
```