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.

# Funciones matemáticas
<a name="Math_functions-spark"></a>

En esta sección se describen las funciones y los operadores matemáticos compatibles con AWS Clean Rooms Spark SQL. 

**Topics**
+ [Símbolos de operadores matemáticos](OPERATOR_SYMBOLS.md)
+ [Función ABS](ABS.md)
+ [Función ACOS](ACOS.md)
+ [Función ASIN](ASIN.md)
+ [Función ATAN](ATAN.md)
+ [ATAN2 función](ATAN2.md)
+ [Función CBRT](CBRT.md)
+ [Función CEILING (o CEIL)](CEILING_FLOOR.md)
+ [Función COS](COS.md)
+ [Función COT](COT.md)
+ [Función DEGREES](DEGREES.md)
+ [Función DIV](DIV.md)
+ [Función EXP](EXP.md)
+ [Función FLOOR](FLOOR.md)
+ [Función LN](LN.md)
+ [Función LOG](LOG.md)
+ [Función MOD](MOD.md)
+ [Función PI](PI.md)
+ [Función POWER](POWER.md)
+ [Función RADIANS](RADIANS.md)
+ [Función RAND](RAND.md)
+ [Función RANDOM](RANDOM.md)
+ [Función ROUND](ROUND.md)
+ [Función SIGN](SIGN.md)
+ [Función SIN](SIN.md)
+ [Función SQRT](SQRT.md)
+ [Función TRUNC](TRUNC.md)

# Símbolos de operadores matemáticos
<a name="OPERATOR_SYMBOLS"></a>

 En la tabla siguiente, se muestran los operadores matemáticos admitidos. 

## Operadores admitidos
<a name="OPERATOR_SYMBOLS-supported-operators"></a>

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/clean-rooms/latest/sql-reference/OPERATOR_SYMBOLS.html)

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

Se calcula la comisión pagada más una tarifa de manipulación de 2,00 \$1 para una determinada transacción: 

```
select commission, (commission + 2.00) as comm
from sales where salesid=10000;

commission | comm
-----------+-------
28.05      | 30.05
(1 row)
```

Calcule el 20% del precio de venta para una transacción dada: 

```
select pricepaid, (pricepaid * .20) as twentypct
from sales where salesid=10000;

pricepaid | twentypct
----------+-----------
187.00    |    37.400
(1 row)
```

Prevea la venta de tickets según un patrón de crecimiento continuo. En este ejemplo, la subconsulta devuelve la cantidad de tickets vendidos en 2008. El resultado se multiplica exponencialmente por un índice de crecimiento continuo del 5 % a 10 años. 

```
select (select sum(qtysold) from sales, date
where sales.dateid=date.dateid and year=2008)
^ ((5::float/100)*10) as qty10years;

qty10years
------------------
587.664019657491
(1 row)
```

Se encuentra el precio total pagado y la comisión por ventas con un ID de fecha que sea mayor que o igual a 2000. Luego, se resta la comisión total del precio total pagado. 

```
select sum (pricepaid) as sum_price, dateid,
sum (commission) as sum_comm, (sum (pricepaid) - sum (commission)) as value
from sales where dateid >= 2000
group by dateid order by dateid limit 10;

 sum_price | dateid | sum_comm |   value
-----------+--------+----------+-----------
 364445.00 |   2044 | 54666.75 | 309778.25
 349344.00 |   2112 | 52401.60 | 296942.40
 343756.00 |   2124 | 51563.40 | 292192.60
 378595.00 |   2116 | 56789.25 | 321805.75
 328725.00 |   2080 | 49308.75 | 279416.25
 349554.00 |   2028 | 52433.10 | 297120.90
 249207.00 |   2164 | 37381.05 | 211825.95
 285202.00 |   2064 | 42780.30 | 242421.70
 320945.00 |   2012 | 48141.75 | 272803.25
 321096.00 |   2016 | 48164.40 | 272931.60
(10 rows)
```

# Función ABS
<a name="ABS"></a>

 ABS calcula el valor absoluto de un número, donde ese número puede ser un valor literal o una expresión que tome el valor de un número. 

## Sintaxis
<a name="ABS-synopsis"></a>

```
ABS (number)
```

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

 *número*   
Número o expresión que toma el valor de un número. Puede ser SMALLINT, INTEGER, BIGINT FLOAT4, DECIMAL o type. FLOAT8 

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

