MaxCompute mathematical functions - MaxCompute - Centre de documentation Alibaba Cloud

MaxCompute V2.0 propose 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, vous devez ajouter set odps.sql.type.system.odps2=true; avant l'instruction SQL que vous souhaitez exécuter, puis valider et exécuter le tout 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 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 Guide des versions de types de données.

Exemple de données

Afin de vous aider à comprendre comment utiliser 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. Une valeur de type DOUBLE, BIGINT ou DECIMAL. Si la valeur d'entrée est de type STRING, elle est implicitement convertie en une 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 de BIGINT, la valeur est convertie au type DOUBLE. Cette conversion peut entraîner une perte de précision.
Valeur de retour
Le type de données de la valeur de retour 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 des 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 des 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'arc cosinus de number.
Paramètres

number : obligatoire. Une 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 une valeur de type DOUBLE pour le calcul.
Valeur de retour
Le type de données de la valeur renvoyée correspond à celui du paramètre d'entrée. La valeur se situe dans l'intervalle [0, π]. Les règles suivantes s'appliquent :
- Si number est de type DOUBLE ou DECIMAL, une valeur du même type 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 l'intervalle [-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 des 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 des données de table

À partir 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 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 type DOUBLE pour le calcul.
Valeur renvoyée

Une valeur de type DOUBLE est renvoyée. La valeur se situe dans l'intervalle -π/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 l'intervalle [-1, 1]. Elle est 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 renvoyée
Le type de données de la valeur renvoyée correspond à celui du paramètre d'entrée. La valeur se situe dans l'intervalle -π/2 to π/2. Les règles suivantes s'appliquent :
- Si number est de type DOUBLE ou DECIMAL, une valeur du même type 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 l'intervalle [-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 des 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 des données de table

À partir 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'arc tangente 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 type DOUBLE pour le calcul.
Valeur renvoyée

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

Exemples

Exemples avec des 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 des données de table

À partir des données d'exemple, la commande suivante calcule l'arc tangente.

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 pas BIGINT, INT, SMALLINT ou TINYINT, une erreur est renvoyée.
- Si la valeur de number est 0, la fonction renvoie 0.
- Si la valeur de number est NULL, la fonction renvoie NULL.

Exemples

Exemples avec des 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 des données de table

À partir 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 du paramètre number n'est pas BIGINT, INT, SMALLINT, TINYINT, DOUBLE, FLOAT ou STRING, une erreur est renvoyée.
- Si la valeur du paramètre number est NULL, la fonction renvoie NULL.

Exemples

Exemples avec des données statiques

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

Exemples avec des données de table

En vous basant sur les données d'exemple, la commande suivante calcule la racine cubique de toutes les colonnes, à l'exception de 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 à l'entier supérieur. Cette fonction renvoie le plus petit entier qui n'est pas inférieur à 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 du paramètre value est NULL, la fonction renvoie 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 à l'entier supérieur.

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 renvoyé.

+------------+------------+-------------+------------+
| 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 à une autre et renvoie 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, ce qui signifie que 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, ce qui signifie que 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 valeur de la base doit être un entier décimal égal à 2, 8, 10 ou 16. La conversion implicite de type n'est pas prise en charge.
to_base	Oui	La valeur de la base doit être un entier décimal égal à 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, de from_base ou de to_base est NULL, la fonction renvoie NULL.
- La conversion est effectuée avec une précision de 64 bits. En cas de dépassement de capacité (overflow), la fonction renvoie NULL.
- Si la valeur d'entrée de input est de type BIGINT ou DOUBLE, la fonction renvoie NULL en mode non compatible avec Hive, car la conversion implicite n'est pas prise en charge.
- Si la valeur d'entrée de input est négative, la fonction renvoie NULL en mode non compatible avec Hive. En mode compatible avec Hive, elle renvoie 0.
- Si la valeur d'entrée de input est un nombre décimal, la fonction renvoie NULL en mode non compatible avec Hive. En mode compatible avec Hive, la valeur est convertie en entier avant d'être transformée dans la base spécifiée. La partie décimale est ignoré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

Sur la base des 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 renvoyé.

