Funções de agregação aproximada no SQL padrão

As funções de agregação aproximadas são escalonáveis no que diz respeito ao uso e tempo da memória. No entanto, elas produzem resultados aproximados em vez de exatos. Para mais informações, consulte Agregação aproximada.

APPROX_COUNT_DISTINCT

APPROX_COUNT_DISTINCT(expression)

Descrição

Retorna o resultado aproximado de COUNT(DISTINCT expression). O valor retornado é uma estimativa estatística e não necessariamente o valor real.

Essa função é menos exata que COUNT(DISTINCT expression), mas funciona melhor com entradas enormes.

Tipos de argumentos compatíveis

Qualquer tipo de dados, exceto: ARRAY STRUCT

Tipos de dados retornados

INT64

Exemplos

SELECT APPROX_COUNT_DISTINCT(x) as approx_distinct
FROM UNNEST([0, 1, 1, 2, 3, 5]) as x;

+-----------------+
| approx_distinct |
+-----------------+
| 5               |
+-----------------+

APPROX_QUANTILES

APPROX_QUANTILES([DISTINCT] expression, number [{IGNORE|RESPECT} NULLS])

Descrição

Retorna os limites aproximados de um grupo de valores expression, no qual number representa o número de quantis a serem criados. Essa função retorna uma matriz de number + 1 elementos, no qual o primeiro elemento é o mínimo aproximado e o último elemento é o máximo aproximado.

Tipos de argumentos compatíveis

expression pode ser qualquer tipo de dados compatível, exceto: ARRAY STRUCT

number precisa ser INT64.

Cláusulas opcionais

As cláusulas são aplicadas na seguinte ordem:

  1. DISTINCT: cada valor distinto de expression é agregado somente uma vez ao resultado.

  2. IGNORE NULLS ou RESPECT NULLS: se IGNORE NULLS ou se nenhum dos dois for especificado, os valores NULL serão excluídos do resultado. Se RESPECT NULLS for especificado, os valores NULL serão incluídos no resultado. No entanto, um erro será gerado se uma matriz no resultado final da consulta incluir um elemento NULL.

Tipos de dados retornados

Um ARRAY do tipo especificado pelo parâmetro expression.

Retorna NULL, se houver linhas de entrada igual a zero ou expression for avaliada como NULL em todas as linhas.

Exemplos

SELECT APPROX_QUANTILES(x, 2) AS approx_quantiles
FROM UNNEST([NULL, NULL, 1, 1, 1, 4, 5, 6, 7, 8, 9, 10]) AS x;

+------------------+
| approx_quantiles |
+------------------+
| [1, 5, 10]       |
+------------------+

