As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Funções matemáticas
<a name="Math_functions-spark"></a>

Esta seção descreve os operadores e funções matemáticas compatíveis com o AWS Clean Rooms Spark SQL. 

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

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

 A tabela a seguir lista os operadores matemáticos compatíveis. 

## Operadores compatíveis
<a name="OPERATOR_SYMBOLS-supported-operators"></a>

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

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

Calcule a comissão paga mais uma taxa de manuseio de US\$1 2,00 para uma determinada transação: 

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

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

Calcule 20 por cento do preço de venda para determinada transação: 

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

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

Faça a previsão das vendas de ingressos com base em um padrão de crescimento contínuo. Neste exemplo, a subconsulta retorna o número de ingressos vendidos em 2008. Esse resultado é multiplicado exponencialmente por uma taxa de crescimento contínuo de 5% ao longo de 10 anos. 

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

Encontre o preço total pago e a comissão pelas vendas com ID de data maior ou igual a 2.000. Então, subtraia a comissão total do preço total pago. 

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

# Função ABS
<a name="ABS"></a>

 ABS calcula o valor absoluto de um número, que pode ser um literal ou uma expressão que avalie para um número. 

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

```
ABS (number)
```

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

 *número*   
Número ou expressão que avalia para um número. Pode ser do tipo SMALLINT, INTEGER, BIGINT, DECIMAL ou. FLOAT4 FLOAT8 

## Tipo de retorno
<a name="ABS-return-type"></a>

ABS retorna o mesmo tipo de dados que seu argumento. 

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

Calcule o valor absoluto de -38: 

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

Calcule o valor absoluto de (14-76): 

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

# Função ACOS
<a name="ACOS"></a>

ACOS é uma função trigonométrica que retorna o arco cosseno de um número. O valor de retorno é em radianos, entre `0` e `PI`.

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

```
ACOS(number)
```

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

 *número*   
O parâmetro de entrada é um número `DOUBLE PRECISION`. 

## Tipo de retorno
<a name="ACOS-return-type"></a>

`DOUBLE PRECISION`

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

Para retornar o arco cosseno de `-1`, use o exemplo a seguir. 

```
SELECT ACOS(-1);

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

# Função ASIN
<a name="ASIN"></a>

ASIN é uma função trigonométrica que retorna o arco seno de um número. O valor de retorno é em radianos, entre `PI/2` e `-PI/2`. 

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

```
ASIN(number)
```

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

 *número*   
O parâmetro de entrada é um número `DOUBLE PRECISION`. 

## Tipo de retorno
<a name="ASIN-return-type"></a>

`DOUBLE PRECISION`

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

Para retornar o arco seno de `1`, use o exemplo a seguir. 

```
SELECT ASIN(1) AS halfpi;

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

# Função ATAN
<a name="ATAN"></a>

ATAN é uma função trigonométrica que retorna a arco tangente de um número. O valor de retorno é em radianos, entre `-PI` e `PI`.

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

```
ATAN(number)
```

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

 *número*   
O parâmetro de entrada é um número `DOUBLE PRECISION`. 

## Tipo de retorno
<a name="ATAN-return-type"></a>

`DOUBLE PRECISION`

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

Para retornar a arco tangente de `1` e a multiplica por 4, use o exemplo a seguir.

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

# ATAN2 função
<a name="ATAN2"></a>

ATAN2 é uma função trigonométrica que retorna o arco tangente de um número dividido por outro número. O valor de retorno é em radianos, entre `PI/2` e `-PI/2`. 

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

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

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

 *number1*   
Um número `DOUBLE PRECISION`. 

 *number2*   
Um número `DOUBLE PRECISION`. 

## Tipo de retorno
<a name="ATAN2-return-type"></a>

`DOUBLE PRECISION`

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

Para retornar a arco tangente de `2/2` e a multiplica por 4, use o exemplo a seguir. 

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

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

