Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Fonctions mathématiques
<a name="Math_functions-spark"></a>

Cette section décrit les opérateurs mathématiques et les fonctions pris en charge dans AWS Clean Rooms Spark SQL. 

**Topics**
+ [Symboles d’opérateurs mathématiques](OPERATOR_SYMBOLS.md)
+ [Fonction ABS](ABS.md)
+ [Fonction ACOS](ACOS.md)
+ [Fonction ASIN](ASIN.md)
+ [Fonction ATAN](ATAN.md)
+ [ATAN2 fonction](ATAN2.md)
+ [Fonction CBRT](CBRT.md)
+ [Fonction CEILING (ou CEIL)](CEILING_FLOOR.md)
+ [Fonction COS](COS.md)
+ [Fonction COT](COT.md)
+ [Fonction DEGREES](DEGREES.md)
+ [Fonction DIV](DIV.md)
+ [Fonction EXP](EXP.md)
+ [Fonction FLOOR](FLOOR.md)
+ [Fonction LN](LN.md)
+ [Fonction LOG](LOG.md)
+ [Fonction MOD](MOD.md)
+ [Fonction PI](PI.md)
+ [Fonction POWER](POWER.md)
+ [Fonction RADIANS](RADIANS.md)
+ [Fonction RAND](RAND.md)
+ [Fonction RANDOM](RANDOM.md)
+ [Fonction ROUND](ROUND.md)
+ [Fonction SIGN](SIGN.md)
+ [Fonction SIN](SIN.md)
+ [Fonction SQRT](SQRT.md)
+ [Fonction TRUNC](TRUNC.md)

# Symboles d’opérateurs mathématiques
<a name="OPERATOR_SYMBOLS"></a>

 Le tableau suivant répertorie les opérateurs mathématiques pris en charge. 

## Opérateurs pris en charge
<a name="OPERATOR_SYMBOLS-supported-operators"></a>

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

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

Calculez la commission payée plus des frais de gestion de 2\$1 pour une transaction donnée : 

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

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

Calculer 20 % du prix de vente pour une transaction donnée : 

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

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

Prévoyez le nombre de billets vendus en fonction d'un modèle de croissance continue. Dans cet exemple, la sous-requête renvoie le nombre de billets vendus en 2008. Ce résultat est multiplié de façon exponentielle par un taux de croissance continu de 5 % sur 10 ans. 

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

Trouvez le prix total payé et les commissions pour les ventes dont le numéro de date est supérieur ou égal à 2 000. Puis soustrayez la commission totale du prix total payé. 

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

# Fonction ABS
<a name="ABS"></a>

 ABS calcule la valeur absolue d’un nombre, où ce nombre peut être littéral ou une expression qui a pour valeur un nombre. 

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

```
ABS (number)
```

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

 *number*   
Nombre ou expression ayant pour valeur un nombre. Il peut s'agir de SMALLINT, INTEGER, BIGINT, DECIMAL ou de type. FLOAT4 FLOAT8 

## Type de retour
<a name="ABS-return-type"></a>

ABS renvoie le même type de données que sont argument. 

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

Calculez la valeur absolue de -38 : 

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

Calculez la valeur absolue de (14-76) : 

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

# Fonction ACOS
<a name="ACOS"></a>

ACOS est une fonction trigonométrique qui renvoie l’arc cosinus d’un nombre. La valeur de retour est exprimée en radians et se situe entre `0` et `PI`.

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

```
ACOS(number)
```

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

 *number*   
Le paramètre d’entrée est un nombre `DOUBLE PRECISION`. 

## Type de retour
<a name="ACOS-return-type"></a>

`DOUBLE PRECISION`

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

Pour renvoyer l’arc cosinus de `-1`, utilisez l’exemple suivant. 

```
SELECT ACOS(-1);

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

# Fonction ASIN
<a name="ASIN"></a>

ASIN est une fonction trigonométrique qui renvoie l’arc sinus d’un nombre. La valeur de retour est exprimée en radians et se situe entre `PI/2` et `-PI/2`. 

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

```
ASIN(number)
```

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

 *number*   
Le paramètre d’entrée est un nombre `DOUBLE PRECISION`. 

## Type de retour
<a name="ASIN-return-type"></a>

`DOUBLE PRECISION`

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

Pour renvoyer l’arc sinus de `1`, utilisez l’exemple suivant. 

```
SELECT ASIN(1) AS halfpi;

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