ABS devuelve el mismo tipo de datos como su argumento. 

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

Calcular el valor absoluto de -38: 

```
select abs (-38);
abs
-------
38
(1 row)
```

Calcular el valor absoluto de (14-76): 

```
select abs (14-76);
abs
-------
62
(1 row)
```

# Función ACOS
<a name="ACOS"></a>

ACOS es una función trigonométrica que devuelve el arcocoseno de un número. El valor de retorno está en radianes y se encuentra entre `0` y `PI`.

## Sintaxis
<a name="ACOS-synopsis"></a>

```
ACOS(number)
```

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

 *número*   
El parámetro de entrada es un número de `DOUBLE PRECISION`. 

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

`DOUBLE PRECISION`

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

Para devolver el arcoseno de `-1`, use el siguiente ejemplo. 

```
SELECT ACOS(-1);

+-------------------+
|       acos        |
+-------------------+
| 3.141592653589793 |
+-------------------+
```

# Función ASIN
<a name="ASIN"></a>

ASIN es una función trigonométrica que devuelve el arcoseno de un número. El valor de retorno está en radianes y se encuentra entre `PI/2` y `-PI/2`. 

## Sintaxis
<a name="ASIN-synopsis"></a>

```
ASIN(number)
```

## Argumentos
<a name="ASIN-argument"></a>

 *número*   
El parámetro de entrada es un número de `DOUBLE PRECISION`. 

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

`DOUBLE PRECISION`

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

Para devolver el arcoseno de `1`, use el siguiente ejemplo. 

```
SELECT ASIN(1) AS halfpi;

+--------------------+
|       halfpi       |
+--------------------+
| 1.5707963267948966 |
+--------------------+
```

# Función ATAN
<a name="ATAN"></a>

ATAN es una función trigonométrica que devuelve la arcotangente de un número. El valor de retorno está en radianes y se encuentra entre `-PI` y `PI`.

## Sintaxis
<a name="ATAN-synopsis"></a>

```
ATAN(number)
```

## Argumentos
<a name="ATAN-argument"></a>

 *número*   
El parámetro de entrada es un número de `DOUBLE PRECISION`. 

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

`DOUBLE PRECISION`

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

Para devolver la arcotangente de `1` y multiplicarla por 4, use el siguiente ejemplo.

```
SELECT ATAN(1) * 4 AS pi;
            
+-------------------+
|        pi         |
+-------------------+
| 3.141592653589793 |
+-------------------+
```

# ATAN2 función
<a name="ATAN2"></a>

ATAN2 es una función trigonométrica que devuelve el arco tangente de un número dividido por otro número. El valor de retorno está en radianes y se encuentra entre `PI/2` y `-PI/2`. 

## Sintaxis
<a name="ATAN2-synopsis"></a>

```
ATAN2(number1, number2)
```

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

 *number1*   
Un número de `DOUBLE PRECISION`. 

 *number2*   
Un número de `DOUBLE PRECISION`. 

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

`DOUBLE PRECISION`

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

Para devolver la arcotangente de `2/2` y multiplicarla por 4, use el siguiente ejemplo. 

```
SELECT ATAN2(2,2) * 4 AS PI;

+-------------------+
|        pi         |
+-------------------+
| 3.141592653589793 |
+-------------------+
```

# Función CBRT
<a name="CBRT"></a>

 La función CBRT es una función matemática que calcula la raíz cúbica de un número. 

## Sintaxis
<a name="CBRT-synopsis"></a>

```
CBRT (number)
```

## Argumento
<a name="CBRT-argument"></a>

CBRT toma un número con un valor de DOUBLE PRECISION como argumento. 

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

CBRT devuelve un número con un valor de DOUBLE PRECISION. 

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

Calcular la raíz cúbica de la comisión pagada para una transacción dada: 

```
select cbrt(commission) from sales where salesid=10000;

cbrt
------------------
3.03839539048843
(1 row)
```

# Función CEILING (o CEIL)
<a name="CEILING_FLOOR"></a>

La función CEILING o CEIL se usa para redondear un número hacia arriba hasta el próximo número entero. (La [Función FLOOR](FLOOR.md) redondea un número hacia abajo hasta el próximo número entero). 

## Sintaxis
<a name="CEILING_FLOOR-synopsis"></a>

```
CEIL | CEILING(number)
```

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

 *número*   
