MaxCompute mathematical functions - MaxCompute: Central de Documentação do Alibaba Cloud

A tabela a seguir lista as funções matemáticas compatíveis com o MaxCompute SQL.

Função	Recurso
ABS	Calcula o valor absoluto.
ACOS	Calcula o arco cosseno.
ATAN2	Calcula a arco tangente de expr1/expr2.
ASIN	Calcula o arco seno.
ATAN	Calcula a arco tangente.
BIN	Calcula o valor binário.
BIT_COUNT	Conta o número de 1s na representação binária do parâmetro especificado `value`.
CBRT	Calcula a raiz cúbica.
CEIL	Arredonda um valor para cima.
CONV	Converte um número de uma base para outra.
CORR	Calcula o coeficiente de correlação de Pearson.
COS	Calcula o cosseno.
COSH	Calcula o cosseno hiperbólico.
COT	Calcula a cotangente.
DEGREES	Converte radianos em graus.
E	Retorna o valor de e.
EXP	Calcula o valor exponencial.
FACTORIAL	Calcula o fatorial.
FILTER	Filtra elementos em um array ARRAY.
FLOOR	Arredonda um valor para baixo.
FORMAT_NUMBER	Converte um número em uma string no formato especificado.
GREATEST	Compara um conjunto de valores e retorna o valor máximo.
HEX	Retorna o formato hexadecimal de um inteiro ou string.
ISNAN	Verifica se o valor de uma expressão é NaN.
LEAST	Compara um conjunto de valores e retorna o valor mínimo.
LN	Calcula o logaritmo natural.
LOG	Calcula o logaritmo.
LOG10	Calcula o logaritmo decimal.
LOG2	Calcula o logaritmo binário.
NEGATIVE	Retorna o valor negativo de uma expressão.
PI	Retorna o valor de π.
POSITIVE	Retorna o valor de uma expressão.
POW	Calcula a potência.
RADIANS	Converte graus em radianos.
RAND	Retorna um número aleatório.
ROUND	Retorna um valor arredondado para uma casa decimal especificada.
SHIFTLEFT	Calcula o valor de deslocamento à esquerda.
SHIFTRIGHT	Calcula o valor de deslocamento à direita.
SHIFTRIGHTUNSIGNED	Calcula o valor de deslocamento à direita sem sinal.
SIGN	Retorna o sinal do parâmetro de entrada.
SIN	Calcula o seno.
SINH	Calcula o seno hiperbólico.
SQRT	Calcula a raiz quadrada.
TAN	Calcula a tangente.
TANH	Calcula a tangente hiperbólica.
TRUNC	Retorna um valor truncado para uma casa decimal especificada.
UNHEX	Retorna a string representada por uma string hexadecimal.
WIDTH_BUCKET	Retorna o número do bucket no qual um valor de campo especificado se enquadra.

Nota

Para obter mais informações sobre cálculos, como calcular o resto da divisão, consulte Operators.

Notas de uso

O MaxCompute V2.0 fornece funções adicionais. Se as funções que você utiliza envolverem novos tipos de dados compatíveis com a edição de tipos de dados do MaxCompute V2.0, será necessário executar a instrução SET para ativar essa edição. Os novos tipos de dados incluem TINYINT, SMALLINT, INT, FLOAT, VARCHAR, TIMESTAMP e BINARY.

Nível de sessão: Para usar a edição de tipos de dados do MaxCompute V2.0, adicione set odps.sql.type.system.odps2=true; antes da instrução SQL que deseja executar e envie-as juntas para execução.
Nível de projeto: O proprietário do projeto pode ativar a edição de tipos de dados do MaxCompute V2.0 conforme os requisitos do projeto. A configuração entra em vigor após 10 a 15 minutos. Para ativar a edição de tipos de dados do MaxCompute V2.0 no nível do projeto, execute o seguinte comando:
```
setproject odps.sql.type.system.odps2=true; 
```
Para obter mais informações sobre setproject, consulte Project operations. Para saber mais sobre as precauções necessárias ao ativar a edição de tipos de dados do MaxCompute V2.0 no nível do projeto, consulte Data type version guide.

Dados de amostra

Para ajudar você a entender como usar cada função, este tópico fornece dados de origem e exemplos baseados nesses dados. O comando de amostra a seguir cria uma tabela chamada mf_math_fun_t e adiciona dados a ela.

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');

O comando a seguir consulta dados da tabela 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

Sintaxe
```
bigint|double|decimal abs(<number>)
```
Descrição

Calcula o valor absoluto de number.
Parâmetros

number: Obrigatório. Um valor do tipo DOUBLE, BIGINT ou DECIMAL. Se o valor de entrada for do tipo STRING, ele será convertido implicitamente para o tipo DOUBLE para cálculo.

Nota
Se o valor de entrada for do tipo BIGINT e exceder o intervalo de valores desse tipo, o valor será convertido para DOUBLE. Essa conversão pode causar perda de precisão.
Valor de retorno
O tipo de dados do valor de retorno é igual ao tipo de dados do parâmetro de entrada. As seguintes regras se aplicam:
- Se number for do tipo DOUBLE, BIGINT ou DECIMAL, um valor do tipo correspondente será retornado.
- Se number for do tipo STRING, um valor do tipo DOUBLE será retornado.
- Se number for NULL, NULL será retornado.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base nos sample data, o comando a seguir calcula o valor absoluto.

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;

O resultado a seguir é retornado.

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

Sintaxe
```
double|decimal acos(<number>)
```
Descrição

