Fonctions mathématiques MaxCompute - MaxCompute - Centre de documentation Alibaba Cloud

MaxCompute V2.0 fournit des fonctions supplémentaires. Si les fonctions que vous utilisez impliquent de nouveaux types de données pris en charge dans l'édition de type de données MaxCompute V2.0, vous devez exécuter l'instruction SET pour activer cette édition. Les nouveaux types de données incluent TINYINT, SMALLINT, INT, FLOAT, VARCHAR, TIMESTAMP et BINARY.

Niveau session : pour utiliser l'édition de type de données MaxCompute V2.0, ajoutez set odps.sql.type.system.odps2=true; avant l'instruction SQL à exécuter, puis validez et exécutez-les ensemble.
Niveau projet : le propriétaire du projet peut activer l'édition de type de données MaxCompute V2.0 pour le projet en fonction des besoins. La configuration prend effet après 10 à 15 minutes. Pour activer l'édition de type de données MaxCompute V2.0 au niveau du projet, exécutez la commande suivante :
```
setproject odps.sql.type.system.odps2=true; 
```
Pour plus d'informations sur setproject, consultez la rubrique Opérations sur les projets. Pour plus d'informations sur les précautions à prendre lors de l'activation de l'édition de type de données MaxCompute V2.0 au niveau du projet, consultez la rubrique Guide des versions de types de données.

Données d'exemple

Pour faciliter la compréhension de l'utilisation de chaque fonction, cette rubrique fournit des données source et des exemples basés sur ces données. La commande d'exemple suivante crée une table nommée mf_math_fun_t et y ajoute des données.

create table if not exists mf_math_fun_t(
     int_data     int,
     bigint_data  bigint,
     double_data  double,
     decimal_data decimal,
     float_data   float,
     string_data  string
    );
insert into mf_math_fun_t values
(null, -10, 0.525, 0.525BD, cast(0.525 as float), '10'),
(-20, null, -0.1, -0.1BD, cast(-0.1 as float), '-10'),
(0, -1, null, 20.45BD, cast(-1 as float), '30'),
(-40, 4, 0.89, null, cast(0.89 as float), '-30'),
(5, -50, -1, -1BD, null, '50'),
(-60, 6, 1.5, 1.5BD, cast(1.5 as float), '-50'),
(-1, -70, -7.5, -7.5BD, cast(-7.5 as float),null ),
(-80, 1, -10.2, -10.2BD, cast(-10.2 as float), '-1' ),
(9, -90, 2.58, 2.58BD, cast(2.58 as float), '0'),
(-100, 10, -5.8, -5.8BD, cast(-5.8 as float), '-90');

La commande suivante interroge les données de la table mf_math_fun_t :

select * from mf_math_fun_t;
-- The following result is returned.
+----------+-------------+-------------+--------------+------------+-------------+
| int_data | bigint_data | double_data | decimal_data | float_data | string_data |
+----------+-------------+-------------+--------------+------------+-------------+
| NULL     | -10         | 0.525       | 0.525        | 0.525      | 10          |
| -20      | NULL        | -0.1        | -0.1         | -0.1       | -10         |
| 0        | -1          | NULL        | 20.45        | -1         | 30          |
| -40      | 4           | 0.89        | NULL         | 0.89       | -30         |
| 5        | -50         | -1.0        | -1           | NULL       | 50          |
| -60      | 6           | 1.5         | 1.5          | 1.5        | -50         |
| -1       | -70         | -7.5        | -7.5         | -7.5       | NULL        |
| -80      | 1           | -10.2       | -10.2        | -10.2      | -1          |
| 9        | -90         | 2.58        | 2.58         | 2.58       | 0           |
| -100     | 10          | -5.8        | -5.8         | -5.8       | -90         |
+----------+-------------+-------------+--------------+------------+-------------+

ABS

Syntaxe
```
bigint|double|decimal abs(<number>)
```
Description

Calcule la valeur absolue de number.
Paramètres

number : obligatoire. Valeur de type DOUBLE, BIGINT ou DECIMAL. Si la valeur d'entrée est de type STRING, elle est implicitement convertie en valeur de type DOUBLE pour le calcul.

Remarque
Si la valeur d'entrée est de type BIGINT et dépasse la plage de valeurs BIGINT, la valeur est convertie en type DOUBLE. Cette conversion peut entraîner une perte de précision.
Valeur renvoyée
Le type de données de la valeur renvoyée est identique à celui du paramètre d'entrée. Les règles suivantes s'appliquent :
- Si number est de type DOUBLE, BIGINT ou DECIMAL, une valeur du type correspondant est renvoyée.
- Si number est de type STRING, une valeur de type DOUBLE est renvoyée.
- Si number est NULL, NULL est renvoyé.

Exemples

Exemples avec données statiques

--The return value is NULL.
select abs(null);
--The return value is 1.
select abs(-1);
--The return value is 1.2.
select abs(-1.2);
--The return value is 2.0.
select abs("-2");
--The return value is 1.2232083745629837e32.
select abs(122320837456298376592387456923748);
--Calculates the absolute value of the id field in the tbl1 table. The following code provides a complete example on how to use the ABS function in an SQL statement. Other built-in functions, except window functions and aggregate functions, are used in a similar way.
select abs(id) from tbl1;

Exemples avec données de table

Sur la base des données d'exemple, la commande suivante calcule la valeur absolue.

select abs(bigint_data) as bigint_new, abs(double_data) as double_new, abs(decimal_data) as decimal_new, abs(string_data) as string_new from mf_math_fun_t;

Le résultat suivant est renvoyé.

+------------+------------+-------------+------------+
| bigint_new | double_new | decimal_new | string_new |
+------------+------------+-------------+------------+
| 10         | 0.525      | 0.525       | 10.0       |
| NULL       | 0.1        | 0.1         | 10.0       |
| 1          | NULL       | 20.45       | 30.0       |
| 4          | 0.89       | NULL        | 30.0       |
| 50         | 1.0        | 1           | 50.0       |
| 6          | 1.5        | 1.5         | 50.0       |
| 70         | 7.5        | 7.5         | NULL       |
| 1          | 10.2       | 10.2        | 1.0        |
| 90         | 2.58       | 2.58        | 0.0        |
| 10         | 5.8        | 5.8         | 90.0       |
+------------+------------+-------------+------------+

ACOS

Syntaxe
```
double|decimal acos(<number>)
```
Description

Calcule l'arccosinus de number.
Paramètres

number : obligatoire. Valeur comprise dans la plage [-1, 1]. La valeur est de type DOUBLE ou DECIMAL. Si la valeur d'entrée est de type STRING ou BIGINT, elle est implicitement convertie en valeur de type DOUBLE pour le calcul.
Valeur renvoyée
Le type de données de la valeur renvoyée est identique à celui du paramètre d'entrée. La valeur est comprise dans la plage de 0 à π. Les règles suivantes s'appliquent :
- Si number est de type DOUBLE ou DECIMAL, une valeur du type correspondant est renvoyée.
- Si number est de type STRING ou BIGINT, une valeur de type DOUBLE est renvoyée.
- Si la valeur de number n'est pas comprise dans la plage [-1, 1], NULL est renvoyé. En mode compatible Hive, NaN est renvoyé.
- Si la valeur de number est NULL, NULL est renvoyé.

Exemples

Exemples avec données statiques

--The return value is 0.5155940062460905.
select acos("0.87");
--The return value is 1.5707963267948966.
select acos(0);
--The return value is NULL.
select acos(null);

Exemples avec données de table

Sur la base des données d'exemple, la commande suivante calcule l'arccosinus.

select acos(bigint_data) as bigint_new, acos(double_data) as double_new, acos(decimal_data) as decimal_new, acos(string_data) as string_new from mf_math_fun_t;

Le résultat suivant est renvoyé.

+-------------------+--------------------+--------------------+---------------------+
| bigint_new        | double_new         | decimal_new        | string_new          |
+-------------------+--------------------+--------------------+---------------------+
| NULL              | 1.0180812136981134 | 1.0180812136981134 | NULL                |
| NULL              | 1.6709637479564565 | 1.6709637479564565 | NULL                |
| 3.141592653589793 | NULL               | NULL               | NULL                |
| NULL              | 0.4734511572720662 | NULL               | NULL                |
| NULL              | 3.141592653589793  | 3.141592653589793  | NULL                |
| NULL              | NULL               | NULL               | NULL                |
| NULL              | NULL               | NULL               | NULL                |
| 0.0               | NULL               | NULL               | 3.141592653589793   |
| NULL              | NULL               | NULL               | 1.5707963267948966  |
| NULL              | NULL               | NULL               | NULL                |
+-------------------+--------------------+--------------------+---------------------+

ATAN2

Syntaxe
```
double atan2(<expr1>, <expr2>)
```
Description

Calcule l'arctangente de expr1/expr2.
Paramètres
- expr1 : obligatoire. Valeur de type DOUBLE. Si la valeur d'entrée est de type STRING, BIGINT ou DECIMAL, elle est implicitement convertie en valeur de type DOUBLE pour le calcul.
- expr2 : obligatoire. Valeur de type DOUBLE. Si la valeur d'entrée est de type STRING, BIGINT ou DECIMAL, elle est implicitement convertie en valeur de type DOUBLE pour le calcul.
Valeur renvoyée

Une valeur de type DOUBLE est renvoyée. La valeur est comprise dans la plage de -π/2 to π/2. Si la valeur de expr1 ou de expr2 est NULL, NULL est renvoyé.

Exemple

--The return value is 0.0.
select atan2(0, 0);

ASIN

Syntaxe
```
double|decimal asin(<number>)
```
Description

Calcule l'arcsinus de number.
Paramètres

number : obligatoire. Valeur comprise dans la plage [-1, 1]. La valeur est de type DOUBLE ou DECIMAL. Si la valeur d'entrée est de type STRING ou BIGINT, elle est implicitement convertie en valeur de type DOUBLE pour le calcul.
Valeur renvoyée
Le type de données de la valeur renvoyée est identique à celui du paramètre d'entrée. La valeur est comprise dans la plage de -π/2 to π/2. Les règles suivantes s'appliquent :
- Si number est de type DOUBLE ou DECIMAL, une valeur du type correspondant est renvoyée.
- Si number est de type STRING ou BIGINT, une valeur de type DOUBLE est renvoyée.
- Si la valeur de number n'est pas comprise dans la plage [-1, 1], NULL est renvoyé. En mode compatible Hive, NaN est renvoyé.
- Si la valeur de number est NULL, NULL est renvoyé.

Exemples

Exemples avec données statiques

--The return value is 1.5707963267948966.
select asin(1);
--The return value is -1.5707963267948966.
select asin(-1);
--The return value is NULL.
select asin(null);

Exemples avec données de table

Sur la base des données d'exemple, la commande suivante calcule l'arcsinus.

select asin(bigint_data) as bigint_new, asin(double_data) as double_new, asin(decimal_data) as decimal_new, asin(string_data) as string_new from mf_math_fun_t;

Le résultat suivant est renvoyé.

+--------------------+---------------------+---------------------+---------------------+
| bigint_new         | double_new          | decimal_new         | string_new          |
+--------------------+---------------------+---------------------+---------------------+
| NULL               | 0.5527151130967832  | 0.5527151130967832  | NULL                |
| NULL               | -0.1001674211615598 | -0.1001674211615598 | NULL                |
| -1.5707963267948966| NULL                | NULL                | NULL                |
| NULL               | 1.0973451695228305  | NULL                | NULL                |
| NULL               | -1.5707963267948966 | -1.5707963267948966 | NULL                |
| NULL               | NULL                | NULL                | NULL                |
| NULL               | NULL                | NULL                | NULL                |
| 1.5707963267948966 | NULL                | NULL                | -1.5707963267948966 |
| NULL               | NULL                | NULL                | 0.0                 |
| NULL               | NULL                | NULL                | NULL                |
+--------------------+---------------------+---------------------+---------------------+

ATAN

Syntaxe
```
double atan(<number>)
```
Description

Calcule l'arctangente de number.
Paramètres

number : obligatoire. Valeur de type DOUBLE. Si la valeur d'entrée est de type STRING, BIGINT ou DECIMAL, elle est implicitement convertie en valeur de type DOUBLE pour le calcul.
Valeur renvoyée

Une valeur de type DOUBLE est renvoyée. La valeur est comprise dans la plage de -π/2 to π/2. Si la valeur de number est NULL, NULL est renvoyé.

Exemples

Exemples avec données statiques

--The return value is 0.7853981633974483.
select atan(1);
--The return value is -0.7853981633974483.
select atan(-1);
--The return value is NULL.
select atan(null);

