Funciones de agregación

Documentación de funciones de agregación

Las funciones de agregación funcionan de la forma habitual, como cabría esperar para los expertos en bases de datos.

ClickHouse también admite:

• Funciones de agregación paramétricas, que aceptan otros parámetros además de las columnas.
• Combinadores, que cambian el comportamiento de las funciones de agregación.

​

Procesamiento de NULL

Durante la agregación, se omiten todos los argumentos NULL. Si la agregación tiene varios argumentos, se ignorará cualquier fila en la que uno o más de ellos sean NULL.

Hay una excepción a esta regla: las funciones first_value, last_value y sus alias (any y anyLast, respectivamente) cuando van seguidas del modificador RESPECT NULLS. Por ejemplo, FIRST_VALUE(b) RESPECT NULLS.

Ejemplos:

Considere la siguiente tabla:

┌─x─┬────y─┐
│ 1 │    2 │
│ 2 │ ᴺᵁᴸᴸ │
│ 3 │    2 │
│ 3 │    3 │
│ 3 │ ᴺᵁᴸᴸ │
└───┴──────┘

Supongamos que necesitas sumar los valores de la columna y:

SELECT sum(y) FROM t_null_big

┌─sum(y)─┐
│      7 │
└────────┘

Ahora puedes usar la función groupArray para crear un array a partir de la columna y:

SELECT groupArray(y) FROM t_null_big

┌─groupArray(y)─┐
│ [2,2,3]       │
└───────────────┘

groupArray no incluye NULL en el array resultante.

Puedes usar COALESCE para convertir NULL en un valor que tenga sentido en tu caso de uso. Por ejemplo: avg(COALESCE(column, 0)) usará el valor de la columna en la agregación, o cero si es NULL:

SELECT
    avg(y),
    avg(coalesce(y, 0))
FROM t_null_big

┌─────────────avg(y)─┬─avg(coalesce(y, 0))─┐
│ 2.3333333333333335 │                 1.4 │
└────────────────────┴─────────────────────┘

Además, puede usar Tuple para evitar el comportamiento de omisión de NULL. Un Tuple que contiene solo un valor NULL no es NULL, por lo que las funciones de agregación no omitirán esa fila por ese valor NULL.

SELECT
    groupArray(y),
    groupArray(tuple(y)).1
FROM t_null_big;

┌─groupArray(y)─┬─tupleElement(groupArray(tuple(y)), 1)─┐
│ [2,2,3]       │ [2,NULL,2,3,NULL]                     │
└───────────────┴───────────────────────────────────────┘

Tenga en cuenta que las agregaciones se omiten cuando las columnas se usan como argumentos de una función de agregación. Por ejemplo, count sin parámetros (count()) o con parámetros constantes (count(1)) contará todas las filas del bloque (independientemente del valor de la columna de GROUP BY, ya que no es un argumento), mientras que count(column) solo devolverá el número de filas en las que column no es NULL.

SELECT
    v,
    count(1),
    count(v)
FROM
(
    SELECT if(number < 10, NULL, number % 3) AS v
    FROM numbers(15)
)
GROUP BY v

┌────v─┬─count()─┬─count(v)─┐
│ ᴺᵁᴸᴸ │      10 │        0 │
│    0 │       1 │        1 │
│    1 │       2 │        2 │
│    2 │       2 │        2 │
└──────┴─────────┴──────────┘

Y aquí tienes un ejemplo de first_value con RESPECT NULLS, donde podemos ver que se respetan los valores de entrada NULL y que devolverá el primer valor leído, sea NULL o no:

SELECT
    col || '_' || ((col + 1) * 5 - 1) AS range,
    first_value(odd_or_null) AS first,
    first_value(odd_or_null) IGNORE NULLS as first_ignore_null,
    first_value(odd_or_null) RESPECT NULLS as first_respect_nulls
FROM
(
    SELECT
        intDiv(number, 5) AS col,
        if(number % 2 == 0, NULL, number) AS odd_or_null
    FROM numbers(15)
)
GROUP BY col
ORDER BY col

┌─range─┬─first─┬─first_ignore_null─┬─first_respect_nulls─┐
│ 0_4   │     1 │                 1 │                ᴺᵁᴸᴸ │
│ 1_9   │     5 │                 5 │                   5 │
│ 2_14  │    11 │                11 │                ᴺᵁᴸᴸ │
└───────┴───────┴───────────────────┴─────────────────────┘