El número o la expresión que toma el valor de un número. Puede ser SMALLINT, INTEGER, BIGINT FLOAT4, DECIMAL o type. FLOAT8 

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

CEILING y CEIL devuelven el mismo tipo de datos como su argumento. 

## Ejemplo
<a name="CEILING_FLOOR-example"></a>

Calcular el límite máximo de la comisión pagada para una transacción dada de ventas: 

```
select ceiling(commission) from sales
where salesid=10000;

ceiling
---------
29
(1 row)
```

# Función COS
<a name="COS"></a>

COS es una función trigonométrica que devuelve el coseno de un número. El valor de retorno está en radianes y se encuentra entre `-1` y `1`, inclusive. 

## Sintaxis
<a name="COS-synopsis"></a>

```
COS(double_precision)
```

## Argumento
<a name="COS-argument"></a>

 *número*   
El parámetro de entrada es un número de doble precisión. 

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

La función COS devuelve un número de doble precisión. 

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

El siguiente ejemplo devuelve el coseno de 0: 

```
select cos(0);
cos
-----
1
(1 row)
```

El siguiente ejemplo devuelve el coseno de Pi: 

```
select cos(pi());
cos
-----
-1
(1 row)
```

# Función COT
<a name="COT"></a>

COT es una función trigonométrica que devuelve la cotangente de un número. El parámetro de entrada debe ser distinto de cero. 

## Sintaxis
<a name="COT-synopsis"></a>

```
COT(number)
```

## Argumento
<a name="COT-argument"></a>

 *número*   
El parámetro de entrada es un número de `DOUBLE PRECISION`. 

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

`DOUBLE PRECISION`

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

Para devolver la cotangente de 1, use el siguiente ejemplo. 

```
SELECT COT(1);

+--------------------+
|        cot         |
+--------------------+
| 0.6420926159343306 |
+--------------------+
```

# Función DEGREES
<a name="DEGREES"></a>

Convierte un ángulo en radianes a su equivalente en grados. 

## Sintaxis
<a name="DEGREES-synopsis"></a>

```
DEGREES(number)
```

## Argumento
<a name="DEGREES-argument"></a>

 *número*   
El parámetro de entrada es un número de `DOUBLE PRECISION`. 

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

`DOUBLE PRECISION`

## Ejemplo
<a name="DEGREES-examples"></a>

Para devolver el equivalente en grados de .5 radianes, use el siguiente ejemplo. 

```
SELECT DEGREES(.5);

+-------------------+
|      degrees      |
+-------------------+
| 28.64788975654116 |
+-------------------+
```

Para convertir radianes de Pi a grados, use el siguiente ejemplo. 

```
SELECT DEGREES(pi());

+---------+
| degrees |
+---------+
|     180 |
+---------+
```

# Función DIV
<a name="DIV"></a>

El operador DIV devuelve la parte integral de la división del dividendo por el divisor. 

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

```
dividend div divisor
```

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

 *dividendo*   
Expresión que se evalúa como un valor numérico o un intervalo.

*divisor*  
Un tipo de intervalo coincidente si `dividend` es un intervalo, numérico en caso contrario.

## Tipo de devolución
<a name="DIV-returns"></a>

`BIGINT`

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

En el siguiente ejemplo, se seleccionan dos columnas de la tabla de ardillas: la `id` columna, que contiene el identificador único de cada ardilla, y una `calculated` columna`age div 2`, que representa la división de enteros de la columna de edad entre 2. El `age div 2` cálculo divide los enteros de la `age` columna, redondeando así la edad al entero par más próximo. Por ejemplo, si la `age` columna contiene valores como 3, 5, 7 y 10, contendrá los valores 1, 2, 3 y 5, respectivamente. `age div 2` 

```
SELECT id, age div 2 FROM squirrels
```

Esta consulta puede resultar útil en situaciones en las que necesite agrupar o analizar datos en función de los rangos de edad y desee simplificar los valores de edad redondeándolos al número entero par más cercano. El resultado resultante proporcionaría la edad `id` y la edad divididas por 2 para cada ardilla de la `squirrels` tabla. 

# Función EXP
<a name="EXP"></a>

La función EXP implementa la función exponencial para una expresión numérica, o la base del logaritmo natural, `e`, elevada a potencia de expresión. La función EXP es la operación inversa de [Función LN](LN.md). 

## Sintaxis
<a name="EXP-synopsis"></a>