Calcula o arco cosseno de number.
Parâmetros

number: Obrigatório. Um valor no intervalo de [-1, 1]. O valor deve ser do tipo DOUBLE ou DECIMAL. Se o valor de entrada for do tipo STRING ou BIGINT, ele será convertido implicitamente para o tipo DOUBLE para cálculo.
Valor de retorno
O tipo de dados do valor de retorno é igual ao tipo de dados do parâmetro de entrada. O valor está no intervalo de 0 a π. As seguintes regras se aplicam:
- Se number for do tipo DOUBLE ou DECIMAL, um valor do tipo correspondente será retornado.
- Se number for do tipo STRING ou BIGINT, um valor do tipo DOUBLE será retornado.
- Se o valor de number não estiver no intervalo de [-1, 1], NULL será retornado. No modo compatível com Hive, NaN é retornado.
- Se o valor de number for NULL, NULL será retornado.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base nos sample data, o comando a seguir calcula o arco cosseno.

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;

O resultado a seguir é retornado.

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

Sintaxe
```
double atan2(<expr1>, <expr2>)
```
Descrição

Calcula a arco tangente de expr1/expr2.
Parâmetros
- expr1: Obrigatório. Um valor do tipo DOUBLE. Se o valor de entrada for do tipo STRING, BIGINT ou DECIMAL, ele será convertido implicitamente para o tipo DOUBLE para cálculo.
- expr2: Obrigatório. Um valor do tipo DOUBLE. Se o valor de entrada for do tipo STRING, BIGINT ou DECIMAL, ele será convertido implicitamente para o tipo DOUBLE para cálculo.
Valor de retorno

Um valor do tipo DOUBLE é retornado. O valor está no intervalo de -π/2 to π/2. Se o valor de expr1 ou expr2 for NULL, NULL será retornado.

Exemplo

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

ASIN

Sintaxe
```
double|decimal asin(<number>)
```
Descrição

Calcula o arco seno de number.
Parâmetros

number: Obrigatório. Um valor no intervalo de [-1, 1]. O valor deve ser do tipo DOUBLE ou DECIMAL. Se o valor de entrada for do tipo STRING ou BIGINT, ele será convertido implicitamente para o tipo DOUBLE para cálculo.
Valor de retorno
O tipo de dados do valor de retorno é igual ao tipo de dados do parâmetro de entrada. O valor está no intervalo de -π/2 to π/2. As seguintes regras se aplicam:
- Se number for do tipo DOUBLE ou DECIMAL, um valor do tipo correspondente será retornado.
- Se number for do tipo STRING ou BIGINT, um valor do tipo DOUBLE será retornado.
- Se o valor de number não estiver no intervalo de [-1, 1], NULL será retornado. No modo compatível com Hive, NaN é retornado.
- Se o valor de number for NULL, NULL será retornado.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base nos sample data, o comando a seguir calcula o arco seno.

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;

O resultado a seguir é retornado.

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

Sintaxe
```
double atan(<number>)
```
Descrição

Calcula a arco tangente de number.
Parâmetros

number: Obrigatório. Um valor do tipo DOUBLE. Se o valor de entrada for do tipo STRING, BIGINT ou DECIMAL, ele será convertido implicitamente para o tipo DOUBLE para cálculo.
Valor de retorno

Um valor do tipo DOUBLE é retornado. O valor está no intervalo de -π/2 to π/2. Se o valor de number for NULL, NULL será retornado.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base nos sample data, o comando a seguir calcula a arco 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;

O resultado a seguir é retornado.

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

Sintaxe
```
string bin(<number>)
```
Descrição

Retorna a representação binária de number. Esta é uma função de extensão no MaxCompute V2.0.
Parâmetros

number: Obrigatório. Um valor do tipo BIGINT, INT, SMALLINT ou TINYINT.
Valor de retorno
Um valor do tipo STRING é retornado. As seguintes regras se aplicam:
- Se o tipo de dados de number não for BIGINT, INT, SMALLINT ou TINYINT, um erro será retornado.
- Se o valor de number for 0, 0 será retornado.
- Se o valor de number for NULL, NULL será retornado.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base nos sample data, o comando a seguir obtém as representações binárias das colunas int_data e 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;

O resultado a seguir é retornado.

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

Sintaxe
```
double cbrt(<number>)
```
Descrição

Calcula a raiz cúbica de number. Esta é uma função de extensão no MaxCompute V2.0.
Parâmetros

number: Obrigatório. Um valor do tipo BIGINT, INT, SMALLINT, TINYINT, DOUBLE, FLOAT ou STRING.
Valor de retorno
Um valor do tipo DOUBLE é retornado. As seguintes regras se aplicam:
- Se o tipo de dados de number não for BIGINT, INT, SMALLINT, TINYINT, DOUBLE, FLOAT ou STRING, um erro será retornado.
- Se o valor de number for NULL, NULL será retornado.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base nos sample data, o comando a seguir obtém a raiz cúbica de todas as colunas, exceto 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;

O resultado a seguir é retornado.

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

Sintaxe
```
bigint ceil(<value>)
```
Descrição

Arredonda um valor para cima. Esta função retorna o menor inteiro que não seja menor que o valor de entrada value.
Parâmetros

value: Obrigatório. Um valor do tipo DOUBLE ou DECIMAL. Se o valor de entrada for do tipo STRING ou BIGINT, ele será convertido implicitamente para o tipo DOUBLE para cálculo.
Valor de retorno

Um valor do tipo BIGINT é retornado. Se o valor de value for NULL, NULL será retornado.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base nos sample data, o comando a seguir arredonda um valor para cima.

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;

