Todos os produtos
Search

Este produto

    MaxCompute:Visão geral das funções de agregação

    Central de documentação

    MaxCompute:Visão geral das funções de agregação

    Última atualização: Aug 21, 2026

    As funções de agregação combinam vários registros de entrada em um único valor de saída. Você pode usar uma função de agregação com a cláusula group by no MaxCompute SQL. Este tópico descreve os formatos de comando, os parâmetros e os exemplos das funções de agregação compatíveis com o MaxCompute SQL e orienta o desenvolvimento de dados com essas funções.

    A tabela a seguir descreve as funções de agregação compatíveis com o MaxCompute SQL.

    Função

    Recursos

    ANY

    Verifica se pelo menos um dos valores de entrada é True.

    ANY_VALUE

    Retorna um valor de um intervalo especificado.

    APPROX_DISTINCT

    Retorna um número aproximado de valores de entrada distintos em uma coluna especificada.

    ARG_MAX

    Retorna o valor da coluna da linha correspondente ao valor máximo de uma coluna especificada.

    ARG_MIN

    Retorna o valor da coluna da linha correspondente ao valor mínimo de uma coluna específica.

    AVG

    Calcula o valor médio.

    BITWISE_AND_AGG

    Agrega valores de entrada com base na operação AND bit a bit.

    BITWISE_OR_AGG

    Agrega valores de entrada com base na operação OR bit a bit.

    BITWISE_XOR_AGG

    Agrega valores de entrada com base na operação XOR bit a bit.

    BOOL_AND

    Executa uma operação AND lógica em um conjunto de valores booleanos.

    BOOL_OR

    Executa uma operação OR lógica em um conjunto de valores booleanos.

    COLLECT_LIST

    Agrega as colunas especificadas em um array.

    COLLECT_SET

    Agrega valores distintos de uma coluna especificada em um array.

    CORR

    Calcula o coeficiente de correlação de Pearson de duas colunas.

    COUNT

    Conta os registros.

    COUNT_IF

    Retorna o número de registros cujo valor de expr é True.

    COVAR_POP

    Calcula a covariância populacional de duas colunas numéricas especificadas.

    COVAR_SAMP

    Calcula a covariância amostral de duas colunas numéricas especificadas.

    HISTOGRAM

    Retorna um map contendo o número de vezes que cada valor de entrada aparece.

    MAP_AGG

    Constrói um Map a partir de dois campos de entrada.

    MAP_UNION

    Retorna um novo map que representa a união de todos os maps de entrada.

    MAP_UNION_SUM

    Retorna um novo map resultante da união de todos os maps de entrada. O map de saída soma os valores das chaves correspondentes em todos os maps de entrada.

    MAX

    Calcula o valor máximo.

    MAX_BY

    Retorna o valor da coluna da linha correspondente ao valor máximo de uma coluna especificada.

    MEDIAN

    Calcula a mediana.

    MIN

    Calcula o valor mínimo.

    MIN_BY

    Retorna o valor da coluna da linha correspondente ao valor mínimo de uma coluna específica.

    MULTIMAP_AGG

    Retorna um map criado usando a e b. a é a chave no map. b é usado para criar um array, que serve como valor da chave no map.

    NUMERIC_HISTOGRAM

    Retorna um histograma aproximado com base em uma coluna especificada.

    PERCENTILE

    Calcula um percentil exato. Esta função é adequada para cenários com pequeno volume de dados.

    PERCENTILE_APPROX

    Retorna percentis aproximados. Aplica-se a cenários com grande volume de dados.

    PERCENTILE_CONT

    Calcula um percentil exato.

    PERCENTILE_DISC

    Calcula um determinado valor de percentil.

    STDDEV

    Retorna o desvio padrão populacional de todos os valores de entrada.

    STDDEV_SAMP

    Retorna o desvio padrão amostral de todos os valores de entrada.

    SUM

    Retorna a soma de uma coluna.

    VAR_SAMP

    Calcula a variância amostral de uma coluna numérica especificada.

    VARIANCE/VAR_POP

    Calcula a variância de uma coluna numérica especificada.

    WM_CONCAT

    Concatena strings com um delimitador especificado.

    Precauções

    O MaxCompute V2.0 fornece funções adicionais. Se as funções utilizadas envolverem novos tipos de dados compatíveis com a edição de tipos de dados do MaxCompute V2.0, execute 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 um novo tipo de dados, adicione a instrução set odps.sql.type.system.odps2=true; antes da sua instrução SQL e envie ambas juntas para execução.

    • Um Project Owner pode definir configurações no nível do projeto conforme necessário. As alterações entram em vigor entre 10 e 15 minutos. O comando é o seguinte:

      setproject odps.sql.type.system.odps2=true;

      Para obter mais informações sobre setproject, consulte Project operations. Para mais detalhes sobre as precauções ao ativar tipos de dados no nível do projeto, veja Data type versions.

    • Um worker pode conter no máximo 2 milhões de elementos.

    Ao executar uma instrução SQL que inclui múltiplas funções de agregação com recursos de projeto insuficientes, pode ocorrer estouro de memória. Recomendamos otimizar a instrução SQL ou adquirir recursos de computação conforme necessário.

    Sintaxe

    Sintaxe de uma função de agregação:

    <aggregate_name>(<expression>[,...]) [WITHIN GROUP (ORDER BY <col1>[,<col2>…])] [FILTER (WHERE <where_condition>)]

    • <aggregate_name>(<expression>[,...]): uma função de agregação integrada ou uma user-defined aggregate function (UDAF). O formato específico depende da sintaxe da função de agregação.

    • WITHIN GROUP (ORDER BY <col1>[,<col2>…]): Se uma função de agregação contiver esta expressão, os dados de entrada de <col1>[,<col2>…] serão classificados em ordem ascendente por padrão. Para classificar os dados em ordem descendente, utilize a expressão WITHIN GROUP (ORDER BY <col1>[,<col2>…] DESC).

      Observe os seguintes pontos ao usar esta expressão:

      • Esta expressão aplica-se apenas a WM_CONCAT, COLLECT_LIST, COLLECT_SET e UDAFs.

      • Caso múltiplas funções de agregação em uma instrução SELECT contenham a expressão WITHIN GROUP (ORDER BY <col1>[,<col2>…]), a cláusula ORDER BY <col1>[,<col2>…] deve ser idêntica em todas essas funções.

      • Quando os parâmetros de uma função de agregação incluem a palavra-chave DISTINCT, apenas as colunas DISTINCT podem ser usadas na cláusula ORDER BY <col1>[,<col2>…]. O conjunto de colunas na cláusula ORDER BY deve ser um subconjunto das colunas DISTINCT. Além disso, os tipos de dados dos campos em <col1>[,<col2>…] devem corresponder aos tipos de dados dos parâmetros de entrada da função de agregação.

        Nota

        Funções de agregação que suportam a expressão WITHIN GROUP (ORDER BY <col1>[,<col2>…]) aceitam apenas um parâmetro de entrada. Portanto, se uma função de agregação usar a palavra-chave DISTINCT, a cláusula ORDER BY poderá incluir apenas uma coluna, e seu tipo de dados deve corresponder ao do parâmetro de entrada da função de agregação.

        Por exemplo, o parâmetro de entrada da função WM_CONCAT deve ser do tipo STRING, logo o campo após a cláusula ORDER BY também deve ser do tipo STRING. Para mais informações, consulte o Exemplo 4 abaixo. Para detalhes sobre a criação da tabela emp usada no exemplo, veja WM_CONCAT.

      Exemplos:

      -- Example 1: Sort the input data in ascending order and then return the output.
SELECT x, wm_concat(',', y) WITHIN GROUP (ORDER BY y) FROM 
  VALUES('k', 1),('k', 3),('k', 2) AS t(x, y) GROUP BY x;
-- The following result is returned.
+------------+------------+
| x          | _c1        |
+------------+------------+
| k          | 1,2,3      |
+------------+------------+

-- Example 2: Sort the input data in descending order and then return the output.
SELECT x, wm_concat(',', y) WITHIN GROUP (ORDER BY y DESC) FROM
  VALUES('k', 1),('k', 3),('k', 2) AS t(x, y) GROUP BY x;
-- The following result is returned.
+------------+------------+
| x          | _c1        |
+------------+------------+
| k          | 3,2,1      |
+------------+------------+

-- Example 3
SELECT id, wm_concat(DISTINCT ',', name) WITHIN GROUP (ORDER BY name DESC) FROM 
  VALUES('k', '1'),('k', '3'),('k', '2') AS t(id, name) GROUP BY id;

-- The following result is returned.
+------------+------------+
| id         | _c1        |
+------------+------------+
| k          | 3,2,1      |
+------------+------------+

-- Example 4
-- Because the parameters of the aggregate function contain the DISTINCT keyword, the sal input parameter of the BIGINT type in the wm_concat function is implicitly converted to the STRING type.
-- To be consistent with the input parameter type of the wm_concat function, you must use cast to convert sal to the STRING type in `order by sal`. Otherwise, an error is reported.
SELECT deptno, wm_concat(DISTINCT ',', sal) 
  WITHIN GROUP (ORDER BY cast(sal AS STRING ) DESC) 
  FROM emp GROUP BY deptno ORDER BY deptno;

-- The following result is returned.
+------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | 5000,2450,1300 |
| 20         | 800,3000,2975,1100 |
| 30         | 950,2850,1600,1500,1250 |
+------------+------------+

    • [FILTER (WHERE <where_condition>)]: Se uma função de agregação contiver esta expressão, ela processará apenas os dados que atendem à <where_condition>. Para mais informações sobre <where_condition>, consulte WHERE clause (where_condition).

      Atente-se aos seguintes pontos ao utilizar esta expressão:

      • Apenas funções de agregação integradas suportam esta expressão. UDAFs não oferecem suporte.

      • count(*) suporta a expressão [FILTER (WHERE <where_condition>)].

      • COUNT_IF não suporta a expressão [FILTER (WHERE <where_condition>)].

      Exemplos:

      -- Example 1: Filter and aggregate data.