```
EXP (expression)
```

## Argumento
<a name="EXP-argument"></a>

 *expresión*   
La expresión debe ser un tipo de datos INTEGER, DECIMAL o DOUBLE PRECISION. 

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

EXP devuelve un número con un valor de DOUBLE PRECISION. 

## Ejemplo
<a name="EXP-example"></a>

Se utiliza la función EXP para prever las ventas de tickets según un patrón de crecimiento continuo. En este ejemplo, la subconsulta devuelve la cantidad de tickets vendidos en 2008. El resultado se multiplica por el resultado de la función EXP, que especifica un índice de crecimiento continuo del 7% durante 10 años. 

```
select (select sum(qtysold) from sales, date
where sales.dateid=date.dateid
and year=2008) * exp((7::float/100)*10) qty2018;

qty2018
------------------
695447.483772222
(1 row)
```

# Función FLOOR
<a name="FLOOR"></a>

La función FLOOR redondea un número hacia abajo hasta el próximo número entero. 

## Sintaxis
<a name="FLOOR-synopsis"></a>

```
FLOOR (number)
```

## Argumento
<a name="FLOOR-argument"></a>

 *número*   
El número o la expresión que toma el valor de un número. Puede ser SMALLINT, INTEGER, BIGINT, FLOAT4 DECIMAL o type. FLOAT8 

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

FLOOR devuelve el mismo tipo de datos como su argumento. 

## Ejemplo
<a name="FLOOR-example"></a>

En el ejemplo se muestra el valor de la comisión pagada por una transacción de ventas determinada antes y después de usar la función FLOOR. 

```
select commission from sales
where salesid=10000;

floor
-------
28.05
(1 row)

select floor(commission) from sales
where salesid=10000;

floor
-------
28
(1 row)
```

# Función LN
<a name="LN"></a>

La función LN devuelve el logaritmo natural del parámetro de entrada. 

## Sintaxis
<a name="LN-synopsis"></a>

```
LN(expression)
```

## Argumento
<a name="LN-argument"></a>

 *expresión*   
La columna o expresión de destino sobre la que opera la función.   
Esta función devuelve un error para algunos tipos de datos si la expresión hace referencia a una tabla AWS Clean Rooms creada por el usuario o a una tabla del sistema AWS Clean Rooms STL o STV. 
Las expresiones con los siguientes tipos de datos producen un error si usa como referencia una tabla de sistema o creada por usuarios.  
+ BOOLEANO 
+ CHAR 
+ DATE 
+ DECIMAL o NUMERIC 
+ TIMESTAMP 
+ VARCHAR 
Las expresiones con los siguientes tipos de datos se ejecutan con éxito en tablas creadas por usuarios y tablas de sistema STL o STV:   
+ BIGINT 
+ DOUBLE PRECISION 
+ INTEGER 
+ REAL 
+ SMALLINT 

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

La función LN devuelve el mismo tipo que la expresión. 

## Ejemplo
<a name="LN-example"></a>

El siguiente ejemplo devuelve el logaritmo natural, o la base de logaritmo, del número 2,718281828: 

```
select ln(2.718281828);
ln
--------------------
0.9999999998311267
(1 row)
```

Tenga en cuenta que la respuesta es casi igual a 1. 

En este ejemplo, se devuelve el logaritmo natural de los valores en la columna USERID en la tabla USERS: 

```
select username, ln(userid) from users order by userid limit 10;

 username |        ln
----------+-------------------
 JSG99FHE |                 0
 PGL08LJI | 0.693147180559945
 IFT66TXU |  1.09861228866811
 XDZ38RDD |  1.38629436111989
 AEB55QTM |   1.6094379124341
 NDQ15VBM |  1.79175946922805
 OWY35QYB |  1.94591014905531
 AZG78YIP |  2.07944154167984
 MSD36KVR |  2.19722457733622
 WKW41AIW |  2.30258509299405
(10 rows)
```

# Función LOG
<a name="LOG"></a>

Devuelve el logaritmo de `expr` con`base`.

## Sintaxis
<a name="LOG-synopsis"></a>

```
LOG(base, expr)
```

## Argumento
<a name="LOG-argument"></a>

 *expr*   
La expresión debe ser un tipo de datos entero, decimal o de punto flotante. 

 *base*   
La base para el cálculo del logaritmo. Debe ser un número positivo (distinto de 1) del tipo de datos de doble precisión. 

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