Exemples avec données de table

Sur la base des données d'exemple, la commande suivante calcule l'arctangente.

select atan(bigint_data) as bigint_new, atan(double_data) as double_new, atan(decimal_data) as decimal_new, atan(string_data) as string_new from mf_math_fun_t;

Le résultat suivant est renvoyé.

+---------------------+----------------------+----------------------+---------------------+
| bigint_new          | double_new           | decimal_new          | string_new          |
+---------------------+----------------------+----------------------+---------------------+
| -1.4711276743037347 | 0.483447001567199    | 0.483447001567199    | 1.4711276743037347  |
| NULL                | -0.09966865249116204 | -0.09966865249116204 | -1.4711276743037347 |
| -0.7853981633974483 | NULL                 | 1.521935491607842    | 1.5374753309166493  |
| 1.3258176636680326  | 0.7272626879966904   | NULL                 | -1.5374753309166493 |
| -1.550798992821746  | -0.7853981633974483  | -0.7853981633974483  | 1.550798992821746   |
| 1.4056476493802699  | 0.982793723247329    | 0.982793723247329    | -1.550798992821746  |
| -1.5565115842075    | -1.4382447944982226  | -1.4382447944982226  | NULL                |
| 0.7853981633974483  | -1.473069419436178   | -1.473069419436178   | -0.7853981633974483 |
| -1.5596856728972892 | 1.2010277920014796   | 1.2010277920014796   | 0.0                 |
| 1.4711276743037347  | -1.4000611153196139  | -1.4000611153196139  | -1.5596856728972892 |
+---------------------+----------------------+----------------------+---------------------+

BIN

Syntaxe
```
string bin(<number>)
```
Description

Renvoie la représentation binaire de number. Il s'agit d'une fonction d'extension dans MaxCompute V2.0.
Paramètres

number : obligatoire. Valeur de type BIGINT, INT, SMALLINT ou TINYINT.
Valeur renvoyée
Une valeur de type STRING est renvoyée. Les règles suivantes s'appliquent :
- Si le type de données de number n'est ni BIGINT, ni INT, ni SMALLINT, ni TINYINT, une erreur est renvoyée.
- Si la valeur de number est 0, 0 est renvoyé.
- Si la valeur de number est NULL, NULL est renvoyé.

Exemples

Exemples avec données statiques

--The return value is 0.
select bin(0);
--The return value is NULL.
select bin(null);
--The return value is 1100.
select bin(12);

Exemples avec données de table

Sur la base des données d'exemple, la commande suivante obtient les représentations binaires des colonnes int_data et bigint_data.

--Enable new data types of MaxCompute V2.0. You must run this command together with the SQL statement.
set odps.sql.type.system.odps2=true;
select bin(int_data) as int_new, bin(bigint_data) as bigint_new from mf_math_fun_t;

Le résultat suivant est renvoyé.

+----------------------------------------------------------------------------+------------------------------------------------------------------+
| int_new                                                                    | bigint_new                                                       |
+----------------------------------------------------------------------------+------------------------------------------------------------------+
| NULL                                                                       | 1111111111111111111111111111111111111111111111111111111111110110 |
| 1111111111111111111111111111111111111111111111111111111111101100           | NULL                                                             |
| 0                                                                          | 1111111111111111111111111111111111111111111111111111111111111111 |
| 1111111111111111111111111111111111111111111111111111111111011000           | 100                                                              |
| 101                                                                        | 1111111111111111111111111111111111111111111111111111111111001110 |
| 1111111111111111111111111111111111111111111111111111111111000100           | 110                                                              |
| 1111111111111111111111111111111111111111111111111111111111111111           | 1111111111111111111111111111111111111111111111111111111110111010 |
| 1111111111111111111111111111111111111111111111111111111110110000           | 1                                                                |
| 1001                                                                       | 1111111111111111111111111111111111111111111111111111111110100110 |
| 1111111111111111111111111111111111111111111111111111111110011100           | 1010                                                             |
+----------------------------------------------------------------------------+------------------------------------------------------------------+

CBRT

Syntaxe
```
double cbrt(<number>)
```
Description

Calcule la racine cubique de number. Il s'agit d'une fonction d'extension dans MaxCompute V2.0.
Paramètres

number : obligatoire. Valeur de type BIGINT, INT, SMALLINT, TINYINT, DOUBLE, FLOAT ou STRING.
Valeur renvoyée
Une valeur de type DOUBLE est renvoyée. Les règles suivantes s'appliquent :
- Si le type de données de number n'est ni BIGINT, ni INT, ni SMALLINT, ni TINYINT, ni DOUBLE, ni FLOAT, ni STRING, une erreur est renvoyée.
- Si la valeur de number est NULL, NULL est renvoyé.

Exemples

Exemples avec données statiques

--The return value is 2.0.
select cbrt(8);
--The return value is NULL.
select cbrt(null);

Exemples avec données de table

Sur la base des données d'exemple, la commande suivante obtient la racine cubique de toutes les colonnes sauf decimal_data.

--Enable new data types of MaxCompute V2.0. You must run this command together with the SQL statement.
set odps.sql.type.system.odps2=true;
select cbrt(int_data) as int_new, cbrt(bigint_data) as bigint_new, cbrt(double_data) as double_new, cbrt(float_data) as float_new, cbrt(string_data) as string_new from mf_math_fun_t;

Le résultat suivant est renvoyé.

+---------------------+---------------------+----------------------+---------------------+---------------------+
| int_new             | bigint_new          | double_new           | float_new           | string_new          |
+---------------------+---------------------+----------------------+---------------------+---------------------+
| NULL                | -2.1544346900318834 | 0.806714323012272    | 0.8067143108004823  | 2.1544346900318834  |
| -2.7144176165949063 | NULL                | -0.46415888336127786 | -0.46415888566678   | -2.1544346900318834 |
| 0.0                 | -1.0                | NULL                 | -1.0                | 3.107232505953859   |
| -3.4199518933533937 | 1.5874010519681996  | 0.9619001716077046   | 0.961900166454112   | -3.107232505953859  |
| 1.7099759466766968  | -3.6840314986403864 | -1.0                 | NULL                | 3.6840314986403864  |
| -3.9148676411688634 | 1.8171205928321394  | 1.1447142425533317   | 1.1447142425533317  | -3.6840314986403864 |
| -1.0                | -4.121285299808557  | -1.9574338205844317  | -1.9574338205844317 | NULL                |
| -4.308869380063767  | 1.0                 | -2.168702885250197   | -2.1687028717323127 | -1.0                |
| 2.080083823051904   | -4.481404746557165  | 1.3715339700741747   | 1.3715339565548288  | 0.0                 |
| -4.641588833612778  | 2.1544346900318834  | -1.7967017791430528  | -1.7967017988380907 | -4.481404746557165  |
+---------------------+---------------------+----------------------+---------------------+---------------------+

CEIL

Syntaxe
```
bigint ceil(<value>)
```
Description

Arrondit une valeur par excès. Cette fonction renvoie le plus petit entier supérieur ou égal à la valeur d'entrée value.
Paramètres

value : obligatoire. Valeur de type DOUBLE ou DECIMAL. Si la valeur d'entrée est de type STRING ou BIGINT, elle est implicitement convertie en type DOUBLE pour le calcul.
Valeur de retour

Une valeur de type BIGINT est renvoyée. Si la valeur de value est NULL, la fonction retourne NULL.

Exemples

Exemples avec des données statiques

--The return value is 2.
select ceil(1.1);
--The return value is -1.
select ceil(-1.1);
--The return value is NULL.
select ceil(null);

Exemples avec des données de table

En vous basant sur les données d'exemple, la commande suivante arrondit une valeur par excès.

select ceil(bigint_data) as bigint_new, ceil(double_data) as double_new, ceil(decimal_data) as decimal_new, ceil(string_data) as string_new from mf_math_fun_t;

Le résultat suivant est retourné.

+------------+------------+-------------+------------+
| bigint_new | double_new | decimal_new | string_new |
+------------+------------+-------------+------------+
| -10        | 1          | 1           | 10         |
| NULL       | 0          | 0           | -10        |
| -1         | NULL       | 21          | 30         |
| 4          | 1          | NULL        | -30        |
| -50        | -1         | -1          | 50         |
| 6          | 2          | 2           | -50        |
| -70        | -7         | -7          | NULL       |
| 1          | -10        | -10         | -1         |
| -90        | 3          | 3           | 0          |
| 10         | -5         | -5          | -90        |
+------------+------------+-------------+------------+

CONV

Syntaxe

STRING CONV(<input>, BIGINT <from_base>, BIGINT <to_base>)

Description

Cette fonction convertit un nombre d'une base vers une autre et retourne le résultat sous forme de chaîne.

Paramètres

Paramètre	Obligatoire	Description
input	Oui	Valeur de type STRING. Remarque Si votre projet est en mode compatible Hive, c'est-à-dire si vous avez exécuté la commande `set odps.sql.hive.compatible=true;`, la conversion implicite des valeurs BIGINT et DOUBLE est prise en charge. Si votre projet n'est pas en mode compatible Hive, c'est-à-dire si vous avez exécuté la commande `set odps.sql.hive.compatible=false;`, la conversion implicite des valeurs BIGINT et DOUBLE n'est pas prise en charge.
from_base	Oui	La base doit être un entier décimal valant 2, 8, 10 ou 16. La conversion implicite de type n'est pas prise en charge.
to_base	Oui	La base doit être un entier décimal valant 2, 8, 10 ou 16. La conversion implicite de type n'est pas prise en charge.

Valeur de retour
Une valeur de type STRING est renvoyée. Les règles suivantes s'appliquent :
- Si la valeur de input, from_base ou to_base est NULL, la fonction retourne NULL.
- La conversion s'effectue avec une précision de 64 bits. En cas de dépassement, NULL est retourné.
- Si la valeur d'entrée de input est de type BIGINT ou DOUBLE, NULL est retourné en mode non compatible Hive, car la conversion implicite n'est pas prise en charge.
- Si la valeur d'entrée de input est négative, NULL est retourné en mode non compatible Hive. En mode compatible Hive, 0 est retourné.
- Si la valeur d'entrée de input est un nombre décimal, NULL est retourné en mode non compatible Hive. En mode compatible Hive, la valeur est convertie en entier avant d'être convertie dans la base spécifiée. La partie décimale est alors tronquée.

Exemples

Exemples avec des données statiques

--The return value is 12.
SELECT CONV('1100', 2, 10);
--The return value is C.
SELECT CONV('1100', 2, 16);
--The return value is 171.
SELECT CONV('ab', 16, 10);
--The return value is AB.
SELECT CONV('ab', 16, 16);
--The return value is NULL.
SELECT CONV('1100', null, 10);

Exemples avec des données de table

En vous basant sur les données d'exemple, la commande suivante convertit les valeurs au format binaire.

SELECT CONV(bigint_data,10,2) AS bigint_new, CONV(double_data,10,2) AS double_new, CONV(decimal_data,10,2) AS decimal_new, CONV(string_data,10,2) AS string_new FROM mf_math_fun_t;

Le résultat suivant est retourné.

+------------+------------+-------------+------------+
| bigint_new | double_new | decimal_new | string_new |
+------------+------------+-------------+------------+
| NULL       | 0          | 0           | 1010       |
| NULL       | NULL       | NULL        | NULL       |
| NULL       | NULL       | 10100       | 11110      |
| 100        | 0          | NULL        | NULL       |
| NULL       | NULL       | NULL        | 110010     |
| 110        | 1          | 1           | NULL       |
| NULL       | NULL       | NULL        | NULL       |
| 1          | NULL       | NULL        | NULL       |
| NULL       | 10         | 10          | 0          |
| 1010       | NULL       | NULL        | NULL       |
+------------+------------+-------------+------------+

CORR

Syntaxe
```
double corr(<col1>, <col2>)
```
Description

Calcule le coefficient de corrélation de Pearson entre deux colonnes de données. Il s'agit d'une fonction d'extension disponible dans MaxCompute V2.0.
Paramètres

col1 et col2 : obligatoires. Noms des deux colonnes de la table pour lesquelles vous souhaitez calculer le coefficient de corrélation de Pearson. Ces colonnes doivent être de type DOUBLE, BIGINT, INT, SMALLINT, TINYINT, FLOAT ou DECIMAL. Les types de données de col1 et col2 peuvent différer.
Valeur de retour

Une valeur de type DOUBLE est renvoyée. Si une ligne d'une colonne d'entrée contient une valeur NULL, cette ligne est exclue du calcul.
Exemple