select
  sum(x),
  sum(x) filter (where y > 1),
  sum(x) filter (where y > 2)
  from values(null, 1),(1, 2),(2, 3),(3, null) as t(x, y);
-- The following result is returned.
+------------+------------+------------+
| _c0        | _c1        | _c2        |
+------------+------------+------------+
| 6          | 3          | 2          |
+------------+------------+------------+

-- Example 2: Use multiple aggregate functions to filter and aggregate data.
select
  count_if(x > 2),
  sum(x) filter (where y > 1),
  sum(x) filter (where y > 2)
  from values(null, 1),(1, 2),(2, 3),(3, null) as t(x, y);
-- The following result is returned.
+------------+------------+------------+
| _c0        | _c1        | _c2        |
+------------+------------+------------+
| 1          | 3          | 2          |
+------------+------------+------------+

    Dados de amostra

    Os exemplos a seguir utilizam estes dados de amostra. Crie e preencha a tabela emp:

    create table if not exists emp
   (empno bigint,
    ename string,
    job string,
    mgr bigint,
    hiredate datetime,
    sal bigint,
    comm bigint,
    deptno bigint);
tunnel upload emp.txt emp;

    O arquivo emp.txt contém os seguintes dados:

    7369,SMITH,CLERK,7902,1980-12-17 00:00:00,800,,20
7499,ALLEN,SALESMAN,7698,1981-02-20 00:00:00,1600,300,30
7521,WARD,SALESMAN,7698,1981-02-22 00:00:00,1250,500,30
7566,JONES,MANAGER,7839,1981-04-02 00:00:00,2975,,20
7654,MARTIN,SALESMAN,7698,1981-09-28 00:00:00,1250,1400,30
7698,BLAKE,MANAGER,7839,1981-05-01 00:00:00,2850,,30
7782,CLARK,MANAGER,7839,1981-06-09 00:00:00,2450,,10
7788,SCOTT,ANALYST,7566,1987-04-19 00:00:00,3000,,20
7839,KING,PRESIDENT,,1981-11-17 00:00:00,5000,,10
7844,TURNER,SALESMAN,7698,1981-09-08 00:00:00,1500,0,30
7876,ADAMS,CLERK,7788,1987-05-23 00:00:00,1100,,20
7900,JAMES,CLERK,7698,1981-12-03 00:00:00,950,,30
7902,FORD,ANALYST,7566,1981-12-03 00:00:00,3000,,20
7934,MILLER,CLERK,7782,1982-01-23 00:00:00,1300,,10
7948,JACCKA,CLERK,7782,1981-04-12 00:00:00,5000,,10
7956,WELAN,CLERK,7649,1982-07-20 00:00:00,2450,,10
7956,TEBAGE,CLERK,7748,1982-12-30 00:00:00,1300,,10

    Expressões de filtro

    • Limites

      • Somente funções de agregação integradas do MaxCompute suportam expressões de filtro. UDAFs não oferecem esse suporte.

      • Não é possível usar count(*) com expressões de filtro. Utilize a função COUNT_IF como alternativa.

    • Sintaxe

      <aggregate_name>(<expression>[,...]) [filter (where <where_condition>)]

    • Descrição

      Todas as funções de agregação suportam expressões de filtro. Ao especificar uma condição de filtro, apenas os dados das linhas que atendem a essa condição são passados para a função de agregação relacionada para processamento.

    • Parâmetros

      • aggregate_name: obrigatório. Nome da função de agregação. Selecione uma função de agregação descrita neste tópico conforme necessário.

      • expression: obrigatório. Parâmetros da função de agregação selecionada. Especifique este parâmetro com base na descrição da função escolhida.

      • where_condition: opcional. A condição de filtro. Para mais informações sobre where_condition, consulte WHERE clause (where_condition).

    • Valor de retorno

      Para mais detalhes, consulte a descrição do valor de retorno de cada função de agregação.

    • Exemplo de uso

      select sum(sal) filter (where deptno=10), sum(sal) filter (where deptno=20), sum(sal) filter (where deptno=30) from emp;

      O resultado retornado é:

      +------------+------------+------------+
| _c0        | _c1        | _c2        |
+------------+------------+------------+
| 17500      | 10875      | 9400       |
+------------+------------+------------+

    ANY

    • Sintaxe

      BOOLEAN ANY(BOOLEAN <colname>)

    • Descrição

      Agrupa os valores na coluna especificada por colname em um array e verifica se pelo menos um elemento é TRUE. Caso exista ao menos um valor TRUE, a função retorna TRUE.

    • Parâmetros

      colname: Obrigatório. A coluna deve ser do tipo BOOLEAN.

    • Valor de retorno

      Retorna um valor do tipo BOOLEAN. Se o valor de colname for NULL, a linha será excluída do cálculo.

    • Exemplos

      -- Returns true.
SELECT ANY(colname) FROM VALUES (true), (false), (false) AS tab(colname);
-- Returns true.
SELECT ANY(colname) FROM VALUES (NULL), (true), (false) AS tab(colname);
-- Returns false.
SELECT ANY(colname) FROM VALUES (false), (false), (NULL) AS tab(colname);
-- Returns true.
SELECT ANY(colname1) FILTER(WHERE colname2 = 2) FROM VALUES (true, 1), (false, 1), (true, 2) AS tab(colname1, colname2);

    ANY_VALUE

    • Sintaxe

      any_value(<colname>)

    • Descrição

      Esta função de extensão do MaxCompute V2.0 retorna um valor arbitrário de um intervalo especificado.

    • Parâmetros

      colname: Obrigatório. A coluna pode ser de qualquer tipo de dado.

    • Valor de retorno

      O tipo de dado do valor retornado é igual ao do parâmetro colname. Se o valor do parâmetro colname for null, a linha contendo esse valor não será utilizada no cálculo.

    • Exemplos

      • Exemplo 1: Selecionar um dos funcionários. Instrução de exemplo:

        select any_value(ename) from emp;

        O resultado retornado é:

        +------------+
| _c0        |
+------------+
| SMITH      |
+------------+

      • Exemplo 2: Utilize esta função com group by para agrupar todos os funcionários por departamento (deptno) e selecionar um funcionário aleatório de cada grupo. Comando de exemplo:

        select deptno, any_value(ename) from emp group by deptno;

        O resultado retornado é:

        +------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | CLARK      |
| 20         | SMITH      |
| 30         | ALLEN      |
+------------+------------+

    APPROX_DISTINCT

    • Sintaxe

      approx_distinct(<colname>)

    • Descrição do comando

      Retorna o número aproximado de valores de entrada distintos em uma coluna especificada. Esta é uma função adicional do MaxCompute V2.0.

    • Parâmetros

      colname: obrigatório. Nome da coluna da qual os duplicados devem ser removidos.

    • Valor de retorno

      Retorna um valor do tipo BIGINT. Esta função produz um erro padrão de 5%. Se um valor da coluna especificada pelo parâmetro colname for null, a linha contendo esse valor não será usada no cálculo.

    • Exemplos

      • Exemplo 1: Calcular um número aproximado de valores distintos na coluna sal. Instrução de exemplo:

        select approx_distinct(sal) from emp;

        O resultado retornado é:

        +-------------------+
| numdistinctvalues |
+-------------------+
| 12                |
+-------------------+

      • Exemplo 2: Combine esta função com group by para agrupar todos os funcionários por departamento (deptno) e calcular o número aproximado de valores distintos de salário (sal) em cada grupo. Comando de exemplo:

        select deptno, approx_distinct(sal) from emp group by deptno;

        O resultado retornado é:

        +------------+-------------------+
| deptno     | numdistinctvalues |
+------------+-------------------+
| 10         | 3                 |
| 20         | 4                 |
| 30         | 5                 |
+------------+-------------------+

    ARG_MAX

    • Sintaxe

      arg_max(<valueToMaximize>, <valueToReturn>)

    • Descrição do comando

      Localiza a linha onde o valor de valueToMaximize está incluído e retorna o valor de valueToReturn nessa linha. Esta é uma função adicional do MaxCompute V2.0.

    • Parâmetros

      • valueToMaximize: Obrigatório. Aceita qualquer tipo de dado.

      • valueToReturn: Obrigatório. Aceita um valor de qualquer tipo de dado.

    • Valor de retorno

      O tipo de dado do valor retornado corresponde ao do parâmetro valueToReturn. Se várias linhas contiverem o maior valor de valueToMaximize, o valor de valueToReturn de uma dessas linhas será retornado aleatoriamente. Caso o valor de valueToMaximize seja null, a linha contendo esse valor não participará do cálculo.

    • Exemplos

      • Exemplo 1: Retornar o nome do funcionário com o maior salário. Instrução de exemplo:

        select arg_max(sal, ename) from emp;

        O resultado retornado é:

        +------------+
| _c0        |
+------------+
| KING       |
+------------+

      • Exemplo 2: Utilize esta função com group by para agrupar todos os funcionários por departamento (deptno) e retornar o nome do funcionário com o maior salário em cada grupo. Comando de exemplo:

        select deptno, arg_max(sal, ename) from emp group by deptno;

        O resultado retornado é:

        +------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | KING       |