La función LOG devuelve un número de doble precisión. 

## Ejemplo
<a name="LOG-example"></a>

El siguiente ejemplo devuelve el logaritmo de base 10 del número 100: 

```
select log(10, 100);
--------
2
(1 row)
```

# Función MOD
<a name="MOD"></a>

Devuelve el resto de dos números, también denominada operación de *módulo*. Para calcular el resultado, el primer parámetro se divide entre el segundo.

## Sintaxis
<a name="MOD-synopsis"></a>

```
MOD(number1, number2)
```

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

 *number1*   
El primer parámetro de entrada es un número con un valor de tipo INTEGER, SMALLINT, BIGINT o DECIMAL. Si cada parámetro es de tipo DECIMAL, el otro parámetro debe ser también un tipo DECIMAL. Si cada parámetro es un valor INTEGER, el otro parámetro puede ser INTEGER, SMALLINT o BIGINT. Ambos parámetros pueden ser SMALLINT o BIGINT, pero un parámetro no puede ser SMALLINT si el otro es BIGINT. 

 *number2*   
El segundo parámetro de entrada es un número con un valor de tipo INTEGER, SMALLINT, BIGINT o DECIMAL. Se aplican las mismas reglas de tipo de datos en *number2* y en *number1*. 

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

Los tipos de retorno válidos son DECIMAL, INT, SMALLINT y BIGINT. El tipo de retorno de la función MOD es el mismo tipo numérico que los parámetros de entrada, si ambos parámetros de entrada son del mismo tipo. No obstante, si algún parámetro de entrada es un valor INTEGER, el tipo de retorno también será INTEGER. 

## Notas de uso
<a name="MOD-usage-notes"></a>

Puede utilizar *%* como operador de módulo.

## Ejemplos
<a name="MOD-example"></a>

En el siguiente ejemplo, se devuelve el resto cuando se divide un número entre otro:

```
SELECT MOD(10, 4);
               
 mod
------
 2
```

En el siguiente ejemplo, se devuelve un resultado decimal:

```
SELECT MOD(10.5, 4);
               
 mod
------
 2.5
```

Puede convertir valores de parámetro:

```
SELECT MOD(CAST(16.4 as integer), 5);
               
 mod
------
 1
```

Compruebe si el primer parámetro es par dividiéndolo entre 2:

```
SELECT mod(5,2) = 0 as is_even;
               
 is_even
--------
 false
```

Puede utilizar *%* como operador de módulo:

```
SELECT 11 % 4 as remainder;
               
 remainder
-----------
 3
```

El siguiente ejemplo devuelve la información para categorías con números impares en la tabla CATEGORY: 

```
select catid, catname
from category
where mod(catid,2)=1
order by 1,2;

 catid |  catname
-------+-----------
     1 | MLB
     3 | NFL
     5 | MLS
     7 | Plays
     9 | Pop
    11 | Classical

(6 rows)
```

# Función PI
<a name="PI"></a>

La función PI devuelve el valor de Pi a 14 lugares decimales. 

## Sintaxis
<a name="PI-synopsis"></a>

```
PI()
```

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

`DOUBLE PRECISION`

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

Para devolver el valor de pi, utilice el ejemplo siguiente.

```
SELECT PI();

+-------------------+
|        pi         |
+-------------------+
| 3.141592653589793 |
+-------------------+
```

# Función POWER
<a name="POWER"></a>

 La función POWER es una función exponencial que eleva una expresión numérica a la potencia de una segunda expresión numérica. Por ejemplo, 2 a la tercera potencia se calcula como `POWER(2,3)`, con un resultado de `8`. 

## Sintaxis
<a name="POWER-synopsis"></a>

```
{POWER(expression1, expression2)
```

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

 *expression1*   
Expresión numérica que se elevará. Debe ser un tipo de datos `INTEGER`, `DECIMAL` o `FLOAT`. 

 *expression2*   
Potencia a la que se va a elevar *expression1*. Debe ser un tipo de datos `INTEGER`, `DECIMAL` o `FLOAT`. 

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

`DOUBLE PRECISION`

## Ejemplo
<a name="POWER-examples"></a>

```
SELECT (SELECT SUM(qtysold) FROM sales, date
WHERE sales.dateid=date.dateid
AND year=2008) * POW((1+7::FLOAT/100),10) qty2010;

+-------------------+
|      qty2010      |
+-------------------+
| 679353.7540885945 |
+-------------------+
```

