Use funções de agregação do AnalyticDB for MySQL - AnalyticDB: Central de Documentação do Alibaba Cloud

As funções de agregação calculam um único resultado a partir de um conjunto de valores de entrada. Esta página aborda as funções de agregação compatíveis com o AnalyticDB for MySQL, incluindo sintaxe, tipos de entrada e retorno, além de exemplos executáveis.

Funções abordadas: ARBITRARY, AVG, BIT_AND, BIT_OR, BIT_XOR, COUNT, MAX, MIN, STD / STDDEV / STDDEV_POP, STDDEV_SAMP, SUM, VARIANCE / VAR_POP, VAR_SAMP, GROUP_CONCAT

Observações de uso

Tratamento de NULL

A maioria das funções de agregação ignora valores NULL. Nas funções MAX e MIN, o cálculo exclui linhas em que a coluna de entrada é NULL. Para VARIANCE, VAR_POP e seus aliases, se todos os valores no conjunto de entrada forem NULL, a função retornará NULL.

Modificador DISTINCT

Use DISTINCT para contar ou agregar apenas valores únicos. Por exemplo, COUNT(DISTINCT a) conta valores distintos não NULL na coluna a.

Tabela de teste usada nos exemplos

Exceto pelo GROUP_CONCAT, todos os exemplos usam uma tabela chamada testtable, criada e preenchida da seguinte forma:

CREATE TABLE testtable(a INT) DISTRIBUTED BY HASH(a);
INSERT INTO testtable VALUES (1),(2),(3);

Funções de agregação gerais

ARBITRARY

arbitrary(x)

Retorna um único valor do conjunto de entrada. O valor retornado é não determinístico.

Tipos de entrada	Todos os tipos de dados
Tipo de retorno	Igual à entrada

Exemplo

SELECT arbitrary(a) FROM testtable;

+--------------+
| arbitrary(a) |
+--------------+
|            2 |
+--------------+

AVG

avg(x)

Retorna a média aritmética dos valores de entrada.

Tipos de entrada	BIGINT, DOUBLE, FLOAT
Tipo de retorno	DOUBLE

Exemplo

SELECT avg(a) FROM testtable;

+--------+
| avg(a) |
+--------+
|    2.0 |
+--------+

COUNT

count([DISTINCT | ALL] x)

Conta o número de linhas no conjunto de resultados.

ALL (padrão): conta todas as linhas, incluindo duplicatas.
DISTINCT: conta apenas linhas com valores únicos.

Tipos de entrada	NUMERIC, STRING, BOOLEAN
Tipo de retorno	BIGINT

Exemplos

Conte valores distintos na coluna a:

SELECT count(DISTINCT a) FROM testtable;

+-------------------+
| count(distinct a) |
+-------------------+
|                 3 |
+-------------------+

Conte todas as linhas na coluna a:

SELECT count(ALL a) FROM testtable;

+--------------+
| count(all a) |
+--------------+
|            3 |
+--------------+

MAX

max(x)

Retorna o valor máximo no conjunto de entrada. Valores BOOLEAN e linhas NULL são excluídos.

Tipos de entrada	Todos os tipos de dados (BOOLEAN excluído)
Tipo de retorno	Igual à entrada

Exemplo

SELECT max(a) FROM testtable;

+--------+
| max(a) |
+--------+
|      3 |
+--------+

MIN

min(x)

Retorna o valor mínimo no conjunto de entrada. Valores BOOLEAN e linhas NULL são excluídos.

Tipos de entrada	Todos os tipos de dados (BOOLEAN excluído)
Tipo de retorno	Igual à entrada

Exemplo

SELECT min(a) FROM testtable;

+--------+
| min(a) |
+--------+
|      1 |
+--------+

SUM

sum(x)

Retorna a soma de todos os valores de entrada.

Tipos de entrada	BIGINT, DOUBLE, FLOAT
Tipo de retorno	BIGINT

Exemplo

SELECT sum(a) FROM testtable;

+--------+
| sum(a) |
+--------+
|      6 |
+--------+

GROUP_CONCAT

GROUP_CONCAT([DISTINCT] col_name
             [ORDER BY col_name [ASC | DESC]]
             [SEPARATOR str_val])

Concatena valores de um grupo em uma única string, usando os resultados de uma cláusula GROUP BY. Retorna NULL somente se todos os valores concatenados forem NULL.

Cláusula	Obrigatória	Descrição
`DISTINCT`	Não	Remove valores duplicados antes da concatenação
`ORDER BY`		Ordena os valores dentro do grupo antes da concatenação. O padrão é ordem crescente
`SEPARATOR`		Define o delimitador entre os valores. O padrão é vírgula (`,`)