SELECT APPROX_QUANTILES(x, 100)[OFFSET(90)] AS percentile_90
FROM UNNEST([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) AS x;

+---------------+
| percentile_90 |
+---------------+
| 9             |
+---------------+

SELECT APPROX_QUANTILES(DISTINCT x, 2) AS approx_quantiles
FROM UNNEST([NULL, NULL, 1, 1, 1, 4, 5, 6, 7, 8, 9, 10]) AS x;

+------------------+
| approx_quantiles |
+------------------+
| [1, 6, 10]       |
+------------------+

SELECT FORMAT("%T", APPROX_QUANTILES(x, 2 RESPECT NULLS)) AS approx_quantiles
FROM UNNEST([NULL, NULL, 1, 1, 1, 4, 5, 6, 7, 8, 9, 10]) AS x;

+------------------+
| approx_quantiles |
+------------------+
| [NULL, 4, 10]    |
+------------------+

SELECT FORMAT("%T", APPROX_QUANTILES(DISTINCT x, 2 RESPECT NULLS)) AS approx_quantiles
FROM UNNEST([NULL, NULL, 1, 1, 1, 4, 5, 6, 7, 8, 9, 10]) AS x;

+------------------+
| approx_quantiles |
+------------------+
| [NULL, 6, 10]    |
+------------------+

APPROX_TOP_COUNT

APPROX_TOP_COUNT(expression, number)

Descrição

Retorna os elementos superiores aproximados da expression. O parâmetro number especifica o número de elementos retornados.

Tipos de argumentos compatíveis

expression pode ser quaisquer tipos de dados compatíveis com a cláusula GROUP BY.

number precisa ser INT64.

Tipos de dados retornados

Um ARRAY do tipo STRUCT que contém dois campos. O primeiro campo (chamado value) contém um valor de entrada. O segundo (chamado count) contém um INT64 que especifica o número de vezes que o valor foi retornado.

Retorna NULL, se houver linhas de entrada igual a zero.

Exemplos

SELECT APPROX_TOP_COUNT(x, 2) as approx_top_count
FROM UNNEST(["apple", "apple", "pear", "pear", "pear", "banana"]) as x;

+-------------------------+
| approx_top_count        |
+-------------------------+
| [{pear, 3}, {apple, 2}] |
+-------------------------+

Tratamento de NULL

APPROX_TOP_COUNT não ignora NULLs na entrada. Por exemplo:

SELECT APPROX_TOP_COUNT(x, 2) as approx_top_count
FROM UNNEST([NULL, "pear", "pear", "pear", "apple", NULL]) as x;

+------------------------+
| approx_top_count       |
+------------------------+
| [{pear, 3}, {NULL, 2}] |
+------------------------+

APPROX_TOP_SUM

APPROX_TOP_SUM(expression, weight, number)

Descrição

Retorna os elementos superiores aproximados de expression, com base na soma de um weight atribuído. O parâmetro number especifica o número de elementos retornados.

Se a entrada weight for negativa ou NaN, essa função retornará um erro.

Tipos de argumentos compatíveis

expression pode ser quaisquer tipos de dados compatíveis com a cláusula GROUP BY.

weight precisa ser um dos itens a seguir:

  • INT64
  • FLOAT64

number precisa ser INT64.

Tipos de dados retornados

Um ARRAY do tipo STRUCT. O STRUCT contém dois campos: value e sum. O campo value contém o valor da expressão da entrada. O campo sum tem o mesmo tipo de weight. Ele é a soma aproximada da ponderação de entrada associada ao campo value.

Retorna NULL, se houver linhas de entrada igual a zero.

Exemplos

SELECT APPROX_TOP_SUM(x, weight, 2) AS approx_top_sum FROM
UNNEST([
  STRUCT("apple" AS x, 3 AS weight),
  ("pear", 2),
  ("apple", 0),
  ("banana", 5),
  ("pear", 4)
]);

+--------------------------+
| approx_top_sum           |
+--------------------------+
| [{pear, 6}, {banana, 5}] |
+--------------------------+

Tratamento de NULL

APPROX_TOP_SUM não ignora os valores NULL dos parâmetros expression e weight.

SELECT APPROX_TOP_SUM(x, weight, 2) AS approx_top_sum FROM
UNNEST([STRUCT("apple" AS x, NULL AS weight), ("pear", 0), ("pear", NULL)]);

+----------------------------+
| approx_top_sum             |
+----------------------------+
| [{pear, 0}, {apple, NULL}] |
+----------------------------+
SELECT APPROX_TOP_SUM(x, weight, 2) AS approx_top_sum FROM
UNNEST([STRUCT("apple" AS x, 0 AS weight), (NULL, 2)]);

+-------------------------+
| approx_top_sum          |
+-------------------------+
| [{NULL, 2}, {apple, 0}] |
+-------------------------+
SELECT APPROX_TOP_SUM(x, weight, 2) AS approx_top_sum FROM
UNNEST([STRUCT("apple" AS x, 0 AS weight), (NULL, NULL)]);

+----------------------------+
| approx_top_sum             |
+----------------------------+
| [{apple, 0}, {NULL, NULL}] |
+----------------------------+
Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Precisa de ajuda? Acesse nossa página de suporte.