| 20         | SCOTT      |
| 30         | BLAKE      |
+------------+------------+

    ARG_MIN

    • Sintaxe

      arg_min(<valueToMinimize>, <valueToReturn>)

    • Descrição

      Localiza a linha onde o valor mínimo de valueToMinimize está incluído e retorna o valor de valueToReturn nessa linha. Esta é uma função adicional do MaxCompute V2.0.

    • Parâmetros

      • valueToMinimize: obrigatório. Um valor de qualquer tipo de dado.

      • valueToReturn: obrigatório. Um valor de qualquer tipo de dado.

    • Valores de retorno

      O tipo de dado do valor retornado corresponde ao do parâmetro valueToReturn. Se várias linhas contiverem o menor valor de valueToMinimize, o valor de valueToReturn de uma dessas linhas será retornado aleatoriamente. Caso o valor de valueToMinimize seja null, a linha contendo esse valor não participará do cálculo.

    • Exemplos

      • Exemplo 1: Retornar o nome do funcionário com o menor salário. Instrução de exemplo:

        select arg_min(sal, ename) from emp;

        O resultado retornado é:

        +------------+
| _c0        |
+------------+
| SMITH      |
+------------+

      • Exemplo 2: Utilize esta função com group by para agrupar todos os funcionários por departamento (deptno) e retornar o nome do funcionário com o menor salário em cada grupo. Comando de exemplo:

        select deptno, arg_min(sal, ename) from emp group by deptno;

        O resultado retornado é:

        +------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | MILLER     |
| 20         | SMITH      |
| 30         | JAMES      |
+------------+------------+

    AVG

    • Sintaxe

      DECIMAL|DOUBLE  avg(<colname>)

    • Descrição

      Calcula o valor médio.

    • Parâmetros

      colname: obrigatório. Os valores da coluna suportam todos os tipos de dados e podem ser convertidos para o tipo DOUBLE antes do cálculo.

    • Valor de retorno

      Se o valor de colname for null, a linha contendo esse valor não será usada no cálculo. A tabela a seguir descreve os mapeamentos entre os tipos de dados de entrada e os valores de retorno.

      Tipo de entrada

      Tipo do valor de retorno

      TINYINT

      DOUBLE

      SMALLINT

      DOUBLE

      INT

      DOUBLE

      BIGINT

      DOUBLE

      FLOAT

      DOUBLE

      DOUBLE

      DOUBLE

      DECIMAL

      DECIMAL

    • Exemplos

      • Exemplo 1: Calcular a média dos valores de salário (sal) de todos os funcionários. Instrução de exemplo:

        select avg(sal) from emp;

        O resultado retornado é:

        +------------+
| _c0        |
+------------+
| 2222.0588235294117 |
+------------+

      • Exemplo 2: Utilize esta função com group by para agrupar todos os funcionários por departamento (deptno) e calcular o salário médio (sal) de cada departamento. Comando de exemplo:

        select deptno, avg(sal) from emp group by deptno;

        O resultado retornado é:

        +------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | 2916.6666666666665 |
| 20         | 2175.0     |
| 30         | 1566.6666666666667 |
+------------+------------+

    BITWISE_AND_AGG

    • Sintaxe

      BIGINT bitwise_and_agg(BIGINT value)

    • Descrição

      Agrupa valores de entrada com base na operação AND bit a bit.

    • Parâmetros

      value: Obrigatório. Um valor do tipo BIGINT. Valores NULL são excluídos do cálculo.

    • Valor de retorno

      Retorna um valor do tipo BIGINT.

    • Exemplos

      SELECT id, bitwise_and_agg(v) FROM
    VALUES (1L, 2L), (1L, 1L), (2L, null), (1L, null) t(id, v) GROUP BY id;

      O resultado retornado é:

      +------------+------------+
| id         | _c1        |
+------------+------------+
| 1          | 0          |
| 2          | NULL       |
+------------+------------+

    BITWISE_OR_AGG

    • Declaração da função

      bigint bitwise_or_agg(bigint value)

    • Descrição

      Agrupa valores de entrada com base na operação OR bit a bit.

    • Parâmetros

      value: obrigatório. Um valor do tipo BIGINT. O valor null não é utilizado no cálculo.

    • Valor de retorno

      Retorna um valor do tipo BIGINT.

    • Exemplos

      select id, bitwise_or_agg(v) from
    values (1L, 2L), (1L, 1L), (2L, null), (1L, null) t(id, v) group by id;

      O resultado retornado é:

      +------------+------------+
| id         | _c1        |
+------------+------------+
| 1          | 3          |
| 2          | NULL       |
+------------+------------+

    BITWISE_XOR_AGG

    • Declaração da função

      BIGINT BITWISE_XOR_AGG(BIGINT|INT|SMALLINT|TINYINT value)

    • Descrição

      Agrupa valores de entrada utilizando a operação XOR bit a bit.

    • Parâmetros

      value: Obrigatório. Um valor do tipo BIGINT, INT, SMALLINT ou TINYINT. Valores NULL são excluídos do cálculo.

    • Valor de retorno

      Retorna um valor do tipo BIGINT. Aplicam-se as seguintes regras:

      • Se value não for do tipo BIGINT, INT, SMALLINT ou TINYINT, um erro será retornado.

      • Retorna NULL se value for NULL.

    • Exemplo

      SELECT id, bitwise_xor_agg(v) FROM 
  VALUES (1L, 2L), (1L, 1L), (2L, NULL), (1L, NULL) t(id, v) GROUP BY id;

      O resultado retornado é:

      +------------+------------+
| id         | _c1        | 
+------------+------------+
| 1          | 3          | 
| 2          | NULL       | 
+------------+------------+

    BOOL_AND

    • Sintaxe

      BOOLEAN BOOL_AND(<colname>)

    • Descrição do comando

      Agrupa os valores na coluna especificada por colname em um array e executa uma operação AND lógica nos valores booleanos.

    • Parâmetros

      colname: Obrigatório. Nome de uma coluna da tabela. A coluna deve ser do tipo BOOLEAN.

    • Valor de retorno

      Retorna um valor do tipo BOOLEAN. Aplicam-se as seguintes regras:

      • Se todos os valores de entrada forem true, a função retorna true. Caso contrário, retorna false.

      • A função BOOL_AND() ignora valores NULL no grupo.

    • Exemplos

      -- Example 1: Perform a simple logical AND operation.
SELECT bool_and(colname) FROM VALUES (true), (false), (true) AS tab(colname);
-- The following result is returned.
+------+
| _c0  | 
+------+
| false | 
+------+

-- Example 2: The BOOL_AND() function ignores NULL values in the group.
SELECT bool_and(colname) FROM VALUES (NULL), (true), (true) AS tab(colname);
-- The following result is returned.
+------+
| _c0  | 
+------+
| true | 
+------+

-- Example 3: Aggregate only a specific column.
SELECT bool_and(colname1) FROM VALUES (true, 1), (false, 2), (true, 1) AS tab(colname1, colname2);
-- The following result is returned.
+------+
| _c0  | 
+------+
| false | 
+------+

-- Example 4: Perform a logical AND operation after filtering.
SELECT bool_and(colname1) FILTER(WHERE colname2 = 1) FROM VALUES (true, 1), (false, 2), (true, 1) AS tab(colname1, colname2);
-- The following result is returned.
+------+
| _c0  | 
+------+
| true | 
+------+

    BOOL_OR

    • Sintaxe

      BOOLEAN BOOL_OR(BOOLEAN <colname>)

    • Descrição do comando

      Agrupa os valores na coluna especificada por colname em um array e executa uma operação OR lógica nos valores booleanos.

    • Parâmetros

      colname: Obrigatório. Nome de uma coluna da tabela. A coluna deve ser do tipo BOOLEAN.

    • Valor de retorno

      Retorna um valor do tipo BOOLEAN. Aplicam-se as seguintes regras:

      • Se pelo menos um valor de entrada no grupo for true, a função retorna true. Se todos os valores forem false, a função retorna false.

      • A função BOOL_OR() ignora valores NULL no grupo.

    • Exemplos

      -- Example 1: Perform a simple logical OR operation.
SELECT bool_or(colname) FROM VALUES (true), (false), (false) AS tab(colname);
-- The following result is returned.
+------+
| _c0  | 
+------+
| true | 
+------+

-- Example 2: The BOOL_OR() function ignores NULL values in the group.
SELECT bool_or(colname) FROM VALUES (NULL), (true), (false) AS tab(colname);
-- The following result is returned.
+------+
| _c0  | 
+------+
| true | 
+------+

-- Example 3
SELECT bool_or(colname1) FROM VALUES (false), (false), (NULL) AS tab(colname1);
-- The following result is returned.
+------+
| _c0  | 
+------+
| false | 
+------+

-- Example 4: Perform a logical OR operation after filtering.
SELECT bool_or(colname1) FILTER(WHERE colname2 = 1) FROM VALUES (true, 1), (false, 1), (true, 2) AS tab(colname1, colname2);
-- The following result is returned.
+------+
| _c0  | 
+------+
| true | 
+------+

    COLLECT_LIST

    • Sintaxe

      array collect_list(<colname>)

    • Descrição

      Agrupa os valores na coluna especificada por colname em um array. Esta função é uma extensão fornecida pelo MaxCompute V2.0.

    • Parâmetros

      colname: Obrigatório. Nome de uma coluna da tabela. A coluna pode ser de qualquer tipo de dado.

    • Valor de retorno

      Retorna um valor do tipo ARRAY. Se um valor da coluna especificada por colname for null, a linha contendo esse valor não será usada no cálculo.

    • Exemplos

      • Exemplo 1: Agrupar os valores de salário (sal) de todos os funcionários em um array. Instrução de exemplo:

        select collect_list(sal) from emp;

        O resultado retornado é:

        +------------+
| _c0        |
+------------+
| [800,1600,1250,2975,1250,2850,2450,3000,5000,1500,1100,950,3000,1300,5000,2450,1300] |
+------------+

      • Exemplo 2: Utilize esta função com group by para agrupar todos os funcionários por departamento (deptno) e agregar os salários (sal) dos funcionários do mesmo grupo em um array. Comando de exemplo:

        select deptno, collect_list(sal) from emp group by deptno;

        O resultado retornado é:

        +------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | [2450,5000,1300,5000,2450,1300] |