+------------+------------+-------------+------------+
| 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 de deux colonnes de données. Il s'agit d'une fonction d'extension dans MaxCompute V2.0.
Paramètres

col1 et col2 : Obligatoire. Noms des deux colonnes de la table pour lesquelles vous souhaitez calculer le coefficient de corrélation de Pearson. Les colonnes doivent être de type DOUBLE, BIGINT, INT, SMALLINT, TINYINT, FLOAT ou DECIMAL. Les types de données de col1 et de 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 n'est pas utilisée dans le calcul.
Exemple

Sur la base des 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 est 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 renvoyée.
- Si number est de type STRING ou BIGINT, une valeur de type DOUBLE est renvoyée.
- Si la valeur de number est NULL, la fonction renvoie 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

Sur la base des 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 renvoyé.

+---------------------+--------------------+----------------------+---------------------+
| 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 renvoyée.
- Si number est de type STRING ou BIGINT, une valeur de type DOUBLE est renvoyée.
- Si la valeur de number est NULL, NULL est renvoyé.

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

Sur la base des 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 renvoyé.

+-----------------------+--------------------+--------------------+----------------------+
| 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 est 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 renvoyée.
- Si number est de type STRING ou BIGINT, une valeur de type DOUBLE est renvoyée.
- Si la valeur de number est NULL, NULL est renvoyé.

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

Sur la base des 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 renvoyé.

+-----------------------+---------------------+---------------------+----------------------+
| 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 de radians en degrés.
Paramètres

number : Obligatoire. Une valeur de type DOUBLE, BIGINT, INT, SMALLINT, TINYINT, FLOAT, DECIMAL ou STRING. Il s'agit d'une fonction d'extension dans MaxCompute V2.0.
Valeur renvoyée

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

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

Sur la base des données d'exemple, la commande suivante obtient les degrés correspondant à 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 renvoyé.

+---------------------+---------------------+---------------------+---------------------+---------------------+---------------------+
| 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

Renvoie la valeur de e. Il s'agit d'une fonction d'extension dans MaxCompute V2.0.
Valeur renvoyée

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. Une valeur de type DOUBLE ou DECIMAL. Si la valeur d'entrée est de type STRING ou BIGINT, elle est implicitement convertie en une valeur de type DOUBLE pour le calcul.
Valeur renvoyée
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 renvoyée.
- Si number est de type STRING ou BIGINT, une valeur de type DOUBLE est renvoyée.
- Si la valeur de number est NULL, NULL est renvoyé.

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

Sur la base des 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 renvoyé.

+-------------------------+-------------------------+-------------------------+-------------------------+
| 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

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

number : Obligatoire. Une valeur de type BIGINT, INT, SMALLINT ou TINYINT. La valeur doit se situer dans la plage [0, 20].
Valeur renvoyée
Une valeur de type BIGINT est renvoyée. Les règles suivantes s'appliquent :
- Si la valeur de number est 0, 1 est renvoyé.
- Si la valeur de number est NULL ou n'est pas comprise dans l'intervalle [0, 20], NULL est renvoyé.

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

À partir des 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 renvoyé.

+------------+------------+
| 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. Ce paramètre spécifie un tableau. T dans array<T> indique le type de données des éléments du tableau. Les éléments peuvent être de n'importe quel type de données.
- func : obligatoire. Ce paramètre spécifie la fonction intégrée, la fonction définie par l'utilisateur ou l'expression utilisée pour filtrer les éléments du tableau a. La valeur doit être du même type de données que les éléments du tableau a. Le résultat de sortie de la fonction ou de l'expression est de type BOOLEAN.
Valeur de retour

Une valeur de type ARRAY est renvoyée.
Exemple
```
-- The return value is [2, 3]. 
select filter(array(1, 2, 3), x -> x > 1);
```
Remarque
Dans cet exemple, la combinaison d'un trait d'union et d'un chevron fermant (->) est utilisée. Pour plus d'informations sur l'utilisation de la combinaison d'un trait d'union et d'un chevron fermant (->) dans les fonctions Lambda, consultez la rubrique Fonctions Lambda.

FLOOR

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

Arrondit une valeur à l'entier inférieur. Cette fonction renvoie le plus grand entier qui n'est pas supérieur à 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, NULL est renvoyé.

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