O resultado a seguir é retornado.

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

Sintaxe

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

Descrição

Esta função converte um número de uma base para outra e retorna o resultado como uma string.

Parâmetros

Parâmetro	Obrigatório	Descrição
input	Sim	Um valor do tipo STRING. Nota Se o seu projeto estiver no modo compatível com Hive, ou seja, se você tiver executado o comando `set odps.sql.hive.compatible=true;`, a conversão implícita de valores BIGINT e DOUBLE é suportada. Caso o projeto não esteja no modo compatível com Hive, indicando que o comando `set odps.sql.hive.compatible=false;` foi executado, a conversão implícita de valores BIGINT e DOUBLE não é suportada.
from_base	Sim	O valor da base deve ser um inteiro decimal de 2, 8, 10 ou 16. A conversão implícita de tipos não é suportada.
to_base	Sim	O valor da base deve ser um inteiro decimal de 2, 8, 10 ou 16. A conversão implícita de tipos não é suportada.

Valor de retorno
Retorna um valor do tipo STRING. As seguintes regras se aplicam:
- Se o valor de input, from_base ou to_base for NULL, o retorno será NULL.
- A conversão ocorre com precisão de 64 bits. Em caso de overflow, NULL é retornado.
- Quando o valor de entrada de input for do tipo BIGINT ou DOUBLE, NULL será retornado no modo não compatível com Hive, pois a conversão implícita não é suportada.
- Caso o valor de entrada de input seja negativo, NULL é retornado no modo não compatível com Hive. No modo compatível com Hive, 0 é retornado.
- Se o valor de entrada de input for um decimal, NULL é retornado no modo não compatível com Hive. Já no modo compatível com Hive, o valor é convertido para inteiro e depois para a base especificada, descartando-se a parte decimal.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base na sample data, o comando a seguir converte valores para o formato binário.

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;

O seguinte resultado é retornado.

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

Sintaxe
```
double corr(<col1>, <col2>)
```
Descrição

Calcula o coeficiente de correlação de Pearson de duas colunas de dados. Esta é uma função de extensão no MaxCompute V2.0.
Parâmetros

col1 e col2: Obrigatórios. Os nomes das duas colunas na tabela para as quais você deseja calcular o coeficiente de correlação de Pearson. As colunas devem ser do tipo DOUBLE, BIGINT, INT, SMALLINT, TINYINT, FLOAT ou DECIMAL. Os tipos de dados de col1 e col2 podem ser diferentes.
Valor de retorno

Retorna um valor do tipo DOUBLE. Se uma linha em uma coluna de entrada contiver um valor NULL, essa linha não será utilizada no cálculo.
Exemplo

Com base na sample data, o comando a seguir calcula o coeficiente de correlação de Pearson das colunas double_data e float_data.
```
select corr(double_data,float_data) from mf_math_fun_t;
```
O valor retornado é 1.0.

COS

Sintaxe
```
double|decimal cos(<number>)
```
Descrição

Calcula o cosseno de number. O valor de entrada está em radianos.
Parâmetros

number: Obrigatório. Um valor do tipo DOUBLE ou DECIMAL. Se o valor de entrada for do tipo STRING ou BIGINT, ele será implicitamente convertido para o tipo DOUBLE para o cálculo.
Valor de retorno
Retorna um valor do tipo DOUBLE ou DECIMAL. As seguintes regras se aplicam:
- Se number for do tipo DOUBLE ou DECIMAL, um valor do tipo correspondente é retornado.
- Caso number seja do tipo STRING ou BIGINT, um valor do tipo DOUBLE é retornado.
- Quando o valor de number for NULL, NULL é retornado.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base na sample data, o comando a seguir calcula o cosseno.

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;

O seguinte resultado é retornado.

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

Sintaxe
```
double|decimal cosh(<number>)
```
Descrição

Calcula o cosseno hiperbólico de number.
Parâmetros

number: Obrigatório. Um valor do tipo DOUBLE ou DECIMAL. Se o valor de entrada for do tipo STRING ou BIGINT, ele será implicitamente convertido para o tipo DOUBLE para o cálculo.
Valor de retorno
Retorna um valor do tipo DOUBLE ou DECIMAL. As seguintes regras se aplicam:
- Se number for do tipo DOUBLE ou DECIMAL, um valor do tipo correspondente é retornado.
- Caso number seja do tipo STRING ou BIGINT, um valor do tipo DOUBLE é retornado.
- Quando o valor de number for NULL, NULL é retornado.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base na sample data, o comando a seguir calcula o cosseno hiperbólico.

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;

O seguinte resultado é retornado.

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

Sintaxe
```
double|decimal cot(<number>)
```
Descrição

Calcula a cotangente de number. O valor de entrada está em radianos.
Parâmetros

number: Obrigatório. Um valor do tipo DOUBLE ou DECIMAL. Se o valor de entrada for do tipo STRING ou BIGINT, ele será implicitamente convertido para o tipo DOUBLE para o cálculo.
Valor de retorno
Retorna um valor do tipo DOUBLE ou DECIMAL. As seguintes regras se aplicam:
- Se number for do tipo DOUBLE ou DECIMAL, um valor do tipo correspondente é retornado.
- Caso number seja do tipo STRING ou BIGINT, um valor do tipo DOUBLE é retornado.
- Quando o valor de number for NULL, NULL é retornado.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base na sample data, o comando a seguir calcula a 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;

O seguinte resultado é retornado.

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