| 20         | [800,2975,3000,1100,3000] |
| 30         | [1600,1250,1250,2850,1500,950] |
+------------+------------+

      • Exemplo 3: Combine esta função com group by para agrupar todos os funcionários por departamento (deptno) e agregar os valores distintos de salário (sal) dos funcionários do mesmo grupo em um array. Comando de exemplo:

        select deptno, collect_list(distinct sal) from emp group by deptno;

        O resultado retornado é:

        +------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | [1300,2450,5000] |
| 20         | [800,1100,2975,3000] |
| 30         | [950,1250,1500,1600,2850] |
+------------+------------+

    COLLECT_SET

    • Sintaxe

      array collect_set(<colname>)

    • Descrição

      Agrupa os valores especificados por colname em um array contendo apenas valores distintos. Esta é uma função adicional do MaxCompute V2.0.

    • Parâmetros

      colname: obrigatório. Nome de uma coluna, que pode ser de qualquer tipo de dado.

    • Valor de retorno

      Retorna um valor do tipo ARRAY. Se um valor da coluna especificada por colname for null, a linha contendo esse valor não será usada no cálculo.

    • Exemplos

      • Exemplo 1: Agrupar os valores de salário (sal) de todos os funcionários em um array com apenas valores distintos. Instrução de exemplo:

        select collect_set(sal) from emp;

        O resultado retornado é:

        +------------+
| _c0        |
+------------+
| [800,950,1100,1250,1300,1500,1600,2450,2850,2975,3000,5000] |
+------------+

      • Exemplo 2: Utilize esta função com group by para agrupar todos os funcionários por departamento (deptno) e agregar os salários (sal) dos funcionários do mesmo grupo em um array de valores distintos. Comando de exemplo:

        select deptno, collect_set(sal) from emp group by deptno;

        O resultado retornado é:

        +------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | [1300,2450,5000] |
| 20         | [800,1100,2975,3000] |
| 30         | [950,1250,1500,1600,2850] |
+------------+------------+

    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 do MaxCompute V2.0.

    • Parâmetros

      col1 e col2: Obrigatórios. Nomes das duas colunas da tabela para as quais 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 nos 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.

    COUNT

    Sintaxe

    -- Count the number of records.
BIGINT COUNT([DISTINCT|ALL] <colname>)

-- Count the number of records in the window.
BIGINT COUNT(*) OVER ([partition_clause] [orderby_clause] [frame_clause])
BIGINT COUNT([DISTINCT] <expr>[,...]) OVER ([partition_clause] [orderby_clause] [frame_clause])

    Parâmetros

    Parâmetro

    Obrigatório

    Descrição

    `DISTINCT

    ALL`

    Não

    Controla o tratamento de duplicatas. ALL (padrão) conta todas as linhas não NULL. DISTINCT conta apenas valores únicos não NULL.

    colname

    Sim

    A coluna a ser contada. Aceita qualquer tipo de dado. Use * para contar todas as linhas, incluindo aquelas onde o valor da coluna é NULL.

    expr

    Sim

    Uma expressão de qualquer tipo de dado. Linhas NULL são excluídas. Com DISTINCT, apenas valores únicos não NULL são contados. COUNT([DISTINCT] <expr>[,...]) OVER conta linhas onde todas as expressões especificadas são não NULL.

    partition_clause, orderby_clause, frame_clause

    Não

    Cláusulas de definição de janela. Consulte Window Functions Overview.

    Valor de retorno

    Retorna BIGINT. Linhas NULL são excluídas, a menos que você utilize COUNT(*).

    Exemplos

    Preparar dados de teste

    Caso já possua dados, pule esta etapa.

    1. Baixe os dados de teste test_data.txt.

    2. Crie uma tabela de teste.

      CREATE TABLE IF NOT EXISTS emp(
  empno BIGINT,
  ename STRING,
  job STRING,
  mgr BIGINT,
  hiredate DATETIME,
  sal BIGINT,
  comm BIGINT,
  deptno BIGINT
);

    3. Carregue os dados.

      Substitua FILE_PATH pelo caminho e nome reais do arquivo de dados.

      TUNNEL UPLOAD {{FILE_PATH}} emp;

    Exemplo 1: Particionar uma janela sem ordenação

    Particione a janela por sal. Sem ORDER BY, cada linha retorna a contagem total de linhas em sua partição.

    SELECT sal, COUNT(sal) OVER (PARTITION BY sal) AS count
FROM emp;

    Resultado:

    +------------+------------+
| sal        | count      |
+------------+------------+
| 800        | 1          |
| 950        | 1          |
| 1100       | 1          |
| 1250       | 2          |  -- Two rows share sal=1250; both return 2.
| 1250       | 2          |
| 1300       | 2          |
| 1300       | 2          |
| 1500       | 1          |
| 1600       | 1          |
| 2450       | 2          |
| 2450       | 2          |
| 2850       | 1          |
| 2975       | 1          |
| 3000       | 2          |
| 3000       | 2          |
| 5000       | 2          |
| 5000       | 2          |
+------------+------------+

    Exemplo 2: Particionar uma janela com ordenação (modo não compatível com Hive)

    No modo não compatível com Hive, adicionar ORDER BY produz uma contagem cumulativa. Cada linha retorna a contagem acumulada da primeira linha até a linha atual em sua partição.

    -- Disable Hive compatible mode.
SET odps.sql.hive.compatible=false;

SELECT sal, COUNT(sal) OVER (PARTITION BY sal ORDER BY sal) AS count
FROM emp;

    Resultado:

    +------------+------------+
| sal        | count      |
+------------+------------+
| 800        | 1          |
| 950        | 1          |
| 1100       | 1          |
| 1250       | 1          |  -- Running count starts at 1 for the first row in the partition.
| 1250       | 2          |  -- Increments to 2 for the second row.
| 1300       | 1          |
| 1300       | 2          |
| 1500       | 1          |
| 1600       | 1          |
| 2450       | 1          |
| 2450       | 2          |
| 2850       | 1          |
| 2975       | 1          |
| 3000       | 1          |
| 3000       | 2          |
| 5000       | 1          |
| 5000       | 2          |
+------------+------------+

    Exemplo 3: Particionar uma janela com ordenação (modo compatível com Hive)

    No modo compatível com Hive, ORDER BY não produz uma contagem cumulativa. Cada linha na partição retorna a contagem total da partição, o mesmo que omitir ORDER BY.

    -- Enable Hive compatible mode.
SET odps.sql.hive.compatible=true;

SELECT sal, COUNT(sal) OVER (PARTITION BY sal ORDER BY sal) AS count
FROM emp;

    Resultado:

    +------------+------------+
| sal        | count      |
+------------+------------+
| 800        | 1          |
| 950        | 1          |
| 1100       | 1          |
| 1250       | 2          |  -- Both rows in the partition return the full partition count.
| 1250       | 2          |
| 1300       | 2          |
| 1300       | 2          |
| 1500       | 1          |
| 1600       | 1          |
| 2450       | 2          |
| 2450       | 2          |
| 2850       | 1          |
| 2975       | 1          |
| 3000       | 2          |
| 3000       | 2          |
| 5000       | 2          |
| 5000       | 2          |
+------------+------------+

    Exemplo 4: Contar todas as linhas em uma tabela

    SELECT COUNT(*) FROM emp;

    Resultado:

    +------------+
| _c0        |
+------------+
| 17         |
+------------+

    Exemplo 5: Contar linhas por grupo

    Utilize COUNT com GROUP BY para obter o número de funcionários por departamento.

    SELECT deptno, COUNT(*) FROM emp GROUP BY deptno;

    Resultado:

    +------------+------------+
| deptno     | _c1        |
+------------+------------+
| 20         | 5          |
| 30         | 6          |
| 10         | 6          |
+------------+------------+

    Exemplo 6: Contar valores únicos

    Use DISTINCT para contar o número de departamentos distintos.

    SELECT COUNT(DISTINCT deptno) FROM emp;

    Resultado:

    +------------+
| _c0        |
+------------+
| 3          |
+------------+

    COUNT_IF

    • Sintaxe

      bigint count_if(boolean <expr>)

    • Descrição

      Retorna o número de registros cujo valor de expr é True.

    • Parâmetros

      expr: obrigatório. Uma expressão BOOLEAN.

    • Valor de retorno

      Retorna um valor do tipo BIGINT. Se o valor do parâmetro expr for False ou o valor de uma coluna específica em expr for null, a linha contendo esse valor não será usada no cálculo.

    • Exemplos

      select count_if(sal > 1000), count_if(sal <=1000) from emp;

      O resultado retornado é:

      +------------+------------+
| _c0        | _c1        |
+------------+------------+
| 15         | 2          |
+------------+------------+

    COVAR_POP

    • Sintaxe

      double covar_pop(<colname1>, <colname2>)

    • Descrição

      Calcula a covariância populacional de duas colunas numéricas especificadas. Esta é uma função adicional do MaxCompute V2.0.

    • Parâmetros

      colname1 e colname2: obrigatórios. Colunas do tipo de dado numérico. Se a coluna especificada não for numérica, um valor null será retornado.

    • Exemplos

      Execute os comandos a seguir para anexar dados à tabela emp:

      -- sal_new is the new salary column.
alter table emp add columns (sal_new bigint);
insert overwrite table emp select empno, ename, job, mgr, hiredate, sal, comm, deptno, sal+1000 from emp;

      • Exemplo 1: Calcular a covariância populacional das colunas sal e sal_new. Instrução de exemplo:

        select covar_pop(sal, sal_new) from emp;

        O resultado retornado é:

        +------------+
| _c0        |
+------------+
| 1594550.1730103805 |
+------------+

      • Exemplo 2: Utilize esta função com group by para agrupar todos os funcionários por departamento (deptno) e calcular a covariância populacional das colunas sal e sal_new para cada grupo. Comando de exemplo:

        select deptno, covar_pop(sal, sal_new) from emp group by deptno;

        O resultado retornado é:

        +------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | 2390555.5555555555 |