# Função CBRT
<a name="CBRT"></a>

 A função CBRT é uma função matemática que calcula a raiz cúbica de um número. 

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

```
CBRT (number)
```

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

CBRT assume um número de DOUBLE PRECISION como um argumento. 

## Tipo de retorno
<a name="CBRT-return-type"></a>

CBRT retorna um número de DOUBLE PRECISION. 

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

Calcule a raiz cúbica da comissão paga para determinada transação: 

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

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

# Função CEILING (ou CEIL)
<a name="CEILING_FLOOR"></a>

A função CEILING ou CEIL é usada para arredondar um número para o número inteiro seguinte. (A função [Função FLOOR](FLOOR.md) arredonda um número para o número inteiro anterior.) 

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

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

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

 *número*   
O número ou expressão avaliada como um número. Pode ser do tipo SMALLINT, INTEGER, BIGINT, DECIMAL ou. FLOAT4 FLOAT8 

## Tipo de retorno
<a name="CEILING_FLOOR-return-type"></a>

CEILING e CEIL retornam o mesmo tipo de dados que seu argumento. 

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

Calcule o teto da comissão paga para determinada transação de vendas: 

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

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

# Função COS
<a name="COS"></a>

COS é uma função trigonométrica que retorna o cosseno de um número. O valor de retorno é em radianos, entre `-1` e `1`, incluindo ambos. 

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

```
COS(double_precision)
```

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

 *número*   
O parâmetro de entrada é um número de precisão dupla. 

## Tipo de retorno
<a name="COS-return-type"></a>

A função COS retorna um número de precisão dupla. 

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

O seguinte exemplo retorna o cosseno de 0: 

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

O seguinte exemplo retorna o cosseno de PI: 

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

# Função COT
<a name="COT"></a>

COT é uma função trigonométrica que retorna a cotangente de um número. O parâmetro de entrada deve ser diferente de zero. 

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

```
COT(number)
```

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

 *número*   
O parâmetro de entrada é um número `DOUBLE PRECISION`. 

## Tipo de retorno
<a name="COT-return-type"></a>

`DOUBLE PRECISION`

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

Para retornar a cotangente de 1, use o exemplo a seguir. 

```
SELECT COT(1);

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

# Função DEGREES
<a name="DEGREES"></a>

Converte um ângulo em radianos para seu equivalente em graus. 

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

```
DEGREES(number)
```

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

 *número*   
O parâmetro de entrada é um número `DOUBLE PRECISION`. 

## Tipo de retorno
<a name="DEGREES-return-type"></a>

`DOUBLE PRECISION`

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

Para retornar o grau equivalente de 0,5 radiano, use o exemplo a seguir. 

```
SELECT DEGREES(.5);

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

Para converter PI radianos em graus, use o exemplo a seguir. 