Sintaxe
```
double degrees(<number>) 
```
Descrição

Converte um valor de radianos para graus.
Parâmetros

number: Obrigatório. Um valor do tipo DOUBLE, BIGINT, INT, SMALLINT, TINYINT, FLOAT, DECIMAL ou STRING. Esta é uma função de extensão no MaxCompute V2.0.
Valor de retorno

Retorna um valor do tipo DOUBLE. Se o valor de number for NULL, NULL é retornado.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base na sample data, o comando a seguir obtém os graus correspondentes a todas as colunas.

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

O seguinte resultado é retornado.

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

Sintaxe
```
double e()
```
Descrição

Retorna o valor de e. Esta é uma função de extensão no MaxCompute V2.0.
Valor de retorno

Retorna um valor do tipo DOUBLE.

Exemplo

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

EXP

Sintaxe
```
double|decimal exp(<number>)
```
Descrição

Calcula o valor exponencial de number.
Parâmetros

number: Obrigatório. Um valor do tipo DOUBLE ou DECIMAL. Se o valor de entrada for do tipo STRING ou BIGINT, ele será implicitamente convertido para o tipo DOUBLE para o cálculo.
Valor de retorno
Retorna um valor do tipo DOUBLE ou DECIMAL. As seguintes regras se aplicam:
- Se number for do tipo DOUBLE ou DECIMAL, um valor do tipo correspondente é retornado.
- Caso number seja do tipo STRING ou BIGINT, um valor do tipo DOUBLE é retornado.
- Quando o valor de number for NULL, NULL é retornado.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base na sample data, o comando a seguir calcula o valor exponencial.

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;

O seguinte resultado é retornado.

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

Sintaxe
```
bigint factorial(<number>)
```
Descrição

Retorna o fatorial de number. Esta é uma função de extensão no MaxCompute V2.0.
Parâmetros

number: Obrigatório. Um valor do tipo BIGINT, INT, SMALLINT ou TINYINT. O valor deve estar no intervalo de [0, 20].
Valor de retorno
Retorna um valor do tipo BIGINT. As seguintes regras se aplicam:
- Se o valor de number for 0, 1 é retornado.
- Caso o valor de number seja NULL ou não esteja no intervalo de [0, 20], NULL é retornado.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base na sample data, o comando a seguir calcula o fatorial das colunas int_data e 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;

O seguinte resultado é retornado.

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

Sintaxe

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

Parâmetros
- a: obrigatório. Este parâmetro especifica um array. T em array<T> especifica o tipo de dados dos elementos no array. Os elementos podem ser de qualquer tipo de dado.
- func: obrigatório. Este parâmetro especifica a função interna, função definida pelo usuário ou expressão usada para filtrar os elementos no Array a. O valor deve ter o mesmo tipo de dados que os elementos no Array a. O resultado de saída da função ou expressão é do tipo BOOLEAN.
Valor de retorno

Retorna um valor do tipo ARRAY.
Exemplo
```
-- The return value is [2, 3]. 
select filter(array(1, 2, 3), x -> x > 1);
```
Nota
Neste exemplo, utiliza-se a combinação de um hífen e um sinal de maior que (->). Para mais informações sobre como usar a combinação de hífen e sinal de maior que (->) em funções Lambda, consulte Lambda functions.

FLOOR

Sintaxe
```
bigint floor(<number>)
```
Descrição

Arredonda um valor para baixo. Esta função retorna o maior inteiro que não seja superior a number.
Parâmetros

number: Obrigatório. Um valor do tipo DOUBLE ou DECIMAL. Se o valor de entrada for do tipo STRING ou BIGINT, ele será implicitamente convertido para o tipo DOUBLE para o cálculo.
Valor de retorno

Retorna um valor do tipo BIGINT. Se o valor de number for NULL, NULL é retornado.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base na sample data, o comando a seguir arredonda um valor para baixo.

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;

O seguinte resultado é retornado.

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

Sintaxe

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

Descrição

Converte um número em uma string com um formato especificado. Esta é uma função de extensão no MaxCompute V2.0.
Parâmetros
- expr1: Obrigatório. Os dados a serem formatados. O valor pode ser do tipo DOUBLE, BIGINT, INT, SMALLINT, TINYINT, FLOAT, DECIMAL ou STRING.
- expr2: Obrigatório. O formato de destino. Você pode especificar o número de casas decimais a serem mantidas. Também é possível definir uma descrição de formato, como #,###,###.##.
Valor de retorno
Retorna um valor do tipo STRING. As seguintes regras se aplicam:
- Se expr2 > 0, o valor é arredondado para o número especificado de casas decimais.
- Quando expr2 = 0, nenhum ponto decimal ou parte decimal é incluído.
- Caso expr2 < 0 ou expr2 > 340, um erro é retornado.
- Se o valor de expr1 ou expr2 for NULL, NULL é retornado.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base na sample data, o comando a seguir mantém um número específico de casas decimais para todas as colunas.

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

O seguinte resultado é retornado.

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

Sintaxe
```
string hex(<number>) 
```
Descrição

Converte um valor numérico ou uma string para o formato hexadecimal. Esta é uma função de extensão no MaxCompute V2.0.
Parâmetros

number: Obrigatório. Um valor do tipo DOUBLE, BIGINT, INT, SMALLINT, TINYINT, FLOAT, DECIMAL ou STRING.
Valor de retorno

Retorna um valor do tipo STRING. As seguintes regras se aplicam:
- Se o valor de number não for 0 nem NULL, um valor do tipo STRING será retornado.
- Caso o valor de number seja 0, o retorno será 0.
- Quando o valor de number for NULL, NULL será retornado.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base na sample data, o comando a seguir converte todas as colunas para o formato hexadecimal.

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