# Función RADIANS
<a name="RADIANS"></a>

La función RADIANS convierte un ángulo en grados a su equivalente en radianes. 

## Sintaxis
<a name="RADIANS-synopsis"></a>

```
RADIANS(number)
```

## Argumento
<a name="RADIANS-argument"></a>

 *número*   
El parámetro de entrada es un número de `DOUBLE PRECISION`. 

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

`DOUBLE PRECISION`

## Ejemplo
<a name="RADIANS-examples"></a>

Para devolver el equivalente en radianes de 180 grados, use el siguiente ejemplo. 

```
SELECT RADIANS(180);

+-------------------+
|      radians      |
+-------------------+
| 3.141592653589793 |
+-------------------+
```

# Función RAND
<a name="RAND"></a>

La función RAND genera un número aleatorio de punto flotante entre 0 y 1. La función RAND genera un nuevo número aleatorio cada vez que se llama.

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

```
RAND()
```

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

RANDOM devuelve un DOUBLE. 

## Ejemplo
<a name="RAND-example"></a>

El siguiente ejemplo genera una columna de números aleatorios de punto flotante entre 0 y 1 para cada fila de la tabla. `squirrels` El resultado sería una sola columna con una lista de valores decimales aleatorios, con un valor para cada fila de la tabla Squirrels. 

```
SELECT rand() FROM squirrels
```

Este tipo de consulta resulta útil cuando se necesitan generar números aleatorios, por ejemplo, para simular eventos aleatorios o para introducir la aleatoriedad en el análisis de datos. En el contexto de la `squirrels` tabla, podría usarse para asignar valores aleatorios a cada ardilla, que luego podrían usarse para su posterior procesamiento o análisis.

# Función RANDOM
<a name="RANDOM"></a>

La función RANDOM genera un valor aleatorio entre 0,0 (inclusive) y 1,0 (exclusive). 

## Sintaxis
<a name="RANDOM-synopsis"></a>

```
RANDOM()
```

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

RANDOM devuelve un número con un valor de DOUBLE PRECISION. 

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

1. Se computa un valor aleatorio entre 0 y 99. Si el número aleatorio está comprendido entre 0 y 1, esta consulta produce un número aleatorio comprendido entre 0 y 100: 

   ```
   select cast (random() * 100 as int);
   
   INTEGER
   ------
   24
   (1 row)
   ```

1. Recupera una muestra aleatoria uniforme de 10 objetos:

   ```
   select * 
   from sales
   order by random()
   limit 10;
   ```

   Ahora recupera una muestra aleatoria de 10 objetos, pero elige los objetos en proporción a sus precios. Por ejemplo, un objeto que cuesta el doble del precio de otro tendría el doble de posibilidades de aparecer en los resultados de la búsqueda:

   ```
   select * 
   from sales
   order by log(1 - random()) / pricepaid
   limit 10;
   ```

1. En este ejemplo se usa el comando SET para establecer un valor SEED de modo que RANDOM genere una secuencia predecible de números. 

   Primero, se devuelven tres valores enteros RANDOM sin establecer antes el valor SEED: 

   ```
   select cast (random() * 100 as int);
   INTEGER
   ------
   6
   (1 row)
   
   select cast (random() * 100 as int);
   INTEGER
   ------
   68
   (1 row)
   
   select cast (random() * 100 as int);
   INTEGER
   ------
   56
   (1 row)
   ```

   Ahora, establezca el valor SEED en `.25` y devuelva tres números RANDOM más: 

   ```
   set seed to .25;
   select cast (random() * 100 as int);
   INTEGER
   ------
   21
   (1 row)
   
   select cast (random() * 100 as int);
   INTEGER
   ------
   79
   (1 row)
   
   select cast (random() * 100 as int);
   INTEGER
   ------
   12
   (1 row)
   ```

   Finalmente, restablezca el valor SEED a `.25` y verifique que RANDOM devuelva los mismos resultados que en las tres ejecuciones anteriores: 

   ```
   set seed to .25;
   select cast (random() * 100 as int);
   INTEGER
   ------
   21
   (1 row)
   
   select cast (random() * 100 as int);
   INTEGER
   ------
   79
   (1 row)
   
   select cast (random() * 100 as int);
   INTEGER
   ------
   12
   (1 row)
   ```