# Fonction ATAN
<a name="ATAN"></a>

ATAN est une fonction trigonométrique qui renvoie l’arc tangente d’un nombre. La valeur de retour est exprimée en radians et se situe entre `-PI` et `PI`.

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

```
ATAN(number)
```

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

 *number*   
Le paramètre d’entrée est un nombre `DOUBLE PRECISION`. 

## Type de retour
<a name="ATAN-return-type"></a>

`DOUBLE PRECISION`

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

Pour renvoyer l’arc tangente de `1` et le multiplier par 4, utilisez l’exemple suivant.

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

# ATAN2 fonction
<a name="ATAN2"></a>

ATAN2 est une fonction trigonométrique qui renvoie l'arc tangente d'un nombre divisé par un autre nombre. La valeur de retour est exprimée en radians et se situe entre `PI/2` et `-PI/2`. 

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

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

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

 *number1*   
Nombre `DOUBLE PRECISION`. 

 *number2*   
Nombre `DOUBLE PRECISION`. 

## Type de retour
<a name="ATAN2-return-type"></a>

`DOUBLE PRECISION`

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

Pour renvoyer l’arc tangente de `2/2` et le multiplier par 4, utilisez l’exemple suivant. 

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

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

# Fonction CBRT
<a name="CBRT"></a>

 La fonction CBRT est une fonction mathématique qui calcule la racine cubique d'un nombre. 

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

```
CBRT (number)
```

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

CBRT prend un certain nombre DOUBLE PRECISION en tant qu'argument. 

## Type de retour
<a name="CBRT-return-type"></a>

CBRT renvoie un nombre DOUBLE PRECISION. 

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

Calculez la racine cubique de la commission payée pour une transaction donnée : 

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

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

# Fonction CEILING (ou CEIL)
<a name="CEILING_FLOOR"></a>

La fonction CEILING (ou CEIL) permet d’arrondir un nombre jusqu’au nombre entier supérieur suivant. (Le [Fonction FLOOR](FLOOR.md) arrondit un nombre au nombre entier inférieur suivant.) 

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

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

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

 *number*   
Nombre ou expression ayant pour valeur un nombre. Il peut s'agir de SMALLINT, INTEGER, BIGINT, DECIMAL ou de type. FLOAT4 FLOAT8 

## Type de retour
<a name="CEILING_FLOOR-return-type"></a>

CEILING et CEIL renvoient le même type de données que leur argument. 

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

Calculez le plafond de la commission payée pour une transaction de vente donnée : 

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

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

# Fonction COS
<a name="COS"></a>

COS est une fonction trigonométrique qui renvoie le cosinus d’un nombre. La valeur de retour est exprimée en radians et se situe entre `-1` et `1`, inclus. 

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

```
COS(double_precision)
```

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

 *number*   
Le paramètre d'entrée est un nombre double précision. 

## Type de retour
<a name="COS-return-type"></a>

La fonction COS renvoie un nombre double précision. 

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

L'exemple suivant renvoie le cosinus de 0 : 

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

L'exemple suivant renvoie le cosinus de PI : 

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

# Fonction COT
<a name="COT"></a>

COT est une fonction trigonométrique qui renvoie la cotangente d’un nombre. Le paramètre d’entrée doit être différent de zéro. 

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

```
COT(number)
```

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

 *number*   
Le paramètre d’entrée est un nombre `DOUBLE PRECISION`. 

## Type de retour
<a name="COT-return-type"></a>

`DOUBLE PRECISION`

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

Pour renvoyer la cotangente de 1, utilisez l’exemple suivant. 

```
SELECT COT(1);

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

# Fonction DEGREES
<a name="DEGREES"></a>

Convertit un angle en radians en son équivalent en degrés. 

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

```
DEGREES(number)
```

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

 *number*   
Le paramètre d’entrée est un nombre `DOUBLE PRECISION`. 

## Type de retour
<a name="DEGREES-return-type"></a>

`DOUBLE PRECISION`

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

Pour renvoyer l’équivalent en degrés de 0,5 radian, utilisez l’exemple suivant. 

```
SELECT DEGREES(.5);

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

Pour convertir PI radians en degrés, utilisez l’exemple suivant. 

