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à.

# Funzione CAST
<a name="r_CAST_function"></a>

La funzione CAST converte un tipo di dati in un altro tipo di dati compatibile. Ad esempio, puoi convertire una stringa in una data o un tipo numerico in una stringa. CAST esegue una conversione in fase di runtime, il che significa che la conversione non modifica il tipo di dati di un valore in una tabella di origine. Viene modificato solo nel contesto della query.

La funzione CAST è molto simile a [Funzione CONVERT](r_CONVERT_function.md), in quanto entrambe eseguono la conversione da un tipo di dati all'altro, ma vengono chiamate in modo diverso.

Alcuni tipi di dati richiedono una conversione esplicita in altri tipi di dati utilizzando la funzione CAST o CONVERT. Altri tipi di dati possono essere convertiti implicitamente, come parte di un altro comando, senza utilizzare CAST o CONVERT. Per informazioni, consulta [Conversione e compatibilità dei tipi](c_Supported_data_types.md#r_Type_conversion). 

## Sintassi
<a name="r_CAST_function-syntax"></a>

Utilizza i seguenti due formati di sintassi equivalenti per convertire espressioni da un tipo di dati a un altro:

```
CAST ( expression AS type )
expression :: type
```

## Arguments (Argomenti)
<a name="r_CAST_function-arguments"></a>

 *espressione*   
Un'espressione che valuta uno o più valori, ad esempio un nome di colonna o un letterale. La conversione di valori null restituisce null. L'espressione non può contenere stringhe o spazi vuoti. 

 *tipo*   
Uno dei metodi supportati [Tipi di dati](c_Supported_data_types.md). 

## Tipo restituito
<a name="r_CAST_function-return-type"></a>

CAST restituisce il tipo di dati specificato dall'argomento *tipo*. 

**Nota**  
Amazon Redshift restituisce un errore se provi a eseguire una conversione problematica, come la seguente conversione DECIMAL che perde precisione:   

```
select 123.456::decimal(2,1);
```
o una conversione INTEGER che provoca un eccesso:   

```
select 12345678::smallint;
```

## Esempi
<a name="r_CAST_function-examples"></a>

La maggior parte degli esempi usa il [database TICKIT](https://docs.aws.amazon.com/redshift/latest/dg/c_sampledb.html) di esempio. Per ulteriori informazioni sul caricamento di dati di esempio, consulta [Caricare i dati](https://docs.aws.amazon.com/redshift/latest/gsg/cm-dev-t-load-sample-data.html).

Le seguenti due query sono equivalenti. Entrambi assegnano un valore decimale a un integer: 

```
select cast(pricepaid as integer)
from sales where salesid=100;

pricepaid
-----------
162
(1 row)
```

```
select pricepaid::integer
from sales where salesid=100;

pricepaid
-----------
162
(1 row)
```

La seguente query produce un risultato simile. Non richiede dati di esempio per l'esecuzione: 

```
select cast(162.00 as integer) as pricepaid;

pricepaid
-----------
162
(1 row)
```

In questo esempio, i valori in una colonna timestamp vengono convertiti come date, il che comporta la rimozione dell'ora da ogni risultato:

```
select cast(saletime as date), salesid
from sales order by salesid limit 10;

 saletime  | salesid
-----------+---------
2008-02-18 |       1
2008-06-06 |       2
2008-06-06 |       3
2008-06-09 |       4
2008-08-31 |       5
2008-07-16 |       6
2008-06-26 |       7
2008-07-10 |       8
2008-07-22 |       9
2008-08-06 |      10
(10 rows)
```

Se non hai usato CAST come illustrato nell'esempio precedente, i risultati includono l'ora: *18-02-2008 02:36:48*.

La seguente query converte i dati di caratteri variabili in una data. Non richiede dati di esempio per l'esecuzione. 

```
select cast('2008-02-18 02:36:48' as date) as mysaletime;

mysaletime    
--------------------
2008-02-18  
(1 row)
```

In questo esempio, il casting dei valori in una colonna di data viene eseguito come timestamps: 

```
select cast(caldate as timestamp), dateid
from date order by dateid limit 10;

      caldate       | dateid
--------------------+--------
2008-01-01 00:00:00 |   1827
2008-01-02 00:00:00 |   1828
2008-01-03 00:00:00 |   1829
2008-01-04 00:00:00 |   1830
2008-01-05 00:00:00 |   1831
2008-01-06 00:00:00 |   1832
2008-01-07 00:00:00 |   1833
2008-01-08 00:00:00 |   1834
2008-01-09 00:00:00 |   1835
2008-01-10 00:00:00 |   1836
(10 rows)
```

In un caso come nell'esempio precedente, è possibile ottenere un ulteriore controllo sulla formattazione dell'output utilizzando [TO\$1CHAR](https://docs.aws.amazon.com/redshift/latest/dg/r_TO_CHAR.html).

In questo esempio, un integer è assegnato come una stringa di caratteri: 

```
select cast(2008 as char(4));

bpchar
--------
2008
```

In questo esempio, un valore DECIMAL(6,3) viene assegnato come valore DECIMAL(4,1): 

```
select cast(109.652 as decimal(4,1));

numeric
---------
109.7
```

Questo esempio mostra un'espressione più complessa. La colonna PRICEPAID (una colonna DECIMAL(8,2)) nella tabella SALES viene convertita in una colonna DECIMAL(38,2) e i valori vengono moltiplicati per 100000000000000000000: 

```
select salesid, pricepaid::decimal(38,2)*100000000000000000000
as value from sales where salesid<10 order by salesid;


 salesid |           value
---------+----------------------------
       1 | 72800000000000000000000.00
       2 |  7600000000000000000000.00
       3 | 35000000000000000000000.00
       4 | 17500000000000000000000.00
       5 | 15400000000000000000000.00
       6 | 39400000000000000000000.00
       7 | 78800000000000000000000.00
       8 | 19700000000000000000000.00
       9 | 59100000000000000000000.00
(9 rows)
```

**Nota**  
Non è possibile eseguire un'operazione CAST o CONVERT sul tipo di dati `GEOMETRY` per modificarlo in un altro tipo di dati. Tuttavia, è possibile fornire una rappresentazione esadecimale di una stringa letterale in formato Extended Well-Known Binary (EWKB) come input per funzioni che accettano un argomento di tipo `GEOMETRY`. Ad esempio, la seguente funzione `ST_AsText` si aspetta un tipo di dati `GEOMETRY`.   

```
SELECT ST_AsText('01010000000000000000001C400000000000002040');
```

```
st_astext  
------------
 POINT(7 8)
```
È anche possibile specificare esplicitamente il tipo di dati `GEOMETRY`.   

```
SELECT ST_AsText('010100000000000000000014400000000000001840'::geometry);
```

```
st_astext  
------------
 POINT(5 6)
```