# Función ROUND
<a name="ROUND"></a>

La función ROUND redondea los números hasta el valor entero o decimal más cercano. 

La función ROUND puede incluir, de forma opcional, un segundo argumento como un valor entero que indique la cantidad de lugares decimales para el redondeo, sea cual sea la dirección. Cuando no se proporciona el segundo argumento, la función redondea al número entero más cercano. Cuando se especifica el segundo argumento *>n*, la función redondea al número más cercano con una precisión de hasta *n* decimales. 

## Sintaxis
<a name="ROUND-synopsis"></a>

```
ROUND (number [ , integer ] )
```

## Argumento
<a name="ROUND-argument"></a>

 *número*   
Un número o una expresión que toma el valor de un número. Puede ser el DECIMAL o el FLOAT8 tipo. AWS Clean Rooms puede convertir otros tipos de datos según las reglas de conversión implícitas. 

*integer* (opcional)  
Un número entero que indica la cantidad de lugares decimales para el redondeo, sea cual sea la dirección. 

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

ROUND devuelve el mismo tipo de datos numérico como el argumento de entrada. 

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

Se redondea la comisión pagada para una transacción dada hasta el número entero más cercano. 

```
select commission, round(commission)
from sales where salesid=10000;

commission | round
-----------+-------
     28.05 |    28
(1 row)
```

Se redondea la comisión pagada para una transacción dada hasta el primer lugar decimal. 

```
select commission, round(commission, 1)
from sales where salesid=10000;

commission | round
-----------+-------
     28.05 |  28.1
(1 row)
```

Para la misma consulta, se extiende la precisión en la dirección opuesta. 

```
select commission, round(commission, -1)
from sales where salesid=10000;

commission | round
-----------+-------
     28.05 |    30
(1 row)
```

# Función SIGN
<a name="SIGN"></a>

 La función SIGN devuelve el signo (positivo o negativo) de un número. El resultado de la función SIGN es `1`, `-1` o `0`, lo que indica el signo del argumento. 

## Sintaxis
<a name="SIGN-synopsis"></a>

```
SIGN (number)
```

## Argumento
<a name="SIGN-argument"></a>

 *número*   
Número o expresión que toma el valor de un número. Puede ser del DECIMALor FLOAT8 tipo. AWS Clean Rooms puede convertir otros tipos de datos según las reglas de conversión implícitas.

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

SIGN devuelve el mismo tipo de datos numérico como el argumento de entrada. Si la entrada es DECIMAL, la salida es DECIMAL(1,0). 

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

Para determinar el signo de la comisión pagada por una transacción determinada a partir de la tabla SALES, utilice el siguiente ejemplo. 

```
SELECT commission, SIGN(commission)
FROM sales WHERE salesid=10000;

+------------+------+
| commission | sign |
+------------+------+
|      28.05 |    1 |
+------------+------+
```

# Función SIN
<a name="SIN"></a>

SIN es una función trigonométrica que devuelve el seno de un número. El valor devuelto está comprendido entre `-1` y `1`. 

## Sintaxis
<a name="SIN-synopsis"></a>

```
SIN(number)
```

## Argumento
<a name="SIN-argument"></a>

 *número*   
Un número de `DOUBLE PRECISION` en radianes. 

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

`DOUBLE PRECISION` 

## Ejemplo
<a name="SIN-examples"></a>

Para devolver el seno de `-PI`, use el siguiente ejemplo.

```
SELECT SIN(-PI());

+-------------------------+
|           sin           |
+-------------------------+
| -0.00000000000000012246 |
+-------------------------+
```

# Función SQRT
<a name="SQRT"></a>

 La función SQRT devuelve la raíz cuadrada de un valor numérico. La raíz cuadrada es un número multiplicado por sí mismo para obtener el valor dado.

## Sintaxis
<a name="SQRT-synopsis"></a>

```
SQRT (expression)
```

## Argumento
<a name="SQRT-argument"></a>

 *expresión*   
La expresión debe ser un tipo de datos entero, decimal o de punto flotante. La expresión puede incluir funciones. Es posible que el sistema realice conversiones de tipos implícitos. 

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

SQRT devuelve un número con valor de DOUBLE PRECISION.

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

El siguiente ejemplo devuelve la raíz cuadrada de un número. 

```
select sqrt(16);
               
sqrt
---------------
4
```

El siguiente ejemplo realiza una conversión de tipo implícita.