| 20         | 1009500.0  |
| 30         | 372222.2222222222 |
+------------+------------+

    COVAR_SAMP

    • Sintaxe

      double covar_samp(<colname1>, <colname2>)

    • Descrição

      Calcula a covariância amostral de duas colunas numéricas especificadas. Esta é uma função adicional do MaxCompute V2.0.

    • Parâmetros

      colname1 e colname2: obrigatórios. Colunas do tipo de dado numérico. Se a coluna especificada não for numérica, um valor null será retornado.

    • Exemplos

      Execute os comandos a seguir para anexar dados à tabela emp:

      -- sal_new is the new salary column.
alter table emp add columns (sal_new bigint);
insert overwrite table emp select empno, ename, job, mgr, hiredate, sal, comm, deptno, sal+1000 from emp;

      • Exemplo 1: Calcular a covariância amostral das colunas sal e sal_new. Instrução de exemplo:

        select covar_samp(sal, sal_new) from emp;

        O resultado retornado é:

        +------------+
| _c0        |
+------------+
| 1694209.5588235292 |
+------------+

      • Exemplo 2: Utilize esta função com group by para agrupar todos os funcionários por departamento (deptno) e calcular a covariância amostral das colunas sal e sal_new para cada grupo. Comando de exemplo:

        select deptno, covar_samp(sal, sal_new) from emp group by deptno;

        O resultado retornado é:

        +------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | 2868666.6666666665 |
| 20         | 1261875.0  |
| 30         | 446666.6666666666 |
+------------+------------+

    HISTOGRAM

    • Declaração da função

      map<K, bigint> histogram(K input);

    • Descrição do comando

      Retorna um map contendo o número de vezes que cada valor de entrada aparece. As chaves no map são os valores de entrada. Cada valor no map representa a frequência de aparição de um valor de entrada. O valor null é ignorado.

    • Parâmetros

      input: valores de entrada, utilizados como chaves no map.

    • Valor de retorno

      Retorna um map contendo o número de vezes que cada valor de entrada aparece.

    • Exemplos

      select histogram(a) from values
    ('hi'), (null), ('apple'), ('pie'), ('apple') t(a);

      O resultado retornado é:

      +----------------------------+
| _c0                        |
+----------------------------+
| {"pie":1,"hi":1,"apple":2} |
+----------------------------+

    MAP_AGG

    • Declarações da função

      map<K, V> map_agg(K a, V b);

    • Descrição do comando

      Retorna um map criado usando a e b. a é a chave no map. b é o valor da chave no map. Se a chave no map for null, ela será ignorada. Caso o campo chave tenha valores duplicados, um dos valores será retido aleatoriamente.

    • Parâmetros

      • a: um campo de entrada usado como chave no map.

      • b: um campo de entrada usado como valor no map.

    • Valor de retorno

      Retorna um novo map.

    • Exemplos

      select map_agg(a, b) from
        values (1L, 'apple'), (2L, 'hi'), (null, 'good'), (1L, 'pie') t(a, b);

      O resultado retornado é:

      +------------------------+
| _c0                    |
+------------------------+
| {"2":"hi","1":"apple"} |
+------------------------+

    MAP_UNION

    • Declaração da função

      map<K, V> map_union(map<K, V> input);

    • Descrição do comando

      Retorna um novo map que representa a união de todos os maps de entrada. Se uma chave existir em múltiplos maps de entrada, um dos valores correspondentes a essa chave será retido aleatoriamente.

    • Parâmetros

      input: os maps de entrada.

    • Valor de retorno

      Retorna um novo map.

    • Exemplos

      select map_union(a) from values
    (map(1L, 'hi', 2L, 'apple', 3L, 'pie')), (map(1L, 'good', 4L, 'this')), (null) t(a);

      O resultado retornado é:

      +-----------------------------------------------+
| _c0                                           |
+-----------------------------------------------+
| {"4":"this","1":"good","2":"apple","3":"pie"} |
+-----------------------------------------------+

    MAP_UNION_SUM

    • Declaração da função

      map<K, V> map_union_sum(map<K, V> input);

    • Descrição

      Retorna um novo map resultante da união de todos os maps de entrada. O map de saída soma os valores das chaves correspondentes em todos os maps de entrada. Se o valor correspondente a uma chave for NULL, ele será convertido em 0.

      Nota

      Os valores nos maps de entrada devem ser dos tipos de dados BIGINT, INT, SMALLINT, TINYINT, FLOAT, DOUBLE ou DECIMAL.

    • Parâmetros

      input: os maps de entrada.

    • Valor de retorno

      Retorna um novo map.

      Nota

      Os valores no novo map são dos tipos BIGINT, DOUBLE ou DECIMAL.

    • Exemplos

      select map_union_sum(a) from values
    (map('hi', 2L, 'apple', 3L, 'pie', 1L)), (map('apple', null, 'hi', 4L)), (null) t(a);

      O resultado retornado é:

      +----------------------------+
| _c0                        |
+----------------------------+
| {"apple":3,"hi":6,"pie":1} |
+----------------------------+

    MAX

    • Sintaxe

      max(<colname>)

    • Descrição

      Retorna o valor máximo de uma coluna.

    • Parâmetros

      colname: obrigatório. Nome de uma coluna, que pode ser de qualquer tipo de dado exceto BOOLEAN.

    • Valor de retorno

      O tipo do valor retornado é igual ao do parâmetro colname. O valor retornado varia conforme as seguintes regras:

      • Se o valor de colname for null, a linha contendo esse valor não será usada no cálculo.

      • Se o valor de colname for do tipo BOOLEAN, o valor não será utilizado no cálculo.

    • Exemplos

      • Exemplo 1: Calcular o maior salário (sal) de todos os funcionários. Instrução de exemplo:

        select max(sal) from emp;

        O resultado retornado é:

        +------------+
| _c0        |
+------------+
| 5000       |
+------------+

      • Exemplo 2: Utilize esta função com group by para agrupar todos os funcionários por departamento (deptno) e calcular o maior salário (sal) em cada departamento. Comando de exemplo:

        select deptno, max(sal) from emp group by deptno;

        O resultado retornado é:

        +------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | 5000       |
| 20         | 3000       |
| 30         | 2850       |
+------------+------------+

    MAX_BY

    • Sintaxe

      max_by(<valueToReturn>,<valueToMaximize>)

    • Descrição

      Nota

      A função MAX_BY oferece o mesmo recurso que a função ARG_MAX. A diferença reside na ordem dos parâmetros. A função MAX_BY foi introduzida no MaxCompute para manter a compatibilidade com a sintaxe open source.

      Localiza a linha onde o valor de valueToMaximize está incluído e retorna o valor de valueToReturn nessa linha. Esta é uma função adicional do MaxCompute V2.0.

    • Parâmetros

      • valueToMaximize: obrigatório. Um valor de qualquer tipo de dado.

      • valueToReturn: obrigatório. Um valor de qualquer tipo de dado.

    • Valor de retorno

      O tipo de dado do valor retornado corresponde ao do parâmetro valueToReturn. Se várias linhas tiverem o maior valor de valueToMaximize, o valor de valueToReturn de uma dessas linhas será retornado aleatoriamente. Caso o valor de valueToMaximize seja null, a linha contendo esse valor não participará do cálculo.

    • Exemplos

      • Exemplo 1: Retornar o nome do funcionário com o maior salário. Instrução de exemplo:

        select max_by(ename,sal) from emp;

        O resultado retornado é:

        +------------+
| _c0        |
+------------+
| KING       |
+------------+

      • Exemplo 2: Utilize esta função com group by para agrupar todos os funcionários por departamento (deptno) e retornar o nome do funcionário com o maior salário em cada grupo. Comando de exemplo:

        select deptno, max_by(ename,sal) from emp group by deptno;

        O resultado retornado é:

        +------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | KING       |
| 20         | SCOTT      |
| 30         | BLAKE      |
+------------+------------+

    MEDIAN

    • Sintaxe

      double median(double <colname>)
decimal median(decimal <colname>)

    • Descrição

      Retorna o valor da mediana de uma coluna.

    • Parâmetros

      colname: obrigatório. Nome de uma coluna, que pode ser do tipo DOUBLE ou DECIMAL. Se o valor de entrada for do tipo STRING ou BIGINT, ele será implicitamente convertido para o tipo DOUBLE antes do cálculo.

    • Valor de retorno

      Se o valor de colname for null, a linha contendo esse valor não será usada no cálculo. A tabela a seguir descreve os mapeamentos entre os tipos de dados de entrada e os valores de retorno.

      Tipo de entrada

      Tipo do valor de retorno

      TINYINT

      DOUBLE

      SMALLINT

      DOUBLE

      INT

      DOUBLE

      BIGINT

      DOUBLE

      FLOAT

      DOUBLE

      DOUBLE

      DOUBLE

      DECIMAL

      DECIMAL

    • Exemplos

      • Exemplo 1: Calcular a mediana dos valores de salário (sal) de todos os funcionários. Instrução de exemplo:

        select median(sal) from emp;

        O resultado retornado é:

        +------------+
| _c0        |
+------------+
| 1600.0     |
+------------+

      • Exemplo 2: Utilize esta função com group by para agrupar todos os funcionários por departamento (deptno) e calcular o salário mediano (sal) de cada departamento. Comando de exemplo:

        select deptno, median(sal) from emp group by deptno;

        O resultado retornado é:

        +------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | 2450.0     |