```
SELECT DEGREES(pi());

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

# Fonction DIV
<a name="DIV"></a>

L'opérateur DIV renvoie la partie intégrante de la division du dividende par diviseur. 

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

```
dividend div divisor
```

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

 *dividende*   
Expression dont l'évaluation correspond à un chiffre ou à un intervalle.

*divisor*  
Un intervalle correspondant de type if `dividend` est un intervalle, un intervalle numérique dans le cas contraire.

## Type de retour
<a name="DIV-returns"></a>

`BIGINT`

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

L'exemple suivant sélectionne deux colonnes dans la table des écureuils : la `id` colonne, qui contient l'identifiant unique de chaque écureuil, et une `calculated` colonne`age div 2`, qui représente la division entière de la colonne d'âge par 2. Le `age div 2` calcul effectue une division entière sur la `age` colonne, arrondissant ainsi l'âge au nombre entier pair le plus proche. Par exemple, si la `age` colonne contient des valeurs telles que 3, 5, 7 et 10, elle contiendra les valeurs 1, 2, 3 et 5, respectivement. `age div 2` 

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

Cette requête peut être utile dans les scénarios où vous devez regrouper ou analyser des données en fonction de tranches d'âge, et vous souhaitez simplifier les valeurs d'âge en les arrondissant à l'entier pair le plus proche. Le résultat obtenu fournirait l'âge `id` et l'âge divisés par 2 pour chaque écureuil du `squirrels` tableau. 

# Fonction EXP
<a name="EXP"></a>

La fonction EXP implémente la fonction exponentielle pour une expression numérique, ou la base du logarithme naturel, `e`, élevée à la puissance de l'expression. La fonction EXP est l’inverse de [Fonction LN](LN.md). 

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

```
EXP (expression)
```

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

 *expression*   
L'expression doit être un type de données INTEGER, DECIMAL ou DOUBLE PRECISION. 

## Type de retour
<a name="EXP-return-type"></a>

EXP renvoie un nombre DOUBLE PRECISION. 

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

Utilisez la fonction EXP de planifier des ventes de billets selon un modèle de croissance continue. Dans cet exemple, la sous-requête renvoie le nombre de billets vendus en 2008. Ce résultat est multiplié par le résultat de la fonction EXP, qui spécifie une croissance continue de 7 % sur 10 ans. 

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

# Fonction FLOOR
<a name="FLOOR"></a>

La fonction FLOOR arrondit un nombre au nombre entier inférieur suivant. 

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

```
FLOOR (number)
```

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

 *number*   
Nombre ou expression ayant pour valeur un nombre. Il peut s'agir de SMALLINT, INTEGER, BIGINT, DECIMAL ou de type. FLOAT4 FLOAT8 

## Type de retour
<a name="FLOOR-return-type"></a>

FLOOR renvoie le même type de données que sont argument. 

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

L'exemple montre la valeur de la commission payée pour une transaction de vente donnée avant et après l'utilisation de la fonction 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)
```

# Fonction LN
<a name="LN"></a>

La fonction LN renvoie le logarithme naturel du paramètre d'entrée. 

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

```
LN(expression)
```

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

 *expression*   
Colonne cible ou expression sur laquelle la fonction opère.   
Cette fonction renvoie une erreur pour certains types de données si l'expression fait référence à une table AWS Clean Rooms créée par l'utilisateur ou à une table AWS Clean Rooms système STL ou STV. 
Les expressions régulières avec les types de données suivants génèrent une erreur si elles font référence à une table créée par l’utilisateur ou à une table système.  
+ BOOLEAN 
+ CHAR 
+ DATE 
+ DECIMAL ou NUMERIC 
+ TIMESTAMP 
+ VARCHAR 
Les expressions régulières avec les types de données suivants s’exécutent avec succès sur des tables créées par l’utilisateur ou des tables système STL ou STV :   
+ BIGINT 
+ DOUBLE PRECISION 
+ INTEGER 
+ REAL 
+ SMALLINT 

## Type de retour
<a name="LN-return-type"></a>

La fonction LN renvoie le même type que l'expression. 

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

L'exemple suivant renvoie le logarithme naturel, ou logarithme de base e, du nombre 2,718281828 : 

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

Notez que la réponse est presque égale à 1. 