En vous basant sur les données d'exemple, la commande suivante calcule le coefficient de corrélation de Pearson des colonnes double_data et float_data.
```
select corr(double_data,float_data) from mf_math_fun_t;
```
La valeur de retour est 1.0.

COS

Syntaxe
```
double|decimal cos(<number>)
```
Description

Calcule le cosinus de number. La valeur d'entrée doit être exprimée en radians.
Paramètres

number : obligatoire. Valeur de type DOUBLE ou DECIMAL. Si la valeur d'entrée est de type STRING ou BIGINT, elle est implicitement convertie en type DOUBLE pour le calcul.
Valeur de retour
Une valeur de type DOUBLE ou DECIMAL est renvoyée. Les règles suivantes s'appliquent :
- Si number est de type DOUBLE ou DECIMAL, une valeur du type correspondant est retournée.
- Si number est de type STRING ou BIGINT, une valeur de type DOUBLE est retournée.
- Si la valeur de number est NULL, la fonction retourne NULL.

Exemples

Exemples avec des données statiques

--The return value is 2.6794896585028633e-8.
select cos(3.1415926/2);
--The return value is -0.9999999999999986.
select cos(3.1415926);
--The return value is NULL.
select cos(null);

Exemples avec des données de table

En vous basant sur les données d'exemple, la commande suivante calcule le cosinus.

select cos(bigint_data) as bigint_new, cos(double_data) as double_new, cos(decimal_data) as decimal_new, cos(string_data) as string_new from mf_math_fun_t;

Le résultat suivant est retourné.

+---------------------+--------------------+----------------------+---------------------+
| bigint_new          | double_new         | decimal_new          | string_new          |
+---------------------+--------------------+----------------------+---------------------+
| -0.8390715290764524 | 0.8653239416229412 | 0.8653239416229412   | -0.8390715290764524 |
| NULL                | 0.9950041652780258 | 0.9950041652780258   | -0.8390715290764524 |
| 0.5403023058681398  | NULL               | -0.02964340851507803 | 0.15425144988758405 |
| -0.6536436208636119 | 0.6294120265736969 | NULL                 | 0.15425144988758405 |
| 0.9649660284921133  | 0.5403023058681398 | 0.5403023058681398   | 0.9649660284921133  |
| 0.960170286650366   | 0.0707372016677029 | 0.0707372016677029   | 0.9649660284921133  |
| 0.6333192030862999  | 0.3466353178350258 | 0.3466353178350258   | NULL                |
| 0.5403023058681398  | -0.7142656520272003| -0.7142656520272003  | 0.5403023058681398  |
| -0.4480736161291701 | -0.8464080412157756| -0.8464080412157756  | 1.0                 |
| -0.8390715290764524 | 0.8855195169413189 | 0.8855195169413189   | -0.4480736161291701 |
+---------------------+--------------------+----------------------+---------------------+

COSH

Syntaxe
```
double|decimal cosh(<number>)
```
Description

Calcule le cosinus hyperbolique de number.
Paramètres

number : obligatoire. Valeur de type DOUBLE ou DECIMAL. Si la valeur d'entrée est de type STRING ou BIGINT, elle est implicitement convertie en type DOUBLE pour le calcul.
Valeur de retour
Une valeur de type DOUBLE ou DECIMAL est renvoyée. Les règles suivantes s'appliquent :
- Si number est de type DOUBLE ou DECIMAL, une valeur du type correspondant est retournée.
- Si number est de type STRING ou BIGINT, une valeur de type DOUBLE est retournée.
- Si la valeur de number est NULL, la fonction retourne NULL.

Exemples

Exemples avec des données statiques

--The return value is 2.5091784169949913.
select cosh(3.1415926/2);
--The return value is NULL.
select cosh(null);

Exemples avec des données de table

En vous basant sur les données d'exemple, la commande suivante calcule le cosinus hyperbolique.

select cosh(bigint_data) as bigint_new, cosh(double_data) as double_new, cosh(decimal_data) as decimal_new, cosh(string_data) as string_new from mf_math_fun_t;

Le résultat suivant est retourné.

+-----------------------+--------------------+--------------------+----------------------+
| bigint_new            | double_new         | decimal_new        | string_new           |
+-----------------------+--------------------+--------------------+----------------------+
| 11013.232920103324    | 1.1410071063729532 | 1.1410071063729532 | 11013.232920103324   |
| NULL                  | 1.0050041680558035 | 1.0050041680558035 | 11013.232920103324   |
| 1.5430806348152437    | NULL               | 380445243.96844625 | 5343237290762.231    |
| 27.308232836016487    | 1.42289270202111   | NULL               | 5343237290762.231    |
| 2.592352764293536e21  | 1.5430806348152437 | 1.5430806348152437 | 2.592352764293536e21 |
| 201.7156361224559     | 2.352409615243247  | 2.352409615243247  | 2.592352764293536e21 |
| 1.2577193354595834e30 | 904.0214837702166  | 904.0214837702166  | NULL                 |
| 1.5430806348152437    | 13451.593055733929 | 13451.593055733929 | 1.5430806348152437   |
| 6.102016471589204e38  | 6.636456081840602  | 6.636456081840602  | 1.0                  |
| 11013.232920103324    | 165.151293732197   | 165.151293732197   | 6.102016471589204e38 |
+-----------------------+--------------------+--------------------+----------------------+

COT

Syntaxe
```
double|decimal cot(<number>)
```
Description

Calcule la cotangente de number. La valeur d'entrée doit être exprimée en radians.
Paramètres

number : obligatoire. Valeur de type DOUBLE ou DECIMAL. Si la valeur d'entrée est de type STRING ou BIGINT, elle est implicitement convertie en type DOUBLE pour le calcul.
Valeur de retour
Une valeur de type DOUBLE ou DECIMAL est renvoyée. Les règles suivantes s'appliquent :
- Si number est de type DOUBLE ou DECIMAL, une valeur du type correspondant est retournée.
- Si number est de type STRING ou BIGINT, une valeur de type DOUBLE est retournée.
- Si la valeur de number est NULL, la fonction retourne NULL.

Exemples

Exemples avec des données statiques

--The return value is 2.6794896585028643E-8.
select cot(3.1415926/2);
--The return value is NULL.
select cot(null);

Exemples avec des données de table

En vous basant sur les données d'exemple, la commande suivante calcule la cotangente.

select cot(bigint_data) as bigint_new, cot(double_data) as double_new, cot(decimal_data) as decimal_new, cot(string_data) as string_new from mf_math_fun_t;

Le résultat suivant est retourné.

+-----------------------+---------------------+---------------------+----------------------+
| bigint_new            | double_new          | decimal_new         | string_new           |
+-----------------------+---------------------+---------------------+----------------------+
| -1.54235104535692     | 1.7264594764178474  | 1.7264594764178474  | 1.54235104535692     |
| NULL                  | -9.966644423259238  | -9.966644423259238  | -1.54235104535692    |
| -0.6420926159343308   | NULL                | -0.02965644140592836| -0.15611995216165922 |
| 0.8636911544506167    | 0.8099792954471944  | NULL                | 0.15611995216165922  |
| 3.6778144508505695    | -0.6420926159343308 | -0.6420926159343308 | -3.6778144508505695  |
| -3.436353004180128    | 0.07091484430265245 | 0.07091484430265245 | 3.6778144508505695   |
| -0.8183574478651038   | -0.36954725630901636| -0.36954725630901636| NULL                 |
| 0.6420926159343308    | -1.0205622016180353 | -1.0205622016180353 | -0.6420926159343308  |
| 0.5012027833801532    | -1.5893944776331337 | -1.5893944776331337 | 1.0                  |
| 1.54235104535692      | 1.9059736612916494  | 1.9059736612916494  | 0.5012027833801532   |
+-----------------------+---------------------+---------------------+----------------------+

DEGREES

Syntaxe
```
double degrees(<number>) 
```
Description

Convertit une valeur exprimée en radians en degrés.
Paramètres

number : obligatoire. Valeur de type DOUBLE, BIGINT, INT, SMALLINT, TINYINT, FLOAT, DECIMAL ou STRING. Il s'agit d'une fonction d'extension disponible dans MaxCompute V2.0.
Valeur de retour

Une valeur de type DOUBLE est renvoyée. Si la valeur de number est NULL, la fonction retourne NULL.

Exemples

Exemples avec des données statiques

--The return value is 90.0.
select degrees(1.5707963267948966);
--The return value is 0.0.
select degrees(0);
--The return value is NULL.
select degrees(null);

Exemples avec des données de table

En vous basant sur les données d'exemple, la commande suivante obtient les degrés correspondants pour toutes les colonnes.

--Enable new data types of MaxCompute V2.0. You must run this command together with the SQL statement.
set odps.sql.type.system.odps2=true;
select degrees(int_data) as int_new, degrees(bigint_data) as bigint_new, degrees(double_data) as double_new, degrees(decimal_data) as decimal_new, degrees(float_data) as float_new, degrees(string_data) as string_new from mf_math_fun_t;

Le résultat suivant est retourné.

+---------------------+---------------------+---------------------+---------------------+---------------------+---------------------+
| int_new             | bigint_new          | double_new          | decimal_new         | float_new           | string_new          |
+---------------------+---------------------+---------------------+---------------------+---------------------+---------------------+
| NULL                | -572.9577951308232  | 30.08028424436822   | 30.08028424436822   | 30.080282878330387  | 572.9577951308232   |
| -1145.9155902616465 | NULL                | -5.729577951308232  | -5.729577951308232  | -5.729578036685597  | -572.9577951308232  |
| 0.0                 | -57.29577951308232  | NULL                | 1171.6986910425335  | -57.29577951308232  | 1718.8733853924698  |
| -2291.831180523293  | 229.1831180523293   | 50.99324376664326   | NULL                | 50.99324294702057   | -1718.8733853924698 |
| 286.4788975654116   | -2864.7889756541163 | -57.29577951308232  | -57.29577951308232  | NULL                | 2864.7889756541163  |
| -3437.7467707849396 | 343.77467707849394  | 85.94366926962348   | 85.94366926962348   | 85.94366926962348   | -2864.7889756541163 |
| -57.29577951308232  | -4010.7045659157625 | -429.71834634811745 | -429.71834634811745 | -429.71834634811745 | NULL                |
| -4583.662361046586  | 57.29577951308232   | -584.4169510334397  | -584.4169510334397  | -584.416940105137   | -57.29577951308232  |
| 515.662015617741    | -5156.620156177409  | 147.8231111437524   | 147.8231111437524   | 147.82310677243132  | 0.0                 |
| -5729.5779513082325 | 572.9577951308232   | -332.31552117587745 | -332.31552117587745 | -332.31553210418014 | -5156.620156177409  |
+---------------------+---------------------+---------------------+---------------------+---------------------+---------------------+

E

Syntaxe
```
double e()
```
Description

Retourne la valeur de e. Il s'agit d'une fonction d'extension disponible dans MaxCompute V2.0.
Valeur de retour

Une valeur de type DOUBLE est renvoyée.

Exemple

--The return value is 2.718281828459045.
select e();

EXP

Syntaxe
```
double|decimal exp(<number>)
```
Description

Calcule la valeur exponentielle de number.
Paramètres

number : obligatoire. Valeur de type DOUBLE ou DECIMAL. Si la valeur d'entrée est de type STRING ou BIGINT, elle est implicitement convertie en type DOUBLE pour le calcul.
Valeur de retour
Une valeur de type DOUBLE ou DECIMAL est renvoyée. Les règles suivantes s'appliquent :
- Si number est de type DOUBLE ou DECIMAL, une valeur du type correspondant est retournée.
- Si number est de type STRING ou BIGINT, une valeur de type DOUBLE est retournée.
- Si la valeur de number est NULL, la fonction retourne NULL.

Exemples

Exemples avec des données statiques

--The return value is 4.810477252069109.
select exp(3.1415926/2);
--The return value is NULL.
select exp(null);

Exemples avec des données de table

En vous basant sur les données d'exemple, la commande suivante calcule la valeur exponentielle.

select exp(bigint_data) as bigint_new, exp(double_data) as double_new, exp(decimal_data) as decimal_new, exp(string_data) as string_new from mf_math_fun_t;

Le résultat suivant est retourné.