| 20         | 2975.0     |
| 30         | 1375.0     |
+------------+------------+

    MIN

    • Sintaxe

      min(<colname>)

    • Descrição do comando

      Calcula o valor mínimo.

    • Parâmetros

      colname: obrigatório. Nome de uma coluna, que pode ser de qualquer tipo de dado exceto BOOLEAN.

    • Valor de retorno

      O valor de retorno é do mesmo tipo que colname. Aplicam-se as seguintes regras:

      • Se o valor de colname for NULL, a linha será excluída do cálculo.

      • Se colname for do tipo BOOLEAN, não poderá ser utilizado nos cálculos.

    • Exemplos

      • Exemplo 1: Calcular o menor salário (sal) de todos os funcionários. Instrução de exemplo:

        select min(sal) from emp;

        O resultado retornado é:

        +------------+
| _c0        |
+------------+
| 800        |
+------------+

      • Exemplo 2: Utilize esta função com group by para agrupar todos os funcionários por departamento (deptno) e calcular o menor salário (sal) em cada departamento. Comando de exemplo:

        select deptno, min(sal) from emp group by deptno;

        O resultado retornado é:

        +------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | 1300       |
| 20         | 800        |
| 30         | 950        |
+------------+------------+

    MIN_BY

    • Sintaxe

      min_by(<valueToReturn>,<valueToMinimize>)

    • Descrição

      Nota

      A função MIN_BY oferece o mesmo recurso que a função ARG_MIN. No entanto, as funções diferem na ordem dos parâmetros. A função MIN_BY foi introduzida no MaxCompute para manter a compatibilidade com a sintaxe open source.

      Localiza a linha onde o valor mínimo de valueToMinimize está incluído e retorna o valor de valueToReturn nessa linha. Esta é uma função adicional do MaxCompute V2.0.

    • Parâmetros

      • valueToMinimize: obrigatório. Um valor de qualquer tipo de dado.

      • valueToReturn: obrigatório. Um valor de qualquer tipo de dado.

    • Valor de retorno

      O tipo de dado do valor retornado corresponde ao do parâmetro valueToReturn. Se várias linhas contiverem o menor valor de valueToMinimize, o valor de valueToReturn de uma dessas linhas será retornado aleatoriamente. Caso o valor de valueToMinimize seja null, a linha contendo esse valor não participará do cálculo.

    • Exemplos

      • Exemplo 1: Retornar o nome do funcionário com o menor salário. Instrução de exemplo:

         select min_by(ename,sal) from emp;

        O resultado retornado é:

        +------------+
| _c0        |
+------------+
| SMITH      |
+------------+

      • Exemplo 2: Utilize esta função com group by para agrupar todos os funcionários por departamento (deptno) e retornar o nome do funcionário com o menor salário em cada grupo. Comando de exemplo:

        select deptno, min_by(ename,sal) from emp group by deptno;

        O resultado retornado é:

        +------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | MILLER     |
| 20         | SMITH      |
| 30         | JAMES      |
+------------+------------+

      • MULTIMAP_AGG

      • Declaração da função

        map<K, array<V>> multimap_agg(K a, V b);

      • Descrição

        Retorna um map criado usando a e b. a é a chave no map. b é usado para criar um array, que serve como valor da chave no map. Se a chave no map for null, ela será ignorada.

      • Parâmetros

        • a: um campo de entrada usado como chave no map.

        • b: um campo de entrada usado como valor no map. Campos correspondentes à mesma chave são colocados no mesmo array e usados como valores no map.

      • Valor de retorno

        Retorna um novo map.

      • Exemplos

        select multimap_agg(a, b) from
        values (1L, 'apple'), (2L, 'hi'), (null, 'good'), (1L, 'pie') t(a, b);

        O resultado retornado é:

        +----------------------------------+
| _c0                              |
+----------------------------------+
| {"2":["hi"],"1":["apple","pie"]} |
+----------------------------------+

      NUMERIC_HISTOGRAM

      • Sintaxe

        map<double key, double value> numeric_histogram(bigint <buckets>,
                                                double <colname>
                                                [, double <weight>])

      • Descrição

        Retorna um histograma aproximado com base em uma coluna especificada. Esta é uma função adicional do MaxCompute V2.0.

      • Parâmetros

        • buckets: obrigatório. Um valor do tipo BIGINT. Este parâmetro especifica o número máximo de buckets na coluna cujo histograma aproximado será retornado.

        • colname: obrigatório. Um valor do tipo DOUBLE. Este parâmetro especifica as colunas cujos histogramas aproximados precisam ser calculados.

        • weight: opcional. O valor de peso dos dados em cada linha. O valor é do tipo DOUBLE.

      • Valor de retorno

        Retorna um valor do tipo map<double key, double value>. No valor retornado, a chave representa a coordenada do eixo x do histograma aproximado, e o valor representa a altura aproximada no eixo y. Aplicam-se as seguintes regras:

        • Se o valor de buckets for null, null será retornado.

        • Se o valor de colname for null, a linha contendo esse valor não será usada no cálculo.

      • Exemplos

        • Retornar um histograma aproximado da coluna sal. Instrução de exemplo:

          select numeric_histogram(5, sal) from emp;

          O resultado retornado é:

          +------------+
| _c0        |
+------------+
| {"1328.5714285714287":7.0,"2450.0":2.0,"5000.0":2.0,"875.0":2.0,"2956.25":4.0} |
+------------+

        • Calcular um histograma aproximado para a coluna de salário (sal), onde deptno em cada linha representa o peso do departamento. Comando de exemplo:

          select numeric_histogram(5, sal, deptno) from emp;

          O resultado retornado é:

          +------------+
| _c0        |
+------------+
| {"2944.4444444444443":90.0,"2450.0":20.0,"5000.0":20.0,"890.0":50.0,"1350.0":160.0} |
+------------+

      PERCENTILE

      • Sintaxe

        double percentile(bigint <colname>, <p>)
-- Return multiple exact percentiles as an array.
array percentile(bigint <colname>, array(<p1> [, <p2>...]))

      • Descrição

        Calcula um percentil exato. Esta função é adequada para pequenos volumes de dados. Ela primeiro classifica a coluna especificada em ordem ascendente e então obtém o p-ésimo percentil exato. p deve estar entre 0 e 1. O cálculo de percentile começa no índice 0. Por exemplo, se uma coluna contiver os valores 100, 200 e 300, seus índices serão 0, 1 e 2. Para calcular o percentil 0.3, o resultado de percentile é 2 × 0.3 = 0.6. Isso significa que o valor está entre os índices 0 e 1. O resultado é 100 + (200 - 100) × 0.6 = 160. Esta é uma função de extensão do MaxCompute V2.0.

      • Parâmetros

        • colname: obrigatório. Uma coluna do tipo BIGINT.

        • p: Obrigatório. O percentil exato, que deve estar no intervalo [0.0, 1.0].

      • Valor de retorno

        Retorna um valor do tipo DOUBLE ou ARRAY.

      • Exemplos

        • Exemplo 1: O comando a seguir calcula o percentil 0.3 do salário (sal):

          select percentile(sal, 0.3) from emp;

          O resultado retornado é:

          +------------+
| _c0        |
+------------+
| 1290.0     |
+------------+

        • Exemplo 2: Utilize esta função com group by para agrupar todos os funcionários por departamento (deptno) e calcular o percentil 0.3 do salário (sal) para cada grupo. Comando de exemplo:

          select deptno, percentile(sal, 0.3) from emp group by deptno;

          O resultado retornado é:

          +------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | 1875.0     |
| 20         | 1475.0     |
| 30         | 1250.0     |
+------------+------------+

        • Exemplo 3: Combine esta função com group by para agrupar todos os funcionários por departamento (deptno) e calcular os percentis 0.3, 0.5 e 0.8 do salário (sal) para cada grupo. Comando de exemplo:

          set odps.sql.type.system.odps2=true;
select deptno, percentile(sal, array(0.3, 0.5, 0.8)) from emp group by deptno;

          O resultado retornado é:

          +------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | [1875.0,2450.0,5000.0] |
| 20         | [1475.0,2975.0,3000.0] |
| 30         | [1250.0,1375.0,1600.0] |
+------------+------------+

      PERCENTILE_APPROX

      • Sintaxe

        double percentile_approx (double <colname>[, double <weight>], <p> [, <B>]))
-- Return multiple approximate percentiles as an array.
array<double> percentile_approx (double <colname>
                                 [, double <weight>],
                                 array(<p1> [, <p2>...])
                                 [, <B>])

      • Descrição

        Esta é uma função de extensão do MaxCompute V2.0. O cálculo de percentile_approx é indexado a partir de 1. Para calcular o p-ésimo percentil de uma coluna com n entradas de dados, a função percentile_approx primeiro classifica a coluna em ordem ascendente. Os dados classificados da coluna são tratados como um array chamado arr, e o resultado de percentile_approx é res. O índice para o percentil é calculado como index = n * p.

        • Se index <= 1, então res = arr[0].

        • Se index >= n - 1, então res = arr[n-1].

        • Se 1 < index < n - 1, calcule diff = index + 0.5 - ceil(index):

          Se a condição abs(diff) < 0.5 for atendida, res é calculado pela fórmula: res = arr[ceil(index) - 1].

          Se a condição abs(diff) = 0.5 for atendida, res é calculado pela fórmula: res = arr[index - 1] + (arr[index] - arr[index - 1]) × 0.5.

          O valor de abs(diff) não pode ser maior que 0.5.

        Por exemplo, se a coluna col contiver os valores 100, 200, 300 e 400, seus índices serão 1, 2, 3 e 4. Então:

        • percentile_approx(col, 0.25) = 100 (index = 1).

        • percentile_approx(col, 0.5) = 200 + (300 - 200) * 0.5 = 250 (index = 2).

        • percentile_approx(col, 0.75) = 400 (index = 3).

        Nota

        percentile_approx e percentile diferem nas seguintes formas:

        • Precisão

          percentile_approx retorna um resultado aproximado; percentile retorna um resultado exato.

        • Memória

          Para grandes volumes de dados, percentile pode falhar devido a limites de memória; percentile_approx não apresenta esse problema.

        • Algoritmo

          percentile_approx é implementado de forma consistente com a função de mesmo nome do Hive, mas usa um algoritmo diferente de percentile. Como resultado, para volumes de dados muito pequenos, as duas funções podem retornar resultados diferentes.

      • Parâmetros

        • colname: obrigatório. Nome de uma coluna, que pode ser do tipo DOUBLE.

        • weight: opcional. O valor de peso dos dados em cada linha. O valor é do tipo DOUBLE.

        • p: Obrigatório. O percentil aproximado, que deve estar no intervalo [0.0, 1.0].

        • B: a precisão do valor de retorno. Uma precisão maior indica um valor mais preciso. Se você não especificar este parâmetro, 10000 será usado.

      • Valor de retorno

        Retorna um valor do tipo DOUBLE ou ARRAY. O valor retornado varia conforme as seguintes regras:

        • Se o valor de colname for null, a linha contendo esse valor não será usada no cálculo.

        • Se o valor de p ou B for null, um erro será retornado.

      • Exemplos

        • Exemplo 1: O comando a seguir calcula o percentil 0.3 do salário (sal):

          select percentile_approx(sal, 0.3) from emp;

          O resultado retornado é:

          +------------+
