Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Función CAST
<a name="CAST_function"></a>

La función CAST convierte un tipo de datos en otro tipo compatible. Por ejemplo, puede convertir una cadena en una fecha o un tipo numérico en una cadena. CAST realiza una conversión en tiempo de ejecución, lo que significa que la conversión no cambia el tipo de datos de un valor en una tabla de origen. Solo cambia en el contexto de la consulta.

Algunos tipos de datos requieren una conversión explícita a otros tipos de datos mediante la función CAST. Otros tipos de datos se pueden convertir implícitamente, como parte de otro comando, sin usar CAST. Consulte [Conversión y compatibilidad de tipos](s_Type_conversion.md). 

## Sintaxis
<a name="CAST_function-syntax"></a>

Utilice cualquiera de estas dos formas sintácticas equivalentes para convertir expresiones de un tipo de datos a otro.

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

## Argumentos
<a name="CAST_function-arguments"></a>

 *expresión*   
Una expresión que toma el valor de uno o más valores, como un nombre de columna o un literal. La conversión de valores nulos devuelve valores nulos. La expresión no puede tener cadenas en blanco ni vacías. 

 *type*   
Uno de los compatibles[Tipos de datos](s_Supported_data_types.md), excepto los tipos de datos BINARY y BINARY VARIANT. 

## Tipo de devolución
<a name="CAST_function-return-type"></a>

CAST devuelve el tipo de datos especificado por el argumento *type*. 

**nota**  
AWS Clean Rooms devuelve un error si intenta realizar una conversión problemática, como una conversión DECIMAL que pierde precisión, como la siguiente:   

```
select 123.456::decimal(2,1);
```
o una conversión a un valor de INTEGER que genera un desbordamiento:   

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

## Ejemplos
<a name="CAST_function-examples"></a>

Las siguientes dos consultas son equivalentes. Ambas convierten un valor decimal en uno entero: 

```
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)
```

Lo siguiente produce un resultado similar. No requiere datos de muestra para ejecutarse: 

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

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

En este ejemplo, los valores de una columna de marca temporal se convierten en fechas, lo que elimina la hora de cada resultado:

```
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)
```

Si no utilizara CAST como se ilustra en el ejemplo anterior, los resultados incluirían la hora: *2008-02-18 02:36:48*.

La siguiente consulta convierte los datos de caracteres variables en una fecha. No requiere datos de muestra para ejecutarse. 

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

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

En este ejemplo, los valores en una columna de fecha se convierten en marcas temporales: 

```
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)
```

En un caso como el del ejemplo anterior, puede obtener control adicional sobre el formato de salida mediante el uso de [TO\$1CHAR](TO_CHAR.md).

En este ejemplo, un valor entero se convierte en una cadena de caracteres: 

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

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

En este ejemplo, un valor DECIMAL (6,3) se convierte en un valor DECIMAL (4,1): 

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

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

Este ejemplo muestra una expresión más compleja. La columna PRICEPAID (una columna DECIMAL(8,2)) de la tabla SALES se convierte en una columna DECIMAL(38,2) y los valores se multiplican por 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)
```