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à.
# 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)
```