À partir des données d'exemple, la commande suivante arrondit une valeur à l'entier inférieur.

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 renvoyé.

+------------+------------+-------------+------------+
| 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 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. Vous pouvez également spécifier une description de format, telle 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 point décimal ni partie décimale n'est inclus.
- Si expr2 < 0 ou expr2 > 340, une erreur est renvoyée.
- Si la valeur de expr1 ou de expr2 est NULL, NULL est renvoyé.

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

Sur la base des 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 renvoyé.

+---------+------------+------------+-------------+-----------+------------+
| 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 au format hexadécimal. Il s'agit d'une fonction d'extension dans MaxCompute V2.0.
Paramètres

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

Une valeur de type STRING est renvoyée. Les règles suivantes s'appliquent :
- Si la valeur de number n'est pas 0 ou NULL, une valeur de type STRING 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 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

Sur la base des 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 renvoyé.

+------------------+------------------+------------+-------------+------------+------------+
| 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. Une 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, True est renvoyé. Sinon, False est renvoyé.
- Si la valeur de expr est NULL, False est renvoyé.

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. Une 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 renvoyée.
- Si number est de type STRING ou BIGINT, une valeur de type DOUBLE est renvoyée.
- Si la valeur de number est un nombre négatif ou 0, NULL est renvoyé.
- Si la valeur de number est NULL, NULL est renvoyé.

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 renvoyé.

+--------------------+----------------------+---------------------+---------------------+
| 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 à la base base.
Paramètres
- base : Obligatoire. La base. Une valeur de type DOUBLE ou DECIMAL. Si la valeur d'entrée est de type STRING ou BIGINT, elle est implicitement convertie en une valeur de type DOUBLE pour le calcul.
- x : Obligatoire. La valeur dont vous souhaitez calculer le logarithme. Une valeur de type DOUBLE ou DECIMAL. Si la valeur d'entrée est de type STRING ou BIGINT, elle est implicitement convertie en une valeur de type DOUBLE pour le calcul.
Valeur de retour
Une valeur de type DOUBLE est renvoyée. Les règles suivantes s'appliquent :
- Si la valeur de base ou de x est NULL, NULL est renvoyé.
- Si la valeur de base ou de x est un nombre négatif ou 0, NULL est renvoyé.
- Si la valeur de base est 1, ce qui provoque une erreur de division par zéro, NULL est renvoyé.

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 renvoyé.

+--------------------+----------------------+--------------------+--------------------+
| 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

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

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

Une valeur de type DOUBLE est renvoyée. Si la valeur de number est 0, un nombre négatif ou NULL, la fonction renvoie 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

Sur la base des 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 renvoyé.

+--------------------+--------------------+---------------------+---------------------+-----------------------+--------------------+
| 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

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

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

Une valeur de type DOUBLE est renvoyée. Si la valeur de number est 0, un nombre négatif ou NULL, la fonction renvoie 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

Sur la base des 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 renvoyé.

+--------------------+--------------------+----------------------+--------------------+----------------------+--------------------+
| 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

Renvoie 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

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

Exemple

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

PI

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

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

Une valeur de type DOUBLE est renvoyé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

Renvoie la valeur de l'expression expr.
Paramètres

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

Renvoie 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 renvoyée
Une valeur de type DOUBLE ou DECIMAL est renvoyée. Les règles suivantes s'appliquent :
- Si x ou y est de type DOUBLE ou DECIMAL, une valeur du type correspondant est renvoyée.
- Si x ou y est de type STRING ou BIGINT, une valeur de type DOUBLE est renvoyée.
- Si la valeur de x ou de y est NULL, la valeur NULL est renvoyée.

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

Sur la base des 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 renvoyé.

+------------+----------------------+----------------------+------------+
| 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 de degrés en 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 renvoyée

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

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

Sur la base des 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 renvoyé.

+-----------------------+-----------------------+------------------------+------------------------+------------------------+-----------------------+
| 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

Renvoie 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. Si l'environnement d'exécution et la valeur de seed restent identiques, la valeur de retour sera la même. Pour obtenir un résultat différent, vous devez modifier la valeur de seed.