| _c0        |
+------------+
| 1252.5     |
+------------+

        • Exemplo 2: Utilize esta função com group by para agrupar todos os funcionários por departamento (deptno) e calcular o percentil 0.3 do salário (sal) para cada grupo. Comando de exemplo:

          select deptno, percentile_approx(sal, 0.3) from emp group by deptno;

          O resultado retornado é:

          +------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | 1300.0     |
| 20         | 950.0      |
| 30         | 1070.0     |
+------------+------------+

        • Exemplo 3: Combine esta função com group by para agrupar todos os funcionários por departamento (deptno) e calcular os percentis 0.3, 0.5 e 0.8 do salário (sal) para cada grupo. Comando de exemplo:

          set odps.sql.type.system.odps2=true;
select deptno, percentile_approx(sal, array(0.3, 0.5, 0.8), 1000) from emp group by deptno;

          O resultado retornado é:

          +------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | [1300.0,1875.0,3470.000000000001] |
| 20         | [950.0,2037.5,2987.5] |
| 30         | [1070.0,1250.0,1580.0] |
+------------+------------+

        • Exemplo 4 (com peso): Utilize esta função com group by para agrupar todos os funcionários por departamento (deptno) e calcular os percentis 0.3, 0.5 e 0.8 do salário (sal) para cada grupo. A coluna cnt na tabela emp representa o número de pessoas com aquele salário. Comando de exemplo:

          select deptno, percentile_approx(sal, deptno, array(0.3, 0.5, 0.8), 1000)
  from emp group by deptno;

          O resultado retornado é:

          +------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | [1300.0,1875.0,3470.0] |
| 20         | [950.0,2037.5,2987.5] |
| 30         | [1070.0,1250.0,1580.0] |
+------------+------------+

      PERCENTILE_CONT

      • Sintaxe

        -- Calculate the exact percentile
PERCENTILE_CONT(<col_name>, DOUBLE <percentile>[, BOOLEAN <isIgnoreNull>])

-- Calculate the exact percentile in a window
PERCENTILE_CONT(<col_name>, DOUBLE <percentile>[, BOOLEAN <isIgnoreNull>]) OVER ([partition_clause] [orderby_clause])

      • Descrição

        Calcula o percentil exato. Utiliza um algoritmo de interpolação linear, classifica a coluna especificada em ordem ascendente e retorna o valor exato no percentile especificado.

      • Parâmetros

        • col_name: Obrigatório. Uma coluna do tipo DOUBLE ou DECIMAL.

        • percentile: Obrigatório. O percentil a ser calculado. Uma constante DOUBLE no intervalo de [0, 1].

        • isIgnoreNull: Opcional. Especifica se valores NULL devem ser ignorados. Uma constante BOOLEAN. O valor padrão é TRUE. Se definido como FALSE, valores NULL serão tratados como o valor mínimo durante a classificação.

        • partition_clause e orderby_clause: Para mais informações, consulte windowing_definition..

      • Valor de retorno

        Retorna o valor do percentil calculado como DOUBLE.

      • Exemplos

        • Exemplo 1: Ignorar valores NULL e calcular o percentil exato em uma janela.

          SELECT
  PERCENTILE_CONT(x, 0) OVER() AS min,
  PERCENTILE_CONT(x, 0.01) OVER() AS percentile1,
  PERCENTILE_CONT(x, 0.5) OVER() AS median,
  PERCENTILE_CONT(x, 0.9) OVER() AS percentile90,
  PERCENTILE_CONT(x, 1) OVER() AS max
FROM VALUES(0D),(3D),(NULL),(1D),(2D) AS tbl(x) LIMIT 1;

-- Return result
+------------+-------------+------------+--------------+------------+
| min        | percentile1 | median     | percentile90 | max        | 
+------------+-------------+------------+--------------+------------+
| 0.0        | 0.03        | 1.5        | 2.7          | 3.0        | 
+------------+-------------+------------+--------------+------------+

        • Exemplo 2: Não ignorar valores NULL. Valores NULL são tratados como o valor mínimo durante a classificação. Calcular o percentil exato em uma janela.

          SELECT
  PERCENTILE_CONT(x, 0, false) OVER() AS min,
  PERCENTILE_CONT(x, 0.01, false) OVER() AS percentile1,
  PERCENTILE_CONT(x, 0.5, false) OVER() AS median,
  PERCENTILE_CONT(x, 0.9, false) OVER() AS percentile90,
  PERCENTILE_CONT(x, 1, false) OVER() AS max
FROM VALUES(0D),(3D),(NULL),(1D),(2D) AS tbl(x) LIMIT 1;

-- Return result
+------------+-------------+------------+--------------+------------+
| min        | percentile1 | median     | percentile90 | max        | 
+------------+-------------+------------+--------------+------------+
| NULL       | 0.0         | 1.0        | 2.6          | 3.0        | 
+------------+-------------+------------+--------------+------------+

      PERCENTILE_DISC

      • Sintaxe

        -- Calculate a given percentile value
PERCENTILE_DISC(<col_name>, DOUBLE <percentile>[, BOOLEAN <isIgnoreNull>])

-- Calculate the percentile value in a window
PERCENTILE_DISC(<col_name>, DOUBLE <percentile>[, BOOLEAN <isIgnoreNull>]) OVER ([partition_clause] [orderby_clause])

      • Descrição

        Calcula um determinado valor de percentil. Primeiro classifica a coluna especificada em ordem ascendente e depois retorna o primeiro valor cuja distribuição cumulativa seja maior ou igual ao percentil especificado.

      • Parâmetros

        • col_name: Obrigatório. Uma coluna com qualquer tipo de dado classificável.

        • percentile: Obrigatório. O percentil a ser calculado. Uma constante DOUBLE no intervalo de [0, 1].

        • isIgnoreNull: Opcional. Especifica se valores NULL devem ser ignorados. Uma constante BOOLEAN. O valor padrão é TRUE. Se definido como FALSE, valores NULL serão tratados como o valor mínimo durante a classificação.

        • partition_clause e orderby_clause: Para mais informações, consulte windowing_definition.

      • Valor de retorno

        Retorna o valor do percentil calculado. O tipo de dado é o mesmo da coluna de entrada col_name.

      • Exemplos

        • Exemplo 1: Ignorar valores NULL e calcular o valor do percentil em uma janela.

          SELECT
  x,
  PERCENTILE_DISC(x, 0) OVER() AS min,
  PERCENTILE_DISC(x, 0.5) OVER() AS median,
  PERCENTILE_DISC(x, 1) OVER() AS max
FROM VALUES('c'),(NULL),('b'),('a') AS tbl(x);

-- Return result
+------------+------------+------------+------------+
| x          | min        | median     | max        | 
+------------+------------+------------+------------+
| c          | a          | b          | c          | 
| NULL       | a          | b          | c          | 
| b          | a          | b          | c          | 
| a          | a          | b          | c          | 
+------------+------------+------------+------------+

        • Exemplo 2: Não ignorar valores NULL. Valores NULL são tratados como o valor mínimo durante a classificação. Calcular o valor do percentil em uma janela.

          SELECT
  x,
  PERCENTILE_DISC(x, 0, false) OVER() AS min,
  PERCENTILE_DISC(x, 0.5, false) OVER() AS median,
  PERCENTILE_DISC(x, 1, false) OVER() AS max
FROM VALUES('c'),(NULL),('b'),('a') AS tbl(x);

-- Return result
+------------+------------+------------+------------+
| x          | min        | median     | max        | 
+------------+------------+------------+------------+
| c          | NULL       | a          | c          | 
| NULL       | NULL       | a          | c          | 
| b          | NULL       | a          | c          | 
| a          | NULL       | a          | c          | 
+------------+------------+------------+------------+

      STDDEV

      • Sintaxe

        double stddev(double <colname>)
decimal stddev(decimal <colname>)

      • Descrição

        Retorna o desvio padrão populacional de todos os valores de entrada.

      • Parâmetros

        colname: obrigatório. Nome de uma coluna, que pode ser do tipo DOUBLE ou DECIMAL. Se o valor de entrada for do tipo STRING ou BIGINT, ele será implicitamente convertido para o tipo DOUBLE antes do cálculo.

      • Valor de retorno

        Se o valor de colname for null, a linha contendo esse valor não será usada no cálculo. A tabela a seguir descreve os mapeamentos entre os tipos de dados de entrada e os valores de retorno.

        Tipo de entrada

        Tipo do valor de retorno

        TINYINT

        DOUBLE

        SMALLINT

        DOUBLE

        INT

        DOUBLE

        BIGINT

        DOUBLE

        FLOAT

        DOUBLE

        DOUBLE

        DOUBLE

        DECIMAL

        DECIMAL

      • Exemplos

        • Exemplo 1: Calcular o desvio padrão populacional dos valores de salário (sal) de todos os funcionários. Instrução de exemplo:

          select stddev(sal) from emp;

          O resultado retornado é:

          +------------+