O resultado a seguir é retornado.

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

Sintaxe
```
boolean isnan(<expr>)
```
Descrição

Verifica se o valor de expr é NaN.
Parâmetros

expr: Obrigatório. Um valor do tipo DOUBLE. Se o valor de entrada for do tipo STRING, BIGINT ou DECIMAL, ele será convertido implicitamente para o tipo DOUBLE para cálculo.
Valor de retorno
- Retorna True se o valor de expr for NaN. Caso contrário, retorna False.
- Retorna False quando o valor de expr for NULL.

Exemplo

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

LN

Sintaxe
```
double|decimal ln(<number>)
```
Descrição

Calcula o logaritmo natural de number.
Parâmetros

number: Obrigatório. Um valor do tipo DOUBLE ou DECIMAL. Se o valor de entrada for do tipo STRING ou BIGINT, ele será convertido implicitamente para o tipo DOUBLE para cálculo.
Valor de retorno
Retorna um valor do tipo DOUBLE ou DECIMAL. As seguintes regras se aplicam:
- Se number for do tipo DOUBLE ou DECIMAL, um valor do tipo correspondente será retornado.
- Caso number seja do tipo STRING ou BIGINT, um valor do tipo DOUBLE será retornado.
- Retorna NULL se o valor de number for um número negativo ou 0.
- Quando o valor de number for NULL, NULL será retornado.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base na sample data, o comando a seguir calcula o logaritmo natural.

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;

O resultado a seguir é retornado.

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

Sintaxe
```
double log(<base>, <x>)
```
Descrição

Calcula o logaritmo de x na base base.
Parâmetros
- base: Obrigatório. A base. Um valor do tipo DOUBLE ou DECIMAL. Se o valor de entrada for do tipo STRING ou BIGINT, ele será convertido implicitamente para o tipo DOUBLE para cálculo.
- x: Obrigatório. O valor para o qual você deseja calcular o logaritmo. Um valor do tipo DOUBLE ou DECIMAL. Se o valor de entrada for do tipo STRING ou BIGINT, ele será convertido implicitamente para o tipo DOUBLE para cálculo.
Valor de retorno
Retorna um valor do tipo DOUBLE. As seguintes regras se aplicam:
- Retorna NULL se o valor de base ou x for NULL.
- Caso o valor de base ou x seja um número negativo ou 0, NULL será retornado.
- Quando o valor de base for 1, o que causa um erro de divisão por zero, NULL será retornado.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base na sample data, o comando a seguir calcula o logaritmo na base 2 das colunas.

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;

O resultado a seguir é retornado.

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

Sintaxe
```
double log10(<number>)
```
Descrição

Retorna o logaritmo na base 10 de number. Esta é uma função de extensão no MaxCompute V2.0.
Parâmetros

number: Obrigatório. Um valor do tipo DOUBLE, BIGINT, INT, SMALLINT, TINYINT, FLOAT, DECIMAL ou STRING.
Valor de retorno

Retorna um valor do tipo DOUBLE. Retorna NULL se o valor de number for 0, um número negativo ou NULL.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base na sample data, o comando a seguir calcula o logaritmo na base 10 de todas as colunas.

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

O resultado a seguir é retornado.

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

Sintaxe
```
double log2(<number>)
```
Descrição

Retorna o logaritmo na base 2 de number. Esta é uma função de extensão no MaxCompute V2.0.
Parâmetros

number: Obrigatório. Um valor do tipo DOUBLE, BIGINT, INT, SMALLINT, TINYINT, FLOAT, DECIMAL ou STRING.
Valor de retorno

Retorna um valor do tipo DOUBLE. Retorna NULL se o valor de number for 0, um número negativo ou NULL.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base na sample data, o comando a seguir calcula o logaritmo na base 2 de todas as colunas.

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

O resultado a seguir é retornado.

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

Sintaxe

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

Descrição

Retorna o valor negativo de expr.
Parâmetros

expr: Obrigatório. A expressão de entrada. O valor pode ser do tipo TINYINT, SMALLINT, INT, BIGINT, DOUBLE ou DECIMAL.
Valor de retorno

Retorna o valor negativo da expressão expr.

Exemplo

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

PI

Sintaxe
```
double pi()
```
Descrição

Retorna o valor de π. Esta é uma função de extensão no MaxCompute V2.0.
Valor de retorno

Retorna um valor do tipo DOUBLE.

Exemplo

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

POSITIVE

Sintaxe

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

Descrição

Retorna o valor de expr.
Parâmetros

expr: Obrigatório. A expressão de entrada. O valor pode ser do tipo TINYINT, SMALLINT, INT, BIGINT, DOUBLE ou DECIMAL.
Valor de retorno

Retorna o valor da expressão expr.

Exemplo

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

POW

Sintaxe
```
double|decimal pow(<x>, <y>)
```
Descrição

Calcula o valor de x elevado à potência de y, ou seja, x^y.
Parâmetros
- x: Obrigatório. Um valor do tipo DOUBLE ou DECIMAL. Se o valor de entrada for do tipo STRING ou BIGINT, ele será convertido implicitamente para o tipo DOUBLE para cálculo.
- y: Obrigatório. Um valor do tipo DOUBLE ou DECIMAL. Se o valor de entrada for do tipo STRING ou BIGINT, ele será convertido implicitamente para o tipo DOUBLE para cálculo.
Valor de retorno
Retorna um valor do tipo DOUBLE ou DECIMAL. As seguintes regras se aplicam:
- Se x ou y for do tipo DOUBLE ou DECIMAL, um valor do tipo correspondente será retornado.
- Caso x ou y seja do tipo STRING ou BIGINT, um valor do tipo DOUBLE será retornado.
- Retorna NULL se o valor de x ou y for NULL.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base na sample data, o comando a seguir calcula o valor das colunas elevado à potência de 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;