Cet exemple renvoie le logarithme naturel des valeurs de la colonne USERID de la table 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)
```

# Fonction LOG
<a name="LOG"></a>

Renvoie le logarithme de `expr` with`base`.

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

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

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

 *expr*   
L’expression doit comporter un type de données de nombre entier, décimale ou à virgule flottante. 

 *base*   
Base pour le calcul du logarithme. Doit être un nombre positif (différent de 1) de type de données à double précision. 

## Type de retour
<a name="LOG-return-type"></a>

La fonction LOG renvoie un nombre double précision. 

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

L'exemple suivant renvoie le logarithme de base 10 du chiffre 100 : 

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

# Fonction MOD
<a name="MOD"></a>

Renvoie le reste de deux nombres, autrement dit une opération *modulo*. Pour calculer le résultat, le premier paramètre est divisé par le second.

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

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

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

 *number1*   
Le premier paramètre d'entrée est un nombre INTEGER, SMALLINT, BIGINT ou DECIMAL. Si un paramètre est de type DECIMAL, l'autre paramètre doit également être un type DECIMAL. Si un paramètre est un INTEGER, l'autre paramètre peut être un INTEGER, SMALLINT ou BIGINT. Les deux paramètres peuvent également être SMALLINT ou BIGINT, mais un paramètre ne peut pas être un SMALLINT si l'autre est un BIGINT. 

 *number2*   
Le second paramètre est un nombre INTEGER, SMALLINT, BIGINT ou DECIMAL. Les mêmes règles de type de données s’appliquent à *number2* en ce qui concerne *number1*. 

## Type de retour
<a name="MOD-return-type"></a>

Les types de retour valides sont DECIMAL, INT, SMALLINT et BIGINT. Le type de retour de la fonction MOD est le même type numérique que les paramètres d’entrée, si les deux paramètres d’entrée sont de même type. Si un paramètre d'entrée est un INTEGER, toutefois, le type de retour sera également un INTEGER. 

## Notes d’utilisation
<a name="MOD-usage-notes"></a>

Vous pouvez utiliser *%* comme opérateur modulo.

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

L'exemple suivant renvoie le reste lorsqu'un nombre est divisé par un autre :

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

L'exemple suivant renvoie un résultat décimal :

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

Vous pouvez projeter les valeurs des paramètres :

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

Vérifiez si le premier paramètre est pair en le divisant par 2 :

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

Vous pouvez utiliser le *%* comme opérateur modulo :

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

L'exemple suivant renvoie des informations pour les catégories impaires dans la table 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)
```

# Fonction PI
<a name="PI"></a>

La fonction PI renvoie la valeur de pi à 14 décimales. 

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

```
PI()
```

## Type de retour
<a name="PI-return-type"></a>

`DOUBLE PRECISION`

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

Pour renvoyer la valeur de pi, utilisez l’exemple suivant.

```
SELECT PI();

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

# Fonction POWER
<a name="POWER"></a>

 La fonction POWER est une fonction exponentielle qui élève une expression numérique à la puissance d’une seconde expression numérique. Par exemple, 2 à la puissance 3 est calculé sous la forme `POWER(2,3)`, avec un résultat de `8`. 

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

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

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

 *expression1*   
Expression numérique à élever. Doit avoir le type de données `INTEGER`, `DECIMAL` ou `FLOAT`. 

 *expression2*   
Puissance à laquelle élever *expression1*. Doit avoir le type de données `INTEGER`, `DECIMAL` ou `FLOAT`. 

## Type de retour
<a name="POWER-return-type"></a>

`DOUBLE PRECISION`

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

# Fonction RADIANS
<a name="RADIANS"></a>

La fonction RADIANS convertit un angle en degrés en son équivalent en radians. 

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

```
RADIANS(number)
```

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

 *number*   
Le paramètre d’entrée est un nombre `DOUBLE PRECISION`. 

## Type de retour
<a name="RADIANS-return-type"></a>

`DOUBLE PRECISION`

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

Pour renvoyer l’équivalent en radians de 180 degrés, utilisez l’exemple suivant. 

```
SELECT RADIANS(180);

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

# Fonction RAND
<a name="RAND"></a>

La fonction RAND génère un nombre aléatoire à virgule flottante compris entre 0 et 1. La fonction RAND génère un nouveau nombre aléatoire à chaque fois qu'elle est appelée.

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

```
RAND()
```

## Type de retour
<a name="RAND-return-type"></a>