| _c0        |
+------------+
| 1262.7549932628976 |
+------------+

        • Exemplo 2: Utilize esta função com group by para agrupar todos os funcionários por departamento (deptno) e calcular o desvio padrão populacional do salário (sal) de cada departamento. Comando de exemplo:

          select deptno, stddev(sal) from emp group by deptno;

          O resultado retornado é:

          +------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | 1546.1421524412158 |
| 20         | 1004.7387720198718 |
| 30         | 610.1001739241043 |
+------------+------------+

      STDDEV_SAMP

      • Sintaxe

        double stddev_samp(double <colname>)
decimal stddev_samp(decimal <colname>)

      • Descrição

        Retorna o desvio padrão amostral de todos os valores de entrada.

      • Parâmetros

        colname: obrigatório. Nome de uma coluna, que pode ser do tipo DOUBLE ou DECIMAL. Se o valor de entrada for do tipo STRING ou BIGINT, ele será implicitamente convertido para o tipo DOUBLE antes do cálculo.

      • Valor de retorno

        Se o valor de colname for null, a linha contendo esse valor não será usada no cálculo. A tabela a seguir descreve os mapeamentos entre os tipos de dados de entrada e os valores de retorno.

        Tipo de entrada

        Tipo do valor de retorno

        TINYINT

        DOUBLE

        SMALLINT

        DOUBLE

        INT

        DOUBLE

        BIGINT

        DOUBLE

        FLOAT

        DOUBLE

        DOUBLE

        DOUBLE

        DECIMAL

        DECIMAL

      • Exemplos

        • Exemplo 1: Calcular o desvio padrão amostral dos valores de salário (sal) de todos os funcionários. Instrução de exemplo:

          select stddev_samp(sal) from emp;

          O resultado retornado é:

          +------------+
| _c0        |
+------------+
| 1301.6180541247609 |
+------------+

        • Exemplo 2: Utilize esta função com group by para agrupar todos os funcionários por departamento (deptno) e calcular o desvio padrão amostral do salário (sal) de cada departamento. Comando de exemplo:

          select deptno, stddev_samp(sal) from emp group by deptno;

          O resultado retornado é:

          +------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | 1693.7138680032901 |
| 20         | 1123.3320969330487 |
| 30         | 668.3312551921141 |
+------------+------------+

      SUM

      • Sintaxe

        DECIMAL|DOUBLE|BIGINT  sum(<colname>)

      • Descrição

        Calcula a soma.

      • Parâmetros

        colname: obrigatório. Os valores da coluna suportam todos os tipos de dados e podem ser convertidos para o tipo DOUBLE antes do cálculo. Nome de uma coluna, que pode ser do tipo DOUBLE, DECIMAL ou BIGINT. Se o valor de entrada for do tipo STRING, ele será implicitamente convertido para o tipo DOUBLE antes do cálculo.

      • Valor de retorno

        Se o valor de colname for null, a linha contendo esse valor não será usada no cálculo. A tabela a seguir descreve os mapeamentos entre os tipos de dados de entrada e os valores de retorno.

        Tipo de entrada

        Tipo do valor de retorno

        TINYINT

        BIGINT

        SMALLINT

        BIGINT

        INT

        BIGINT

        BIGINT

        BIGINT

        FLOAT

        DOUBLE

        DOUBLE

        DOUBLE

        DECIMAL

        DECIMAL

      • Exemplos

        • Exemplo 1: Calcular a soma dos valores de salário (sal) de todos os funcionários. Instrução de exemplo:

          select sum(sal) from emp;

          O resultado retornado é:

          +------------+
| _c0        |
+------------+
| 37775      |
+------------+

        • Exemplo 2: Utilize esta função com group by para agrupar todos os funcionários por departamento (deptno) e calcular a soma do salário (sal) de cada departamento. Comando de exemplo:

          select deptno, sum(sal) from emp group by deptno;

          O resultado retornado é:

          +------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | 17500      |
| 20         | 10875      |
| 30         | 9400       |
+------------+------------+

      VAR_SAMP

      • Sintaxe

        double var_samp(<colname>)

      • Descrição

        Calcula a variância amostral de uma coluna numérica especificada. Esta é uma função adicional do MaxCompute V2.0.

      • Parâmetros

        colname: obrigatório. Uma coluna do tipo de dado numérico. Se a coluna especificada não for numérica, um valor null será retornado.

      • Valor de retorno

        Retorna um valor do tipo DOUBLE.

      • Exemplos

        • Exemplo 1: Calcular a variância amostral dos valores de salário (sal) de todos os funcionários. Instrução de exemplo:

          select var_samp(sal) from emp;

          O resultado retornado é:

          +------------+
| _c0        |
+------------+
| 1694209.5588235292 |
+------------+

        • Exemplo 2: Utilize esta função com group by para agrupar todos os funcionários por departamento (deptno) e calcular a variância amostral do salário (sal) para cada grupo. Comando de exemplo:

          select deptno, var_samp(sal) from emp group by deptno;

          O resultado retornado é:

          +------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | 2868666.666666667 |
| 20         | 1261875.0  |
| 30         | 446666.6666666667 |
+------------+------------+

      VARIANCE/VAR_POP

      • Sintaxe

        double variance(<colname>)
double var_pop(<colname>)

      • Descrição do comando

        Calcula a variância de uma coluna numérica especificada.

      • Parâmetros

        colname: obrigatório. Uma coluna do tipo de dado numérico. Se a coluna especificada não for numérica, um valor null será retornado. Esta é uma função adicional do MaxCompute V2.0.

      • Valor de retorno

        Retorna um valor do tipo DOUBLE.

      • Exemplos

        • Exemplo 1: Calcular a variância dos valores de salário (sal) de todos os funcionários. Instrução de exemplo:

          select variance(sal) from emp;
-- This is equivalent to the following statement.
select var_pop(sal) from emp;

          O resultado retornado é:

          +------------+
| _c0        |
+------------+
| 1594550.1730103805 |
+------------+

        • Exemplo 2: Utilize esta função com group by para agrupar todos os funcionários por departamento (deptno) e calcular a variância do salário (sal) para cada grupo. Comando de exemplo:

          select deptno, variance(sal) from emp group by deptno;
-- This is equivalent to the following statement.
select deptno, var_pop(sal) from emp group by deptno;

          O resultado retornado é:

          +------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | 2390555.5555555555 |
| 20         | 1009500.0  |
| 30         | 372222.22222222225 |
+------------+------------+

      WM_CONCAT

      • Sintaxe

        string wm_concat(string <separator>, string <colname>)

      • Descrição do comando

        Concatena valores em colname usando um delimitador especificado por separator.

      • Parâmetros

        • separator: obrigatório. O delimitador, que é uma constante do tipo STRING.

        • colname: obrigatório. Um valor do tipo STRING. Se o valor de entrada for do tipo BIGINT, DOUBLE ou DATETIME, o valor será implicitamente convertido para o tipo STRING antes do cálculo.

      • Valor de retorno (ao usar group by para agrupamento, os valores de retorno dentro de um grupo não são classificados)

        Retorna um valor do tipo STRING. O valor retornado varia conforme as seguintes regras:

        • Se o valor de separator não for uma constante do tipo STRING, um erro será retornado.

        • Se o valor de colname não for do tipo STRING, BIGINT, DOUBLE ou DATETIME, um erro será retornado.

        • Se o valor de colname for null, a linha contendo esse valor não será usada no cálculo.

        Nota

        Na instrução select wm_concat(',', name) from table_name;, se table_name for um conjunto vazio, a instrução retornará NULL.

      • Exemplos

        • Exemplo 1: Concatenar os nomes (ename) de todos os funcionários. Instrução de exemplo:

          select wm_concat(',', ename) from emp;

          O resultado retornado é:

          +------------+
| _c0        |
+------------+
| SMITH,ALLEN,WARD,JONES,MARTIN,BLAKE,CLARK,SCOTT,KING,TURNER,ADAMS,JAMES,FORD,MILLER,JACCKA,WELAN,TEBAGE |
+------------+

        • Exemplo 2: Utilize esta função com group by para agrupar todos os funcionários por departamento (deptno) e concatenar os nomes (ename) dos funcionários do mesmo grupo. Comando de exemplo:

          select deptno, wm_concat(',', ename) from emp group by deptno order by deptno;

          O resultado retornado é:

          +------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | CLARK,KING,MILLER,JACCKA,WELAN,TEBAGE |
| 20         | SMITH,JONES,SCOTT,ADAMS,FORD |
| 30         | ALLEN,WARD,MARTIN,BLAKE,TURNER,JAMES |
+------------+------------+

        • Exemplo 3: Combine esta função com group by para agrupar todos os funcionários por departamento (deptno) e concatenar os valores distintos de salário (sal) dos funcionários do mesmo grupo. Comando de exemplo:

          select deptno, wm_concat(distinct ',', sal) from emp group by deptno order by deptno;

          O resultado retornado é:

          +------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | 1300,2450,5000 |
| 20         | 1100,2975,3000,800 |
| 30         | 1250,1500,1600,2850,950 |
+------------+------------+

        • Exemplo 4: Utilize esta função com group by e order by para agrupar todos os funcionários por departamento (deptno), classificar seus salários (sal) e concatená-los. Comando de exemplo:

          select deptno, wm_concat(',',sal) within group(order by sal) from emp group by deptno order by deptno;

          O resultado retornado é:

          +------------+------------+
|deptno|_c1|
+------------+------------+
|10|1300,1300,2450,2450,5000,5000|
|20|800,1100,2975,3000,3000|
|30|950,1250,1250,1500,1600,2850|
+------------+------------+