Vous pouvez ajouter 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 d'instance actuel comme seed initial 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 initial pour le nombre aléatoire. Toutefois, la fonction RAND n'est plus idempotente et ne peut pas être utilisée comme clé de brassage (shuffle key). Cela entraîne des résultats différents lors de l'exécution ultérieure de la fonction.
Valeur de retour

Une valeur de type DOUBLE est renvoyé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 spécifique de décimales.
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 spécifie le nombre de décimales auxquelles vous souhaitez 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 négative. Si la valeur est négative, la fonction arrondit les chiffres situés à gauche de la virgule décimale et ne conserve pas la partie décimale. Si la valeur de decimal_places est supérieure à la longueur de la partie entière, 0 est renvoyé.
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 renvoyée.
- Si number est de type STRING ou BIGINT, une valeur de type DOUBLE est renvoyée.
- Si le type de données de decimal_places n'est pas BIGINT, une erreur est renvoyée.
- Si la valeur de number ou de decimal_places est NULL, NULL est renvoyé.

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

Sur la base des données d'exemple, la commande suivante arrondit les valeurs des colonnes à un nombre spécifique de décimales.

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 renvoyé.

+------------+------------+-------------+------------+
| 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 binaire 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 renvoyé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 renvoyée.
- Si le type de données de number2 n'est pas INT, une erreur est renvoyée.
- Si la valeur de number1 ou de number2 est NULL, la valeur NULL est renvoyée.

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

À partir des 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 renvoyé.

+---------+------------+
| 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. Une valeur de type TINYINT, SMALLINT, INT ou BIGINT.
- number2 : Obligatoire. Une valeur de type INT.
Valeur de retour
Une valeur de type INT ou BIGINT est renvoyé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 renvoyée.
- Si le type de données de number2 n'est pas INT, une erreur est renvoyée.
- Si la valeur de number1 ou de number2 est NULL, la valeur NULL est renvoyée.

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 effectue 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 vers la droite non signé (>>>). Il s'agit d'une fonction d'extension dans MaxCompute V2.0.
Paramètres
- number1 : Obligatoire. Un entier de type TINYINT, SMALLINT, INT ou BIGINT.
- number2 : Obligatoire. Un entier de type INT.
Valeur de retour
Une valeur de type INT ou BIGINT est renvoyé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 renvoyée.
- Si le type de données de number2 n'est pas INT, une erreur est renvoyée.
- Si la valeur de number1 ou de number2 est NULL, la valeur NULL est renvoyée.

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

À partir des données d'exemple, la commande suivante renvoie la valeur du décalage vers la droite non signé 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

Renvoie le signe d'un paramètre d'entrée. Il s'agit d'une fonction d'extension dans MaxCompute V2.0.
Paramètres

number : Obligatoire. Une valeur de type DOUBLE, BIGINT, INT, SMALLINT, TINYINT, FLOAT, DECIMAL ou STRING.
Valeur de retour
Une valeur de type DOUBLE est renvoyée. Les règles suivantes s'appliquent :
- Si la valeur de number est un nombre positif, 1,0 est renvoyé.
- Si la valeur de number est un nombre négatif, -1,0 est renvoyé.
- Si la valeur de number est 0, 0,0 est renvoyé.
- Si la valeur de number est NULL, NULL est renvoyé.

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 est exprimée en radians.
Paramètres

number : Obligatoire. Une 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 renvoyée.
- Si number est de type STRING ou BIGINT, une valeur de type DOUBLE est renvoyée.
- Si la valeur de number est NULL, NULL est renvoyé.

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

Sur la base des données d'exemple, la commande suivante 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. Une 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 renvoyée.
- Si number est de type STRING ou BIGINT, une valeur de type DOUBLE est renvoyée.
- Si la valeur de number est NULL, NULL est renvoyé.

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

Sur la base des 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. La valeur doit être supérieure à 0. Si la valeur est inférieure à 0, NULL est renvoyé. 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 renvoyée.
- Si number est de type STRING ou BIGINT, une valeur de type DOUBLE est renvoyée.
- Si la valeur de number est NULL, NULL est renvoyé.

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