O resultado a seguir é retornado.

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

Sintaxe
```
double radians(<number>)
```
Descrição

Converte um valor de graus para radianos. Esta é uma função de extensão no MaxCompute V2.0.
Parâmetros

number: Obrigatório. Um valor do tipo DOUBLE, BIGINT, INT, SMALLINT, TINYINT, FLOAT, DECIMAL ou STRING.
Valor de retorno

Retorna um valor do tipo DOUBLE. Retorna NULL se o valor de number for NULL.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base na sample data, o comando a seguir converte todas as colunas para radianos.

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

O resultado a seguir é retornado.

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

Sintaxe
```
double rand(bigint <seed>)
```
Descrição

Retorna um número aleatório do tipo DOUBLE no intervalo de 0 a 1.
Parâmetros

seed: Opcional. Um valor do tipo BIGINT. A semente determina o valor inicial para uma sequência de números aleatórios.

Nota
Use seed para especificar uma sequência de números aleatórios. Após definir seed, o valor de retorno desta função torna-se fixo. Se o ambiente de execução e o valor de seed permanecerem os mesmos, o valor de retorno será idêntico. Para obter um resultado diferente, altere o valor de seed.

Adicione o parâmetro a seguir antes de uma instrução SQL. O valor padrão é false.
```
set odps.sql.executionengine.enable.rand.time.seed=true|false;
```
- Se este parâmetro estiver definido como false, a função RAND usa o ID da instância atual como a seed inicial para o número aleatório, garantindo a idempotência da função.
- Caso este parâmetro esteja definido como true, a função RAND usa a hora atual do sistema como a seed inicial para o número aleatório. No entanto, a função RAND deixa de ser idempotente e não pode ser usada como chave de embaralhamento (shuffle key). Isso gera resultados diferentes ao executar a função novamente.
Valor de retorno

Retorna um valor do tipo DOUBLE.

Exemplo

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

ROUND

Sintaxe

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

Descrição

Arredonda um valor para uma casa decimal específica.
Parâmetros
- number: Obrigatório. Um valor do tipo DOUBLE ou DECIMAL. Se o valor de entrada for do tipo STRING ou BIGINT, ele será convertido implicitamente para o tipo DOUBLE para cálculo.
- decimal_places: Opcional. Uma constante do tipo BIGINT. Este parâmetro especifica o número de casas decimais para arredondamento. Se você omitir este parâmetro, o valor será arredondado para o inteiro mais próximo. O valor padrão é 0.
  
  Nota
  O valor de decimal_places pode ser um número negativo. Se for negativo, a função arredonda os dígitos à esquerda do ponto decimal e não retém a parte decimal. Caso o valor de decimal_places seja maior que o comprimento da parte inteira, 0 será retornado.
Valor de retorno
Retorna um valor do tipo DOUBLE ou DECIMAL. As seguintes regras se aplicam:
- Se number for do tipo DOUBLE ou DECIMAL, um valor do tipo correspondente será retornado.
- Caso number seja do tipo STRING ou BIGINT, um valor do tipo DOUBLE será retornado.
- Retorna um erro se o tipo de dados de decimal_places não for BIGINT.
- Quando o valor de number ou decimal_places for NULL, NULL será retornado.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base na sample data, o comando a seguir arredonda os valores nas colunas para uma casa decimal específica.

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;

O resultado a seguir é retornado.

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

Sintaxe

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

Descrição

Executa um deslocamento à esquerda (<<). Esta é uma função de extensão no MaxCompute V2.0.
Parâmetros
- number1: Obrigatório. Um valor do tipo TINYINT, SMALLINT, INT ou BIGINT.
- number2: Obrigatório. Um valor do tipo INT.
Valor de retorno
Retorna um valor do tipo INT ou BIGINT. As seguintes regras se aplicam:
- Retorna um erro se o tipo de dados de number1 não for TINYINT, SMALLINT, INT ou BIGINT.
- Caso o tipo de dados de number2 não seja INT, um erro será retornado.
- Quando o valor de number1 ou number2 for NULL, NULL será retornado.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base na sample data, o comando a seguir executa um deslocamento à esquerda nas colunas int_data e 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;

O resultado a seguir é retornado.

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

Sintaxe

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

Descrição

Executa um deslocamento à direita (>>). Esta é uma função de extensão no MaxCompute V2.0.
Parâmetros
- number1: Obrigatório. Um valor do tipo TINYINT, SMALLINT, INT ou BIGINT.
- number2: Obrigatório. Um valor do tipo INT.
Valor de retorno
Retorna um valor do tipo INT ou BIGINT. As seguintes regras se aplicam:
- Se o tipo de dados de number1 não for TINYINT, SMALLINT, INT ou BIGINT, um erro será retornado.
- Se o tipo de dados de number2 não for INT, um erro será retornado.
- Caso o valor de number1 ou number2 seja NULL, a função retorna NULL.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base na sample data, o comando a seguir executa um deslocamento à direita nas colunas int_data e 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;

O resultado a seguir é retornado.

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

Sintaxe

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

Descrição