```
SELECT DEGREES(pi());

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

# Função DIV
<a name="DIV"></a>

O operador DIV retorna a parte integral da divisão do dividendo por divisor. 

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

```
dividend div divisor
```

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

 *dividendo*   
Uma expressão que é avaliada como numérica ou intervalo.

*divisor*  
Um tipo de intervalo correspondente se `dividend` for um intervalo, caso contrário, um numérico.

## Tipo de retorno
<a name="DIV-returns"></a>

`BIGINT`

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

O exemplo a seguir seleciona duas colunas da tabela de esquilos: a `id` coluna, que contém o identificador exclusivo para cada esquilo, e uma `calculated` coluna,`age div 2`, que representa a divisão inteira da coluna de idade por 2. O `age div 2` cálculo realiza a divisão de números inteiros na `age` coluna, arredondando efetivamente a idade para o número inteiro par mais próximo. Por exemplo, se a `age` coluna contiver valores como 3, 5, 7 e 10, a `age div 2` coluna conterá os valores 1, 2, 3 e 5, respectivamente. 

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

Essa consulta pode ser útil em cenários em que você precisa agrupar ou analisar dados com base em faixas etárias e deseja simplificar os valores de idade arredondando-os para o número inteiro par mais próximo. O resultado resultante forneceria a idade `id` e a divisão por 2 para cada esquilo na `squirrels` tabela. 

# Função EXP
<a name="EXP"></a>

A função EXP implementa a função exponencial de uma expressão numérica, ou a base de um logaritmo natural, `e`, elevada à potência da expressão. A função EXP é o inverso de [Função LN](LN.md). 

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

```
EXP (expression)
```

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

 *expressão*   
A expressão deve ser um tipo de dados INTEGER, DECIMAL ou DOUBLE PRECISION. 

## Tipo de retorno
<a name="EXP-return-type"></a>

EXP retorna um número de DOUBLE PRECISION. 

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

Use a função EXP para prever as vendas de ingressos com base em um padrão de crescimento contínuo. Neste exemplo, a subconsulta retorna o número de ingressos vendidos em 2008. Esse resultado é multiplicado pelo resultado da função EXP, que especifica uma taxa de crescimento contínuo de 7% por 10 anos. 

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

# Função FLOOR
<a name="FLOOR"></a>

A função FLOOR arredonda um número para o número inteiro anterior. 

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

```
FLOOR (number)
```

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

 *número*   
O número ou expressão avaliada como um número. Pode ser do tipo SMALLINT, INTEGER, BIGINT, DECIMAL ou. FLOAT4 FLOAT8 

## Tipo de retorno
<a name="FLOOR-return-type"></a>

FLOOR retorna o mesmo tipo de dados que seu argumento. 

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

O exemplo mostra o valor da comissão paga por determinada transação de vendas antes e depois de usar a função 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)
```

# Função LN
<a name="LN"></a>

A função LN retorna o logaritmo natural do parâmetro de entrada. 

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

```
LN(expression)
```

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

 *expressão*   
A coluna ou expressão de destino na qual a função opera.   
Essa função retornará um erro para alguns tipos de dados se a expressão fizer referência a uma tabela AWS Clean Rooms criada pelo usuário ou a uma tabela do AWS Clean Rooms sistema STL ou STV. 
As expressões com os seguintes tipos de dados produzem um erro se fizerem referência a uma tabela criada por usuário ou uma tabela de sistema.  
+ BOOLEAN 
+ CHAR 
+ DATE 
+ DECIMAL ou NUMERIC 
+ TIMESTAMP 
+ VARCHAR 
Expressões com os seguintes tipos de dados executam com êxito em tabelas criadas por usuário ou tabelas de sistema STL ou STV:   
+ BIGINT 
+ DOUBLE PRECISION 
+ INTEGER 
+ REAL 
+ SMALLINT 

## Tipo de retorno
<a name="LN-return-type"></a>

A função LN retorna o mesmo tipo que a expressão. 

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

O seguinte exemplo retorna o logaritmo natural, ou logaritmo de base e, do número 2,718281828: 

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

Observe que a resposta é quase igual a 1. 