Tipo de entrada	STRING
Tipo de retorno	STRING

Exemplo

Crie e preencha a tabela person:

CREATE TABLE person(id INT, name VARCHAR, age INT) DISTRIBUTED BY HASH(id);
INSERT INTO person VALUES (1,'mary',13),(2,'eva',14),(2,'adam',13),(3,'eva',13),(3,null,13),(3,null,null),(4,null,13),(4,null,null);

Agrupe por id, concatene nomes distintos em ordem decrescente, separados por #:

SELECT
  id,
  GROUP_CONCAT(DISTINCT name ORDER BY name DESC SEPARATOR '#')
FROM person
GROUP BY id;

+------+--------------------------------------------------------------+
| id   | GROUP_CONCAT(DISTINCT name ORDER BY name DESC SEPARATOR '#') |
+------+--------------------------------------------------------------+
|    2 | eva#adam                                                     |
|    1 | mary                                                         |
|    4 | NULL                                                         |
|    3 | eva                                                          |
+------+--------------------------------------------------------------+

Funções de agregação bit a bit

BIT_AND

bit_and(x)

Retorna o resultado de uma operação AND bit a bit em todos os valores de entrada.

Tipos de entrada	BIGINT, DOUBLE, FLOAT
Tipo de retorno	BIGINT

Exemplo

SELECT bit_and(a) FROM testtable;

+------------+
| bit_and(a) |
+------------+
|          0 |
+------------+

BIT_OR

bit_or(x)

Retorna o resultado de uma operação OR bit a bit em todos os valores de entrada.

Tipos de entrada	BIGINT, DOUBLE, FLOAT
Tipo de retorno	BIGINT

Exemplo

SELECT bit_or(a) FROM testtable;

+-----------+
| bit_or(a) |
+-----------+
|         3 |
+-----------+

BIT_XOR

bit_xor(x)

Retorna o resultado de uma operação XOR bit a bit em todos os valores de entrada.

Tipos de entrada	BIGINT, DOUBLE, FLOAT
Tipo de retorno	BIGINT

Exemplo

SELECT bit_xor(a) FROM testtable;

+------------+
| bit_xor(a) |
+------------+
|          0 |
+------------+

Funções de agregação estatística

STD / STDDEV / STDDEV_POP

std(x)
stddev(x)
stddev_pop(x)

Retorna o desvio padrão populacional dos valores de entrada. STD, STDDEV e STDDEV_POP são aliases para a mesma função.

Tipos de entrada	BIGINT, DOUBLE
Tipo de retorno	DOUBLE
Aliases	`std`, `stddev`, `stddev_pop`

Exemplos

SELECT std(a) FROM testtable;

+-------------------+
| std(a)            |
+-------------------+
| 0.816496580927726 |
+-------------------+

SELECT stddev_pop(a) FROM testtable;

+-------------------+
| stddev_pop(a)     |
+-------------------+
| 0.816496580927726 |
+-------------------+

STDDEV_SAMP

stddev_samp(x)

Retorna o desvio padrão amostral dos valores de entrada.

Tipos de entrada	BIGINT, DOUBLE
Tipo de retorno	DOUBLE

Exemplo

SELECT stddev_samp(a) FROM testtable;

+----------------+
| stddev_samp(a) |
+----------------+
|            1.0 |
+----------------+

VARIANCE / VAR_POP

variance(x)
var_pop(x)

Retorna a variância populacional dos valores de entrada. Linhas com valores NULL são ignoradas; se todos os valores forem NULL, a função retorna NULL.

VARIANCE é uma extensão do MySQL ao SQL padrão. VAR_POP é o equivalente no SQL padrão. Ambas as funções produzem resultados idênticos.

Tipos de entrada	BIGINT, DOUBLE
Tipo de retorno	DOUBLE
Aliases	`variance`, `var_pop`

Exemplos

SELECT variance(a) FROM testtable;

+--------------------+
| variance(a)        |
+--------------------+
| 0.6666666666666666 |
+--------------------+

SELECT var_pop(a) FROM testtable;

+--------------------+
| var_pop(a)         |
+--------------------+
| 0.6666666666666666 |
+--------------------+

VAR_SAMP

var_samp(x)

Retorna a variância amostral dos valores de entrada.

Tipos de entrada	BIGINT, DOUBLE
Tipo de retorno	DOUBLE

Exemplo

SELECT var_samp(a) FROM testtable;

+-------------+
| var_samp(a) |
+-------------+
|         1.0 |
+-------------+