Realiza um deslocamento à direita sem sinal (>>>). Trata-se de uma função de extensão no MaxCompute V2.0.
Parâmetros
- number1: Obrigatório. Um inteiro do tipo TINYINT, SMALLINT, INT ou BIGINT.
- number2: Obrigatório. Um inteiro do tipo INT.
Valor de retorno
Retorna um valor do tipo INT ou BIGINT. As seguintes regras se aplicam:
- Se o tipo de dados de number1 não for TINYINT, SMALLINT, INT ou BIGINT, um erro será retornado.
- Se o tipo de dados de number2 não for INT, um erro será retornado.
- Caso o valor de number1 ou number2 seja NULL, a função retorna NULL.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base na sample data, o comando a seguir retorna o valor do deslocamento à direita sem sinal das colunas int_data e 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;

O resultado a seguir é retornado.

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

Sintaxe
```
double sign(<number>)
```
Descrição

Obtém o sinal de um parâmetro de entrada. Esta é uma função de extensão no MaxCompute V2.0.
Parâmetros

number: Obrigatório. Um valor do tipo DOUBLE, BIGINT, INT, SMALLINT, TINYINT, FLOAT, DECIMAL ou STRING.
Valor de retorno
Retorna um valor do tipo DOUBLE. As seguintes regras se aplicam:
- Quando o valor de number for positivo, a função retorna 1.0.
- Quando o valor de number for negativo, a função retorna -1.0.
- Se o valor de number for 0, o retorno é 0.0.
- Caso o valor de number seja NULL, a função retorna NULL.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base na sample data, o comando a seguir obtém o sinal de todas as colunas.

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

O resultado a seguir é retornado.

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

Sintaxe
```
double|decimal sin(<number>)
```
Descrição

Calcula o seno de number. O valor de entrada deve estar em radianos.
Parâmetros

number: Obrigatório. Um valor do tipo DOUBLE ou DECIMAL. Se o valor de entrada for do tipo STRING ou BIGINT, ele será convertido implicitamente para DOUBLE para o cálculo.
Valor de retorno
Retorna um valor do tipo DOUBLE ou DECIMAL. As seguintes regras se aplicam:
- Se number for do tipo DOUBLE ou DECIMAL, um valor do tipo correspondente será retornado.
- Se number for do tipo STRING ou BIGINT, um valor do tipo DOUBLE será retornado.
- Caso o valor de number seja NULL, a função retorna NULL.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base na sample data, o comando a seguir calcula o seno das colunas.

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;

O resultado a seguir é retornado.

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

Sintaxe
```
double|decimal sinh(<number>)
```
Descrição

Calcula o seno hiperbólico de number.
Parâmetros

number: Obrigatório. Um valor do tipo DOUBLE ou DECIMAL. Se o valor de entrada for do tipo STRING ou BIGINT, ele será convertido implicitamente para DOUBLE para o cálculo.
Valor de retorno
Retorna um valor do tipo DOUBLE ou DECIMAL. As seguintes regras se aplicam:
- Se number for do tipo DOUBLE ou DECIMAL, um valor do tipo correspondente será retornado.
- Se number for do tipo STRING ou BIGINT, um valor do tipo DOUBLE será retornado.
- Caso o valor de number seja NULL, a função retorna NULL.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base na sample data, o comando a seguir calcula o seno hiperbólico das colunas.

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;

O resultado a seguir é retornado.

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

Sintaxe
```
double|decimal sqrt(<number>)
```
Descrição

Calcula a raiz quadrada de number.
Parâmetros

number: Obrigatório. Um valor do tipo DOUBLE ou DECIMAL. O valor deve ser maior que 0. Se o valor for menor que 0, NULL será retornado. Se o valor de entrada for do tipo STRING ou BIGINT, ele será convertido implicitamente para DOUBLE para o cálculo.
Valor de retorno
Retorna um valor do tipo DOUBLE ou DECIMAL. As seguintes regras se aplicam:
- Se number for do tipo DOUBLE ou DECIMAL, um valor do tipo correspondente será retornado.
- Se number for do tipo STRING ou BIGINT, um valor do tipo DOUBLE será retornado.
- Caso o valor de number seja NULL, a função retorna NULL.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base na sample data, o comando a seguir calcula a raiz quadrada das colunas.

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;

O resultado a seguir é retornado.

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

Sintaxe
```
double|decimal tan(<number>)
```
Descrição

Calcula a tangente de number. O valor de entrada deve estar em radianos.
Parâmetros

number: Obrigatório. Um valor do tipo DOUBLE ou DECIMAL. Se o valor de entrada for do tipo STRING ou BIGINT, ele será convertido implicitamente para DOUBLE para o cálculo.
Valor de retorno
Retorna um valor do tipo DOUBLE ou DECIMAL. As seguintes regras se aplicam:
- Se number for do tipo DOUBLE ou DECIMAL, um valor do tipo correspondente será retornado.
- Se number for do tipo STRING ou BIGINT, um valor do tipo DOUBLE será retornado.
- Caso o valor de number seja NULL, a função retorna NULL.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base na sample data, o comando a seguir calcula a tangente das colunas.

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;

O resultado a seguir é retornado.

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

Sintaxe
```
double|decimal tanh(<number>)
```
Descrição

Calcula a tangente hiperbólica de number.
Parâmetros