```
select sqrt('16');
               
sqrt
---------------
4
```

En el ejemplo siguiente se anidan las funciones para realizar una tarea más compleja. 

```
select sqrt(round(16.4)); 

sqrt
---------------
4
```

El siguiente ejemplo da como resultado la longitud del radio si se da el área de un círculo. Calcula el radio en pulgadas, por ejemplo, cuando se le da el área en pulgadas cuadradas. El área del ejemplo es 20. 

```
select sqrt(20/pi());
```

Esto devuelve el valor 5,046265044040321.

El siguiente ejemplo devuelve la raíz cuadrada para valores COMMISSION de la tabla SALES. La columna COMMISSION es una columna DECIMAL. En este ejemplo se muestra cómo se puede utilizar la función en una consulta con una lógica condicional más compleja. 

```
select sqrt(commission)
from sales where salesid < 10 order by salesid;

sqrt
------------------
10.4498803820905
3.37638860322683
7.24568837309472
5.1234753829798
...
```

La siguiente consulta devuelve la raíz cuadrada redondeada para el mismo conjunto de valores COMMISSION. 

```
select salesid, commission, round(sqrt(commission))
from sales where salesid < 10 order by salesid;

salesid | commission | round
--------+------------+-------
      1 |     109.20 |    10
      2 |      11.40 |     3
      3 |      52.50 |     7
      4 |      26.25 |     5
...
```

Para obtener más información sobre los datos de muestra AWS Clean Rooms, consulte [Base de datos de muestra](https://docs.aws.amazon.com/redshift/latest/dg/c_sampledb.html).

# Función TRUNC
<a name="TRUNC"></a>

La función TRUNC trunca los números hasta el valor entero o decimal anterior. 

La función TRUNC puede incluir, de forma opcional, un segundo argumento como un valor entero que indique la cantidad de lugares decimales para el redondeo, sea cual sea la dirección. Cuando no se proporciona el segundo argumento, la función redondea al número entero más cercano. Cuando se especifica el segundo argumento *>n*, la función redondea al número más cercano con una precisión de hasta *>n* decimales. Esta función también trunca una marca temporal y devuelve una fecha.

## Sintaxis
<a name="TRUNC-synopsis"></a>

```
TRUNC (number [ , integer ] |
timestamp )
```

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

 *número*   
Un número o una expresión que toma el valor de un número. Puede ser el tipo DECIMAL o el FLOAT8 tipo. AWS Clean Rooms puede convertir otros tipos de datos según las reglas de conversión implícitas. 

 *integer* (opcional)   
Un número entero que indica la cantidad de lugares decimales de precisión, sea cual sea la dirección. Si no se proporciona un valor entero, el número se trunca como un número entero; si se especifica un número entero, el número se trunca hasta el lugar decimal especificado. 

 *timestamp*   
La función también devuelve la fecha de una marca temporal. (Para devolver un valor de marca temporal con `00:00:00` como la hora, convierta el resultado de la función en una marca temporal). 

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

TRUNC devuelve el mismo tipo de datos como el primer argumento de entrada. Para las marcas temporales, TRUNC devuelve una fecha. 

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

Se trunca la comisión pagada para una transacción dada de ventas. 

```
select commission, trunc(commission)
from sales where salesid=784;

commission | trunc
-----------+-------
    111.15 |   111

(1 row)
```

Se trunca el mismo valor de comisión hasta el primer lugar decimal. 

```
select commission, trunc(commission,1)
from sales where salesid=784;

commission | trunc
-----------+-------
    111.15 | 111.1

(1 row)
```

Se trunca la comisión con un valor negativo para el segundo argumento; `111.15` se redondea hacia abajo hasta `110`. 

```
select commission, trunc(commission,-1)
from sales where salesid=784;

commission | trunc
-----------+-------
    111.15 |   110
(1 row)
```

Se devuelve la parte de fecha desde el resultado de la función SYSDATE (que devuelve una marca temporal): 

```
select sysdate;

timestamp
----------------------------
2011-07-21 10:32:38.248109
(1 row)

select trunc(sysdate);

trunc
------------
2011-07-21
(1 row)
```

Se aplica la función TRUNC a una columna TIMESTAMP. El tipo de retorno es una fecha. 

```
select trunc(starttime) from event
order by eventid limit 1;

trunc
------------
2008-01-25
(1 row)
```