Sur la base 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 est 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 renvoyée.
- Si number est de type STRING ou BIGINT, une valeur de type DOUBLE est renvoyée.
- Si la valeur de number est NULL, NULL est renvoyé.

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 type DOUBLE pour le calcul.
Valeur renvoyée
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 renvoyée.
- Si number est de type STRING ou BIGINT, une valeur de type DOUBLE est renvoyée.
- Si la valeur de number est NULL, NULL est renvoyé.

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

Sur la base des données d'exemple, la commande suivante 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 à un nombre spécifié de décimales.

Remarque
En mode compatible Hive, cette fonction sert à la conversion de dates plutôt qu'à des calculs mathématiques. Pour plus d'informations sur la fonction de date correspondante, consultez DATETRUNC. Vous pouvez définir la version du type de données pour votre projet MaxCompute selon vos besoins. Pour en savoir plus 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 type DOUBLE pour le calcul.
- decimal_places : facultatif. Constante de type BIGINT. Ce paramètre indique le nombre de décimales auxquelles vous souhaitez tronquer la valeur. Si vous omettez 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 troncature s'effectue de la virgule décimale vers la gauche et la partie décimale n'est pas conservée. Si la valeur de decimal_places est supérieure à la longueur de la partie entière, 0 est renvoyé.
Valeur renvoyée
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 renvoyée.
- Si number est de type STRING ou BIGINT, une valeur de type DOUBLE est renvoyée.
- Si le type de données de decimal_places n'est pas BIGINT, une erreur est renvoyée.
- Si la valeur de number ou de decimal_places est NULL, NULL est renvoyé.
Remarque
- Si une valeur de type DOUBLE est renvoyée, le résultat peut ne pas correspondre aux attentes. Par exemple, trunc(125.815,1). Ce problème d'affichage lié au type DOUBLE existe dans 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

Sur la base des données d'exemple, la commande suivante tronque les valeurs des colonnes à un nombre spécifié de décimales.

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 renvoyée
Une valeur de type BINARY est renvoyée. Les règles suivantes s'appliquent :
- Si la valeur de number est 0, une erreur est renvoyée.
- Si la valeur de number est NULL, la valeur NULL est renvoyée.

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 spécifié de groupes de taille égale en se basant sur la valeur minimale, la valeur maximale et le nombre de groupes indiqués. Elle renvoie le numéro du groupe auquel appartient la valeur d'un champ spécifié. 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 fonction d'extension dans 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 de groupes.
- max_value : obligatoire. Valeur maximale de la plage de groupes. La valeur maximale doit être supérieure à la valeur minimale.
- num_buckets : obligatoire. Nombre de groupes. La valeur doit être supérieure à 0.
Valeur de retour
Une valeur de type BIGINT est renvoyée. La valeur varie de 0 au nombre spécifié de groupes plus 1. La valeur est renvoyée selon les règles suivantes :
- Si la valeur de expr est inférieure à la valeur de min_value, 0 est renvoyé.
- Si la valeur de expr est supérieure à la valeur de max_value, le nombre spécifié de groupes plus 1 est renvoyé.
- Si la valeur de expr est NULL, la valeur NULL est renvoyée. Dans les autres cas, le numéro de groupe auquel appartient la valeur du champ est renvoyé. Le numéro de groupe est calculé à l'aide de la formule suivante : floor( num_buckets * (expr - min_value)/(max_value - min_value) + 1).
- Si la valeur de min_value, de max_value ou de num_buckets est NULL, la valeur NULL est renvoyée.

Exemples

Exemple 1 : Aucun des paramètres d'entrée n'est NULL. Commande d'exemple :

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. Commande d'exemple :

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écédentes ne répondent pas à vos besoins, vous pouvez utiliser des fonctions définies par l'utilisateur (UDF) dans MaxCompute. Pour plus d'informations sur les UDF, consultez Présentation des UDF MaxCompute.
Pour plus d'informations sur la FAQ relative à MaxCompute SQL, consultez :
Pour plus d'informations sur les codes d'erreur courants et la FAQ relatifs aux fonctions intégrées de MaxCompute, consultez :
- Codes d'erreur courants pour les fonctions intégrées
- FAQ sur les fonctions intégrées