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à.
# Uso di SQL
**Topics**
+ [Convenzioni del riferimento SQL](c_SQL_reference_conventions.md)
+ [Elementi base](c_Basic_elements.md)
+ [Espressioni](r_expressions.md)
+ [Condizioni](r_conditions.md)
Il linguaggio SQL è composto da comandi e funzioni che usi per lavorare con database e oggetti di database. Il linguaggio applica anche regole relative all'uso di tipi di dati, espressioni e letterali.
# Convenzioni del riferimento SQL
Questa sezione descrive le convenzioni utilizzate per scrivere la sintassi per le funzioni, i comandi e le espressioni SQL descritte nella sezione del riferimento SQL.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/c_SQL_reference_conventions.html)
# Elementi base
**Topics**
+ [Nomi e identificatori](r_names.md)
+ [Valori letterali](r_Literals.md)
+ [Nulls](r_Nulls.md)
+ [Tipi di dati](c_Supported_data_types.md)
+ [Sequenze di regole di confronto](c_collation_sequences.md)
Questa sezione comprende le regole per lavorare con nomi oggetto di database, valori letterali, null e tipi di dati.
# Nomi e identificatori
I nomi identificano oggetti di database, comprese tabelle e colonne, nonché utenti e password. È possibile usare i termini *nome* e *identificatore* in modo intercambiabile. Ci sono due tipi di identificatori, gli identificatori standard e gli identificatori delimitati o racchiusi tra virgolette. È necessario che gli identificatori contengano solo caratteri stampabili UTF-8. Le lettere ASCII negli identificatori standard e delimitati fanno distinzione tra maiuscole e minuscole e sono scritte in minuscolo nel database. Nei risultati delle query, i nomi delle colonne vengono restituiti in lettere minuscole per impostazione predefinita. Per restituire i nomi delle colonne in lettere maiuscole, impostare il parametro di configurazione [describe\$1field\$1name\$1in\$1uppercase](r_describe_field_name_in_uppercase.md) su **true**.
## Identificatori standard
Gli identificatori SQL standard rispettano un insieme di regole ed è necessario che:
+ Inizino con un carattere alfabetico o di sottolineatura a byte singolo ASCII oppure con un carattere multibyte UTF-8 da due a quattro byte di lunghezza.
+ È possibile che i caratteri seguenti siano caratteri alfanumerici, di sottolineatura o segni di dollaro a byte singolo ASCII oppure caratteri multibyte UTF-8 da due a quattro byte di lunghezza.
+ Abbiano una lunghezza compresa tra 1 e 127 byte, senza comprendere le virgolette per gli identificatori delimitati.
+ Non contengano virgolette e spazi.
+ Non siano una parola chiave di SQL riservata.
## Identificatori delimitati
Gli identificatori delimitati (conosciuti anche come identificatori tra virgolette) iniziano e terminano con le virgolette doppie ("). Se vedi un identificatore delimitato, è necessario usare le virgolette doppie per ogni riferimento a quell'oggetto. L'identificatore può contenere qualsiasi carattere stampabile UTF-8 standard diverso dalle virgolette doppie. Pertanto, è possibile creare nomi di colonna o tabella che comprendono caratteri altrimenti non ammessi, come spazi o il simbolo di percentuale.
Le lettere ASCII negli identificatori delimitati fanno distinzione tra maiuscole e minuscole e sono scritte in minuscolo. Per usare una virgoletta doppia in una stringa, è necessario farla precedere da un altro carattere di virgoletta doppia.
## Identificatori con distinzione maiuscolo/minuscolo
Gli identificatori con distinzione tra maiuscole e minuscole (noti anche come identificatori misti) possono contenere lettere maiuscole e minuscole. Per utilizzare gli identificatori con distinzione tra maiuscole e minuscole, è possibile impostare la configurazione da `enable_case_sensitive_identifier` a `true`. È possibile impostare questa configurazione per il cluster o per una sessione. Per ulteriori informazioni, consulta [Valori di parametro predefiniti](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-parameter-groups.html#default-param-group-values) nella *Guida alla gestione di Amazon Redshift* e [enable\$1case\$1sensitive\$1identifier](r_enable_case_sensitive_identifier.md).
## Nomi di colonna di sistema
Non è possibile usare i seguenti i nomi delle colonne di sistema PostgreSQL come nomi delle colonne definite dall'utente. Per ulteriori informazioni, consulta [https://www.postgresql.org/docs/8.0/static/ddl-system-columns.html](https://www.postgresql.org/docs/8.0/static/ddl-system-columns.html).
+ `oid`
+ `tableoid`
+ `xmin`
+ `cmin`
+ `xmax`
+ `cmax`
+ `ctid`
## Esempi
Questa tabella mostra esempi di identificatori delimitati, l'output risultante e una discussione:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/r_names.html)
Per creare una tabella chiamata group con una colonna di nome this "is it":
```
create table "group" (
"This ""IS IT""" char(10));
```
Le seguenti query restituiscono lo stesso risultato:
```
select "This ""IS IT"""
from "group";
this "is it"
--------------
(0 rows)
```
```
select "this ""is it"""
from "group";
this "is it"
--------------
(0 rows)
```
Anche la seguente sintassi `table.column` completa restituisce lo stesso risultato:
```
select "group"."this ""is it"""
from "group";
this "is it"
--------------
(0 rows)
```
Il seguente comando CREATE TABLE crea una tabella con una barra nel nome di una colonna:
```
create table if not exists city_slash_id(
"city/id" integer not null,
state char(2) not null);
```
# Valori letterali
Un valore letterale o una costante è un valore di dati fisso, composto da una sequenza di caratteri o da una costante numerica. Amazon Redshift supporta diversi tipi di letterali, tra cui:
+ Valori letterali per numeri interi, decimali e in virgola mobile. Per ulteriori informazioni, consultare [Valori letterali interi e in virgola mobile](r_numeric_literals201.md).
+ Valori letterali carattere, definiti anche come stringe, stringhe di caratteri o costanti di caratteri
+ Valori letterali di intervallo e datetime, usati con i tipi di dati datetime. Per ulteriori informazioni, consultare [Valori letterali di data, ora e timestamp](r_Date_and_time_literals.md) e [Tipi di dati e valori letterali relativi agli intervalli](r_interval_data_types.md).
# Nulls
Se una colonna in una riga è mancante, sconosciuta o non applicabile, è un valore null o viene detta contenere un valore null. I valori null possono comparire nei campi di qualsiasi tipo di dati non limitati da una chiave primaria o da vincoli NOT NULL. Un valore null non equivale al valore zero o a una stringa vuota.
Qualsiasi espressione aritmetica contenente un valore null viene sempre valutata come valore null. Tutti gli operatori restituiscono un valore null quando viene fornito loro un operando o un argomento null.
Per testare valori null, usa le condizioni di confronto IS NULL e IS NOT NULL. Dato che un valore null rappresenta una mancanza di dati, un valore null non è uguale o disuguale a nessun valore o a un altro valore null.
# Tipi di dati
**Topics**
+ [Caratteri multibyte](#c_Supported_data_types-multi-byte-characters)
+ [Tipi numerici](r_Numeric_types201.md)
+ [Tipi di carattere](r_Character_types.md)
+ [Tipi datetime](r_Datetime_types.md)
+ [Tipo booleano](r_Boolean_type.md)
+ [Tipo HLLSKETCH](r_HLLSKTECH_type.md)
+ [Tipo SUPER](r_SUPER_type.md)
+ [Tipo VARBYTE](r_VARBYTE_type.md)
+ [Conversione e compatibilità dei tipi](#r_Type_conversion)
Ciascun valore che Amazon Redshift memorizza o recupera ha un tipo di dati con un set fisso di proprietà associate. I tipi di dati vengono dichiarati al momento della creazione delle tabelle. Un tipo di dati limita il set di valori che un argomento o una colonna può contenere.
Nella tabella seguente sono elencati i tipi di dati che è possibile usare nelle tabelle di Amazon Redshift.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/c_Supported_data_types.html)
**Nota**
Per informazioni sui tipi di dati non supportati, come “char” (da notare che char è racchiuso tra virgolette), consultare [Tipi di dati PostgreSQL non supportati](c_unsupported-postgresql-datatypes.md).
## Caratteri multibyte
Il tipo di dati VARCHAR supporta caratteri multibyte UTF-8 fino a un massimo di quattro byte. I caratteri a cinque byte o più non sono supportati. Per calcolare la dimensione di una colonna VARCHAR che contiene caratteri multibyte, moltiplica il numero di caratteri per il numero di byte per carattere. Ad esempio, se una stringa ha quattro caratteri cinesi e ciascun carattere è lungo tre byte, allora avrai bisogno di una colonna VARCHAR(12) per memorizzare la stringa.
Il tipo di dati VARCHAR non supporta i punti di codice UTF-8 non validi seguenti:
`0xD800 – 0xDFFF` (Sequenze di byte: `ED A0 80` – `ED BF BF`)
Il tipo di dati CHAR non supporta caratteri multibyte.
# Tipi numerici
**Topics**
+ [Tipi Integer](#r_Numeric_types201-integer-types)
+ [Tipo DECIMAL o NUMERIC](#r_Numeric_types201-decimal-or-numeric-type)
+ [Note sull'utilizzo di colonne NUMERIC o DECIMAL a 128 bit](#r_Numeric_types201-notes-about-using-128-bit-decimal-or-numeric-columns)
+ [Tipi in virgola mobile](#r_Numeric_types201-floating-point-types)
+ [Calcoli con valori numerici](r_numeric_computations201.md)
+ [Valori letterali interi e in virgola mobile](r_numeric_literals201.md)
+ [Esempi con tipi numerici](r_Examples_with_numeric_types201.md)
I tipi di dati numerici comprendono numeri interi, decimali e in virgola mobile.
## Tipi Integer
Usa i tipi di dati SMALLINT, INTEGER e BIGINT per memorizzare numeri interi di intervalli diversi. Non è possibile salvare valori non compresi nell'intervallo consentito per ciascun tipo.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/r_Numeric_types201.html)
## Tipo DECIMAL o NUMERIC
Usare il tipo di dati DECIMAL o NUMERIC per memorizzare i valori con una *precisione definita dall'utente*. Le parole chiave DECIMAL e NUMERIC sono interscambiabili. In questo documento, *decimale* è il termine preferito per questo tipo di dati. Il termine *numerici* è usato solitamente per riferirsi a tipi di dati interi, decimali e in virgola mobile.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/r_Numeric_types201.html)
Definisci una colonna DECIMAL in una tabella specificando *precisione* e *scala*:
```
decimal(precision, scale)
```
*precisione*
Il numero totale di cifre significative nell'intero valore: il numero di cifre su entrambi i lati del punto decimale. Ad esempio, il numero `48.2891` ha una precisione di 6 e una scala di 4. La precisione predefinita, se non specificata, è 18. La precisione massima è 38.
Se il numero di cifre alla sinistra del punto decimale in un valore input supera la precisione della colonna meno la sua scala, non è possibile copiare il valore nella colonna (o inserito o aggiornato). Questa regola si applica a qualsiasi valore che non rientra nell'intervallo della definizione della colonna. Ad esempio, gli intervalli di valori ammessi per una colonna `numeric(5,2)` è da `-999.99` a `999.99`.
*scale*
Il numero di cifre decimale nella parte frazionaria del valore, alla destra del punto decimale. Gli interi hanno una scala di zero. Nella specifica di una colonna, è necessario che il valore della scala sia inferiore o uguale al valore della precisione. La scala predefinita, se non specificata, è 0. La scala massima è 37.
Se la scala di un valore input caricato in una tabella è maggiore della scala della colonna, il valore viene arrotondato alla scala specificata. Ad esempio, la colonna PRICEPAID nella tabella SALES è una colonna DECIMAL(8,2). Se un valore DECIMAL(8,4) viene inserito nella colonna PRICEPAID, il valore viene arrotondato alla scala di 2.
```
insert into sales
values (0, 8, 1, 1, 2000, 14, 5, 4323.8951, 11.00, null);
select pricepaid, salesid from sales where salesid=0;
pricepaid | salesid
-----------+---------
4323.90 | 0
(1 row)
```
Tuttavia, i risultati di espliciti cast di valori selezionati dalle tabelle non sono arrotondati.
**Nota**
Il valore positivo massimo che è possibile inserire in una colonna DECIMAL(19,0) è `9223372036854775807` (263 -1). Il valore negativo massimo è `-9223372036854775808`. Ad esempio, il tentativo di inserire il valore `9999999999999999999` (19 nove) causerà un errore dell'overflow. Indipendentemente dalla posizione del punto decimale, la stringa più grande che Amazon Redshift può rappresentare come numero DECIMAL è `9223372036854775807`. Ad esempio, il valore più grande che è possibile caricare in una colonna DECIMAL(19,18) è `9.223372036854775807`.
Queste regole sono dovute al fatto che i valori di tipo DECIMAL con 19 o meno cifre di precisione significative vengono archiviati internamente come numeri interi a 8 byte, mentre i valori di tipo DECIMAL con 20-38 cifre di precisione significative vengono archiviati come numeri interi a 16 byte.
## Note sull'utilizzo di colonne NUMERIC o DECIMAL a 128 bit
Non assegnare in modo arbitrario la precisione massima alle colonne DECIMAL a meno che non sia certo che l'applicazione richieda tale precisione. I valori a 128 bit usano il doppio dello spazio su disco rispetto ai valori a 64 bit e possono quindi rallentare il tempo di esecuzione delle query.
## Tipi in virgola mobile
Usa i tipi di dati REAL e DOUBLE PRECISION per memorizzare valori numerici con *precisione variabile*. Questi tipi sono *inesatti*, il che significa che alcuni valori vengono memorizzati come approssimazioni, così che la memorizzazione e la restituzione di un valore specifico possono risultare in lievi discrepanze. Se hai bisogno di calcoli e storage precisi (come per importi monetari), usa il tipo di dati DECIMAL.
REAL rappresenta il formato a virgola mobile a precisione singola, secondo lo standard IEEE 754 per l'aritmetica binaria a virgola mobile. Ha una precisione di circa 6 cifre e un intervallo compreso tra 1E-37 e 1E\$137. È inoltre possibile specificare questo tipo di dati come FLOAT4.
DOUBLE PRECISION rappresenta il formato a virgola mobile a precisione doppia, secondo lo standard IEEE 754 per l'aritmetica binaria a virgola mobile. Ha una precisione di circa 15 cifre e un intervallo compreso tra 1E-307 e 1E\$1308. È inoltre possibile specificare questo tipo di dati come FLOAT o FLOAT8.
Oltre ai valori numerici ordinari, i tipi a virgola mobile hanno diversi valori speciali. Usa le virgolette singole per racchiudere questi valori quando li usi in un'istruzione SQL:
+ `NaN` – not-a-number
+ `Infinity`: infinito
+ `-Infinity`: infinito negativo
Ad esempio, per inserire not-a-number nella colonna `day_charge` della tabella, `customer_activity` esegui il seguente codice SQL:
```
insert into customer_activity(day_charge) values('NaN');
```
# Calcoli con valori numerici
In questo contesto, *calcolo* si riferisce a operazioni matematiche binarie: addizione, sottrazione, moltiplicazione e divisione. Questa sezione descrive i tipi restituiti previsti per queste operazioni, nonché la formula specifica che viene applicata per determinare la precisione e la scala quando sono coinvolti tipi di dati DECIMAL.
Quando valori numerici vengono calcolati durante l'elaborazione di query, potresti affrontare casi in cui il calcolo è impossibile e la query restituisce un errore dell'overflow numerico. Potresti anche riscontrare casi in cui la scala di valori calcolati varia o è imprevista. Per alcune operazioni, per risolvere questi problemi, è possibile usare il casting esplicito (promozione del tipo) o i parametri di configurazione di Amazon Redshift.
Per informazioni sui risultati di calcoli simili con funzioni SQL, consultare [Funzioni di aggregazione](c_Aggregate_Functions.md).
## Tipi restituiti per i calcoli
Dato il set di tipi di dati numerici supportato in Amazon Redshift, la tabella seguente mostra i tipi restituiti previsti per operazioni di addizione, sottrazione, moltiplicazione e divisione. La prima colonna sul lato sinistro della tabella rappresenta il primo operando nel calcolo e la riga in alto rappresenta il secondo operando.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/r_numeric_computations201.html)
## Precisione e scala di risultati DECIMAL calcolati
La tabella seguente riassume le regole per la scala e la precisione risultanti dal calcolo quando operazioni matematiche restituiscono risultati DECIMAL. In questa tabella, `p1` e `s1` rappresentano la precisione e la scala del primo operando in un calcolo e `p2` e `s2` rappresentano la precisione e la scala del secondo operando. (Indipendentemente da questi calcoli, la precisione del risultato massima è 38 e la scala del risultato massima è 38.)
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/r_numeric_computations201.html)
Ad esempio, le colonne PRICEPAID e COMMISSION nella tabella SALES sono entrambe colonne DECIMAL(8,2). Se dividi PRICEPAID per COMMISSION (o viceversa), la formula è applicata come segue:
```
Precision = 8-2 + 2 + max(4,2+8-2+1)
= 6 + 2 + 9 = 17
Scale = max(4,2+8-2+1) = 9
Result = DECIMAL(17,9)
```
Il calcolo seguente è la regola generale per il calcolo della scala e della precisione risultanti per le operazioni eseguite su valori DECIMAL con operatori impostati come UNION, INTERSECT ed EXCEPT o funzioni come COALESCE e DECODE:
```
Scale = max(s1,s2)
Precision = min(max(p1-s1,p2-s2)+scale,19)
```
Ad esempio, una DEC1 tabella con una colonna DECIMAL (7,2) viene unita a una DEC2 tabella con una colonna DECIMAL (15,3) per creare una tabella. DEC3 Lo schema di DEC3 mostra che la colonna diventa una colonna NUMERIC (15,3).
```
create table dec3 as select * from dec1 union select * from dec2;
```
Risultato
```
select "column", type, encoding, distkey, sortkey
from pg_table_def where tablename = 'dec3';
column | type | encoding | distkey | sortkey
-------+---------------+----------+---------+---------
c1 | numeric(15,3) | none | f | 0
```
Nell'esempio sopra, la formula è applicata come segue:
```
Precision = min(max(7-2,15-3) + max(2,3), 19)
= 12 + 3 = 15
Scale = max(2,3) = 3
Result = DECIMAL(15,3)
```
## Note sulle operazioni di divisione
Per le operazioni di divisione, le divide-by-zero condizioni restituiscono errori.
Il limite di scala di 100 è applicato dopo aver calcolato la precisione e la scala. Se la scala del risultato calcolata è maggiore di 100, i risultati della divisione vengono scalati come segue:
+ Precisione = ` precision - (scale - max_scale)`
+ Dimensionare = ` max_scale `
Se la precisione calcolata supera la precisione massima (38), la precisione viene ridotta a 38 e la scala diventa il risultato di: `max((38 + scale - precision), min(4, 100))`
## Condizioni di overflow
L'overflow viene controllato per tutti i calcoli numerici. I dati DECIMAL con una precisione di 19 o inferiore vengono memorizzati come interi a 64 bit. I dati DECIMAL con una precisione superiore a 19 vengono memorizzati come interi a 128 bit. La precisione massima per tutti i valori DECIMAL è 38 e la scala massima è 37. Gli errori dell'overflow si verificano quando un valore supera questi limiti, che si applicano agli insiemi dei risultati finali e intermedi:
+ Il casting esplicito risulta in errori dell'overflow runtime quando valori di dati specifici non rientrano nella scala o nella precisione richiesta specificata dalla funzione cast. Ad esempio, non è possibile eseguire il cast di tutti i valori dalla colonna PRICEPAID nella tabella SALES (una colonna DECIMAL(8,2)) e restituire un risultato DECIMAL(7,3):
```
select pricepaid::decimal(7,3) from sales;
ERROR: Numeric data overflow (result precision)
```
Questo errore si verifica perché non è possibile eseguire il cast di *alcuni* dei valori più grandi nella colonna PRICEPAID.
+ Le operazioni di moltiplicazione producono risultati in cui la scala del risultato è la somma della scala di ciascun operando. Se entrambi gli operando hanno una scala di 4, ad esempio, la scala del risultato è 8, lasciando solo 10 cifre per il lato sinistro del punto decimale. Pertanto, è relativamente facile incorrere in condizioni di overflow quando si moltiplicano due grandi numeri che possiedono entrambi una scala significativa.
Il seguente codice restituisce un errore di overflow.
```
SELECT CAST(1 AS DECIMAL(38, 20)) * CAST(10 AS DECIMAL(38, 20));
ERROR: 128 bit numeric data overflow (multiplication)
```
Puoi risolvere l'errore di overflow utilizzando la divisione anziché la moltiplicazione. Utilizza l'esempio seguente per dividere per 1 diviso per il divisore originale.
```
SELECT CAST(1 AS DECIMAL(38, 20)) / (1 / CAST(10 AS DECIMAL(38, 20)));
+----------+
| ?column? |
+----------+
| 10 |
+----------+
```
## Calcoli numerici con tipi INTEGER e DECIMAL
Quando uno degli operandi in un calcolo ha un tipo di dati INTEGER e l'altro operando è DECIMAL, viene implicitamente eseguito il cast dell'operando INTEGER a DECIMAL:
+ INT2 (SMALLINT) viene espresso come DECIMAL (5,0)
+ INT4 (INTEGER) viene espresso come DECIMAL (10,0)
+ INT8 (BIGINT) viene espresso come DECIMAL (19,0)
Ad esempio, se moltiplichi SALES.COMMISSION, una colonna DECIMAL(8,2), e SALES.QTYSOLD, una colonna SMALLINT, per questo calcolo viene eseguito il cast come segue:
```
DECIMAL(8,2) * DECIMAL(5,0)
```
# Valori letterali interi e in virgola mobile
I valori letterali o le costanti che rappresentano numeri possono essere interi o in virgola mobile.
## Valori letterali interi
Una costante intera è una sequenza delle cifre 0-9, con un segno positivo (\$1) o negativo (-) opzionale che le precede.
## Sintassi
```
[ + | - ] digit ...
```
## Esempi
I valori letterali interi includono i seguenti:
```
23
-555
+17
```
## Valori letterali in virgola mobile
I valori letterali in virgola mobile (definiti anche valori letterali decimali, numerici o frazionali) sono sequenze di cifre che possono comprendere un punto decimale e, opzionalmente, il segno dell'esponente (e).
## Sintassi
```
[ + | - ] digit ... [ . ] [ digit ...]
[ e | E [ + | - ] digit ... ]
```
## Arguments (Argomenti)
e \$1 E
e o E indica che il numero è specificato in notazione scientifica.
## Esempi
I valori letterali in virgola mobile validi includono i seguenti:
```
3.14159
-37.
2.0e19
-2E-19
```
# Esempi con tipi numerici
## Istruzione CREATE TABLE
La seguente istruzione CREATE TABLE dimostra la dichiarazione di diversi tipi di dati numerici:
```
create table film (
film_id integer,
language_id smallint,
original_language_id smallint,
rental_duration smallint default 3,
rental_rate numeric(4,2) default 4.99,
length smallint,
replacement_cost real default 25.00);
```
## Tentativo di inserire un intero che non rientra nell'intervallo
L'esempio seguente tenta di inserire il valore 33.000 in una colonna SMALLINT.
```
insert into film(language_id) values(33000);
```
L'intervallo per SMALLINT è da -32.768 a \$132.767, quindi Amazon Redshift restituisce un errore.
```
An error occurred when executing the SQL command:
insert into film(language_id) values(33000)
ERROR: smallint out of range [SQL State=22003]
```
## Inserimento di un valore decimale in una colonna intera
L'esempio seguente inserisce il valore decimale in una colonna INT.
```
insert into film(language_id) values(1.5);
```
Questo valore viene inserito ma arrotondato al valore intero 2.
## Inserimento di un decimale che ha esito positivo perché la sua scala viene arrotondata
L'esempio seguente inserisce un valore decimale che ha una precisione maggiore rispetto alla colonna.
```
insert into film(rental_rate) values(35.512);
```
In questo caso, il valore `35.51` viene inserito nella colonna.
## Tentativo di inserire un valore decimale che non rientra nell'intervallo
In questo caso, il valore `350.10` non rientra nell'intervallo. Il numero di cifre per i valori nelle colonne DECIMAL è uguale alla precisione della colonna meno la sua scala (4 meno 2 per la colonna RENTAL\$1RATE). In altre parole, l'intervallo consentito per una colonna `DECIMAL(4,2)` va da `-99.99` a `99.99`.
```
insert into film(rental_rate) values (350.10);
ERROR: numeric field overflow
DETAIL: The absolute value is greater than or equal to 10^2 for field with precision 4, scale 2.
```
## Inserimento di valori a precisione variabile in una colonna REAL
L'esempio seguente inserisce valori a precisione variabile in una colonna REAL.
```
insert into film(replacement_cost) values(1999999.99);
insert into film(replacement_cost) values(1999.99);
select replacement_cost from film;
+------------------+
| replacement_cost |
+------------------+
| 2000000 |
| 1999.99 |
+------------------+
```
Il valore `1999999.99` viene convertito in `2000000` per soddisfare il requisito di precisione della colonna `REAL`. Il valore `1999.99` viene caricato così com'è.
# Tipi di carattere
**Topics**
+ [Storage e intervalli](#r_Character_types-storage-and-ranges)
+ [CHAR o CHARACTER](#r_Character_types-char-or-character)
+ [VARCHAR o CHARACTER VARYING](#r_Character_types-varchar-or-character-varying)
+ [Tipi NCHAR e NVARCHAR](#r_Character_types-nchar-and-nvarchar-types)
+ [Tipi TEXT e BPCHAR](#r_Character_types-text-and-bpchar-types)
+ [Significato degli spazi finali](#r_Character_types-significance-of-trailing-blanks)
+ [Esempi con tipi di caratteri](r_Examples_with_character_types.md)
I tipi di dati carattere comprendono CHAR (carattere) e VARCHAR (carattere variabile).
## Storage e intervalli
I tipi di dati CHAR e VARCHAR sono definiti in termini di byte, non caratteri. Una colonna CHAR può contenere solo caratteri a byte singolo, quindi una colonna CHAR(10) può contenere una stringa con una lunghezza massima di 10 byte. Una VARCHAR può contenere caratteri multibyte fino a un massimo di quattro byte per carattere. Ad esempio, una colonna VARCHAR(12) può contenere 12 caratteri a byte singolo, 6 caratteri a due byte, 4 caratteri a tre byte o 3 caratteri a quattro byte.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/r_Character_types.html)
**Nota**
La sintassi CREATE TABLE supporta la parola chiave MAX per i tipi di dati carattere. Esempio:
```
create table test(col1 varchar(max));
```
Per CHAR, MAX definisce la larghezza della colonna come 4096 byte.
Per VARCHAR, MAX definisce la larghezza della colonna come 65.535 byte nelle istruzioni CREATE TABLE. Per le operazioni in memoria, VARCHAR (MAX) supporta fino a 16.000.000 di byte.
## CHAR o CHARACTER
Usa una colonna CHAR o CHARACTER per memorizzare stringhe di lunghezza fissa. A queste stringhe vengono aggiunti spazi, quindi una colonna CHAR(10) occupa 10 byte di storage.
```
char(10)
```
Una colonna CHAR senza una specificazione di lunghezza risulta in una colonna CHAR(1).
## VARCHAR o CHARACTER VARYING
Usa una colonna VARCHAR o CHARACTER VARYING per memorizzare stringhe di lunghezza variabile con un limite fisso. A queste stringhe non vengono aggiunti spazi vuoti, quindi una colonna VARCHAR(120) consiste di un massimo di 120 caratteri a byte singolo, 60 caratteri a due byte, 40 caratteri a tre byte o 30 caratteri a quattro byte.
```
varchar(120)
```
Se si utilizza il tipo di dati VARCHAR senza specificare la lunghezza in un'istruzione CREATE TABLE, la lunghezza predefinita è 256.
[Funzioni stringa](String_functions_header.md)ora supporta fino a 16.000.000 di byte. Ad esempio, l'output della funzione CONCAT era precedentemente limitato a 65535 byte, ma ora supporta fino a 16.000.000 di byte.
```
SELECT LEN(CONCAT(REPEAT('A', 5000000), REPEAT('B', 5000000))) AS total_length;
total_length
--------------
10000000
```
## Tipi NCHAR e NVARCHAR
È possibile creare colonne con i tipi NCHAR e NVARCHAR (noti anche come tipi NATIONAL CHARACTER e NATIONAL CHARACTER VARYING). Questi tipi vengono convertiti in tipi CHAR e VARCHAR e vengono memorizzati nel numero di byte specificato.
Una colonna NCHAR senza una specificazione di lunghezza viene convertita in una colonna CHAR(1).
Una colonna NVARCHAR senza una specificazione di lunghezza viene convertita in una colonna VARCHAR(256).
## Tipi TEXT e BPCHAR
È possibile creare una tabella Amazon Redshift con una colonna TEXT ma viene convertita in una colonna VARCHAR(256) che accetta valori di lunghezza variabile con un massimo di 256 caratteri.
È possibile creare una colonna Amazon Redshift con un tipo BPCHAR (caratteri con spazi aggiunti), che Amazon Redshift converte in una colonna CHAR(256) di lunghezza fissa.
## Significato degli spazi finali
Entrambi i tipi di dati CHAR e VARCHAR memorizzano stringhe fino a *n* byte di lunghezza. Un tentativo di memorizzare una stringa più lunga in una colonna di questi tipi risulta in un errore, a meno che i caratteri extra non siano tutti spazi (vuoti); in questo caso la stringa viene troncata alla lunghezza massima. Se la stringa è più corta della lunghezza massima, ai valori CHAR vengono aggiunti spazi, ma i valori VARCHAR memorizzano la stringa senza spazi.
Gli spazi inziali nei valori CHAR sono sempre privi di significato dal punto di vista semantico. Vengono ignorati quando confronti due valori CHAR, non compresi nei calcoli LENGTH, e rimossi quando converti un valore CHAR in un altro tipo di stringa.
Gli spazi finali nei valori VARCHAR e CHAR vengono trattati come insignificanti dal punto di vista semantico quando i valori vengono confrontati.
I calcoli della lunghezza restituiscono la lunghezza delle stringhe di caratteri VARCHAR con spazi finali compresi nella lunghezza. Gli spazi finali non vengono contati nella lunghezza per le stringhe di caratteri a lunghezza fissa.
# Esempi con tipi di caratteri
## Istruzione CREATE TABLE
La seguente istruzione CREATE TABLE dimostra l'uso dei tipi di dati VARCHAR e CHAR:
```
create table address(
address_id integer,
address1 varchar(100),
address2 varchar(50),
district varchar(20),
city_name char(20),
state char(2),
postal_code char(5)
);
```
Gli esempi seguenti usano questa tabella.
## Spazi finali in stringhe di caratteri a lunghezza variabile
Poiché ADDRESS1 è una colonna VARCHAR, gli spazi vuoti finali nel secondo indirizzo inserito sono semanticamente insignificanti. In altre parole, questi due indirizzi inseriti *corrispondono*.
```
insert into address(address1) values('9516 Magnolia Boulevard');
insert into address(address1) values('9516 Magnolia Boulevard ');
```
```
select count(*) from address
where address1='9516 Magnolia Boulevard';
count
-------
2
(1 row)
```
Se la ADDRESS1 colonna fosse una colonna CHAR e fossero inseriti gli stessi valori, la query COUNT (\$1) riconoscerebbe le stringhe di caratteri come uguali e restituirebbe. `2`
## Risultati della funzione LENGTH
La funzione LENGTH riconosce gli spazi finali nelle colonne VARCHAR:
```
select length(address1) from address;
length
--------
23
25
(2 rows)
```
Un valore di `Augusta` nella colonna CITY\$1NAME, che è una colonna CHAR, restituirebbe sempre una lunghezza di 7 caratteri, indipendentemente da qualsiasi spazio finale nella stringa input.
## Valori che superano la lunghezza della colonna
Le stringhe di caratteri non vengono troncate per rientrare nella larghezza della colonna dichiarata:
```
insert into address(city_name) values('City of South San Francisco');
ERROR: value too long for type character(20)
```
Per ovviare a questo problema puoi eseguire il cast del valore alla dimensione della colonna:
```
insert into address(city_name)
values('City of South San Francisco'::char(20));
```
In questo caso, i primi 20 caratteri della stringa (`City of South San Fr`) verrebbero caricati nella colonna.
# Tipi datetime
**Topics**
+ [Storage e intervalli](#r_Datetime_types-storage-and-ranges)
+ [DATE](#r_Datetime_types-date)
+ [TIME](#r_Datetime_types-time)
+ [TIMETZ](#r_Datetime_types-timetz)
+ [TIMESTAMP](#r_Datetime_types-timestamp)
+ [TIMESTAMPTZ](#r_Datetime_types-timestamptz)
+ [Esempi con tipi datetime](r_Examples_with_datetime_types.md)
+ [Valori letterali di data, ora e timestamp](r_Date_and_time_literals.md)
+ [Tipi di dati e valori letterali relativi agli intervalli](r_interval_data_types.md)
I tipi di dati datetime comprendono DATE, TIME, TIMETZ, TIMESTAMP e TIMESTAMPTZ.
## Storage e intervalli
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/r_Datetime_types.html)
## DATE
Utilizzare il tipo di dati DATE per memorizzare semplici date di calendario senza timestamp.
## TIME
TIME è un alias di TIME WITHOUT TIME ZONE.
Utilizzare il tipo di dati TIME per memorizzare l'ora del giorno.
Le colonne TIME memorizzano valori con un massimo di 6 cifre di precisione per frazioni di secondo.
Per impostazione predefinita, i valori TIME sono in formato UTC sia nelle tabelle dell'utente sia nelle tabelle di sistema di Amazon Redshift.
## TIMETZ
TIMETZ è un alias di TIME WITH TIME ZONE.
Utilizzare il tipo di dati TIMETZ per memorizzare l'ora del giorno con un fuso orario.
Le colonne TIMETZ memorizzano valori con un massimo di 6 cifre di precisione per frazioni di secondo.
Per impostazione predefinita, i valori TIMETZ sono UTC sia nelle tabelle dell'utente sia nelle tabelle di sistema Amazon Redshift.
## TIMESTAMP
TIMESTAMP è un alias di TIMESTAMP WITHOUT TIME ZONE.
Utilizzare il tipo di dati TIMESTAMP per memorizzare valori timestamp completi che comprendono la data e l'ora del giorno.
Le colonne TIMESTAMP memorizzano valori fino a un massimo di 6 cifre di precisione per frazioni di secondo.
Se si inserisce una data in una colonna TIMESTAMP o una data con un valore timestamp parziale, il valore viene implicitamente convertito in un valore timestamp completo. Questo valore timestamp completo ha valori predefiniti (00) per le ore, i minuti e i secondi mancanti. I valori di fuso orario nelle stringhe input vengono ignorati.
Per impostazione predefinita, i valori TIMESTAMP sono UTC sia nelle tabelle dell'utente sia nelle tabelle di sistema Amazon Redshift.
## TIMESTAMPTZ
TIMESTAMPTZ è un alias di TIMESTAMP WITH TIME ZONE.
Utilizzare il tipo di dati TIMESTAMPTZ per immettere valori timestamp completi che comprendono la data, l'ora del giorno e il fuso orario. Quando un valore di input include un fuso orario, Amazon Redshift usa il fuso orario per convertire il valore in formato UTC e memorizza il valore UTC.
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();
```
È possibile trovare informazioni attuali sui fusi orari anche nel [database dei fusi orari IANA](https://www.iana.org/time-zones).
La tabella seguente fornisce esempi di formati di fusi orari.
| Formato | Esempio |
| --- | --- |
| gg mmm hh:mi:ss aaaa tz | 17 Dic 07:37:16 1997 PST |
| mm/dd/yyyyhh:mi:ss.ss tz | 12/17/1997 07:37:16.00 PST |
| mm/dd/yyyyhh:mi:ss.ss tz | 12/17/1997 07:37:16.00 US/Pacific |
| yyyy-mm-dd hh:mi:ss\$1/-tz | 1997-12-17 07:37:16-08 |
| dd.mm.yyyy hh:mi:ss tz | 17.12.1997 07:37:16.00 PST |
Le colonne TIMESTAMPTZ memorizzano valori fino a un massimo di 6 cifre di precisione per frazioni di secondo.
Se si inserisce una data in una colonna TIMESTAMPTZ o una data con un valore timestamp parziale, il valore viene implicitamente convertito in un valore timestamp completo. Questo valore timestamp completo ha valori predefiniti (00) per le ore, i minuti e i secondi mancanti.
I valori TIMESTAMPTZ sono in formato UTC nelle tabelle utente.
# Esempi con tipi datetime
Di seguito sono riportati degli esempi per lavorare con tipi datetime supportati da Amazon Redshift.
## Esempi di data
Nei seguenti esempi vengono inserite date con formati diversi e viene visualizzato il risultato.
```
create table datetable (start_date date, end_date date);
```
```
insert into datetable values ('2008-06-01','2008-12-31');
insert into datetable values ('Jun 1,2008','20081231');
```
```
select * from datetable order by 1;
start_date | end_date
-----------------------
2008-06-01 | 2008-12-31
2008-06-01 | 2008-12-31
```
Se si inserisce un valore timestamp in una colonna DATE, la parte dell'ora viene ignorata e viene caricata solo la data.
## Esempi di orari
Negli esempi seguenti vengono inseriti valori TIME e TIMETZ con formati diversi e viene visualizzato il risultato.
```
create table timetable (start_time time, end_time timetz);
```
```
insert into timetable values ('19:11:19','20:41:19 UTC');
insert into timetable values ('191119', '204119 UTC');
```
```
select * from timetable order by 1;
start_time | end_time
------------------------
19:11:19 | 20:41:19+00
19:11:19 | 20:41:19+00
```
## Esempi timestamp
Se inserisci una data in una colonna TIMESTAMP o TIMESTAMPTZ, l'ora diventa mezzanotte per impostazione predefinita. Ad esempio, se inserisci il valore letterale `20081231`, il valore memorizzato è `2008-12-31 00:00:00`.
Per modificare il fuso orario per la sessione corrente, usa il comando [SET](r_SET.md) per impostare il parametro di configurazione [timezone](r_timezone_config.md).
L'esempio seguente inserisce i timestamp con formati diversi e visualizza la tabella risultante.
```
create table tstamp(timeofday timestamp, timeofdaytz timestamptz);
insert into tstamp values('Jun 1,2008 09:59:59', 'Jun 1,2008 09:59:59 EST' );
insert into tstamp values('Dec 31,2008 18:20','Dec 31,2008 18:20');
insert into tstamp values('Jun 1,2008 09:59:59 EST', 'Jun 1,2008 09:59:59');
SELECT * FROM tstamp;
+---------------------+------------------------+
| timeofday | timeofdaytz |
+---------------------+------------------------+
| 2008-06-01 09:59:59 | 2008-06-01 14:59:59+00 |
| 2008-12-31 18:20:00 | 2008-12-31 18:20:00+00 |
| 2008-06-01 09:59:59 | 2008-06-01 09:59:59+00 |
+---------------------+------------------------+
```
# Valori letterali di data, ora e timestamp
Individuare le regole per lavorare con valori letterali data, ora e timestamp supportati da Amazon Redshift.
## Date:
Le seguenti date di input sono tutti esempi validi di valori letterali di data per il tipo di data DATE che puoi caricare nelle tabelle di Amazon Redshift. Si assume che la modalità `MDY DateStyle` di default sia in vigore. Questa modalità indica che il valore del mese precede il valore del giorno in stringhe come `1999-01-08` e `01/02/00`.
**Nota**
È necessario che un valore letterale data o timestamp quando viene caricato in una tabella sia racchiuso tra virgolette.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/r_Date_and_time_literals.html)
## Volte
Le seguenti ore di input sono tutti esempi validi di valori letterali di ora per i tipi di dati TIME e TIMETZ che puoi caricare nelle tabelle di Amazon Redshift.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/r_Date_and_time_literals.html)
## Timestamp
I seguenti timestamp di input sono tutti esempi validi di valori letterali di ora per i tipi di dati TIMESTAMP e TIMESTAMPTZ che puoi caricare nelle tabelle di Amazon Redshift. È possibile combinare tutti i valori letterali di data validi con i seguenti valori letterali di ora.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/r_Date_and_time_literals.html)
## Valori datetime speciali
È possibile usare i valori speciali seguenti come valori letterali datetime e come argomenti per le funzioni della data. Richiedono virgolette singole e vengono convertiti in valori timestamp regolari durante l'elaborazione delle query.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/r_Date_and_time_literals.html)
I seguenti esempi mostrano come `now` e `today` lavorano insieme alla funzione DATEADD.
```
select dateadd(day,1,'today');
date_add
---------------------
2009-11-17 00:00:00
(1 row)
select dateadd(day,1,'now');
date_add
----------------------------
2009-11-17 10:45:32.021394
(1 row)
```
# Tipi di dati e valori letterali relativi agli intervalli
Puoi utilizzare un tipo di dati di intervallo per memorizzare le durate di tempo in unità quali `seconds`, `minutes`, `hours`, `days`, `months` e `years`. I tipi di dati e i valori letterali relativi agli intervalli possono essere utilizzati nei calcoli data/ora, ad esempio aggiungendo intervalli a date e timestamp, sommando gli intervalli e sottraendo un intervallo da una data o un timestamp. I valori letterali relativi agli intervalli possono essere utilizzati come valori per intervallare le colonne dei tipi di dati in una tabella.
## Sintassi del tipo di dati di intervallo
Come specificare un tipo di dati di intervallo per memorizzare una durata di tempo in anni e mesi:
```
INTERVAL year_to_month_qualifier
```
Come specificare un tipo di dati di intervallo per memorizzare una durata in giorni, ore, minuti e secondi:
```
INTERVAL day_to_second_qualifier [ (fractional_precision) ]
```
## Sintassi dell’intervallo letterale
Come specificare un intervallo letterale per definire una durata di tempo in anni e mesi:
```
INTERVAL quoted-string year_to_month_qualifier
```
Come specificare un intervallo letterale per definire una durata in giorni, ore, minuti e secondi:
```
INTERVAL quoted-string day_to_second_qualifier [ (fractional_precision) ]
```
## Arguments (Argomenti)
*quoted-string*
Specifica un valore numerico positivo o negativo che indica una quantità e l’unità data/ora come stringa di input. Se *quoted-string* contiene solo un valore numerico, Amazon Redshift determina le unità da *year\$1to\$1month\$1qualifier* o *day\$1to\$1second\$1qualifier*. Ad esempio, `'23' MONTH` rappresenta `1 year 11 months`, `'-2' DAY` rappresenta `-2 days 0 hours 0 minutes 0.0 seconds`, `'1-2' MONTH` rappresenta `1 year 2 months` e `'13 day 1 hour 1 minute 1.123 seconds' SECOND` rappresenta `13 days 1 hour 1 minute 1.123 seconds`. Per ulteriori informazioni sui formati di output di un intervallo, consulta [Stili di intervallo](#r_interval_data_types-interval-styles).
*year\$1to\$1month\$1qualifier*
Specifica l’intervallo di valori. Se utilizzi un qualificatore e crei un intervallo con unità di tempo più piccole del qualificatore, Amazon Redshift tronca e scarta le parti più piccole dell’intervallo. I valori validi per *year\$1to\$1month\$1qualifier* sono:
+ `YEAR`
+ `MONTH`
+ `YEAR TO MONTH`
*day\$1to\$1second\$1qualifier*
Specifica l’intervallo di valori. Se utilizzi un qualificatore e crei un intervallo con unità di tempo più piccole del qualificatore, Amazon Redshift tronca e scarta le parti più piccole dell’intervallo. I valori validi per *day\$1to\$1second\$1qualifier* sono:
+ `DAY`
+ `HOUR`
+ `MINUTE`
+ `SECOND`
+ `DAY TO HOUR`
+ `DAY TO MINUTE`
+ `DAY TO SECOND`
+ `HOUR TO MINUTE`
+ `HOUR TO SECOND`
+ `MINUTE TO SECOND`
L’output del valore letterale INTERVAL viene troncato in base al componente INTERVAL più piccolo specificato. Ad esempio, quando utilizzi un qualificatore MINUTE, Amazon Redshift elimina le unità di tempo inferiori a MINUTE.
```
select INTERVAL '1 day 1 hour 1 minute 1.123 seconds' MINUTE
```
Il valore risultante viene troncato in `'1 day 01:01:00'`.
*fractional\$1precision*
Parametro facoltativo che specifica il numero di cifre frazionarie consentite nell’intervallo. L’argomento *fractional\$1precision* deve essere specificato solo se l’intervallo contiene SECOND. Ad esempio, `SECOND(3)` crea un intervallo che prevede solo tre cifre frazionarie, ad esempio 1,234 secondi. Il numero massimo di cifre frazionarie è sei.
La configurazione della sessione `interval_forbid_composite_literals` determina se viene restituito un errore quando viene specificato un intervallo con le parti YEAR TO MONTH e DAY TO SECOND. Per ulteriori informazioni, consulta [interval\$1forbid\$1composite\$1literals](r_interval_forbid_composite_literals.md).
## Aritmetica dell’intervallo
Puoi utilizzare i valori di intervallo con altri valori di data e ora per eseguire operazioni aritmetiche. Le tabelle seguenti descrivono le operazioni disponibili e il tipo di dati risultante da ciascuna operazione.
**Nota**
Le operazioni che possono produrre entrambi i risultati `date` e `timestamp` lo fanno in base alla più piccola unità di tempo coinvolta nell’equazione. Ad esempio, quando aggiungi un valore `interval` a un valore `date`, il risultato è un valore `date`, se si tratta di un intervallo YEAR TO MONTH e un timestamp se si tratta di un intervallo DAY TO SECOND.
Le operazioni in cui il primo operando è un valore `interval` producono i seguenti risultati per il secondo operando specificato:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/r_interval_data_types.html)
Le operazioni in cui il primo operando è un `date` producono i seguenti risultati per il secondo operando specificato:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/r_interval_data_types.html)
Le operazioni in cui il primo operando è un `timestamp` producono i seguenti risultati per il secondo operando specificato:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/r_interval_data_types.html)
## Stili di intervallo
Puoi utilizzare il comando SQL [SET](r_SET.md) per modificare il formato di visualizzazione dell’output dei valori di intervallo. Quando utilizzi il tipo di dati di intervallo in SQL, trasmettilo in testo per visualizzare lo stile di intervallo previsto, ad esempio `YEAR TO MONTH::text`. I valori disponibili per IMPOSTARE il valore `IntervalStyle` sono:
+ `postgres`: segue lo stile PostgreSQL. Questa è l’impostazione predefinita.
+ `postgres_verbose`: segue lo stile verboso PostgreSQL.
+ `sql_standard`: segue lo stile dei valori letterali dell’intervallo standard SQL.
Il comando seguente imposta lo stile dell’intervallo su `sql_standard`.
```
SET IntervalStyle to 'sql_standard';
```
**formato di output postgres**
Di seguito è riportato il formato di output per lo stile di intervallo `postgres`. Ogni valore numerico può essere negativo.
```
' [, ...]'
```
```
select INTERVAL '1-2' YEAR TO MONTH::text
varchar
---------------
1 year 2 mons
```
```
select INTERVAL '1 2:3:4.5678' DAY TO SECOND::text
varchar
------------------
1 day 02:03:04.5678
```
**formato di output postgres\$1verbose**
La sintassi di postgres\$1verbose è simile a quella di postgres, ma gli output di postgres\$1verbose contengono anche l’unità di tempo.
```
'[@] [, ...] [direction]'
```
```
select INTERVAL '1-2' YEAR TO MONTH::text
varchar
-----------------
@ 1 year 2 mons
```
```
select INTERVAL '1 2:3:4.5678' DAY TO SECOND::text
varchar
---------------------------
@ 1 day 2 hours 3 mins 4.56 secs
```
**formato di output sql\$1standard**
I valori dell’intervallo da anno a mese sono formattati come segue. Se si specifica un segno negativo prima dell’intervallo, si indica che l’intervallo è un valore negativo e si applica all’intero intervallo.
```
'[-]yy-mm'
```
I valori dell’intervallo da giorno a secondo sono formattati come segue.
```
'[-]dd hh:mm:ss.ffffff'
```
```
SELECT INTERVAL '1-2' YEAR TO MONTH::text
varchar
-------
1-2
```
```
select INTERVAL '1 2:3:4.5678' DAY TO SECOND::text
varchar
---------------
1 2:03:04.5678
```
## Esempi di tipi di dati relativi agli intervalli
Negli esempi seguenti viene illustrato come utilizzare i tipi di dati INTERVAL con le tabelle.
```
create table sample_intervals (y2m interval month, h2m interval hour to minute);
insert into sample_intervals values (interval '20' month, interval '2 days 1:1:1.123456' day to second);
select y2m::text, h2m::text from sample_intervals;
y2m | h2m
---------------+-----------------
1 year 8 mons | 2 days 01:01:00
```
```
update sample_intervals set y2m = interval '2' year where y2m = interval '1-8' year to month;
select * from sample_intervals;
y2m | h2m
---------+-----------------
2 years | 2 days 01:01:00
```
```
delete from sample_intervals where h2m = interval '2 1:1:0' day to second;
select * from sample_intervals;
y2m | h2m
-----+-----
```
## Esempi di valori letterali relativi agli intervalli
Gli esempi seguenti vengono eseguiti con lo stile di intervallo impostato su `postgres`.
L’esempio seguente mostra come creare un valore letterale di INTERVAL di 1 anno.
```
select INTERVAL '1' YEAR
intervaly2m
---------------
1 years 0 mons
```
Se si specifica un argomento *quoted-string* che supera il qualificatore, le unità di tempo rimanenti vengono troncate dall’intervallo. Nell’esempio seguente, un intervallo di 13 mesi diventa 1 anno e 1 mese, ma il mese restante viene escluso a causa del qualificatore YEAR.
```
select INTERVAL '13 months' YEAR
intervaly2m
---------------
1 years 0 mons
```
Se utilizzi un qualificatore inferiore alla stringa di intervallo, vengono incluse le unità rimanenti.
```
select INTERVAL '13 months' MONTH
intervaly2m
---------------
1 years 1 mons
```
Se si specifica una precisione nell’intervallo, il numero di cifre frazionarie viene troncato in base alla precisione specificata.
```
select INTERVAL '1.234567' SECOND (3)
intervald2s
--------------------------------
0 days 0 hours 0 mins 1.235 secs
```
Se non specifichi una precisione, Amazon Redshift utilizza la precisione massima di 6.
```
select INTERVAL '1.23456789' SECOND
intervald2s
-----------------------------------
0 days 0 hours 0 mins 1.234567 secs
```
L’esempio seguente dimostra come creare un intervallo di valori.
```
select INTERVAL '2:2' MINUTE TO SECOND
intervald2s
------------------------------
0 days 0 hours 2 mins 2.0 secs
```
I qualificatori determinano le unità che specificate. Ad esempio, anche se nell’esempio seguente utilizzi lo stesso argomento *quoted-string* di '2:2' dell’esempio precedente, Amazon Redshift riconosce che usa unità di tempo diverse a causa del qualificatore.
```
select INTERVAL '2:2' HOUR TO MINUTE
intervald2s
------------------------------
0 days 2 hours 2 mins 0.0 secs
```
Sono supportati anche le abbreviazioni e i plurali di ciascuna unità. Ad esempio, `5s`, `5 second` e `5 seconds` sono intervalli equivalenti. Le unità supportate sono anni, mesi, ore, minuti e secondi.
```
select INTERVAL '5s' SECOND
intervald2s
------------------------------
0 days 0 hours 0 mins 5.0 secs
```
```
select INTERVAL '5 HOURS' HOUR
intervald2s
------------------------------
0 days 5 hours 0 mins 0.0 secs
```
```
select INTERVAL '5 h' HOUR
intervald2s
------------------------------
0 days 5 hours 0 mins 0.0 secs
```
# Esempi di valori letterali relativi agli intervalli senza sintassi dei qualificatori
**Nota**
Negli esempi seguenti viene illustrato l’utilizzo di un valore letterale relativo agli intervalli senza un qualificatore `YEAR TO MONTH` o `DAY TO SECOND`. Per informazioni sull’utilizzo del valore letterale relativo agli intervalli consigliato con un qualificatore, consulta [Tipi di dati e valori letterali relativi agli intervalli](r_interval_data_types.md).
Usa un valore letterale di intervallo per identificare periodi di tempo specifici, come `12 hours` o `6 months`. È possibile usare questi valori letterali di intervallo in condizioni e calcoli che comprendono espressioni datetime.
Un valore letterale relativo agli intervalli viene espresso come una combinazione della parola chiave INTERVAL con una quantità numerica e una parte di data supportata, ad esempio `INTERVAL '7 days'` o `INTERVAL '59 minutes'`. È possibile collegare diverse quantità e unità per formare un intervallo più preciso; ad esempio `INTERVAL '7 days, 3 hours, 59 minutes'`. Anche abbreviazioni e plurali di ciascuna unità sono supportati; ad esempio: `5 s`, `5 second` e `5 seconds` sono intervalli equivalenti.
Se non si specifica una parte data, il valore di intervallo rappresenterà i secondi. È possibile specificare il valore di quantità come una frazione (ad esempio: `0.5 days`).
Gli esempi seguenti mostrano una serie di calcoli con valori di intervallo diversi.
Quanto segue aggiunge 1 secondo alla data specificata.
```
select caldate + interval '1 second' as dateplus from date
where caldate='12-31-2008';
dateplus
---------------------
2008-12-31 00:00:01
(1 row)
```
Quanto segue aggiunge 1 minuto alla data specificata.
```
select caldate + interval '1 minute' as dateplus from date
where caldate='12-31-2008';
dateplus
---------------------
2008-12-31 00:01:00
(1 row)
```
Vengono aggiunte 3 ore e 35 minuti alla data specificata.
```
select caldate + interval '3 hours, 35 minutes' as dateplus from date
where caldate='12-31-2008';
dateplus
---------------------
2008-12-31 03:35:00
(1 row)
```
Quanto segue aggiunge 52 settimane alla data specificata.
```
select caldate + interval '52 weeks' as dateplus from date
where caldate='12-31-2008';
dateplus
---------------------
2009-12-30 00:00:00
(1 row)
```
Vengono aggiunti 1 settimana, 1 ora, 1 minuto e 1 secondo alla data specificata.
```
select caldate + interval '1w, 1h, 1m, 1s' as dateplus from date
where caldate='12-31-2008';
dateplus
---------------------
2009-01-07 01:01:01
(1 row)
```
Di seguito vengono aggiunte 12 ore (mezza giornata) alla data specificata.
```
select caldate + interval '0.5 days' as dateplus from date
where caldate='12-31-2008';
dateplus
---------------------
2008-12-31 12:00:00
(1 row)
```
Vengono sottratti 4 mesi dal 15 febbraio 2023 e il risultato è il 15 ottobre 2022.
```
select date '2023-02-15' - interval '4 months';
?column?
---------------------
2022-10-15 00:00:00
```
Vengono sottratti 4 mesi dal 31 marzo 2023 e il risultato è il 30 novembre 2022. Il calcolo considera il numero di giorni in un mese.
```
select date '2023-03-31' - interval '4 months';
?column?
---------------------
2022-11-30 00:00:00
```
# Tipo booleano
Usa valori di dati BOOLEAN per memorizzare valori true e false in una colonna a byte singolo. La tabella seguente descrive i tre possibili stati per un valore booleano e i valori letterali che risultano in quello stato. Indipendentemente dalla stringa di input, una colonna booleana memorizza e restituisce "t" per true e "f" per false.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/r_Boolean_type.html)
È possibile utilizzare un confronto IS per controllare il valore Boolean solo come predicato nella clausola WHERE. Non è possibile utilizzare un confronto IS con un valore Boolean nell'elenco SELECT.
## Esempi
È possibile usare una colonna BOOLEAN per memorizzare uno stato "Attivo/Inattivo" per ciascun cliente in una tabella CUSTOMER.
```
create table customer(
custid int,
active_flag boolean default true);
```
```
insert into customer values(100, default);
```
```
select * from customer;
custid | active_flag
-------+--------------
100 | t
```
Se non viene specificato alcun valore predefinito (`true` o `false`) nell'istruzione CREATE TABLE, inserire un valore predefinito significa inserire un valore null.
In questo esempio, la query seleziona dalla tabella USERS utenti a cui piacciono gli sport ma non il teatro:
```
select firstname, lastname, likesports, liketheatre
from users
where likesports is true and liketheatre is false
order by userid limit 10;
firstname | lastname | likesports | liketheatre
----------+------------+------------+-------------
Lars | Ratliff | t | f
Mufutau | Watkins | t | f
Scarlett | Mayer | t | f
Shafira | Glenn | t | f
Winifred | Cherry | t | f
Chase | Lamb | t | f
Liberty | Ellison | t | f
Aladdin | Haney | t | f
Tashya | Michael | t | f
Lucian | Montgomery | t | f
(10 rows)
```
Il seguente esempio seleziona dalla tabella USERS gli utenti per i quali non si sa se gradiscono la musica rock.
```
select firstname, lastname, likerock
from users
where likerock is unknown
order by userid limit 10;
firstname | lastname | likerock
----------+----------+----------
Rafael | Taylor |
Vladimir | Humphrey |
Barry | Roy |
Tamekah | Juarez |
Mufutau | Watkins |
Naida | Calderon |
Anika | Huff |
Bruce | Beck |
Mallory | Farrell |
Scarlett | Mayer |
(10 rows)
```
L'esempio seguente restituisce un errore perché utilizza un confronto IS nell'elenco SELECT.
```
select firstname, lastname, likerock is true as "check"
from users
order by userid limit 10;
[Amazon](500310) Invalid operation: Not implemented
```
L'esempio seguente ha esito positivo perché utilizza un confronto uguale ( = ) nell'elenco SELECT invece del confronto IS.
```
select firstname, lastname, likerock = true as "check"
from users
order by userid limit 10;
firstname | lastname | check
----------+-----------+------
Rafael | Taylor |
Vladimir | Humphrey |
Lars | Ratliff | true
Barry | Roy |
Reagan | Hodge | true
Victor | Hernandez | true
Tamekah | Juarez |
Colton | Roy | false
Mufutau | Watkins |
Naida | Calderon |
```
# Tipo HLLSKETCH
Utilizzate il tipo di dati HLLSKETCH per gli schizzi. HyperLogLog Amazon Redshift supporta rappresentazioni di HyperLogLog schizzi sparse o dense. Gli schizzi iniziano come sparsi e passano a densi quando il formato denso è più efficiente per ridurre al minimo l'ingombro di memoria utilizzato.
Amazon Redshift esegue automaticamente la transizione di uno HyperLogLog schizzo sparso durante l'importazione, l'esportazione o la stampa di schizzi nel seguente formato JSON.
```
{"logm":15,"sparse":{"indices":[4878,9559,14523],"values":[1,2,1]}}
```
Amazon Redshift utilizza una rappresentazione di stringa in formato Base64 per rappresentare uno sketch denso. HyperLogLog
Amazon Redshift utilizza la seguente rappresentazione di stringa in formato Base64 per rappresentare uno sketch denso. HyperLogLog
```
"ABAABA..."
```
La dimensione massima di un oggetto HLLSKETCH è di 24.580 byte se utilizzato nella compressione raw.
# Tipo SUPER
Utilizza il tipo di dati SUPER per memorizzare documenti o dati semistrutturati come valori. Sebbene Amazon Redshift sia in grado di memorizzare tali valori utilizzando VARCHAR, consigliamo di utilizzare invece il tipo di dati SUPER.
I dati semistrutturati non sono conformi alla struttura rigida e tabulare del modello di dati relazionali utilizzato nei database SQL. Contiene tag che fanno riferimento a entità distinte all'interno dei dati. Possono contenere valori complessi quali array, strutture nidificate e altre strutture complesse associate ai formati di serializzazione, ad esempio JSON. Il tipo di dati SUPER è un insieme di valori di struttura e array senza schema che comprendono tutti gli altri tipi scalari di Amazon Redshift.
Il tipo di dati SUPER supporta un massimo di 16 MB di dati per un singolo oggetto SUPER. Per ulteriori informazioni sul tipo di dati SUPER, con esempi di implementazione in una tabella, consulta [Dati semistrutturati in Amazon Redshift](super-overview.md).
Amazon Redshift fornisce un supporto integrato per importare i seguenti formati di dati semistrutturati utilizzando il comando COPY:
+ JSON
+ ARRAY
+ TEXT
+ CSV
Gli oggetti SUPER di dimensioni superiori a 1 MB possono essere importati solo dai seguenti formati di file:
+ Parquet
+ JSON
+ TEXT
+ CSV
Il tipo di dati SUPER presenta le seguenti proprietà:
+ Un valore scalare Amazon Redshift:
+ Un valore null
+ Un valore booleano
+ Un numero, ad esempio smallint, integer, bigint, decimale o virgola mobile (ad esempio float4 o float8)
+ Un valore di stringa, ad esempio varchar o char
+ Un valore complesso:
+ Un array di valori, inclusi scalari o complessi
+ Una struttura, nota anche come tupla o oggetto, ovvero una mappa di nomi e valori degli attributi (scalari o complessi)
Uno qualsiasi dei due tipi di valori complessi contiene i propri scalari o valori complessi senza avere alcuna limitazione sulla regolarità.
La codifica della compressione predefinita per il tipo di dati SUPER è ZSTD. Per informazioni sulla codifica della compressione, consulta [Codifiche di compressione](c_Compression_encodings.md).
Il tipo di dati SUPER supporta la persistenza di dati semistrutturati in un formato senza schema. Anche se il modello di dati gerarchico può cambiare, le vecchie versioni dei dati possono coesistere nella stessa colonna SUPER.
Amazon Redshift utilizza PartiQL per abilitare la navigazione in array e strutture. Amazon Redshift utilizza la sintassi PartiQL anche per eseguire l'iterazione su array SUPER. Per ulteriori informazioni, consulta [PartiQL: un linguaggio di query compatibile con SQL per Amazon Redshift](super-partiql.md).
Amazon Redshift utilizza la digitazione dinamica per elaborare dati SUPER senza schema e non dichiara i tipi di dati prima di utilizzarli nella query. Per ulteriori informazioni, consulta [Digitazione dinamica](query-super.md#dynamic-typing-lax-processing).
Puoi applicare le politiche di mascheramento dinamico dei dati ai valori sui percorsi delle colonne di tipo SUPER. Per ulteriori informazioni sul mascheramento dei dati dinamici, consulta [Mascheramento dinamico dei dati](t_ddm.md). Per informazioni su come usare il mascheramento dei dati dinamici con il tipo di dati SUPER, consulta [Utilizzo del mascheramento dei dati dinamici con percorsi di tipo di dati SUPER](t_ddm-super.md).
Si consiglia di impostare l’opzione di configurazione `r_enable_case_sensitive_super_attribute` su true quando utilizzi i dati SUPER. Per ulteriori informazioni, consulta [enable\$1case\$1sensitive\$1super\$1attribute](r_enable_case_sensitive_super_attribute.md).
# Tipo VARBYTE
Usa una colonna VARBYTE, VARBINARY o BINARY VARYING per memorizzare il valore binario di lunghezza variabile con un limite fisso.
```
varbyte [ (n) ]
```
Il numero massimo di byte (*n*) può variare da 1 a 16.777.216. Il valore di default è 64.000.
Alcuni esempi in cui è possibile utilizzare un tipo di dati VARBYTE sono i seguenti:
+ Unire le tabelle sulle colonne VARBYTE.
+ Creazione di viste materializzate che contengono colonne VARBYTE. È supportato l'aggiornamento incrementale delle viste materializzate che contengono colonne VARBYTE. Tuttavia, le funzioni aggregate diverse da COUNT, MIN e MAX e GROUP BY sulle colonne VARBYTE non supportano l'aggiornamento incrementale.
Per garantire che tutti i byte siano caratteri stampabili, Amazon Redshift utilizza il formato esadecimale per stampare i valori VARBYTE. Ad esempio, il seguente SQL converte la stringa esadecimale `6162` in un valore binario. Anche se il valore restituito è un valore binario, i risultati vengono stampati come esadecimale `6162`.
```
select from_hex('6162');
from_hex
----------
6162
```
Amazon Redshift supporta il casting tra VARBYTE e i seguenti tipi di dati:
+ CHAR
+ VARCHAR
+ SMALLINT
+ INTEGER
+ BIGINT
Quando si esegue il casting con CHAR e VARCHAR viene utilizzato il formato UTF-8. Per ulteriori informazioni sul formato UTF-8, consulta [TO\$1VARBYTE](r_TO_VARBYTE.md). Quando si esegue il casting da SMALLINT, INTEGER e BIGINT, viene mantenuto il numero di byte del tipo di dati originale. Cioè due byte per SMALLINT, quattro byte per INTEGER e otto byte per BIGINT.
La seguente istruzione SQL lancia una stringa VARCHAR in un VARBYTE. Anche se il valore restituito è un valore binario, i risultati vengono stampati come esadecimale `616263`.
```
select 'abc'::varbyte;
varbyte
---------
616263
```
L'istruzione SQL seguente lancia un valore CHAR in una colonna in un VARBYTE. In questo esempio viene creata una tabella con una colonna CHAR (10) (c), inserisce valori di carattere più brevi della lunghezza di 10. Il cast risultante associa il risultato con caratteri spaziali (hex'20') alla dimensione della colonna definita. Anche se il valore restituito è un valore binario, i risultati vengono stampati come esadecimale.
```
create table t (c char(10));
insert into t values ('aa'), ('abc');
select c::varbyte from t;
c
----------------------
61612020202020202020
61626320202020202020
```
La seguente istruzione SQL lancia una stringa SMALLINT in un VARBYTE. Anche se il valore restituito è un valore binario, i risultati vengono stampati come esadecimale `0005`, ovvero due byte o quattro caratteri esadecimali.
```
select 5::smallint::varbyte;
varbyte
---------
0005
```
La seguente istruzione SQL lancia un INTEGER in un VARBYTE. Anche se il valore restituito è un valore binario, i risultati vengono stampati come esadecimale `00000005`, ovvero quattro byte o otto caratteri esadecimali.
```
select 5::int::varbyte;
varbyte
----------
00000005
```
La seguente istruzione SQL lancia un BIGINT in un VARBYTE. Anche se il valore restituito è un valore binario, i risultati vengono stampati come esadecimale `0000000000000005`, ovvero otto byte o 16 caratteri esadecimali.
```
select 5::bigint::varbyte;
varbyte
------------------
0000000000000005
```
Le funzionalità di Amazon Redshift che supportano il tipo di dati VARBYTE includono:
+ [Operatori VARBYTE](r_VARBYTE_OPERATORS.md)
+ [CONCAT](r_CONCAT.md)
+ [LEN](r_LEN.md)
+ [Funzione LENGTH](r_LENGTH.md)
+ [OCTET\$1LENGTH](r_OCTET_LENGTH.md)
+ [Funzione SUBSTRING](r_SUBSTRING.md)
+ [FROM\$1HEX](r_FROM_HEX.md)
+ [TO\$1HEX](r_TO_HEX.md)
+ [FROM\$1VARBYTE](r_FROM_VARBYTE.md)
+ [TO\$1VARBYTE](r_TO_VARBYTE.md)
+ [GETBIT](r_GETBIT.md)
+ [Caricamento di una colonna definita come tipo dati VARBYTE](copy-usage-varbyte.md)
+ [Scaricare una colonna definita come tipo dati VARBYTE](r_UNLOAD.md#unload-usage-notes)
## Limitazioni nell'utilizzo del tipo di dati VARBYTE con Amazon Redshift
Di seguito sono elencale le limitazioni nell'utilizzo del tipo di dati VARBYTE con Amazon Redshift:
+ Amazon Redshift Spectrum supporta il tipo di dati VARBYTE solo per i file Parquet e ORC.
+ L'editor di query Amazon Redshift e l'editor di query Amazon Redshift v2 non supportano ancora completamente il tipo di dati VARBYTE. Pertanto, utilizzare un client SQL diverso quando si lavora con espressioni VARBYTE.
Come soluzione alternativa per utilizzare l'editor di query, se la lunghezza dei dati è pari o inferiore a 16.000.000 di byte e il contenuto è valido in UTF-8, puoi trasmettere i valori VARBYTE a VARCHAR, ad esempio:
```
select to_varbyte('6162', 'hex')::varchar;
```
+ Non è possibile utilizzare i tipi di dati VARBYTE con le funzioni definite dall'utente Python o Lambda (). UDFs
+ Non è possibile creare una colonna HLLSKETCH da una colonna VARBYTE o utilizzare APPROSSIMATE COUNT DISTINCT su una colonna VARBYTE.
+ I valori VARBYTE di dimensioni superiori a 1 MB possono essere importati solo dai seguenti formati di file:
+ Parquet
+ Testo
+ Valori separati da virgole (CSV)
## Conversione e compatibilità dei tipi
Di seguito è riportata una discussione su come le regole di conversione dei tipi e la compatibilità dei tipi di dati funzionano in Amazon Redshift.
### Compatibilità
La corrispondenza dei tipi di dati e la corrispondenza di valori letterali e costanti con tipi di dati avviene durante diverse operazioni di database, comprese le seguenti:
+ Operazioni DML (Data Manipulation Language) sulle tabelle
+ Query UNION, INTERSECT ed EXCEPT
+ Espressioni CASE
+ Valutazione di predicati, come LIKE e IN
+ Valutazione di funzioni SQL che effettuano confronti o estrazioni di dati
+ Confronti con operatori matematici
I risultati di queste operazioni dipendono dalle regole di conversione dei tipi e dalla compatibilità dei tipi di dati. La *compatibilità* implica che non è one-to-one sempre richiesta la corrispondenza tra un determinato valore e un determinato tipo di dati. Dato che alcuni tipi di dati sono *compatibili*, una conversione implicita o *coercizione* può essere effettuata (per maggiori informazioni, consultare [Tipi di conversione implicita](#implicit-conversion-types)). Quando i tipi di dati non sono compatibili, a volte è possibile convertire un valore da un tipo di dati a un altro usando una funzione di conversione esplicita.
### Regole generali di conversione e compatibilità
Osserva le seguenti regole di conversione e compatibilità:
+ In generale, i tipi di dati che rientrano nella stessa categoria (come diversi tipi di dati numerici) sono compatibili ed è possibile convertirli in modo implicito.
Ad esempio, con la conversione implicita è possibile inserire un valore decimale in una colonna intera. Il decimale viene arrotondato per produrre un numero intero. Altrimenti, è possibile estrarre un valore numerico, come `2008`, da una data e inserirlo nella colonna intera.
+ I tipi di dati numerici applicano le condizioni di overflow che si verificano quando si tenta di inserire valori. out-of-range Ad esempio, un valore decimale con una precisione di 5 non rientra in una colonna decimale che è stata definita con una precisione di 4. Un intero o la parte intera di un decimale non viene mai troncata; tuttavia, è possibile arrotondare la parte frazionaria di un decimale per difetto o per eccesso, come appropriato. Tuttavia, i risultati di espliciti cast di valori selezionati dalle tabelle non sono arrotondati.
+ Diversi tipi di stringhe di caratteri sono compatibili; le stringhe colonna VARCHAR contenenti dati a byte singolo e le stringhe colonna CHAR sono confrontabili e convertibili in modo implicito. Le stringhe VARCHAR che contengono dati multibyte non sono confrontabili. Inoltre, è possibile convertire una stringa di caratteri in un valore numerico, timestamp o data se la stringa è un valore letterale appropriato; eventuali spazi iniziali o finali vengono ignorati. Per contro, è possibile convertire un valore numero, timestamp o data in una stringa di caratteri a lunghezza variabile o fissa.
**Nota**
È necessario che una stringa di caratteri per la quale si desidera eseguire il cast a un tipo numerico contenga una rappresentazione in caratteri di un numero. Ad esempio, è possibile eseguire il cast per le stringhe `'1.0'` o `'5.9'` a valori decimali, ma non è possibile eseguire il cast per la stringa `'ABC'` a nessun tipo numerico.
+ Se si confrontano i valori DECIMAL con le stringhe di caratteri, Amazon Redshift tenta di convertire la stringa di caratteri in un valore DECIMAL. Quando si confrontano tutti gli altri valori numerici con stringhe di caratteri, i valori numerici vengono convertiti in stringhe di caratteri. Per applicare la conversione opposta (ad esempio, convertire le stringhe di caratteri in numeri interi o convertire i valori DECIMAL in stringhe di caratteri), usa una funzione esplicita, ad esempio, [CAST](r_CAST_function.md).
+ Per convertire valori DECIMAL o NUMERIC a 64 bit in una precisione più elevata, è necessario usare una funzione di conversione specifica come le funzioni CAST o CONVERT.
+ Quando si convertono DATE o TIMESTAMP in TIMESTAMPTZ o si converte TIME in TIMESTAMPTZ, il fuso orario viene impostato sul fuso orario della sessione attuale. Il fuso orario della sessione è UTC per impostazione predefinita. Per ulteriori informazioni sulle impostazioni del fuso orario della sessione, consultare [timezone](r_timezone_config.md).
+ Allo stesso modo, TIMESTAMPTZ viene convertito in DATE, TIME o TIMESTAMP sulla base del fuso orario della sessione corrente. Il fuso orario della sessione è UTC per impostazione predefinita. Dopo la conversione, le informazioni sul fuso orario vengono rimosse.
+ Le stringhe di caratteri che rappresentano un timestamp con fuso orario specificato vengono convertite in TIMESTAMPTZ usando il fuso orario della sessione corrente, che di default è UTC. Analogamente, le stringhe di caratteri che rappresentano un tempo con fuso orario specificato vengono convertite in TIMETZ usando il fuso orario della sessione attuale, che per impostazione predefinita è UTC.
### Tipi di conversione implicita
Ci sono due tipi di conversione implicita:
+ Conversioni implicite negli incarichi, come i valori delle impostazioni nei comandi INSERT o UPDATE.
+ Conversioni implicite nelle espressioni, come l'esecuzione di confronti nella clausola WHERE.
La tabella seguente elenca i tipi di dati che è possibile convertire in modo implicito negli incarichi o nelle espressioni. È anche possibile usare una funzione di conversione esplicita per eseguire queste conversioni.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/c_Supported_data_types.html)
**Nota**
Le conversioni implicite tra TIMESTAMPTZ, TIMESTAMP, DATE, TIME, TIMETZ o stringhe di caratteri usano il fuso orario della sessione corrente. Per informazioni sulle impostazioni del fuso orario corrente, consultare [timezone](r_timezone_config.md).
I tipi di dati GEOMETRY e GEOGRAPHY non possono essere convertiti implicitamente in nessun altro tipo di dati, eccetto l’un l’altro. Per ulteriori informazioni, consulta [Funzione CAST](r_CAST_function.md).
Il tipo di dati VARBYTE non può essere convertito implicitamente in nessun altro tipo di dati. Per ulteriori informazioni, consulta [Funzione CAST](r_CAST_function.md).
### Utilizzo della digitazione dinamica per il tipo di dati SUPER
Amazon Redshift utilizza la digitazione dinamica per elaborare i dati SUPER senza schema senza la necessità di dichiarare i tipi di dati prima di utilizzarli nella query. La digitazione dinamica utilizza i risultati della navigazione nelle colonne di dati SUPER senza doverne eseguire esplicitamente il casting nei tipi Amazon Redshift. Per ulteriori informazioni su come usare la digitazione dinamica per il tipo di dati SUPER, consultare [Digitazione dinamica](query-super.md#dynamic-typing-lax-processing).
È possibile eseguire il casting di valori SUPER da e verso altri tipi di dati con alcune eccezioni. Per ulteriori informazioni, consultare [Limitazioni](limitations-super.md).
# Sequenze di regole di confronto
Amazon Redshift non supporta sequenze di regole di confronto definite dall'utente o specifiche in termini di impostazioni locali. In generale, i risultati di qualsiasi predicato in qualsiasi contesto potrebbero essere influenzati dalla mancanza di regole specifiche in termini di impostazioni locali per l'ordinamento e il confronto di valori di dati. Ad esempio, le espressioni e le funzioni ORDER BY come MIN, MAX e RANK restituiscono risultati basati sull' UTF8 ordinamento binario dei dati che non tiene conto dei caratteri specifici delle impostazioni locali.
# Espressioni
**Topics**
+ [Espressioni semplici](#r_expressions-simple-expressions)
+ [Espressioni composte](r_compound_expressions.md)
+ [Elenco di espressioni](r_expression_lists.md)
+ [Subquery scalari](r_scalar_subqueries.md)
+ [Espressioni di funzioni](r_function_expressions.md)
Un'espressione è una combinazione di uno o più valori, operatori o funzioni che restituisce un valore. Il tipo di dati di un'espressione è solitamente quello dei suoi componenti.
## Espressioni semplici
Un'espressione semplice è una delle seguenti:
+ Una costante o un valore letterale
+ Un nome o un riferimento di colonna
+ Una funzione scalare
+ Una funzione (set) di aggregazione
+ Una funzione finestra
+ Una subquery scalare
Esempi di espressioni semplici comprendono:
```
5+12
dateid
sales.qtysold * 100
sqrt (4)
max (qtysold)
(select max (qtysold) from sales)
```
# Espressioni composte
Un'espressione composta è una serie di espressioni semplici unite da operatori aritmetici. È necessario che un'espressione semplice usata in un'espressione composta restituisca un valore numerico.
## Sintassi
```
expression
operator
expression | (compound_expression)
```
## Arguments (Argomenti)
*espressione*
Un'espressione semplice che restituisce un valore.
*operatore*
È possibile costruire un'espressione aritmetica composta usando gli operatori seguenti, in questo ordine di precedenza:
+ ( ) : parentesi per controllare l'ordine di valutazione
+ \$1 , - : operatori/segni positivi e negativi
+ ^ , \$1/ , \$1\$1/ : potenza, radice quadrata, radice cubica
+ \$1 , / , % : operatori di moltiplicazione, divisione e modulo
+ @ : valore assoluto
+ \$1 , - : addizione e sottrazione
+ & , \$1, \$1, \$1, <<, >> : operatori bit per bit AND, OR, NOT, shift a sinistra, shift a destra
+ \$1\$1: concatenazione
*(compound\$1expression)*
Le espressioni composte possono essere nidificate utilizzando le parentesi.
## Esempi
Esempi di espressioni composte comprendono:
```
('SMITH' || 'JONES')
sum(x) / y
sqrt(256) * avg(column)
rank() over (order by qtysold) / 100
(select (pricepaid - commission) from sales where dateid = 1882) * (qtysold)
```
È anche possibile nidificare alcune funzioni in altre funzioni. Ad esempio, è possibile nidificare qualsiasi funzione scalare dentro un'altra funzione scalare. Nell'esempio seguente viene restituita la somma dei valori assoluti di un set di numeri:
```
sum(abs(qtysold))
```
Non è possibile usare le funzioni finestra come argomenti per le funzioni di aggregazione o altre funzioni finestra. L'espressione seguente restituirebbe un errore:
```
avg(rank() over (order by qtysold))
```
Le funzioni finestra possono avere una funzione di aggregazione nidificata. L'espressione seguente addiziona set di valori e successivamente li classifica:
```
rank() over (order by sum(qtysold))
```
# Elenco di espressioni
Un elenco di espressioni è una combinazione di espressioni e può comparire nelle condizioni di confronto e appartenenza (clausole WHERE) e in clausole GROUP BY.
## Sintassi
```
expression , expression , ... | (expression, expression, ...)
```
## Arguments (Argomenti)
*espressione*
Un'espressione semplice che restituisce un valore. Un elenco di espressioni può contenere più espressioni separate da virgola o uno o più set di espressioni separate da virgola. Quando sono presenti più set di espressioni, è necessario che ciascun set contenga lo stesso numero di espressioni e sia separato da parentesi. È necessario che il numero di espressioni in ciascun set corrisponda al numero di espressioni prima dell'operatore nella condizione.
## Esempi
Di seguito vengono riportati esempi di elenchi di espressioni in condizioni:
```
(1, 5, 10)
('THESE', 'ARE', 'STRINGS')
(('one', 'two', 'three'), ('blue', 'yellow', 'green'))
```
È necessario che il numero di espressioni in ciascun set corrisponda al numero nella prima parte dell'istruzione:
```
select * from venue
where (venuecity, venuestate) in (('Miami', 'FL'), ('Tampa', 'FL'))
order by venueid;
venueid | venuename | venuecity | venuestate | venueseats
---------+-------------------------+-----------+------------+------------
28 | American Airlines Arena | Miami | FL | 0
54 | St. Pete Times Forum | Tampa | FL | 0
91 | Raymond James Stadium | Tampa | FL | 65647
(3 rows)
```
# Subquery scalari
Una subquery scalare è una query SELECT regolare tra parentesi che restituisce esattamente un valore: una riga con una colonna. La query viene eseguita e il valore restituito viene usato nella query outer. Se la subquery restituisce zero righe, il valore dell'espressione della subquery è null. Se restituisce più di una riga, Amazon Redshift restituisce un errore. La subquery può riferirsi a variabili della query padre, che agirà come costante durante qualsiasi invocazione della subquery.
È possibile usare le subquery scalari nella maggior parte delle istruzioni che chiamano un'espressione. Le subquery scalari non sono espressioni valide nei casi seguenti:
+ Come valori predefiniti per espressioni
+ Nelle clausole GROUP BY e HAVING
## Esempio
La subquery seguente calcola il prezzo medio pagato per vendita nel corso dell'intero anno 2008, quindi la query outer usa quel valore nell'output per confrontarlo rispetto al prezzo medio per vendita per trimestre:
```
select qtr, avg(pricepaid) as avg_saleprice_per_qtr,
(select avg(pricepaid)
from sales join date on sales.dateid=date.dateid
where year = 2008) as avg_saleprice_yearly
from sales join date on sales.dateid=date.dateid
where year = 2008
group by qtr
order by qtr;
qtr | avg_saleprice_per_qtr | avg_saleprice_yearly
-------+-----------------------+----------------------
1 | 647.64 | 642.28
2 | 646.86 | 642.28
3 | 636.79 | 642.28
4 | 638.26 | 642.28
(4 rows)
```
# Espressioni di funzioni
## Sintassi
Qualsiasi funzione integrata può essere usata come espressione. La sintassi per una chiamata di funzione è il nome di una funzione seguito dal suo elenco di argomenti tra parentesi.
```
function ( [expression [, expression...]] )
```
## Arguments (Argomenti)
*funzione*
Qualsiasi funzione integrata. Per alcuni esempi di funzioni, consulta [Informazioni di riferimento sulle funzioni SQL](c_SQL_functions.md).
*espressione*
Qualsiasi espressione che corrisponda al numero di parametri e tipi di dati previsto dalla funzione.
## Esempi
```
abs (variable)
select avg (qtysold + 3) from sales;
select dateadd (day,30,caldate) as plus30days from date;
```
# Condizioni
**Topics**
+ [Sintassi](#r_conditions-synopsis)
+ [Condizione di confronto](r_comparison_condition.md)
+ [Condizioni logiche](r_logical_condition.md)
+ [Condizioni di corrispondenza di modelli](pattern-matching-conditions.md)
+ [Condizione di intervallo BETWEEN](r_range_condition.md)
+ [Condizione Null](r_null_condition.md)
+ [Condizione EXISTS](r_exists_condition.md)
+ [Condizione IN](r_in_condition.md)
Una condizione è un'istruzione di una o più espressioni e operatori logici che restituisce un valore true, false o sconosciuto. A volte le condizioni vengono anche chiamate predicati.
**Nota**
Tutte le corrispondenze tra modelli LIKE e i confronti di stringhe fanno distinzione tra maiuscole e minuscole. Ad esempio, "A" e "a" non corrispondono. Tuttavia, è possibile effettuare una corrispondenza tra modelli che non distingue tra maiuscole e minuscole usando il predicato ILIKE.
## Sintassi
```
comparison_condition
| logical_condition
| range_condition
| pattern_matching_condition
| null_condition
| EXISTS_condition
| IN_condition
```
# Condizione di confronto
Le condizioni di confronto esprimono le relazioni logiche tra due valori. Tutte le condizioni di confronto sono operatori binari con un tipo restituito booleano. Amazon Redshift supporta gli operatori di confronto descritti nella tabella seguente:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/r_comparison_condition.html)
## Note per l'utilizzo
= ANY \$1 SOME
Le parole chiave ANY e SOME sono sinonimi della condizione *IN* e restituiscono true se il confronto ha esito positivo per almeno un valore restituito da una query secondaria che restituisce uno o più valori. Amazon Redshift supporta solo la condizione = (uguale) per ANY e SOME. Le condizioni di disuguaglianza non sono supportate.
Il predicato ALL non è supportato.
<> ALL
La parola chiave ALL è sinonima di NOT IN (vedere la condizione [Condizione IN](r_in_condition.md)) e restituisce true se l'espressione non è compresa nei risultati della query secondaria. Amazon Redshift supporta la condizione <> or \$1= (diverso) solo per ALL. Altre condizioni di confronto non sono supportate.
È TRUE/FALSE/UNKNOWN
I valori diversi da zero equivalgono a TRUE, 0 equivale a FALSE e null equivale a UNKNOWN. consultare il tipo di dati [Tipo booleanoTipo HLLSKETCH](r_Boolean_type.md).
## Esempi
Di seguito sono elencati alcuni semplici esempi di condizioni di confronto:
```
a = 5
a < b
min(x) >= 5
qtysold = any (select qtysold from sales where dateid = 1882
```
La query seguente restituisce sedi con più di 10.000 posti a sedere dalla tabella VENUE:
```
select venueid, venuename, venueseats from venue
where venueseats > 10000
order by venueseats desc;
venueid | venuename | venueseats
---------+--------------------------------+------------
83 | FedExField | 91704
6 | New York Giants Stadium | 80242
79 | Arrowhead Stadium | 79451
78 | INVESCO Field | 76125
69 | Dolphin Stadium | 74916
67 | Ralph Wilson Stadium | 73967
76 | Jacksonville Municipal Stadium | 73800
89 | Bank of America Stadium | 73298
72 | Cleveland Browns Stadium | 73200
86 | Lambeau Field | 72922
...
(57 rows)
```
Questo esempio seleziona dalla tabella USERS gli utenti (USERID) ai quali piace la musica rock:
```
select userid from users where likerock = 't' order by 1 limit 5;
userid
--------
3
5
6
13
16
(5 rows)
```
Questo esempio seleziona dalla tabella USERS gli utenti (USERID) per i quali si sa se gli piace la musica rock:
```
select firstname, lastname, likerock
from users
where likerock is unknown
order by userid limit 10;
firstname | lastname | likerock
----------+----------+----------
Rafael | Taylor |
Vladimir | Humphrey |
Barry | Roy |
Tamekah | Juarez |
Mufutau | Watkins |
Naida | Calderon |
Anika | Huff |
Bruce | Beck |
Mallory | Farrell |
Scarlett | Mayer |
(10 rows
```
## Esempi con una colonna 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 estratte le ore da ogni timetz\$1val.
```
select time_val from time_test where time_val < '3:00';
time_val
---------------
00:00:00.5550
00:58:00
```
L'esempio seguente confronta due valori letterali temporali.
```
select time '18:25:33.123456' = time '18:25:33.123456';
?column?
----------
t
```
## Esempi con una colonna 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 selezionati solo i valori TIMETZ inferiori a `3:00:00 UTC`. Il confronto viene effettuato dopo aver convertito il valore in UTC.
```
select timetz_val from timetz_test where timetz_val < '3:00:00 UTC';
timetz_val
---------------
00:00:00.5550+00
```
L'esempio seguente confronta due valori letterali TIMETZ. Il fuso orario viene ignorato per il confronto.
```
select time '18:25:33.123456 PST' < time '19:25:33.123456 EST';
?column?
----------
t
```
# Condizioni logiche
Le condizioni logiche combinano il risultato di due condizioni per produrre un singolo risultato. Tutte le condizioni logiche sono operatori binari con un tipo restituito booleano.
## Sintassi
```
expression
{ AND | OR }
expression
NOT expression
```
Le condizioni logiche usano una logica booleana a tre valori in cui il valore null rappresenta una relazione sconosciuta. Nella tabella riportata di seguito sono descritti i risultati delle condizioni logiche, dove `E1` ed `E2` rappresentano espressioni:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/r_logical_condition.html)
L'operatore NOT viene valutato prima di AND e l'operatore AND viene valutato prima dell'operatore OR. Eventuali parentesi utilizzate potrebbero sostituire questo ordine di valutazione predefinito.
### Esempi
L'esempio seguente restituisce USERID e USERNAME dalla tabella USERS se agli utenti piacciono sia Las Vegas sia gli sport:
```
select userid, username from users
where likevegas = 1 and likesports = 1
order by userid;
userid | username
--------+----------
1 | JSG99FHE
67 | TWU10MZT
87 | DUF19VXU
92 | HYP36WEQ
109 | FPL38HZK
120 | DMJ24GUZ
123 | QZR22XGQ
130 | ZQC82ALK
133 | LBN45WCH
144 | UCX04JKN
165 | TEY68OEB
169 | AYQ83HGO
184 | TVX65AZX
...
(2128 rows)
```
L'esempio successivo restituisce USERID e USERNAME dalla tabella USERS se agli utenti piacciono Las Vegas o gli sport o entrambi. Questa query restituisce tutti gli output dell'esempio precedente più gli utenti a cui piacciono solo Las Vegas o gli sport.
```
select userid, username from users
where likevegas = 1 or likesports = 1
order by userid;
userid | username
--------+----------
1 | JSG99FHE
2 | PGL08LJI
3 | IFT66TXU
5 | AEB55QTM
6 | NDQ15VBM
9 | MSD36KVR
10 | WKW41AIW
13 | QTF33MCG
15 | OWU78MTR
16 | ZMG93CDD
22 | RHT62AGI
27 | KOY02CVE
29 | HUH27PKK
...
(18968 rows)
```
La query seguente usa le parentesi intorno alla condizione `OR` per trovare i luoghi a New York o in California in cui è stato rappresentato Macbeth:
```
select distinct venuename, venuecity
from venue join event on venue.venueid=event.venueid
where (venuestate = 'NY' or venuestate = 'CA') and eventname='Macbeth'
order by 2,1;
venuename | venuecity
----------------------------------------+---------------
Geffen Playhouse | Los Angeles
Greek Theatre | Los Angeles
Royce Hall | Los Angeles
American Airlines Theatre | New York City
August Wilson Theatre | New York City
Belasco Theatre | New York City
Bernard B. Jacobs Theatre | New York City
...
```
La rimozione delle parentesi in questo esempio modifica la logica e i risultati della query.
L'esempio seguente utilizza l'operatore `NOT`:
```
select * from category
where not catid=1
order by 1;
catid | catgroup | catname | catdesc
-------+----------+-----------+--------------------------------------------
2 | Sports | NHL | National Hockey League
3 | Sports | NFL | National Football League
4 | Sports | NBA | National Basketball Association
5 | Sports | MLS | Major League Soccer
...
```
L'esempio seguente utilizza una condizione `NOT` seguita da una condizione `AND`:
```
select * from category
where (not catid=1) and catgroup='Sports'
order by catid;
catid | catgroup | catname | catdesc
-------+----------+---------+---------------------------------
2 | Sports | NHL | National Hockey League
3 | Sports | NFL | National Football League
4 | Sports | NBA | National Basketball Association
5 | Sports | MLS | Major League Soccer
(4 rows)
```
# Condizioni di corrispondenza di modelli
**Topics**
+ [LIKE](r_patternmatching_condition_like.md)
+ [SIMILAR TO](pattern-matching-conditions-similar-to.md)
+ [Operatori POSIX](pattern-matching-conditions-posix.md)
Un operatore di corrispondenza di modelli cerca una stringa in base a un modello specificato nell'espressione condizionale e restituisce true o false a seconda se trova la corrispondenza. Amazon Redshift utilizza tre metodi per la corrispondenza dei modelli:
+ Espressioni LIKE
L'operatore LIKE confronta un'espressione di stringa, come il nome di colonna, con un modello che usa i caratteri jolly `%` (percentuale) e `_` (sottolineatura). La corrispondenza di modello LIKE copre sempre l'intera stringa. LIKE esegue una corrispondenza che distingue tra maiuscole e minuscole e ILIKE esegue una corrispondenza che non distingue tra maiuscole e minuscole.
+ Espressioni regolari SIMILAR TO
L'operatore SIMILAR TO esegue una corrispondenza tra un'espressione di stringa e un modello di espressione regolare standard SQL, che può comprendere un set di metacaratteri di corrispondenza di modelli che comprende i due supportati dall'operatore LIKE. SIMILAR TO esegue una corrispondenza sull'intera stringa che distingue tra maiuscole e minuscole.
+ Espressioni regolari in stile POSIX
Le espressioni regolari POSIX forniscono un mezzo più potente per la corrispondenza di modelli rispetto agli operatori LIKE e SIMILAR TO. I modelli di espressioni regolari POSIX possono effettuare una corrispondenza su qualsiasi porzione della stringa ed eseguono una corrispondenza che distingue tra maiuscole e minuscole.
La corrispondenza di espressioni regolari, usando operatori SIMILAR TO o POSIX, è costosa in termini di calcolo. Consigliamo di usare LIKE quando possibile, soprattutto se si elaborano grandi quantità di righe. Ad esempio, le query seguenti sono identiche dal punto di vista funzionale, ma la query che usa LIKE viene eseguita molto più velocemente rispetto alla query che usa un'espressione regolare:
```
select count(*) from event where eventname SIMILAR TO '%(Ring|Die)%';
select count(*) from event where eventname LIKE '%Ring%' OR eventname LIKE '%Die%';
```
# LIKE
L'operatore LIKE confronta un'espressione di stringa, come il nome di colonna, con un modello che usa i caratteri jolly % (percentuale) e \$1 (sottolineatura). La corrispondenza di modello LIKE copre sempre l'intera stringa. Per trovare la corrispondenza con una sequenza in qualsiasi parte di una stringa, è necessario che il modello inizi e termini con un segno di percentuale.
LIKE fa distinzione tra maiuscole e minuscole, ILIKE no.
## Sintassi
```
expression [ NOT ] LIKE | ILIKE pattern [ ESCAPE 'escape_char' ]
```
## Arguments (Argomenti)
*espressione*
Un'espressione di caratteri UTF-8 valida, come un nome di colonna.
LIKE \$1 ILIKE
LIKE esegue una corrispondenza di modello che fa distinzione tra maiuscole e minuscole. ILIKE esegue una corrispondenza di modello che non fa distinzione tra maiuscole e minuscole per caratteri UTF-8 (ASCII) a byte singolo. Per eseguire una corrispondenza di modello che non fa distinzione tra maiuscole e minuscole per caratteri multibyte, utilizzare la funzione [LOWER](r_LOWER.md) sull'*espressione* e *modello* con una condizione LIKE.
Al contrario dei predicati di confronto, come = e <>, i predicati LIKE e ILIKE non ignorano implicitamente gli spazi finali. Per ignorare gli spazi finali, utilizzare RTRIM o trasmettere in modo esplicito una colonna CHAR a VARCHAR.
L'operatore `~~` è equivalente a LIKE e `~~*` è equivalente a ILIKE. Inoltre, gli operatori `!~~` e `!~~*` sono equivalenti a NOT LIKE e NOT ILIKE.
*pattern*
Un'espressione di caratteri UTF-8 valida con il modello da associare.
*escape\$1char*
Un'espressione di caratteri che eseguirà l'escape dei metacaratteri nel modello. Per impostazione predefinita sono due barre rovesciate ("\$1\$1").
Se il *modello* non contiene metacaratteri, allora il modello rappresenta solo la stringa stessa; in questo caso LIKE agisce come l'operatore di uguaglianza.
Entrambe le espressioni di caratteri possono essere tipi di dati CHAR o VARCHAR. Se differiscono, Amazon Redshift converte il *modello* al tipo di dati dell'*espressione*.
LIKE supporta i seguenti metacaratteri di corrispondenza di modelli:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/r_patternmatching_condition_like.html)
## Esempi
La tabella seguente mostra esempi di corrispondenza di modelli usando LIKE:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/r_patternmatching_condition_like.html)
L'esempio seguente trova tutte le città il cui nome inizia per "E":
```
select distinct city from users
where city like 'E%' order by city;
city
---------------
East Hartford
East Lansing
East Rutherford
East St. Louis
Easthampton
Easton
Eatontown
Eau Claire
...
```
L'esempio seguente trova tutti gli utenti il cui cognome contiene "ten":
```
select distinct lastname from users
where lastname like '%ten%' order by lastname;
lastname
-------------
Christensen
Wooten
...
```
Nell'esempio seguente viene illustrato come mettere in corrispondenza più modelli.
```
select distinct lastname from tickit.users
where lastname like 'Chris%' or lastname like '%Wooten' order by lastname;
lastname
-------------
Christensen
Christian
Wooten
...
```
L'esempio seguente trova le città il cui terzo e quarto carattere sono "ea". Il comando usa ILIKE per dimostrare che non fa distinzione tra maiuscole e minuscole:
```
select distinct city from users where city ilike '__EA%' order by city;
city
-------------
Brea
Clearwater
Great Falls
Ocean City
Olean
Wheaton
(6 rows)
```
Nell'esempio seguente viene usata la stringa con caratteri escape predefinita (\$1\$1) per ricercare stringhe che contengono "start\$1" (il testo `start` seguito da una sottolineatura `_`):
```
select tablename, "column" from pg_table_def
where "column" like '%start\\_%'
limit 5;
tablename | column
-------------------+---------------
stl_s3client | start_time
stl_tr_conflict | xact_start_ts
stl_undone | undo_start_ts
stl_unload_log | start_time
stl_vacuum_detail | start_row
(5 rows)
```
L'esempio seguente specifica "^" come carattere di escape, quindi usa il carattere di escape per ricercare stringhe che contengono "start\$1" (il testo `start` seguito da una sottolineatura `_`):
```
select tablename, "column" from pg_table_def
where "column" like '%start^_%' escape '^'
limit 5;
tablename | column
-------------------+---------------
stl_s3client | start_time
stl_tr_conflict | xact_start_ts
stl_undone | undo_start_ts
stl_unload_log | start_time
stl_vacuum_detail | start_row
(5 rows)
```
L'esempio seguente utilizza l'operatore `~~*` per eseguire una ricerca senza distinzione tra maiuscole e minuscole (ILIKE) delle città che iniziano con "Ag".
```
select distinct city from users where city ~~* 'Ag%' order by city;
city
------------
Agat
Agawam
Agoura Hills
Aguadilla
```
# SIMILAR TO
L'operatore SIMILAR TO associa un'espressione di stringa, come il nome di colonna, a un modello di espressione regolare standard SQL. Un modello di espressione regolare SQL può comprendere un set di metacaratteri di corrispondenza di modelli, compresi i due supportati dall'operatore LIKE [LIKE](r_patternmatching_condition_like.md).
L'operatore SIMILAR TO restituisce true solo se il modello corrisponde all'intera stringa, a differenza del comportamento dell'espressione regolare POSIX, in cui il modello può corrispondere a qualsiasi porzione della stringa.
SIMILAR TO esegue una corrispondenza che fa distinzione tra maiuscole e minuscole.
**Nota**
La corrispondenza di espressioni regolari usando SIMILAR TO è costosa in termini di calcolo. Consigliamo di usare LIKE quando possibile, soprattutto se si elaborano grandi quantità di righe. Ad esempio, le query seguenti sono identiche dal punto di vista funzionale, ma la query che usa LIKE viene eseguita molto più velocemente rispetto alla query che usa un'espressione regolare:
```
select count(*) from event where eventname SIMILAR TO '%(Ring|Die)%';
select count(*) from event where eventname LIKE '%Ring%' OR eventname LIKE '%Die%';
```
## Sintassi
```
expression [ NOT ] SIMILAR TO pattern [ ESCAPE 'escape_char' ]
```
## Arguments (Argomenti)
*espressione*
Un'espressione di caratteri UTF-8 valida, come un nome di colonna.
SIMILAR TO
SIMILAR TO esegue una corrispondenza di modello che distingue tra maiuscole e minuscole per l'intera stringa nell'*espressione*.
*pattern*
Un'espressione di caratteri UTF-8 valida che rappresenta un modello di espressione regolare standard SQL.
*escape\$1char*
Un'espressione di caratteri che eseguirà l'escape dei metacaratteri nel modello. Per impostazione predefinita sono due barre rovesciate ("\$1\$1").
Se il *modello* non contiene metacaratteri, allora il modello rappresenta solo la stringa stessa.
Entrambe le espressioni di caratteri possono essere tipi di dati CHAR o VARCHAR. Se differiscono, Amazon Redshift converte il *modello* al tipo di dati dell'*espressione*.
SIMILAR TO supporta i seguenti metacaratteri di corrispondenza di modelli:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/pattern-matching-conditions-similar-to.html)
## Esempi
La tabella riportata di seguito mostra esempi di corrispondenza di modelli usando SIMILAR TO:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/pattern-matching-conditions-similar-to.html)
L'esempio seguente trova tutte le città il cui nome contiene "E" o "H":
```
SELECT DISTINCT city FROM users
WHERE city SIMILAR TO '%E%|%H%' ORDER BY city LIMIT 5;
city
-----------------
Agoura Hills
Auburn Hills
Benton Harbor
Beverly Hills
Chicago Heights
```
Nell'esempio seguente viene usata la stringa di escape predefinita ("`\\`") per cercare stringhe che contengono "`_`":
```
SELECT tablename, "column" FROM pg_table_def
WHERE "column" SIMILAR TO '%start\\_%'
ORDER BY tablename, "column" LIMIT 5;
tablename | column
--------------------------+---------------------
stcs_abort_idle | idle_start_time
stcs_abort_idle | txn_start_time
stcs_analyze_compression | start_time
stcs_auto_worker_levels | start_level
stcs_auto_worker_levels | start_wlm_occupancy
```
L'esempio seguente specifica "`^`" come stringa di escape, quindi usa la stringa di escape per cercare stringhe che contengono "`_`":
```
SELECT tablename, "column" FROM pg_table_def
WHERE "column" SIMILAR TO '%start^_%' ESCAPE '^'
ORDER BY tablename, "column" LIMIT 5;
tablename | column
--------------------------+---------------------
stcs_abort_idle | idle_start_time
stcs_abort_idle | txn_start_time
stcs_analyze_compression | start_time
stcs_auto_worker_levels | start_level
stcs_auto_worker_levels | start_wlm_occupancy
```
# Operatori POSIX
Un'espressione regolare POSIX è una sequenza di caratteri che specifica uno schema di corrispondenza. Una stringa corrisponde a un'espressione regolare se è un membro del set regolare descritto dall'espressione regolare.
Le espressioni regolari POSIX forniscono un mezzo più potente per la corrispondenza di modelli rispetto agli operatori [LIKE](r_patternmatching_condition_like.md) e [SIMILAR TO](pattern-matching-conditions-similar-to.md). I modelli di espressioni regolari POSIX possono corrispondere a qualsiasi porzione di una stringa, a differenza dell'operatore SIMILAR TO che restituisce true solo se il modello corrisponde all'intera stringa.
**Nota**
La corrispondenza di espressioni regolari usando operatori POSIX è costosa in termini di calcolo. Consigliamo di usare LIKE quando possibile, soprattutto se si elaborano grandi quantità di righe. Ad esempio, le query seguenti sono identiche dal punto di vista funzionale, ma la query che usa LIKE viene eseguita molto più velocemente rispetto alla query che usa un'espressione regolare:
```
select count(*) from event where eventname ~ '.*(Ring|Die).*';
select count(*) from event where eventname LIKE '%Ring%' OR eventname LIKE '%Die%';
```
## Sintassi
```
expression [ ! ] ~ pattern
```
## Arguments (Argomenti)
*espressione*
Un'espressione di caratteri UTF-8 valida, come un nome di colonna.
\$1
Operatore di negazione. Non corrisponde all'espressione regolare.
\$1
Eseguire una corrispondenza che distingue tra maiuscole e minuscole su qualsiasi sottostringa dell'*espressione*.
Un `~~` è sinonimo di [LIKE](r_patternmatching_condition_like.md).
*pattern*
Un valore letterale di stringa che rappresenta un modello di espressione regolare.
Se il *modello* non contiene caratteri jolly, allora il modello rappresenta solo la stringa stessa.
Per cercare stringhe che comprendono metacaratteri, come "`. * | ? `", ecc., eseguire l'escape del carattere usando due barre rovesciate ("` \\`"). A differenza di `SIMILAR TO` e `LIKE`, la sintassi dell'espressione regolare POSIX non supporta un carattere di escape definito dall'utente.
Entrambe le espressioni di caratteri possono essere tipi di dati CHAR o VARCHAR. Se differiscono, Amazon Redshift converte il *modello* al tipo di dati dell'*espressione*.
Tutte le espressioni di caratteri possono essere tipi di dati CHAR o VARCHAR. Se l'espressione differisce per tipo di dati, Amazon Redshift la converte nel tipo di dati dell'*espressione*.
La corrispondenza di modelli POSIX supporta i seguenti metacaratteri:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/pattern-matching-conditions-posix.html)
Amazon Redshift supporta le seguenti classi di caratteri POSIX.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/pattern-matching-conditions-posix.html)
Amazon Redshift supporta i seguenti operatori influenzati da Perl in espressioni regolari. Esegui l'escape dell'operatore usando due barre rovesciate (‘`\\`').
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/pattern-matching-conditions-posix.html)
## Esempi
La tabella riportata di seguito mostra esempi di corrispondenza di modelli usando operatori POSIX:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/pattern-matching-conditions-posix.html)
L'esempio seguente trova tutte le città il cui nome contiene `E` o `H`:
```
SELECT DISTINCT city FROM users
WHERE city ~ '.*E.*|.*H.*' ORDER BY city LIMIT 5;
city
-----------------
Agoura Hills
Auburn Hills
Benton Harbor
Beverly Hills
Chicago Heights
```
L'esempio seguente trova le città il cui nome non contiene `E` o `H`:
```
SELECT DISTINCT city FROM users WHERE city !~ '.*E.*|.*H.*' ORDER BY city LIMIT 5;
city
-----------------
Aberdeen
Abilene
Ada
Agat
Agawam
```
Nell'esempio seguente viene usata la stringa di escape predefinita ("`\\`") per cercare stringhe che contengono un punto.
```
SELECT venuename FROM venue
WHERE venuename ~ '.*\\..*'
ORDER BY venueid;
venuename
------------------------------
St. Pete Times Forum
Jobing.com Arena
Hubert H. Humphrey Metrodome
U.S. Cellular Field
Superpages.com Center
E.J. Nutter Center
Bernard B. Jacobs Theatre
St. James Theatre
```
# Condizione di intervallo BETWEEN
Una condizione `BETWEEN` testa le espressioni per l'inclusione in un intervallo di valori, usando le parole chiave `BETWEEN` e `AND`.
## Sintassi
```
expression [ NOT ] BETWEEN expression AND expression
```
Le espressioni possono essere numeriche, di caratteri o datetime, ma è necessario che siano compatibili. L'intervallo è inclusivo.
## Esempi
Il primo esempio conta quante transazioni hanno registrato vendite di 2, 3 o 4 biglietti:
```
select count(*) from sales
where qtysold between 2 and 4;
count
--------
104021
(1 row)
```
La condizione di intervallo comprende i valori di inizio e di fine.
```
select min(dateid), max(dateid) from sales
where dateid between 1900 and 1910;
min | max
-----+-----
1900 | 1910
```
È necessario che la prima espressione in una condizione di intervallo sia il valore minore e la seconda espressione il valore maggiore. L'esempio seguente restituirà sempre zero righe a causa dei valori delle espressioni:
```
select count(*) from sales
where qtysold between 4 and 2;
count
-------
0
(1 row)
```
Tuttavia, l'applicazione del modificatore NOT invertirà la logica e produrrà un conto di tutte le righe:
```
select count(*) from sales
where qtysold not between 4 and 2;
count
--------
172456
(1 row)
```
La query seguente restituisce un elenco di sedi con 20.000-50.000 posti a sedere:
```
select venueid, venuename, venueseats from venue
where venueseats between 20000 and 50000
order by venueseats desc;
venueid | venuename | venueseats
---------+-------------------------------+------------
116 | Busch Stadium | 49660
106 | Rangers BallPark in Arlington | 49115
96 | Oriole Park at Camden Yards | 48876
...
(22 rows)
```
L'esempio seguente mostra l'utilizzo di BETWEEN per i valori di data:
```
select salesid, qtysold, pricepaid, commission, saletime
from sales
where eventid between 1000 and 2000
and saletime between '2008-01-01' and '2008-01-03'
order by saletime asc;
salesid | qtysold | pricepaid | commission | saletime
--------+---------+-----------+------------+---------------
65082 | 4 | 472 | 70.8 | 1/1/2008 06:06
110917 | 1 | 337 | 50.55 | 1/1/2008 07:05
112103 | 1 | 241 | 36.15 | 1/2/2008 03:15
137882 | 3 | 1473 | 220.95 | 1/2/2008 05:18
40331 | 2 | 58 | 8.7 | 1/2/2008 05:57
110918 | 3 | 1011 | 151.65 | 1/2/2008 07:17
96274 | 1 | 104 | 15.6 | 1/2/2008 07:18
150499 | 3 | 135 | 20.25 | 1/2/2008 07:20
68413 | 2 | 158 | 23.7 | 1/2/2008 08:12
```
È importante notare che, sebbene l'intervallo di BETWEEN sia inclusivo, le date hanno un valore di ora predefinito di 00:00:00. L'unica riga valida del 3 gennaio per la query di esempio sarebbe una riga con saletime `1/3/2008 00:00:00`.
# Condizione Null
La condizione null testa i valori null, quando un valore manca o è sconosciuto.
## Sintassi
```
expression IS [ NOT ] NULL
```
## Arguments (Argomenti)
*espressione*
Qualsiasi espressione come una colonna.
IS NULL
È true quando il valore dell'espressione è null e false quando ha un valore.
IS NOT NULL
È false quando il valore dell'espressione è null e true quando ha un valore.
## Esempio
Questo esempio indica quante volte la tabella SALES contiene un valore null nel campo QTYSOLD:
```
select count(*) from sales
where qtysold is null;
count
-------
0
(1 row)
```
# Condizione EXISTS
Le condizioni EXISTS testano l'esistenza di righe in una subquery e restituiscono true se una subquery restituisce almeno una riga. Se viene specificato NOT, la condizione restituisce true se una subquery restituisce nessuna riga.
## Sintassi
```
[ NOT ] EXISTS (table_subquery)
```
## Arguments (Argomenti)
EXISTS
È true se *table\$1subquery* restituisce almeno una riga.
NOT EXISTS
È true se *table\$1subquery* restituisce nessuna riga.
*table\$1subquery*
Una subquery che viene valutata una tabella con una o più colonne e una o più righe.
## Esempio
Questo esempio restituisce tutti gli identificatori di data, una volta ciascuno, per ogni data che ha registrato una vendita di qualsiasi tipo:
```
select dateid from date
where exists (
select 1 from sales
where date.dateid = sales.dateid
)
order by dateid;
dateid
--------
1827
1828
1829
...
```
# Condizione IN
Una condizione IN verifica se un valore appartiene a un set di valori o a una subquery.
## Sintassi
```
expression [ NOT ] IN (expr_list | table_subquery)
```
## Arguments (Argomenti)
*espressione*
Un'espressione datetime, di caratteri o numerica che viene valutata rispetto a *expr\$1list* o *table\$1subquery* e deve essere compatibile con il tipo di dati di quell'elenco o subquery.
*expr\$1list*
Una o più espressioni delimitate da virgola o uno o più set di espressioni delimitate da virgola racchiusi tra parentesi.
*table\$1subquery*
Una subquery che viene valutata una tabella con una o più righe ma che è limitata a una sola colonna nel suo elenco di selezione.
IN \$1 NOT IN
IN restituisce true se l'espressione è un membro della query o dell'elenco di espressioni. NOT IN restituisce true se l'espressione non è un membro. IN e NOT IN restituiscono NULL e nessuna riga nei casi seguenti: se l'*espressione* genera un valore null; se non ci sono valori *expr\$1list* o *table\$1subquery* corrispondenti e almeno una di queste righe di confronto restituisce un valore null.
## Esempi
Le condizioni seguenti sono true solo per quei valori elencati:
```
qtysold in (2, 4, 5)
date.day in ('Mon', 'Tues')
date.month not in ('Oct', 'Nov', 'Dec')
```
## Ottimizzazione per grandi elenchi IN
Per ottimizzare l'esecuzione delle query, un elenco IN che comprende più di 10 valori viene internamente valutato come un array scalare. Gli elenchi IN con meno di 10 valori vengono valutati come una serie di predicati OR. Questa ottimizzazione è supportata per i tipi di dati SMALLINT, INTEGER, BIGINT, REAL, DOUBLE PRECISION, BOOLEAN, CHAR, VARCHAR, DATE, TIMESTAMP e TIMESTAMPTZ.
Guarda l'output di EXPLAIN per la query per vedere l'effetto di questa ottimizzazione. Ad esempio:
```
explain select * from sales
QUERY PLAN
--------------------------------------------------------------------
XN Seq Scan on sales (cost=0.00..6035.96 rows=86228 width=53)
Filter: (salesid = ANY ('{1,2,3,4,5,6,7,8,9,10,11}'::integer[]))
(2 rows)
```