+-------------------------+-------------------------+-------------------------+-------------------------+
| bigint_new              | double_new              | decimal_new             | string_new              |
+-------------------------+-------------------------+-------------------------+-------------------------+
| 0.000045399929762484854 | 1.6904588483790914      | 1.6904588483790914      | 22026.465794806718      |
| NULL                    | 0.9048374180359595      | 0.9048374180359595      | 0.000045399929762484854 |
| 0.36787944117144233     | NULL                    | 760890487.9368925       | 10686474581524.463      |
| 54.598150033144236      | 2.4351296512898744      | NULL                    | 9.357622968840175e-14   |
| 1.9287498479639178e-22  | 0.36787944117144233     | 0.36787944117144233     | 5.184705528587072e21    |
| 403.4287934927351       | 4.4816890703380645      | 4.4816890703380645      | 1.9287498479639178e-22  |
| 3.975449735908647e-31   | 0.0005530843701478336   | 0.0005530843701478336   | NULL                    |
| 2.718281828459045       | 0.000037170318684126734 | 0.000037170318684126734 | 0.36787944117144233     |
| 8.194012623990515e-40   | 13.197138159658358      | 13.197138159658358      | 1.0                     |
| 22026.465794806718      | 0.0030275547453758153   | 0.0030275547453758153   | 8.194012623990515e-40   |
+-------------------------+-------------------------+-------------------------+-------------------------+

FACTORIAL

Syntaxe
```
bigint factorial(<number>)
```
Description

Retourne la factorielle de number. Il s'agit d'une fonction d'extension disponible dans MaxCompute V2.0.
Paramètres

number : obligatoire. Valeur de type BIGINT, INT, SMALLINT ou TINYINT. La valeur doit se situer dans l'intervalle [0, 20].
Valeur de retour
Une valeur de type BIGINT est renvoyée. Les règles suivantes s'appliquent :
- Si la valeur de number est 0, la fonction retourne 1.
- Si la valeur de number est NULL ou ne se trouve pas dans l'intervalle [0, 20], NULL est retourné.

Exemples

Exemples avec des données statiques

--The return value is 120. 5! = 5 × 4 × 3 × 2 × 1 = 120
select factorial(5); 
--The return value is 1.
select factorial(0); 
--The return value is NULL.
select factorial(null);

Exemples avec des données de table

En vous basant sur les données d'exemple, la commande suivante calcule la factorielle des colonnes int_data et bigint_data.

--Enable new data types of MaxCompute V2.0. You must run this command together with the SQL statement.
set odps.sql.type.system.odps2=true;
select factorial(int_data) as int_new, factorial(bigint_data) as bigint_new from mf_math_fun_t;

Le résultat suivant est retourné.

+------------+------------+
| int_new    | bigint_new |
+------------+------------+
| NULL       | NULL       |
| NULL       | NULL       |
| 1          | NULL       |
| NULL       | 24         |
| 120        | NULL       |
| NULL       | 720        |
| NULL       | NULL       |
| NULL       | 1          |
| 362880     | NULL       |
| NULL       | 3628800    |
+------------+------------+

FILTER

Syntaxe

array<T> filter(array<T> <a>, function<T,boolean> <func>)