Este exemplo retorna o logaritmo natural dos valores na coluna USERID da tabela 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)
```

# Função LOG
<a name="LOG"></a>

Retorna o logaritmo de `expr` com. `base`

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

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

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

 *expr*   
A expressão deve ter um tipo de dados de número inteiro, decimal ou ponto flutuante. 

 *base*   
A base para o cálculo do logaritmo. Deve ser um número positivo (não igual a 1) do tipo de dados de precisão dupla. 

## Tipo de retorno
<a name="LOG-return-type"></a>

A função LOG retorna um número de precisão dupla. 

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

O seguinte exemplo retorna o logaritmo de base 10 do número 100: 

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

# Função MOD
<a name="MOD"></a>

Retorna o resto de dois números, também chamado de operação *modulo*. Para calcular o resultado, o primeiro parâmetro é dividido pelo segundo.

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

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

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

 *number1*   
O primeiro parâmetro de entrada é um número INTEGER, SMALLINT, BIGINT ou DECIMAL. Se um dos parâmetros for um tipo DECIMAL, os outros parâmetro também devem ser um tipo DECIMAL. Se um dos parâmetros for um INTEGER, os outros parâmetro podem ser INTEGER, SMALLINT ou BIGINT. Ambos os parâmetros também podem ser SMALLINT ou BIGINT, mas um parâmetro não pode ser SMALLINT se o outro for BIGINT. 

 *number2*   
O segundo parâmetro é um número INTEGER, SMALLINT, BIGINT ou DECIMAL. As mesmas regras de tipo de dados são válidas para *number2* e *number1*. 

## Tipo de retorno
<a name="MOD-return-type"></a>

Os tipos de retorno válidos são DECIMAL, INT, SMALLINT e BIGINT. O tipo de retorno da função MOD é o mesmo tipo numérico que os parâmetros de entrada se ambos os parâmetros de entrada forem do mesmo tipo. Se um dos parâmetro de entrada for INTEGER, porém, o tipo de retorno também será INTEGER. 

## Observações de uso
<a name="MOD-usage-notes"></a>

Você pode usar *%* como um operador de modulo.

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

O exemplo a seguir retorna o resto da divisão de um número por outro:

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

O exemplo a seguir retorna um resultado decimal:

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

Você pode converter valores de parâmetros:

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

Verifique se o primeiro parâmetro é par dividindo-o por 2:

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

Você pode usar *%* como um operador de modulo:

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

O seguinte exemplo retorna informações para as categorias com números ímpares da tabela 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)
```

# Função PI
<a name="PI"></a>

A função PI retorna o valor de pi para 14 casas decimais. 

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

```
PI()
```

## Tipo de retorno
<a name="PI-return-type"></a>

`DOUBLE PRECISION`

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

Para retornar o valor de pi, use o exemplo a seguir.

```
SELECT PI();

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

# Função POWER
<a name="POWER"></a>

 A função POWER é uma função exponencial que eleva uma expressão numérica para a potência de uma segunda expressão numérica. Por exemplo, 2 elevado à terceira potência é calculado como `POWER(2,3)`, com um resultado de `8`. 

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

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

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

 *expression1*   
Expressão numérica a ser elevada. Deve ser um tipo de dados `INTEGER`, `DECIMAL` ou `FLOAT`. 

 *expression2*   
Potência a elevar a *expression1*. Deve ser um tipo de dados `INTEGER`, `DECIMAL` ou `FLOAT`. 

## Tipo de retorno
<a name="POWER-return-type"></a>

`DOUBLE PRECISION`

## Exemplo
<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 |
+-------------------+
```

# Função RADIANS
<a name="RADIANS"></a>

A função RADIANS converte um ângulo em graus em seu equivalente em radianos. 

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

```
RADIANS(number)
```

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

 *número*   
O parâmetro de entrada é um número `DOUBLE PRECISION`. 

## Tipo de retorno
<a name="RADIANS-return-type"></a>

`DOUBLE PRECISION`

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

Para retornar o radiano equivalente de 180 graus, use o exemplo a seguir. 