RANDOM renvoie un DOUBLE. 

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

L'exemple suivant génère une colonne de nombres aléatoires à virgule flottante compris entre 0 et 1 pour chaque ligne du tableau. `squirrels` Le résultat obtenu serait une colonne unique contenant une liste de valeurs décimales aléatoires, avec une valeur pour chaque ligne de la table des écureuils. 

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

Ce type de requête est utile lorsque vous devez générer des nombres aléatoires, par exemple pour simuler des événements aléatoires ou pour introduire le caractère aléatoire dans votre analyse de données. Dans le contexte du `squirrels` tableau, il peut être utilisé pour attribuer des valeurs aléatoires à chaque écureuil, qui pourraient ensuite être utilisées pour un traitement ou une analyse plus poussés.

# Fonction RANDOM
<a name="RANDOM"></a>

La fonction RANDOM génère une valeur aléatoire compris entre 0,0 (inclus) et 1,0 (exclusif). 

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

```
RANDOM()
```

## Type de retour
<a name="RANDOM-return-type"></a>

RANDOM renvoie un nombre DOUBLE PRECISION. 

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

1. Calculez une valeur aléatoire comprise entre 0 et 99. Si le nombre aléatoire est de 0 à 1, cette requête génère un nombre aléatoire de 0 à 100 : 

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

1. Récupère un échantillon aléatoire uniforme de 10 éléments :

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

   Maintenant, récupérez un échantillon aléatoire de 10 éléments, mais choisissez les éléments en fonction de leur prix. Par exemple, un élément dont le prix est le double d'un autre a deux fois plus de chance d'apparaître dans les résultats de la requête :

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

1. Cet exemple utilise la commande SET pour définir une valeur SEED afin que RANDOM génère une séquence de nombres prévisible. 

   D’abord, renvoyez trois entiers RANDOM sans définir au préalable la valeur 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)
   ```

   A présent, définissez la valeur SEED sur `.25` et renvoyez trois nombres RANDOM supplémentaires : 

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

   Enfin, réinitialisez la valeur SEED sur `.25` et vérifiez que RANDOM renvoie les mêmes résultats que les trois appels précédents : 

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

# Fonction ROUND
<a name="ROUND"></a>

La fonction ROUND arrondit des nombres à l’entier ou à la décimale la plus proche. 

La fonction ROUND peut éventuellement inclure un second argument sous forme de nombre entier permettant d'indiquer le nombre de décimales de l'arrondi, dans les deux sens. Lorsque vous ne fournissez pas le second argument, la fonction arrondit au nombre entier le plus proche. Lorsque le second argument *>n* est spécifié, la fonction arrondit au nombre le plus proche avec une précision de *n* décimales. 

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

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

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

 *number*   
Nombre ou expression ayant pour valeur un nombre. Il peut s'agir du DECIMAL ou du FLOAT8 type. AWS Clean Rooms peut convertir d'autres types de données selon les règles de conversion implicites. 

*integer* (facultatif)  
Nombre entier qui indique le nombre de décimales pour l'arrondi dans les deux sens. 

## Type de retour
<a name="ROUND-return-type"></a>

ROUND renvoie le même type de données numériques en tant qu'argument(s) d'entrée. 

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

Arrondit la commission payée pour une transaction donnée au nombre entier le plus proche. 

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

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

Arrondit la commission payée pour une transaction donnée à la première décimale. 

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

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

Pour la même requête, étendez la précision dans l'autre sens. 

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

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

# Fonction SIGN
<a name="SIGN"></a>

 La fonction SIGN renvoie le signe (positif ou négatif) d’un nombre. Le résultat de la fonction SIGN est `1`, `-1` ou `0`, ce qui indique le signe de l'argument. 

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

```
SIGN (number)
```

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

 *number*   
Nombre ou expression ayant pour valeur un nombre. C'est peut-être le DECIMALor FLOAT8 genre. AWS Clean Rooms peut convertir d'autres types de données selon les règles de conversion implicites.

## Type de retour
<a name="SIGN-return-type"></a>

SIGN renvoie le même type de données numériques en tant qu'argument(s) d'entrée. Si l'entrée est DECIMAL, la sortie est DECIMAL(1,0). 

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

Pour déterminer le signe de la commission payée pour une transaction donnée à partir de la table SALES, utilisez l’exemple suivant. 

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

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

# Fonction SIN
<a name="SIN"></a>

SIN est une fonction trigonométrique qui renvoie le sinus d’un nombre. La valeur renvoyée est comprise entre `-1` et `1`. 

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

```
SIN(number)
```

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

 *number*   
Nombre `DOUBLE PRECISION` en radians. 

## Type de retour
<a name="SIN-return-type"></a>

`DOUBLE PRECISION` 

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

Pour renvoyer le sinus de `-PI`, utilisez l’exemple suivant.

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

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

# Fonction SQRT
<a name="SQRT"></a>

 La fonction SQRT renvoie la racine carrée d'une valeur numérique. La racine carrée est un nombre multiplié par lui-même pour obtenir la valeur donnée.

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

```
SQRT (expression)
```

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

 *expression*   
L’expression doit comporter un type de données de nombre entier, décimale ou à virgule flottante. L'expression peut inclure des fonctions. Le système peut effectuer des conversions de type implicites. 

## Type de retour
<a name="SQRT-return-type"></a>

SQRT renvoie un nombre DOUBLE PRECISION.

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

L'exemple suivant renvoie la racine carrée d'un nombre. 

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

L'exemple suivant effectue une conversion de type implicite.

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

L'exemple suivant imbrique des fonctions pour effectuer une tâche plus complexe. 

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

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

L'exemple suivant donne la longueur du rayon lorsque l'aire du cercle est indiquée. Il calcule le rayon en pouces, par exemple, lorsque la surface est indiquée en pouces carrés. Dans l'exemple, l'aire est de 20. 

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

La valeur renvoyée est 5.046265044040321.

L'exemple suivant renvoie la racine carrée des valeurs de COMMISSION de la table SALES. La colonne COMMISSION est une colonne DECIMAL. Cet exemple montre comment utiliser la fonction dans une requête ayant une logique conditionnelle plus complexe. 

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

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

La requête suivante renvoie la racine carré arrondie du même ensemble de valeurs 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
...
```