Paramètres
- a : obligatoire. Tableau ARRAY. Dans array<T>, T désigne le type de données des éléments du tableau ARRAY ; ces éléments peuvent être de n'importe quel type.
- func : obligatoire. Fonction (intégrée ou définie par l'utilisateur) ou expression utilisée pour filtrer les éléments de a. Le type des paramètres d'entrée doit correspondre au type de données des éléments de a, et le résultat doit être de type BOOLEAN.
Valeur de retour

Renvoie un type ARRAY.
Exemple
```
--返回[2, 3]。
select filter(array(1, 2, 3), x -> x > 1);
```
Remarque
Pour plus d'informations sur les fonctions Lambda ->, consultez Fonctions Lambda.

FLOOR

Syntaxe
```
bigint floor(<number>)
```
Description

Arrondit une valeur par défaut. Cette fonction renvoie le plus grand entier inférieur ou égal à number.
Paramètres

number : obligatoire. Valeur de type DOUBLE ou DECIMAL. Si la valeur d'entrée est de type STRING ou BIGINT, elle est implicitement convertie en type DOUBLE pour le calcul.
Valeur de retour

Une valeur de type BIGINT est renvoyée. Si la valeur de number est NULL, la fonction retourne NULL.

Exemples

Exemples avec des données statiques

--The return value is 1.
select floor(1.2);
--The return value is 0.
select floor(0.1);
--The return value is -2.
select floor(-1.2);
--The return value is -1.
select floor(-0.1);
--The return value is 0.
select floor(0.0);
--The return value is 0.
select floor(-0.0);
--The return value is NULL.
select floor(null);

Exemples avec des données de table

En vous basant sur les données d'exemple, la commande suivante arrondit une valeur par défaut.

select floor(bigint_data) as bigint_new, floor(double_data) as double_new, floor(decimal_data) as decimal_new, floor(string_data) as string_new from mf_math_fun_t;

Le résultat suivant est retourné.

+------------+------------+-------------+------------+
| bigint_new | double_new | decimal_new | string_new |
+------------+------------+-------------+------------+
| -10        | 0          | 0           | 10         |
| NULL       | -1         | -1          | -10        |
| -1         | NULL       | 20          | 30         |
| 4          | 0          | NULL        | -30        |
| -50        | -1         | -1          | 50         |
| 6          | 1          | 1           | -50        |
| -70        | -8         | -8          | NULL       |
| 1          | -11        | -11         | -1         |
| -90        | 2          | 2           | 0          |
| 10         | -6         | -6          | -90        |
+------------+------------+-------------+------------+

FORMAT_NUMBER

Syntaxe

string format_number(float|double|decimal <expr1>, <expr2>)

Description

Convertit un nombre en chaîne selon un format spécifié. Il s'agit d'une fonction d'extension disponible dans MaxCompute V2.0.
Paramètres
- expr1 : obligatoire. Données à formater. La valeur peut être de type DOUBLE, BIGINT, INT, SMALLINT, TINYINT, FLOAT, DECIMAL ou STRING.
- expr2 : obligatoire. Format de destination. Vous pouvez spécifier le nombre de décimales à conserver ou définir un modèle de formatage, tel que #,###,###.##.
Valeur de retour
Une valeur de type STRING est renvoyée. Les règles suivantes s'appliquent :
- Si expr2 > 0, la valeur est arrondie au nombre de décimales spécifié.
- Si expr2 = 0, aucun séparateur décimal ni partie décimale n'est inclus.
- Si expr2 < 0 ou expr2 > 340, une erreur est retournée.
- Si la valeur de expr1 ou de expr2 est NULL, la fonction retourne NULL.

Exemples

Exemples avec des données statiques

--The return value is 5.230.
select format_number(5.230134523424545456,3);
--The return value is 12,332.123.
select format_number(12332.123456, '#,###,###,###.###');
--The return value is NULL.
select format_number(null,3);

Exemples avec des données de table

En vous basant sur les données d'exemple, la commande suivante conserve un nombre spécifié de décimales pour toutes les colonnes.

--Enable new data types of MaxCompute V2.0. You must run this command together with the SQL statement.
set odps.sql.type.system.odps2=true;
select format_number(int_data, 1) as int_new, format_number(bigint_data, 1) as bigint_new, format_number(double_data, 2) as double_new, format_number(decimal_data, 1) as decimal_new, format_number(float_data, 0) as float_new, format_number(string_data, 1) as string_new from mf_math_fun_t;

Le résultat suivant est retourné.

+---------+------------+------------+-------------+-----------+------------+
| int_new | bigint_new | double_new | decimal_new | float_new | string_new |
+---------+------------+------------+-------------+-----------+------------+
| NULL    | -10.0      | 0.53       | 0.5         | 1         | 10.0       |
| -20.0   | NULL       | -0.10      | -0.1        | -0        | -10.0      |
| 0.0     | -1.0       | NULL       | 20.5        | -1        | 30.0       |
| -40.0   | 4.0        | 0.89       | NULL        | 1         | -30.0      |
| 5.0     | -50.0      | -1.00      | -1.0        | NULL      | 50.0       |
| -60.0   | 6.0        | 1.50       | 1.5         | 2         | -50.0      |
| -1.0    | -70.0      | -7.50      | -7.5        | -8        | NULL       |
| -80.0   | 1.0        | -10.20     | -10.2       | -10       | -1.0       |
| 9.0     | -90.0      | 2.58       | 2.6         | 3         | 0.0        |
| -100.0  | 10.0       | -5.80      | -5.8        | -6        | -90.0      |
+---------+------------+------------+-------------+-----------+------------+

HEX

Syntaxe
```
string hex(<number>) 
```
Description

Convertit une valeur numérique ou une chaîne de caractères au format hexadécimal. Il s'agit d'une fonction d'extension dans MaxCompute V2.0.
Paramètres

number : obligatoire. Valeur de type DOUBLE, BIGINT, INT, SMALLINT, TINYINT, FLOAT, DECIMAL ou STRING.
Valeur de retour

Une valeur de type STRING est retournée. Les règles suivantes s'appliquent :
- Si la valeur de number n'est ni 0 ni NULL, une valeur de type STRING est retournée.
- Si la valeur de number est 0, la fonction retourne 0.
- Si la valeur de number est NULL, la fonction retourne NULL.

Exemples

Exemples avec des données statiques

--The return value is 0.
select hex(0);
--The return value is 616263.
select hex('abc');
--The return value is 11.
select hex(17);
--The return value is 3137.
select hex('17');
--An error is returned. 
select hex(null);

Exemples avec des données de table

En vous basant sur les données d'exemple, la commande suivante convertit toutes les colonnes au format hexadécimal.

--Enable new data types of MaxCompute V2.0. You must run this command together with the SQL statement.
set odps.sql.type.system.odps2=true;
select hex(int_data) as int_new, hex(bigint_data) as bigint_new, hex(double_data) as double_new, hex(decimal_data) as decimal_new, hex(float_data) as float_new, hex(string_data) as string_new from mf_math_fun_t;

Le résultat suivant est retourné.

+------------------+------------------+------------+-------------+------------+------------+
| int_new          | bigint_new       | double_new | decimal_new | float_new  | string_new |
+------------------+------------------+------------+-------------+------------+------------+
| NULL             | FFFFFFFFFFFFFFF6 | 302E353235 | 302E353235  | 302E353235 | 3130       |
| FFFFFFFFFFFFFFEC | NULL             | 2D302E31   | 2D302E31    | 2D302E31   | 2D3130     |
| 0                | FFFFFFFFFFFFFFFF | NULL       | 32302E3435  | 2D31       | 3330       |
| FFFFFFFFFFFFFFD8 | 4                | 302E3839   | NULL        | 302E3839   | 2D3330     |
| 5                | FFFFFFFFFFFFFFCE | 2D312E30   | 2D31        | NULL       | 3530       |
| FFFFFFFFFFFFFFC4 | 6                | 312E35     | 312E35      | 312E35     | 2D3530     |
| FFFFFFFFFFFFFFFF | FFFFFFFFFFFFFFBA | 2D372E35   | 2D372E35    | 2D372E35   | NULL       |
| FFFFFFFFFFFFFFB0 | 1                | 2D31302E32 | 2D31302E32  | 2D31302E32 | 2D31       |
| 9                | FFFFFFFFFFFFFFA6 | 322E3538   | 322E3538    | 322E3538   | 30         |
| FFFFFFFFFFFFFF9C | A                | 2D352E38   | 2D352E38    | 2D352E38   | 2D3930     |
+------------------+------------------+------------+-------------+------------+------------+

ISNAN

Syntaxe
```
boolean isnan(<expr>)
```
Description

Vérifie si la valeur de expr est NaN.
Paramètres

expr : obligatoire. Valeur de type DOUBLE. Si la valeur d'entrée est de type STRING, BIGINT ou DECIMAL, elle est implicitement convertie en type DOUBLE pour le calcul.
Valeur de retour
- Si la valeur de expr est NaN, la fonction retourne True. Sinon, elle retourne False.
- Si la valeur de expr est NULL, la fonction retourne False.

Exemple

--The return value is False.
SELECT isnan(100.1);

LN

Syntaxe
```
double|decimal ln(<number>)
```
Description

Calcule le logarithme naturel de number.
Paramètres

number : obligatoire. Valeur de type DOUBLE ou DECIMAL. Si la valeur d'entrée est de type STRING ou BIGINT, elle est implicitement convertie en type DOUBLE pour le calcul.
Valeur de retour
Une valeur de type DOUBLE ou DECIMAL est retournée. Les règles suivantes s'appliquent :
- Si number est de type DOUBLE ou DECIMAL, une valeur du type correspondant est retournée.
- Si number est de type STRING ou BIGINT, une valeur de type DOUBLE est retournée.
- Si la valeur de number est un nombre négatif ou 0, la fonction retourne NULL.
- Si la valeur de number est NULL, la fonction retourne NULL.

Exemples

Exemples avec des données statiques

--The return value is 1.144729868791239.
select ln(3.1415926);
--The return value is NULL.
select ln(null);

Exemples avec des données de table

En vous basant sur les données d'exemple, la commande suivante calcule le logarithme naturel.

select ln(bigint_data) as bigint_new, ln(double_data) as double_new, ln(decimal_data) as decimal_new, ln(string_data) as string_new from mf_math_fun_t;

Le résultat suivant est retourné.

+--------------------+----------------------+---------------------+---------------------+
| bigint_new         | double_new           | decimal_new         | string_new          |
+--------------------+----------------------+---------------------+---------------------+
| NULL               | -0.6443570163905132  | -0.6443570163905132 | 2.302585092994046   |
| NULL               | NULL                 | NULL                | NULL                |
| NULL               | NULL                 | 3.017982882488811   | 3.4011973816621555  |
| 1.3862943611198906 | -0.11653381625595151 | NULL                | NULL                |
| NULL               | NULL                 | NULL                | 3.912023005428146   |
| 1.791759469228055  | 0.4054651081081644   | 0.4054651081081644  | NULL                |
| NULL               | NULL                 | NULL                | NULL                |
| 0.0                | NULL                 | NULL                | NULL                |
| NULL               | 0.9477893989335261   | 0.9477893989335261  | NULL                |
| 2.302585092994046  | NULL                 | NULL                | NULL                |
+--------------------+----------------------+---------------------+---------------------+

LOG

Syntaxe
```
double log(<base>, <x>)
```
Description

Calcule le logarithme de x en base base.
Paramètres
- base : obligatoire. La base. Valeur de type DOUBLE ou DECIMAL. Si la valeur d'entrée est de type STRING ou BIGINT, elle est implicitement convertie en type DOUBLE pour le calcul.
- x : obligatoire. La valeur dont vous souhaitez calculer le logarithme. Valeur de type DOUBLE ou DECIMAL. Si la valeur d'entrée est de type STRING ou BIGINT, elle est implicitement convertie en type DOUBLE pour le calcul.
Valeur de retour
Une valeur de type DOUBLE est retournée. Les règles suivantes s'appliquent :
- Si la valeur de base ou de x est NULL, la fonction retourne NULL.
- Si la valeur de base ou de x est un nombre négatif ou 0, la fonction retourne NULL.
- Si la valeur de base est 1, ce qui entraîne une erreur de division par zéro, la fonction retourne NULL.

Exemples

Exemples avec des données statiques

--The return value is 4.0.
select log(2, 16);
--The return value is NULL.
select log(2, null);

Exemples avec des données de table

En vous basant sur les données d'exemple, la commande suivante calcule le logarithme en base 2 des colonnes.

select log(2,bigint_data) as bigint_new, log(2,double_data) as double_new, log(2,decimal_data) as decimal_new, log(2,string_data) as string_new from mf_math_fun_t;

Le résultat suivant est retourné.

+--------------------+----------------------+--------------------+--------------------+
| bigint_new         | double_new           | decimal_new        | string_new         |
+--------------------+----------------------+--------------------+--------------------+
| NULL               | -0.929610672108602   | -0.929610672108602 | 3.3219280948873626 |
| NULL               | NULL                 | NULL               | NULL               |
| NULL               | NULL                 | 4.354028938054387  | 4.906890595608519  |
| 2.0                | -0.16812275880832692 | NULL               | NULL               |
| NULL               | NULL                 | NULL               | 5.643856189774724  |
| 2.584962500721156  | 0.5849625007211562   | 0.5849625007211562 | NULL               |
| NULL               | NULL                 | NULL               | NULL               |
| 0.0                | NULL                 | NULL               | NULL               |
| NULL               | 1.3673710656485296   | 1.3673710656485296 | NULL               |
| 3.3219280948873626 | NULL                 | NULL               | NULL               |
+--------------------+----------------------+--------------------+--------------------+

LOG10

Syntaxe
```
double log10(<number>)
```
Description

Retourne le logarithme en base 10 de number. Il s'agit d'une fonction d'extension dans MaxCompute V2.0.
Paramètres

number : obligatoire. Valeur de type DOUBLE, BIGINT, INT, SMALLINT, TINYINT, FLOAT, DECIMAL ou STRING.
Valeur de retour

Une valeur de type DOUBLE est retournée. Si la valeur de number est 0, un nombre négatif ou NULL, la fonction retourne NULL.

Exemples

Exemples avec des données statiques

--The return value is NULL.
select log10(null);
--The return value is NULL.
select log10(0);
--The return value is 0.9030899869919435.
select log10(8);

Exemples avec des données de table

En vous basant sur les données d'exemple, la commande suivante calcule le logarithme en base 10 de toutes les colonnes.

--Enable new data types of MaxCompute V2.0. You must run this command together with the SQL statement.
set odps.sql.type.system.odps2=true;
select log10(int_data) as int_new, log10(bigint_data) as bigint_new, log10(double_data) as double_new, log10(decimal_data) as decimal_new, log10(float_data) as float_new, log10(string_data) as string_new from mf_math_fun_t;

Le résultat suivant est retourné.

+--------------------+--------------------+---------------------+---------------------+-----------------------+--------------------+
| int_new            | bigint_new         | double_new          | decimal_new         | float_new             | string_new         |
+--------------------+--------------------+---------------------+---------------------+-----------------------+--------------------+
| NULL               | NULL               | -0.2798406965940431 | -0.2798406965940431 | -0.27984071631668606  | 1.0                |
| NULL               | NULL               | NULL                | NULL                | NULL                  | NULL               |
| NULL               | NULL               | NULL                | 1.3106933123433606  | NULL                  | 1.4771212547196624 |
| NULL               | 0.6020599913279623 | -0.0506099933550872 | NULL                | -0.050610000335573106 | NULL               |
| 0.6989700043360187 | NULL               | NULL                | NULL                | NULL                  | 1.6989700043360185 |
| NULL               | 0.7781512503836435 | 0.17609125905568124 | 0.17609125905568124 | 0.17609125905568124   | NULL               |
| NULL               | NULL               | NULL                | NULL                | NULL                  | NULL               |
| NULL               | 0.0                | NULL                | NULL                | NULL                  | NULL               |
| 0.9542425094393249 | NULL               | 0.4116197059632301  | 0.4116197059632301  | 0.411619693120579     | NULL               |
| NULL               | 1.0                | NULL                | NULL                | NULL                  | NULL               |
+--------------------+--------------------+---------------------+---------------------+-----------------------+--------------------+

LOG2

Syntaxe
```
double log2(<number>)
```
Description

Retourne le logarithme en base 2 de number. Il s'agit d'une fonction d'extension dans MaxCompute V2.0.
Paramètres

number : obligatoire. Valeur de type DOUBLE, BIGINT, INT, SMALLINT, TINYINT, FLOAT, DECIMAL ou STRING.
Valeur de retour

Une valeur de type DOUBLE est retournée. Si la valeur de number est 0, un nombre négatif ou NULL, la fonction retourne NULL.

Exemples

Exemples avec des données statiques

--The return value is NULL.
select log2(null);
--The return value is NULL.
select log2(0);
--The return value is 3.0.
select log2(8);

Exemples avec des données de table

En vous basant sur les données d'exemple, la commande suivante calcule le logarithme en base 2 de toutes les colonnes.

--Enable new data types of MaxCompute V2.0. You must run this command together with the SQL statement.
set odps.sql.type.system.odps2=true;
select log2(int_data) as int_new, log2(bigint_data) as bigint_new, log2(double_data) as double_new, log2(decimal_data) as decimal_new, log2(float_data) as float_new, log2(string_data) as string_new from mf_math_fun_t;

Le résultat suivant est retourné.

+--------------------+--------------------+----------------------+--------------------+----------------------+--------------------+
| int_new            | bigint_new         | double_new           | decimal_new        | float_new            | string_new         |
+--------------------+--------------------+----------------------+--------------------+----------------------+--------------------+
| NULL               | NULL               | -0.929610672108602   | -0.929610672108602 | -0.9296107376258038  | 3.3219280948873626 |
| NULL               | NULL               | NULL                 | NULL               | NULL                 | NULL               |
| NULL               | NULL               | NULL                 | 4.354028938054387  | NULL                 | 4.906890595608519  |
| NULL               | 2.0                | -0.16812275880832692 | NULL               | -0.16812278199699915 | NULL               |
| 2.321928094887362  | NULL               | NULL                 | NULL               | NULL                 | 5.643856189774724  |
| NULL               | 2.584962500721156  | 0.5849625007211562   | 0.5849625007211562 | 0.5849625007211562   | NULL               |
| NULL               | NULL               | NULL                 | NULL               | NULL                 | NULL               |
| NULL               | 0.0                | NULL                 | NULL               | NULL                 | NULL               |
| 3.1699250014423126 | NULL               | 1.3673710656485296   | 1.3673710656485296 | 1.367371022986166    | NULL               |
| NULL               | 3.3219280948873626 | NULL                 | NULL               | NULL                 | NULL               |
+--------------------+--------------------+----------------------+--------------------+----------------------+--------------------+

NEGATIVE

Syntaxe

TINYINT|SMALLINT|INT|BIGINT|DOUBLE|DECIMAL negative(TINYINT|SMALLINT|INT|BIGINT|DOUBLE|DECIMAL <expr>)

Description

Retourne la valeur négative de expr.
Paramètres

expr : obligatoire. L'expression d'entrée. La valeur peut être de type TINYINT, SMALLINT, INT, BIGINT, DOUBLE ou DECIMAL.
Valeur de retour

Retourne la valeur négative de l'expression expr.

Exemple

--The return value is -1.
SELECT negative(1);

PI

Syntaxe
```
double pi()
```
Description

Retourne la valeur de π. Il s'agit d'une fonction d'extension dans MaxCompute V2.0.
Valeur de retour

Une valeur de type DOUBLE est retournée.

Exemple

--The return value is 3.141592653589793.
select pi();

POSITIVE

Syntaxe

TINYINT|SMALLINT|INT|BIGINT|DOUBLE|DECIMAL positive(TINYINT|SMALLINT|INT|BIGINT|DOUBLE|DECIMAL <expr>)

Description

Retourne la valeur de expr.
Paramètres

expr : obligatoire. L'expression d'entrée. La valeur peut être de type TINYINT, SMALLINT, INT, BIGINT, DOUBLE ou DECIMAL.
Valeur de retour

Retourne la valeur de l'expression expr.

Exemple

--The return value is 1.
SELECT positive(1);

POW

Syntaxe
```
double|decimal pow(<x>, <y>)
```
Description

Calcule la valeur de x élevée à la puissance y, soit x^y.
Paramètres
- x : obligatoire. Valeur de type DOUBLE ou DECIMAL. Si la valeur d'entrée est de type STRING ou BIGINT, elle est implicitement convertie en type DOUBLE pour le calcul.
- y : obligatoire. Valeur de type DOUBLE ou DECIMAL. Si la valeur d'entrée est de type STRING ou BIGINT, elle est implicitement convertie en type DOUBLE pour le calcul.
Valeur de retour
Une valeur de type DOUBLE ou DECIMAL est retournée. Les règles suivantes s'appliquent :
- Si x ou y est de type DOUBLE ou DECIMAL, une valeur du type correspondant est retournée.
- Si x ou y est de type STRING ou BIGINT, une valeur de type DOUBLE est retournée.
- Si la valeur de x ou de y est NULL, la fonction retourne NULL.

Exemples

Exemples avec des données statiques

--The return value is 65536.0.
select pow(2, 16);
--The return value is NULL.
select pow(2, null);

Exemples avec des données de table

En vous basant sur les données d'exemple, la commande suivante calcule la valeur des colonnes élevée à la puissance 2.

select pow(bigint_data, 2) as bigint_new, pow(double_data, 2) as double_new, pow(decimal_data, 2) as decimal_new, pow(string_data, 2) as string_new from mf_math_fun_t;

Le résultat suivant est retourné.

+------------+----------------------+----------------------+------------+
| bigint_new | double_new           | decimal_new          | string_new |
+------------+----------------------+----------------------+------------+
| 100.0      | 0.275625             | 0.275625             | 100.0      |
| NULL       | 0.010000000000000002 | 0.010000000000000002 | 100.0      |
| 1.0        | NULL                 | 418.2025             | 900.0      |
| 16.0       | 0.7921               | NULL                 | 900.0      |
| 2500.0     | 1.0                  | 1.0                  | 2500.0     |
| 36.0       | 2.25                 | 2.25                 | 2500.0     |
| 4900.0     | 56.25                | 56.25                | NULL       |
| 1.0        | 104.03999999999999   | 104.03999999999999   | 1.0        |
| 8100.0     | 6.6564000000000005   | 6.6564000000000005   | 0.0        |
| 100.0      | 33.64                | 33.64                | 8100.0     |
+------------+----------------------+----------------------+------------+

RADIANS

Syntaxe
```
double radians(<number>)
```
Description

Convertit une valeur exprimée en degrés vers des radians. Il s'agit d'une fonction d'extension dans MaxCompute V2.0.
Paramètres

number : obligatoire. Valeur de type DOUBLE, BIGINT, INT, SMALLINT, TINYINT, FLOAT, DECIMAL ou STRING.
Valeur de retour

Une valeur de type DOUBLE est retournée. Si la valeur de number est NULL, la fonction retourne NULL.

Exemples

Exemples avec des données statiques

--The return value is 1.5707963267948966.
select radians(90);
--The return value is 0.0.
select radians(0);
--The return value is NULL.
select radians(null);

Exemples avec des données de table

En vous basant sur les données d'exemple, la commande suivante convertit toutes les colonnes en radians.

--Enable new data types of MaxCompute V2.0. You must run this command together with the SQL statement.
set odps.sql.type.system.odps2=true;
select radians(int_data) as int_new, radians(bigint_data) as bigint_new, radians(double_data) as double_new, radians(decimal_data) as decimal_new, radians(float_data) as float_new, radians(string_data) as string_new from mf_math_fun_t;

Le résultat suivant est retourné.

+-----------------------+-----------------------+------------------------+------------------------+------------------------+-----------------------+
| int_new               | bigint_new            | double_new             | decimal_new            | float_new              | string_new            |
+-----------------------+-----------------------+------------------------+------------------------+------------------------+-----------------------+
| NULL                  | -0.17453292519943295  | 0.00916297857297023    | 0.00916297857297023    | 0.009162978156851308   | 0.17453292519943295   |
| -0.3490658503988659   | NULL                  | -0.0017453292519943296 | -0.0017453292519943296 | -0.0017453292780017621 | -0.17453292519943295  |
| 0.0                   | -0.017453292519943295 | NULL                   | 0.3569198320328404     | -0.017453292519943295  | 0.5235987755982988    |
| -0.6981317007977318   | 0.06981317007977318   | 0.015533430342749534   | NULL                   | 0.015533430093078181   | -0.5235987755982988   |
| 0.08726646259971647   | -0.8726646259971648   | -0.017453292519943295  | -0.017453292519943295  | NULL                   | 0.8726646259971648    |
| -1.0471975511965976   | 0.10471975511965977   | 0.02617993877991494    | 0.02617993877991494    | 0.02617993877991494    | -0.8726646259971648   |
| -0.017453292519943295 | -1.2217304763960306   | -0.1308996938995747    | -0.1308996938995747    | -0.1308996938995747    | NULL                  |
| -1.3962634015954636   | 0.017453292519943295  | -0.17802358370342158   | -0.17802358370342158   | -0.17802358037447025   | -0.017453292519943295 |
| 0.15707963267948966   | -1.5707963267948966   | 0.045029494701453704   | 0.045029494701453704   | 0.04502949336987316    | 0.0                   |
| -1.7453292519943295   | 0.17453292519943295   | -0.10122909661567112   | -0.10122909661567112   | -0.10122909994462247   | -1.5707963267948966   |
+-----------------------+-----------------------+------------------------+------------------------+------------------------+-----------------------+

RAND

Syntaxe
```
double rand(bigint <seed>)
```
Description

Retourne un nombre aléatoire de type DOUBLE compris entre 0 et 1.
Paramètres

seed : facultatif. Valeur de type BIGINT. La graine détermine la valeur initiale d'une séquence de nombres aléatoires.

Remarque
Vous pouvez utiliser seed pour spécifier une séquence de nombres aléatoires. Une fois seed défini, la valeur de retour de cette fonction est fixe. Tant que l'environnement d'exécution et la valeur de seed restent identiques, la valeur retournée demeure inchangée. Pour obtenir un résultat différent, modifiez la valeur de seed.

Ajoutez le paramètre suivant avant une instruction SQL. La valeur par défaut est false.
```
set odps.sql.executionengine.enable.rand.time.seed=true|false;
```
- Si ce paramètre est défini sur false, la fonction RAND utilise l'ID de l'instance actuelle comme seed initiale pour le nombre aléatoire afin de garantir l'idempotence de la fonction.
- Si ce paramètre est défini sur true, la fonction RAND utilise l'heure système actuelle comme seed initiale pour le nombre aléatoire. Toutefois, la fonction RAND n'est plus idempotente et ne peut pas servir de clé de brassage (shuffle key). Cela entraîne des résultats différents lors de nouvelles exécutions de la fonction.
Valeur de retour

Une valeur de type DOUBLE est retournée.

Exemple

--The return value is 4.7147460303803655E-4.
select rand();
--The return value is 0.7308781907032909.
select rand(1);

ROUND

Syntaxe

double|decimal round(<number>[, bigint <decimal_places>])

Description

Arrondit une valeur à un nombre de décimales spécifié.
Paramètres
- number : obligatoire. Valeur de type DOUBLE ou DECIMAL. Si la valeur d'entrée est de type STRING ou BIGINT, elle est implicitement convertie en type DOUBLE pour le calcul.
- decimal_places : facultatif. Constante de type BIGINT. Ce paramètre indique le nombre de décimales auquel arrondir la valeur. Si vous omettez ce paramètre, la valeur est arrondie à l'entier le plus proche. La valeur par défaut est 0.
  
  Remarque
  La valeur de decimal_places peut être un nombre négatif. Dans ce cas, la fonction arrondit les chiffres situés à gauche de la virgule décimale et ne conserve aucune partie décimale. Si la valeur de decimal_places dépasse la longueur de la partie entière, la fonction retourne 0.
Valeur de retour
Une valeur de type DOUBLE ou DECIMAL est retournée. Les règles suivantes s'appliquent :
- Si number est de type DOUBLE ou DECIMAL, une valeur du type correspondant est retournée.
- Si number est de type STRING ou BIGINT, une valeur de type DOUBLE est retournée.
- Si le type de données de decimal_places n'est pas BIGINT, une erreur est retournée.
- Si la valeur de number ou de decimal_places est NULL, la fonction retourne NULL.

Exemples

Exemples avec des données statiques

--The return value is 125.0.
select round(125.315);
--The return value is 125.3.
select round(125.315, 1);
--The return value is 125.32.
select round(125.315, 2);
--The return value is 125.315.
select round(125.315, 3);
--The return value is -125.32.
select round(-125.315, 2);
--The return value is 100.0.
select round(123.345, -2);
--The return value is NULL.
select round(null);
--The return value is 123.345.
select round(123.345, 4);
--The return value is 0.0.
select round(123.345, -4);

Exemples avec des données de table

En vous basant sur les données d'exemple, la commande suivante arrondit les valeurs des colonnes à un nombre de décimales spécifié.

select round(bigint_data, 1) as bigint_new, round(double_data, 2) as double_new, round(decimal_data, 1) as decimal_new, round(string_data) as string_new from mf_math_fun_t;

Le résultat suivant est retourné.

+------------+------------+-------------+------------+
| bigint_new | double_new | decimal_new | string_new |
+------------+------------+-------------+------------+
| -10.0      | 0.53       | 0.5         | 10.0       |
| NULL       | -0.1       | -0.1        | -10.0      |
| -1.0       | NULL       | 20.5        | 30.0       |
| 4.0        | 0.89       | NULL        | -30.0      |
| -50.0      | -1.0       | -1          | 50.0       |
| 6.0        | 1.5        | 1.5         | -50.0      |
| -70.0      | -7.5       | -7.5        | NULL       |
| 1.0        | -10.2      | -10.2       | -1.0       |
| -90.0      | 2.58       | 2.6         | 0.0        |
| 10.0       | -5.8       | -5.8        | -90.0      |
+------------+------------+-------------+------------+

SHIFTLEFT

Syntaxe

int shiftleft(tinyint|smallint|int <number1>, int <number2>)
bigint shiftleft(bigint <number1>, int <number2>)

Description

Effectue un décalage vers la gauche (<<). Il s'agit d'une fonction d'extension dans MaxCompute V2.0.
Paramètres
- number1 : obligatoire. Valeur de type TINYINT, SMALLINT, INT ou BIGINT.
- number2 : obligatoire. Valeur de type INT.
Valeur de retour
Une valeur de type INT ou BIGINT est retournée. Les règles suivantes s'appliquent :
- Si le type de données de number1 n'est pas TINYINT, SMALLINT, INT ou BIGINT, une erreur est retournée.
- Si le type de données de number2 n'est pas INT, une erreur est retournée.
- Si la valeur de number1 ou de number2 est NULL, la fonction retourne NULL.

Exemples

Exemples avec des données statiques

--The return value is 4. The binary value of 1 is shifted to the left by two bits (1<<2, 0001 is shifted to the left by two bits to become 0100).
select shiftleft(1,2); 
--The return value is 32. The binary value of 4 is shifted to the left by three bits (4<<3, 0100 is shifted to the left by three bits to become 100000).
select shiftleft(4,3);
--The return value is NULL.
select shiftleft(null,2);

Exemples avec des données de table

En vous basant sur les données d'exemple, la commande suivante effectue un décalage vers la gauche sur les colonnes int_data et bigint_data.

--Enable new data types of MaxCompute V2.0. You must run this command together with the SQL statement.
set odps.sql.type.system.odps2=true;
select shiftleft(int_data, 1) as int_new, shiftleft(bigint_data, 1) as bigint_new from mf_math_fun_t;

Le résultat suivant est retourné.

+---------+------------+
| int_new | bigint_new |
+---------+------------+
| NULL    | -20        |
| -40     | NULL       |
| 0       | -2         |
| -80     | 8          |
| 10      | -100       |
| -120    | 12         |
| -2      | -140       |
| -160    | 2          |
| 18      | -180       |
| -200    | 20         |
+---------+------------+

SHIFTRIGHT

Syntaxe

int shiftright(tinyint|smallint|int <number1>, int <number2>)
bigint shiftright(bigint <number1>, int <number2>)

Description

Effectue un décalage vers la droite (>>). Il s'agit d'une fonction d'extension dans MaxCompute V2.0.
Paramètres
- number1 : obligatoire. Valeur de type TINYINT, SMALLINT, INT ou BIGINT.
- number2 : obligatoire. Valeur de type INT.
Valeur de retour
Renvoie une valeur de type INT ou BIGINT. Les règles suivantes s'appliquent :
- Une erreur est renvoyée si le type de données de number1 n'est pas TINYINT, SMALLINT, INT ou BIGINT.
- Une erreur est renvoyée si le type de données de number2 n'est pas INT.
- La fonction renvoie NULL lorsque la valeur de number1 ou de number2 est NULL.

Exemples

Exemples avec des données statiques

--The return value is 1. The binary value of 4 is shifted to the right by two bits (4>>2, 0100 is shifted to the right by two bits to become 0001).
select shiftright(4,2);
--The return value is 4. The binary value of 32 is shifted to the right by three bits (32>>3, 100000 is shifted to the right by three bits to become 0100).
select shiftright(32,3);
--The return value is NULL.
select shiftright(null,3);

Exemples avec des données de table

À partir des données d'exemple, la commande suivante applique un décalage vers la droite sur les colonnes int_data et bigint_data.

--Enable new data types of MaxCompute V2.0. You must run this command together with the SQL statement.
set odps.sql.type.system.odps2=true;
select shiftright(int_data, 1) as int_new, shiftright(bigint_data, 1) as bigint_new from mf_math_fun_t;

Le résultat suivant est renvoyé.

+---------+------------+
| int_new | bigint_new |
+---------+------------+
| NULL    | -5         |
| -10     | NULL       |
| 0       | -1         |
| -20     | 2          |
| 2       | -25        |
| -30     | 3          |
| -1      | -35        |
| -40     | 0          |
| 4       | -45        |
| -50     | 5          |
+---------+------------+

SHIFTRIGHTUNSIGNED

Syntaxe

int shiftrightunsigned(tinyint|smallint|int <number1>, int <number2>)
bigint shiftrightunsigned(bigint <number1>, int <number2>)

Description

Effectue un décalage non signé vers la droite (>>>). Cette fonctionnalité est une extension propre à MaxCompute V2.0.
Paramètres
- number1 : obligatoire. Entier de type TINYINT, SMALLINT, INT ou BIGINT.
- number2 : obligatoire. Entier de type INT.
Valeur de retour
Renvoie une valeur de type INT ou BIGINT. Les règles suivantes s'appliquent :
- Une erreur est renvoyée si le type de données de number1 n'est pas TINYINT, SMALLINT, INT ou BIGINT.
- Une erreur est renvoyée si le type de données de number2 n'est pas INT.
- La fonction renvoie NULL lorsque la valeur de number1 ou de number2 est NULL.

Exemples

Exemples avec des données statiques

--The return value is 2. The binary value of 8 is shifted to the right by two bits without considering the sign (8>>>2, 1000 is shifted to the right by two bits to become 0010).
select shiftrightunsigned(8,2);
--The return value is 1073741820. The binary value of -14 is shifted to the right by two bits (-14>>>2, 11111111 11111111 11111111 11110010 is shifted to the right by two bits to become 00111111 11111111 11111111 11111100).
select shiftrightunsigned(-14,2);
--The return value is NULL.
select shiftrightunsigned(-14,null);

Exemples avec des données de table

En se basant sur les données d'exemple, la commande ci-dessous renvoie la valeur du décalage non signé vers la droite pour les colonnes int_data et bigint_data.

--Enable new data types of MaxCompute V2.0. You must run this command together with the SQL statement.
set odps.sql.type.system.odps2=true;
select shiftrightunsigned(int_data, 1) as int_new, shiftrightunsigned(bigint_data, 1) as bigint_new from mf_math_fun_t;

Le résultat suivant est renvoyé.

+------------+---------------------+
| int_new    | bigint_new          |
+------------+---------------------+
| NULL       | 9223372036854775803 |
| 2147483638 | NULL                |
| 0          | 9223372036854775807 |
| 2147483628 | 2                   |
| 2          | 9223372036854775783 |
| 2147483618 | 3                   |
| 2147483647 | 9223372036854775773 |
| 2147483608 | 0                   |
| 4          | 9223372036854775763 |
| 2147483598 | 5                   |
+------------+---------------------+

SIGN

Syntaxe
```
double sign(<number>)
```
Description

Retourne le signe d'un paramètre d'entrée. Cette fonction est une extension de MaxCompute V2.0.
Paramètres

number : obligatoire. Valeur de type DOUBLE, BIGINT, INT, SMALLINT, TINYINT, FLOAT, DECIMAL ou STRING.
Valeur de retour
Renvoie une valeur de type DOUBLE. Les règles suivantes s'appliquent :
- Renvoie 1.0 si la valeur de number est positive.
- Renvoie -1.0 si la valeur de number est négative.
- Renvoie 0.0 si la valeur de number est égale à 0.
- Renvoie NULL si la valeur de number est NULL.

Exemples

Exemples avec des données statiques

--The return value is -1.0.
select sign(-2.5);
--The return value is 1.0.
select sign(2.5);
--The return value is 0.0.
select sign(0);
--The return value is NULL.
select sign(null);

Exemples avec des données de table

Sur la base des données d'exemple, la commande suivante obtient le signe de toutes les colonnes.

--Enable new data types of MaxCompute V2.0. You must run this command together with the SQL statement.
set odps.sql.type.system.odps2=true;
select sign(int_data) as int_new, sign(bigint_data) as bigint_new, sign(double_data) as double_new, sign(decimal_data) as decimal_new, sign(float_data) as float_new, sign(string_data) as string_new from mf_math_fun_t;

Le résultat suivant est renvoyé.

+------------+------------+------------+-------------+------------+------------+
| int_new    | bigint_new | double_new | decimal_new | float_new  | string_new |
+------------+------------+------------+-------------+------------+------------+
| NULL       | -1.0       | 1.0        | 1           | 1.0        | 1.0        |
| -1.0       | NULL       | -1.0       | -1          | -1.0       | -1.0       |
| 0.0        | -1.0       | NULL       | 1           | -1.0       | 1.0        |
| -1.0       | 1.0        | 1.0        | NULL        | 1.0        | -1.0       |
| 1.0        | -1.0       | -1.0       | -1          | NULL       | 1.0        |
| -1.0       | 1.0        | 1.0        | 1           | 1.0        | -1.0       |
| -1.0       | -1.0       | -1.0       | -1          | -1.0       | NULL       |
| -1.0       | 1.0        | -1.0       | -1          | -1.0       | -1.0       |
| 1.0        | -1.0       | 1.0        | 1           | 1.0        | 0.0        |
| -1.0       | 1.0        | -1.0       | -1          | -1.0       | -1.0       |
+------------+------------+------------+-------------+------------+------------+

SIN

Syntaxe
```
double|decimal sin(<number>)
```
Description

Calcule le sinus de number. La valeur d'entrée doit être exprimée en radians.
Paramètres

number : obligatoire. Valeur de type DOUBLE ou DECIMAL. Si la valeur d'entrée est de type STRING ou BIGINT, elle est implicitement convertie en DOUBLE pour le calcul.
Valeur de retour
Renvoie une valeur de type DOUBLE ou DECIMAL. Les règles suivantes s'appliquent :
- Si number est de type DOUBLE ou DECIMAL, une valeur du type correspondant est renvoyée.
- Si number est de type STRING ou BIGINT, une valeur de type DOUBLE est renvoyée.
- NULL est renvoyé si la valeur de number est NULL.

Exemples

Exemples avec des données statiques

--The return value is -0.3048106211022167.
select sin(60);
--The return value is NULL.
select sin(null);

Exemples avec des données de table

À l'aide des données d'exemple, la commande ci-après calcule le sinus des colonnes.

select sin(bigint_data) as bigint_new, sin(double_data) as double_new, sin(decimal_data) as decimal_new, sin(string_data) as string_new from mf_math_fun_t;

Le résultat suivant est renvoyé.

+----------------------+----------------------+----------------------+----------------------+
| bigint_new           | double_new           | decimal_new          | string_new           |
+----------------------+----------------------+----------------------+----------------------+
| 0.5440211108893698   | 0.5012130046737979   | 0.5012130046737979   | -0.5440211108893698  |
| NULL                 | -0.09983341664682815 | -0.09983341664682815 | 0.5440211108893698   |
| -0.8414709848078965  | NULL                 | 0.9995605376022045   | -0.9880316240928618  |
| -0.7568024953079282  | 0.7770717475268238   | NULL                 | 0.9880316240928618   |
| 0.26237485370392877  | -0.8414709848078965  | -0.8414709848078965  | -0.26237485370392877 |
| -0.27941549819892586 | 0.9974949866040544   | 0.9974949866040544   | 0.26237485370392877  |
| -0.7738906815578891  | -0.9379999767747389  | -0.9379999767747389  | NULL                 |
| 0.8414709848078965   | 0.6998746875935423   | 0.6998746875935423   | -0.8414709848078965  |
| -0.8939966636005579  | 0.5325349075556212   | 0.5325349075556212   | 0.0                  |
| -0.5440211108893698  | 0.46460217941375737  | 0.46460217941375737  | -0.8939966636005579  |
+----------------------+----------------------+----------------------+----------------------+

SINH

Syntaxe
```
double|decimal sinh(<number>)
```
Description

Calcule le sinus hyperbolique de number.
Paramètres

number : obligatoire. Valeur de type DOUBLE ou DECIMAL. Si la valeur d'entrée est de type STRING ou BIGINT, elle est implicitement convertie en DOUBLE pour le calcul.
Valeur de retour
Renvoie une valeur de type DOUBLE ou DECIMAL. Les règles suivantes s'appliquent :
- Si number est de type DOUBLE ou DECIMAL, une valeur du type correspondant est renvoyée.
- Si number est de type STRING ou BIGINT, une valeur de type DOUBLE est renvoyée.
- NULL est renvoyé si la valeur de number est NULL.

Exemples

Exemples avec des données statiques

--The return value is 5.343237290762231E12.
select sinh(30);
--The return value is NULL.
select sinh(null);

Exemples avec des données de table

En utilisant les données d'exemple, la commande suivante calcule le sinus hyperbolique des colonnes.

select sinh(bigint_data) as bigint_new, sinh(double_data) as double_new, sinh(decimal_data) as decimal_new, sinh(string_data) as string_new from mf_math_fun_t;

Le résultat suivant est renvoyé.

+------------------------+----------------------+----------------------+-----------------------+
| bigint_new             | double_new           | decimal_new          | string_new            |
+------------------------+----------------------+----------------------+-----------------------+
| -11013.232874703393    | 0.5494517420061382   | 0.5494517420061382   | 11013.232874703393    |
| NULL                   | -0.10016675001984403 | -0.10016675001984403 | -11013.232874703393   |
| -1.1752011936438014    | NULL                 | 380445243.96844625   | 5343237290762.231     |
| 27.28991719712775      | 1.0122369492687646   | NULL                 | -5343237290762.231    |
| -2.592352764293536e21  | -1.1752011936438014  | -1.1752011936438014  | 2.592352764293536e21  |
| 201.71315737027922     | 2.1292794550948173   | 2.1292794550948173   | -2.592352764293536e21 |
| -1.2577193354595834e30 | -904.0209306858466   | -904.0209306858466   | NULL                  |
| 1.1752011936438014     | -13451.593018563612  | -13451.593018563612  | -1.1752011936438014   |
| -6.102016471589204e38  | 6.560682077817757    | 6.560682077817757    | 0.0                   |
| 11013.232874703393     | -165.1482661774516   | -165.1482661774516   | -6.102016471589204e38 |
+------------------------+----------------------+----------------------+-----------------------+

SQRT

Syntaxe
```
double|decimal sqrt(<number>)
```
Description

Calcule la racine carrée de number.
Paramètres

number : obligatoire. Valeur de type DOUBLE ou DECIMAL. Cette valeur doit être supérieure à 0. Si elle est inférieure à 0, NULL est renvoyé. Si la valeur d'entrée est de type STRING ou BIGINT, elle est implicitement convertie en DOUBLE pour le calcul.
Valeur de retour
Renvoie une valeur de type DOUBLE ou DECIMAL. Les règles suivantes s'appliquent :
- Si number est de type DOUBLE ou DECIMAL, une valeur du type correspondant est renvoyée.
- Si number est de type STRING ou BIGINT, une valeur de type DOUBLE est renvoyée.
- NULL est renvoyé si la valeur de number est NULL.

Exemples

Exemples avec des données statiques

--The return value is 2.0.
select sqrt(4);
--The return value is NULL.
select sqrt(null);

Exemples avec des données de table

À partir des données d'exemple, la commande suivante calcule la racine carrée des colonnes.

select sqrt(bigint_data) as bigint_new, sqrt(double_data) as double_new, sqrt(decimal_data) as decimal_new, sqrt(string_data) as string_new from mf_math_fun_t;

Le résultat suivant est renvoyé.

+--------------------+--------------------+-------------------+--------------------+
| bigint_new         | double_new         | decimal_new       | string_new         |
+--------------------+--------------------+-------------------+--------------------+
| NULL               | 0.724568837309472  | 0.724568837309472 | 3.1622776601683795 |
| NULL               | NULL               | NULL              | NULL               |
| NULL               | NULL               | 4.522167621838006 | 5.477225575051661  |
| 2.0                | 0.9433981132056604 | NULL              | NULL               |
| NULL               | NULL               | NULL              | 7.0710678118654755 |
| 2.449489742783178  | 1.224744871391589  | 1.224744871391589 | NULL               |
| NULL               | NULL               | NULL              | NULL               |
| 1.0                | NULL               | NULL              | NULL               |
| NULL               | 1.606237840420901  | 1.606237840420901 | 0.0                |
| 3.1622776601683795 | NULL               | NULL              | NULL               |
+--------------------+--------------------+-------------------+--------------------+

TAN

Syntaxe
```
double|decimal tan(<number>)
```
Description

Calcule la tangente de number. La valeur d'entrée doit être exprimée en radians.
Paramètres

number : obligatoire. Valeur de type DOUBLE ou DECIMAL. Si la valeur d'entrée est de type STRING ou BIGINT, elle est implicitement convertie en DOUBLE pour le calcul.
Valeur de retour
Renvoie une valeur de type DOUBLE ou DECIMAL. Les règles suivantes s'appliquent :
- Si number est de type DOUBLE ou DECIMAL, une valeur du type correspondant est renvoyée.
- Si number est de type STRING ou BIGINT, une valeur de type DOUBLE est renvoyée.
- NULL est renvoyé si la valeur de number est NULL.

Exemples

Exemples avec des données statiques

--The return value is -6.405331196646276.
select tan(30);
--The return value is NULL.
select tan(null);

Exemples avec des données de table

Sur la base des données d'exemple, la commande suivante calcule la tangente des colonnes.

select tan(bigint_data) as bigint_new, tan(double_data) as double_new, tan(decimal_data) as decimal_new, tan(string_data) as string_new from mf_math_fun_t;

Le résultat suivant est renvoyé.

+----------------------+----------------------+----------------------+----------------------+
| bigint_new           | double_new           | decimal_new          | string_new           |
+----------------------+----------------------+----------------------+----------------------+
| -0.6483608274590866  | 0.5792200822893652   | 0.5792200822893652   | 0.6483608274590866   |
| NULL                 | -0.10033467208545055 | -0.10033467208545055 | -0.6483608274590866  |
| -1.5574077246549023  | NULL                 | -33.71948732190433   | -6.405331196646276   |
| 1.1578212823495775   | 1.2345994590490046   | NULL                 | 6.405331196646276    |
| 0.27190061199763077  | -1.5574077246549023  | -1.5574077246549023  | -0.27190061199763077 |
| -0.29100619138474915 | 14.101419947171719   | 14.101419947171719   | 0.27190061199763077  |
| -1.2219599181369434  | -2.706013866772691   | -2.706013866772691   | NULL                 |
| 1.5574077246549023   | -0.979852083895097   | -0.979852083895097   | -1.5574077246549023  |
| 1.995200412208242    | -0.6291704256385503  | -0.6291704256385503  | 0.0                  |
| 0.6483608274590866   | 0.5246662219468002   | 0.5246662219468002   | 1.995200412208242    |
+----------------------+----------------------+----------------------+----------------------+

TANH

Syntaxe
```
double|decimal tanh(<number>)
```
Description

Calcule la tangente hyperbolique de number.
Paramètres

number : obligatoire. Valeur de type DOUBLE ou DECIMAL. Si la valeur d'entrée est de type STRING ou BIGINT, elle est implicitement convertie en DOUBLE pour le calcul.
Valeur de retour
Renvoie une valeur de type DOUBLE ou DECIMAL. Les règles suivantes s'appliquent :
- Si number est de type DOUBLE ou DECIMAL, une valeur du type correspondant est renvoyée.
- Si number est de type STRING ou BIGINT, une valeur de type DOUBLE est renvoyée.
- NULL est renvoyé si la valeur de number est NULL.

Exemples

Exemples avec des données statiques

--The return value is 1.0.
select tanh(30);
--The return value is NULL.
select tanh(null);

Exemples avec des données de table

À l'aide des données d'exemple, la commande ci-après calcule la tangente hyperbolique des colonnes.

select tanh(bigint_data) as bigint_new, tanh(double_data) as double_new, tanh(decimal_data) as decimal_new, tanh(string_data) as string_new from mf_math_fun_t;

Le résultat suivant est renvoyé.

+---------------------+----------------------+----------------------+---------------------+
| bigint_new          | double_new           | decimal_new          | string_new          |
+---------------------+----------------------+----------------------+---------------------+
| -0.9999999958776927 | 0.48154979836430806  | 0.48154979836430806  | 0.9999999958776927  |
| NULL                | -0.09966799462495582 | -0.09966799462495582 | -0.9999999958776927 |
| -0.7615941559557649 | NULL                 | 1.0                  | 1.0                 |
| 0.999329299739067   | 0.7113937318189625   | NULL                 | -1.0                |
| -1.0                | -0.7615941559557649  | -0.7615941559557649  | 1.0                 |
| 0.9999877116507956  | 0.9051482536448664   | 0.9051482536448664   | -1.0                |
| -1.0                | -0.9999993881955461  | -0.9999993881955461  | NULL                |
| 0.7615941559557649  | -0.9999999972367348  | -0.9999999972367348  | -0.7615941559557649 |
| -1.0                | 0.9885821584459533   | 0.9885821584459533   | 0.0                 |
| 0.9999999958776927  | -0.9999816679925603  | -0.9999816679925603  | -1.0                |
+---------------------+----------------------+----------------------+---------------------+

TRUNC

Syntaxe

double|decimal trunc(<number>[, bigint <decimal_places>])

Description

Tronque la valeur d'entrée number au nombre de décimales spécifié.

Remarque
En mode compatible Hive, cette fonction sert à la conversion des dates plutôt qu'en tant que fonction mathématique. Pour plus d'informations sur la fonction de date correspondante, consultez DATETRUNC. Vous pouvez définir la version des types de données de votre projet MaxCompute selon vos besoins. Pour plus d'informations sur les versions des types de données, consultez Versions des types de données.
Paramètres
- number : obligatoire. Valeur de type DOUBLE ou DECIMAL. Si la valeur d'entrée est de type STRING ou BIGINT, elle est implicitement convertie en DOUBLE pour le calcul.
- decimal_places : facultatif. Constante de type BIGINT. Ce paramètre indique le nombre de décimales auquel tronquer la valeur. En l'absence de ce paramètre, la valeur est tronquée à l'entier le plus proche. La valeur de decimal_places peut être négative. Dans ce cas, la fonction tronque à partir de la virgule décimale vers la gauche sans conserver la partie décimale. Si la valeur de decimal_places dépasse la longueur de la partie entière, 0 est renvoyé.
Valeur de retour
Renvoie une valeur de type DOUBLE ou DECIMAL. Les règles suivantes s'appliquent :
- Si number est de type DOUBLE ou DECIMAL, une valeur du type correspondant est renvoyée.
- Si number est de type STRING ou BIGINT, une valeur de type DOUBLE est renvoyée.
- Une erreur est renvoyée si le type de données de decimal_places n'est pas BIGINT.
- NULL est renvoyé si la valeur de number ou de decimal_places est NULL.
Remarque
- Lorsqu'une valeur de type DOUBLE est renvoyée, le résultat peut différer de celui attendu. Par exemple, trunc(125.815,1). Ce problème d'affichage lié au type DOUBLE existe sur tous les systèmes.
- La partie tronquée est complétée par des zéros.

Exemples

Exemples avec des données statiques

--The return value is 125.0.
select trunc(125.815,0);
--The return value is 125.80000000000001.
select trunc(125.815,1);
--The return value is 125.81.
select trunc(125.815,2);
--The return value is 125.815.
select trunc(125.815,3);
--The return value is -125.81.
select trunc(-125.815,2);
--The return value is 120.0.
select trunc(125.815,-1);
--The return value is 100.0.
select trunc(125.815,-2);
--The return value is 0.0.
select trunc(125.815,-3);
--The return value is 123.345.
select trunc(123.345,4);
--The return value is 0.0.
select trunc(123.345,-4);
--The return value is NULL.
select trunc(123.345,null);

Exemples avec des données de table

À partir des données d'exemple, la commande suivante tronque les valeurs des colonnes au nombre de décimales spécifié.

select trunc(bigint_data, 1) as bigint_new, trunc(double_data,1) as double_new, trunc(decimal_data, 1) as decimal_new, trunc(string_data, 1) as string_new from mf_math_fun_t;

Le résultat suivant est renvoyé.

+------------+---------------------+-------------+------------+
| bigint_new | double_new          | decimal_new | string_new |
+------------+---------------------+-------------+------------+
| -10.0      | 0.5                 | 0.5         | 10.0       |
| NULL       | -0.1                | -0.1        | -10.0      |
| -1.0       | NULL                | 20.4        | 30.0       |
| 4.0        | 0.8                 | NULL        | -30.0      |
| -50.0      | -1.0                | -1          | 50.0       |
| 6.0        | 1.5                 | 1.5         | -50.0      |
| -70.0      | -7.5                | -7.5        | NULL       |
| 1.0        | -10.200000000000001 | -10.2       | -1.0       |
| -90.0      | 2.5                 | 2.5         | 0.0        |
| 10.0       | -5.800000000000001  | -5.8        | -90.0      |
+------------+---------------------+-------------+------------+

UNHEX

Syntaxe
```
binary unhex(string <number>)
```
Description

Renvoie la chaîne représentée par une chaîne hexadécimale. Il s'agit d'une fonction d'extension dans MaxCompute V2.0.
Paramètres

number : obligatoire. Chaîne hexadécimale.
Valeur de retour
Renvoie une valeur de type BINARY. Les règles suivantes s'appliquent :
- Une erreur est renvoyée si la valeur de number est 0.
- NULL est renvoyé si la valeur de number est NULL.

Exemple

--The return value is abc.
select unhex('616263');
--The return value is abc.
select unhex(616263);
--The return value is NULL.
select unhex(null);

WIDTH_BUCKET

Syntaxe

width_bucket(numeric <expr>, numeric <min_value>, numeric <max_value>, int <num_buckets>)

Description

Cette fonction construit un nombre défini de groupes de taille égale en fonction des valeurs minimale et maximale ainsi que du nombre de groupes spécifiés. Elle renvoie le numéro du groupe auquel appartient la valeur d'un champ donné. Les types de données pris en charge sont BIGINT, INT, FLOAT, DOUBLE, DECIMAL et DECIMAL(precision, scale) de MaxCompute V2.0. Pour plus d'informations, consultez Éditions des types de données dans MaxCompute V2.0. Cette fonction est une extension de MaxCompute V2.0.
Paramètres
- expr : obligatoire. Champ dont vous souhaitez déterminer le numéro de groupe.
- min_value : obligatoire. Valeur minimale de la plage du groupe.
- max_value : obligatoire. Valeur maximale de la plage du groupe. Cette valeur doit être supérieure à la valeur minimale.
- num_buckets : obligatoire. Nombre de groupes. Cette valeur doit être supérieure à 0.
Valeur de retour
Renvoie une valeur de type BIGINT. Cette valeur varie de 0 au nombre de groupes spécifié plus 1. La valeur est renvoyée selon les règles suivantes :
- Renvoie 0 si la valeur de expr est inférieure à celle de min_value.
- Renvoie le nombre de groupes spécifié plus 1 si la valeur de expr est supérieure à celle de max_value.
- Renvoie NULL si la valeur de expr est NULL. Dans les autres cas, le numéro du groupe auquel appartient la valeur du champ est renvoyé. Ce numéro est calculé selon la formule suivante : floor( num_buckets * (expr - min_value)/(max_value - min_value) + 1).
- NULL est renvoyé si la valeur de min_value, de max_value ou de num_buckets est NULL.

Exemples

Exemple 1 : aucun des paramètres d'entrée n'est NULL. Exemple de commande :

select key,value,width_bucket(value,100,500,5) as value_group
from values 
    (1,99),
    (2,100),
    (3,199),
    (4,200),
    (5,499),
    (6,500),
    (7,501),
    (8,NULL)
as t(key,value);

Le résultat suivant est renvoyé.

+-------+--------+-------------+
| key   | value  | value_group |
+-------+--------+-------------+
| 1     | 99     | 0           |
| 2     | 100    | 1           |
| 3     | 199    | 2           |
| 4     | 200    | 2           |
| 5     | 499    | 5           |
| 6     | 500    | 6           |
| 7     | 501    | 6           |
| 8     | NULL   | NULL        |
+-------+--------+-------------+

Exemple 2 : l'un des paramètres d'entrée est NULL. Exemple de commande :

select key,value,width_bucket(value,100,500,null) as value_group
from values
    (1,99),
    (2,100),
    (3,199),
    (4,200),
    (5,499),
    (6,500),
    (7,501),
    (8,NULL)
as t(key,value);

Le résultat suivant est renvoyé.

+------+-------+-------------+
| key  | value | value_group |
+------+-------+-------------+
| 1    | 99    | NULL        |
| 2    | 100   | NULL        |
| 3    | 199   | NULL        |
| 4    | 200   | NULL        |
| 5    | 499   | NULL        |
| 6    | 500   | NULL        |
| 7    | 501   | NULL        |
| 8    | NULL  | NULL        |
+------+-------+-------------+

Références

Si les fonctions intégrées présentées précédemment ne répondent pas à vos besoins, utilisez les fonctions définies par l'utilisateur (UDF) de MaxCompute. Pour plus d'informations sur les UDF, consultez Présentation des UDF MaxCompute.
Pour en savoir plus sur la FAQ relative à MaxCompute SQL, reportez-vous aux ressources suivantes :
Concernant les codes d'erreur courants et la FAQ des fonctions intégrées de MaxCompute, consultez les rubriques ci-dessous :
- Codes d'erreur courants pour les fonctions intégrées
- FAQ sur les fonctions intégrées