```
SELECT RADIANS(180);

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

# Função RAND
<a name="RAND"></a>

A função RAND gera um número aleatório de ponto flutuante entre 0 e 1. A função RAND gera um novo número aleatório cada vez que é chamada.

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

```
RAND()
```

## Tipo de retorno
<a name="RAND-return-type"></a>

RANDOM retorna um DOUBLE. 

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

O exemplo a seguir gera uma coluna de números aleatórios de ponto flutuante entre 0 e 1 para cada linha na tabela. `squirrels` A saída resultante seria uma única coluna contendo uma lista de valores decimais aleatórios, com um valor para cada linha na tabela de esquilos. 

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

Esse tipo de consulta é útil quando você precisa gerar números aleatórios, por exemplo, para simular eventos aleatórios ou para introduzir aleatoriedade em sua análise de dados. No contexto da `squirrels` tabela, ela pode ser usada para atribuir valores aleatórios a cada esquilo, que podem então ser usados para processamento ou análise posterior.

# Função RANDOM
<a name="RANDOM"></a>

A função RANDOM gera um valor aleatório entre 0,0 (inclusive) e 1,0 (exclusivo). 

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

```
RANDOM()
```

## Tipo de retorno
<a name="RANDOM-return-type"></a>

RANDOM retorna um número de DOUBLE PRECISION. 

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

1. Compute um valor aleatório entre 0 e 99. Se o número aleatório é de 0 a 1, essa consulta produz um número aleatório de 0 a 100: 

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

1. Recupere uma amostra aleatória uniforme de 10 itens:

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

   Agora recupere uma amostra aleatória de 10 itens, mas escolha os itens em proporção aos preços. Por exemplo, um item cujo preço é o dobro de outro tem duas vezes mais probabilidade de aparecer nos resultados de consulta:

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

1. Este exemplo usa o comando SET para definir um valor SEED para que RANDOM gere uma sequência previsível de números. 

   Primeiro, retorne três inteiros RANDOM sem definir o valor de SEED primeiro: 

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

   Agora, defina o valor de SEED como `.25` e retorne mais três números RANDOM: 

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

   Por fim, redefina o valor de SEED como `.25` e verifique se RANDOM retorna os mesmos resultados que as três chamadas 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)
   ```

# Função ROUND
<a name="ROUND"></a>

A função ROUND arredonda números para o inteiro ou decimal mais próximo. 

A função ROUND pode incluir opcionalmente um segundo argumento como um inteiro para indicar o número de casas decimais para arredondamento, em qualquer direção. Quando você não fornece o segundo argumento, a função arredonda para o número inteiro mais próximo. Quando o segundo argumento *>n* for especificado, a função arredonda para o número mais próximo com *n* casas decimais de precisão. 

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

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

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

 *número*   
Um número ou expressão avaliada como um número. Pode ser o DECIMAL ou o FLOAT8 tipo. AWS Clean Rooms pode converter outros tipos de dados de acordo com as regras de conversão implícitas. 

*inteiro* (opcional)  
Um número inteiro que indica o número de casas decimais para arredondamento em ambas as direções. 

## Tipo de retorno
<a name="ROUND-return-type"></a>

ROUND retorna o mesmo tipo de dados numéricos que o(s) argumento(s) de entrada. 

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

Arredonde a comissão paga para determinada transação para o número inteiro mais próximo. 

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

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

Arredonde a comissão paga para determinada transação para a primeira casa decimal. 

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

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

Para a mesma consulta, estenda a precisão no sentido oposto. 

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

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

# Função SIGN
<a name="SIGN"></a>

 A função SIGN retorna o sinal (positivo ou negativo) de um número. O resultado da função SIGN é `1`, `-1` ou `0` indicando o sinal do argumento. 

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

```
SIGN (number)
```

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

 *número*   
Número ou expressão que avalia para um número. Pode ser do DECIMALor FLOAT8 tipo. AWS Clean Rooms pode converter outros tipos de dados de acordo com as regras de conversão implícitas.

## Tipo de retorno
<a name="SIGN-return-type"></a>

SIGN retorna o mesmo tipo de dados numéricos que os argumentos de entrada. Se a entrada for DECIMAL, a saída será DECIMAL(1,0). 

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

Para determinar o sinal da comissão paga por determinada transação na tabela SALES, use o exemplo a seguir. 

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

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

# Função SIN
<a name="SIN"></a>

SIN é uma função trigonométrica que retorna o seno de um número. O valor de retorno está entre `-1` e `1`. 

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

```
SIN(number)
```

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

 *número*   