Pour plus d'informations sur les exemples de données dans AWS Clean Rooms, consultez la section [Exemple de base de données](https://docs.aws.amazon.com/redshift/latest/dg/c_sampledb.html).

# Fonction TRUNC
<a name="TRUNC"></a>

La fonction TRUNC tronque les nombres à l'entier ou à la décimale précédente. 

La fonction TRUNC peut éventuellement inclure un second argument : un nombre entier permettant d'indiquer le nombre de décimales de l'arrondi, dans les deux sens. Lorsque vous ne fournissez pas le second argument, la fonction arrondit au nombre entier le plus proche. Lorsque le second argument *>n* est spécifié, la fonction arrondit au nombre le plus proche avec une précision de *n* décimales. Cette fonction tronque également un horodatage et renvoie une date.

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

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

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

 *number*   
Nombre ou expression ayant pour valeur un nombre. Il peut s'agir du DECIMAL ou du FLOAT8 type. AWS Clean Rooms peut convertir d'autres types de données selon les règles de conversion implicites. 

 *integer* (facultatif)   
Nombre entier qui indique le nombre de décimales de précision, dans les deux sens. Si aucun nombre entier n’est fourni, le nombre est tronqué en tant que nombre entier ; si un nombre entier est spécifié, le nombre est tronqué à la décimale spécifiée. 

 *timestamp*   
La fonction peut également renvoyer la date à partir d'un horodatage. (Pour renvoyer une valeur d'horodatage avec `00:00:00` comme heure, envoyez le résultat de la fonction à un horodatage.) 

## Type de retour
<a name="TRUNC-return-type"></a>

TRUNC renvoie le même type de données que le premier argument d'entrée. Pour les horodatages, TRUNC renvoie une date. 

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

Tronque la commission payée pour une transaction de vente donnée. 

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

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

(1 row)
```

Tronque la même valeur de commission que la première décimale. 

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

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

(1 row)
```

Tronque la commission avec une valeur négative pour le second argument ; `111.15` est arrondi à `110`. 

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

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

Renvoyez la partie de date du résultat de la fonction SYSDATE (qui renvoie un horodatage) : 

```
select sysdate;

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

select trunc(sysdate);

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

Appliquez la fonction TRUNC à une colonne TIMESTAMP. Le type de retour est une date. 

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

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