number: Obrigatório. Um valor do tipo DOUBLE ou DECIMAL. Se o valor de entrada for do tipo STRING ou BIGINT, ele será convertido implicitamente para DOUBLE para o cálculo.
Valor de retorno
Retorna um valor do tipo DOUBLE ou DECIMAL. As seguintes regras se aplicam:
- Se number for do tipo DOUBLE ou DECIMAL, um valor do tipo correspondente será retornado.
- Se number for do tipo STRING ou BIGINT, um valor do tipo DOUBLE será retornado.
- Caso o valor de number seja NULL, a função retorna NULL.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base na sample data, o comando a seguir calcula a tangente hiperbólica das colunas.

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;

O resultado a seguir é retornado.

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

Sintaxe

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

Descrição

Trunca o valor de entrada number para uma casa decimal especificada.

Nota
No modo compatível com Hive, esta função é usada para conversão de datas em vez de atuar como uma função matemática. Para obter mais informações sobre a função de data correspondente, consulte DATETRUNC. Você pode definir a versão do tipo de dados para seu projeto MaxCompute conforme necessário. Para obter mais informações sobre versões de tipos de dados, consulte Data type versions.
Parâmetros
- number: Obrigatório. Um valor do tipo DOUBLE ou DECIMAL. Se o valor de entrada for do tipo STRING ou BIGINT, ele será convertido implicitamente para DOUBLE para o cálculo.
- decimal_places: Opcional. Uma constante do tipo BIGINT. Este parâmetro especifica o número de casas decimais para as quais você deseja truncar o valor. Se você omitir este parâmetro, o valor será truncado para o inteiro mais próximo. O valor de decimal_places pode ser um número negativo. Nesse caso, a função trunca da vírgula decimal para a esquerda e não retém a parte decimal. Se o valor de decimal_places for maior que o comprimento da parte inteira, 0 será retornado.
Valor de retorno
Retorna um valor do tipo DOUBLE ou DECIMAL. As seguintes regras se aplicam:
- Se number for do tipo DOUBLE ou DECIMAL, um valor do tipo correspondente será retornado.
- Se number for do tipo STRING ou BIGINT, um valor do tipo DOUBLE será retornado.
- Se o tipo de dados de decimal_places não for BIGINT, um erro será retornado.
- Caso o valor de number ou decimal_places seja NULL, a função retorna NULL.
Nota
- Ao retornar um valor do tipo DOUBLE, o resultado pode não ser o esperado. Por exemplo, trunc(125.815,1). Esse problema de exibição para o tipo DOUBLE existe em todos os sistemas.
- A parte truncada é preenchida com zeros.

Exemplos

Exemplos com dados estáticos

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

Exemplos com dados de tabela

Com base na sample data, o comando a seguir trunca os valores nas colunas para uma casa decimal especificada.

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;

O resultado a seguir é retornado.

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

Sintaxe
```
binary unhex(string <number>)
```
Descrição

Retorna a string representada por uma string hexadecimal. Esta é uma função de extensão no MaxCompute V2.0.
Parâmetros

number: Obrigatório. Uma string hexadecimal.
Valor de retorno
Retorna um valor do tipo BINARY. As seguintes regras se aplicam:
- Se o valor de number for 0, um erro será retornado.
- Caso o valor de number seja NULL, a função retorna NULL.

Exemplo

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

Sintaxe

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

Descrição

Esta função constrói um número especificado de grupos de tamanho igual com base nos valores mínimo, máximo e na quantidade de grupos definidos. Ela retorna o número do grupo ao qual o valor de um campo especificado pertence. Os tipos de dados suportados são BIGINT, INT, FLOAT, DOUBLE, DECIMAL e DECIMAL(precision, scale) do MaxCompute V2.0. Para obter mais informações, consulte Data type editions in MaxCompute V2.0. Esta é uma função de extensão no MaxCompute V2.0.
Parâmetros
- expr: Obrigatório. O campo cujo número de grupo você deseja determinar.
- min_value: Obrigatório. O valor mínimo do intervalo do grupo.
- max_value: Obrigatório. O valor máximo do intervalo do grupo. O valor máximo deve ser maior que o valor mínimo.
- num_buckets: Obrigatório. O número de grupos. O valor deve ser maior que 0.
Valor de retorno
Retorna um valor do tipo BIGINT. O valor varia de 0 até o número especificado de grupos mais 1. O valor é retornado com base nas seguintes regras:
- Se o valor de expr for menor que o valor de min_value, 0 será retornado.
- Se o valor de expr for maior que o valor de max_value, o número especificado de grupos mais 1 será retornado.
- Caso o valor de expr seja NULL, a função retorna NULL. Nos demais casos, o número do grupo ao qual o valor do campo pertence é retornado. O número do grupo é calculado usando a seguinte fórmula: floor( num_buckets * (expr - min_value)/(max_value - min_value) + 1).
- Se o valor de min_value, max_value ou num_buckets for NULL, NULL será retornado.

Exemplos

Exemplo 1: Nenhum dos parâmetros de entrada é NULL. Comando de exemplo:

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

O resultado a seguir é retornado.

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

Exemplo 2: Um dos parâmetros de entrada é NULL. Comando de exemplo:

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

O resultado a seguir é retornado.

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

Referências

Caso as funções integradas anteriores não atendam aos seus requisitos, utilize funções definidas pelo usuário (UDFs) no MaxCompute. Para obter mais informações sobre UDFs, consulte MaxCompute UDF overview.
Para obter mais informações sobre perguntas frequentes (FAQs) do MaxCompute SQL, consulte:
Para obter mais informações sobre códigos de erro comuns e FAQs para funções integradas do MaxCompute, consulte:
- Common error codes for built-in functions
- FAQs for built-in functions