Um número `DOUBLE PRECISION` em radianos. 

## Tipo de retorno
<a name="SIN-return-type"></a>

`DOUBLE PRECISION` 

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

Para retornar o seno de `-PI`, use o exemplo a seguir.

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

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

# Função SQRT
<a name="SQRT"></a>

 A função SQRT retorna a raiz quadrada de um valor numérico. A raiz quadrada é um número multiplicado por si mesmo para obter o valor fornecido.

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

```
SQRT (expression)
```

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

 *expressão*   
A expressão deve ter um tipo de dados de número inteiro, decimal ou ponto flutuante. A expressão pode incluir funções. O sistema pode realizar conversões de tipo implícitas. 

## Tipo de retorno
<a name="SQRT-return-type"></a>

SQRT retorna um número de DOUBLE PRECISION.

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

O exemplo a seguir retorna a raiz quadrada de um número. 

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

O exemplo a seguir realiza uma conversão de tipo implícita.

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

O exemplo a seguir aninha funções para realizar uma tarefa mais complexa. 

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

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

O exemplo a seguir resulta no comprimento do raio quando dada a área de um círculo. Ele calcula o raio em polegadas, por exemplo, quando dada a área em polegadas quadradas. A área na amostra é 20. 

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

Isso retorna o valor 5.046265044040321.

O seguinte exemplo retorna a raiz quadrada para valores de COMMISSION da tabela SALES. A coluna COMMISSION é uma coluna DECIMAL. Este exemplo mostra como você pode usar a função em uma consulta com uma lógica condicional mais complexa. 

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

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

A seguinte consulta retorna raiz quadrada arredondada para o mesmo conjunto de valores de 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 obter mais informações sobre dados de amostra em AWS Clean Rooms, consulte Banco de [dados de amostra](https://docs.aws.amazon.com/redshift/latest/dg/c_sampledb.html).

# Função TRUNC
<a name="TRUNC"></a>

A função TRUNC trunca números para o inteiro ou decimal anterior. 

A função TRUNC pode incluir opcionalmente um segundo argumento como um inteiro para indicar o número de casas decimais para arredondamento, em qualquer direção. Quando você não fornece o segundo argumento, a função arredonda para o número inteiro mais próximo. Quando o segundo argumento *>n* for especificado, a função arredonda para o número mais próximo com *>n* casas decimais de precisão. Esta função também trunca um timestamp e retorna uma data.

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

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

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

 *número*   
Um número ou expressão avaliada como um número. Pode ser o DECIMAL ou o FLOAT8 tipo. AWS Clean Rooms pode converter outros tipos de dados de acordo com as regras de conversão implícitas. 

 *inteiro* (opcional)   
Um inteiro que indica o número de casas decimais de precisão, em um dos sentidos. Se nenhum inteiro for fornecido, o número será truncado como um número inteiro; se um inteiro for especificado, o número será truncado para a casa decimal especificada. 

 *timestamp*   
A função também pode retornar a data de um timestamp. (Para retornar um valor de timestamp com `00:00:00` como a hora, converta o resultado da função para um timestamp.) 

## Tipo de retorno
<a name="TRUNC-return-type"></a>

TRUNC retorna o mesmo tipo de dados que o primeiro argumento de entrada. Para timestamps, TRUNC retorna uma data. 

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

Trunque a comissão paga para determinada transação de vendas. 

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

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

(1 row)
```

Trunque o mesmo valor de comissão para a primeira casa decimal. 

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

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

(1 row)
```

Trunque a comissão com um valor negativo para o segundo argumento; `111.15` é arredondado para `110`. 

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

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

Retorna a porção de data do resultado da função SYSDATE (que retorna um timestamp): 

```
select sysdate;

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

select trunc(sysdate);

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

Aplique a função TRUNC à uma coluna TIMESTAMP. O tipo de retorno é uma data. 

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

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