Funciones de agregación en SQLite: COUNT, SUM, AVG

Qué hace realmente una función de agregación

La mayoría de las funciones SQL que has visto hasta ahora trabajan fila por fila: UPPER(name) se ejecuta una vez por cada fila, igual que ROUND(price, 2). Las funciones de agregación SQLite funcionan distinto: toman un conjunto entero de filas y lo reducen a un único valor.

Vamos a montar una tabla pequeña para experimentar:

CREATE TABLE orders (
    id INTEGER PRIMARY KEY,
    customer TEXT,
    amount REAL,
    status TEXT
);

INSERT INTO orders (customer, amount, status) VALUES
    ('Ada',   42.00, 'paid'),
    ('Boris', 15.50, 'paid'),
    ('Ada',   88.00, 'paid'),
    ('Carl',  10.00, 'refunded'),
    ('Ada',   NULL,  'pending');

SELECT COUNT(*), SUM(amount), AVG(amount) FROM orders;

Cinco filas entran, una fila sale. Ese es el modelo mental completo: las funciones de agregación en SQLite aplastan filas para devolver un resumen. Si no hay un GROUP BY, ese resumen abarca todas las filas del resultado.

COUNT: filas vs valores

COUNT tiene tres variantes, y la diferencia importa:

CREATE TABLE orders (
    id INTEGER PRIMARY KEY,
    customer TEXT,
    amount REAL
);

INSERT INTO orders (customer, amount) VALUES
    ('Ada',   42.00),
    ('Boris', 15.50),
    ('Ada',   88.00),
    ('Carl',  NULL),
    ('Ada',   NULL);

SELECT
    COUNT(*)               AS filas_totales,
    COUNT(amount)          AS filas_con_importe,
    COUNT(DISTINCT customer) AS clientes_unicos
FROM orders;

• COUNT(*) cuenta filas. Incluye los NULL. Siempre devuelve un número.
• COUNT(columna) cuenta los valores no nulos de esa columna.
• COUNT(DISTINCT columna) cuenta los valores únicos no nulos.

Tenemos cinco filas, tres con amount y tres clientes distintos. Si alguna vez ves que COUNT(amount) da un número menor que COUNT(*), ya sabes por qué: los NULL no se cuentan.

SUM, AVG, MIN y MAX en SQLite

Las funciones de agregación aritméticas se comportan como esperarías, salvo por una regla silenciosa: todas ignoran los NULL:

CREATE TABLE orders (id INTEGER PRIMARY KEY, amount REAL);
INSERT INTO orders (amount) VALUES (10), (20), (30), (NULL);

SELECT
    SUM(amount) AS total,
    AVG(amount) AS promedio,
    MIN(amount) AS menor,
    MAX(amount) AS mayor,
    COUNT(amount) AS contados
FROM orders;

AVG calcula (10 + 20 + 30) / 3 = 20.0, no 60 / 4 = 15.0. El denominador es el número de valores no NULL. Si no es lo que buscas —por ejemplo, si prefieres tratar los datos faltantes como cero—, conviene indicarlo de forma explícita:

CREATE TABLE orders (id INTEGER PRIMARY KEY, amount REAL);
INSERT INTO orders (amount) VALUES (10), (20), (30), (NULL);

SELECT AVG(COALESCE(amount, 0)) FROM orders;

MIN y MAX también funcionan con texto y fechas: comparan de forma lexicográfica en el caso del texto, y como cadenas ISO cuando usas el formato estándar de fecha.

Diferencia entre SUM y TOTAL en SQLite

SQLite incluye una segunda función de agregación parecida a la suma, TOTAL, que resuelve dos detalles molestos de SUM:

CREATE TABLE empty_table (amount REAL);

SELECT SUM(amount), TOTAL(amount) FROM empty_table;

• SUM sobre cero filas devuelve NULL. TOTAL devuelve 0.0.
• SUM cuando todos los valores son NULL devuelve NULL. TOTAL devuelve 0.0.
• TOTAL siempre devuelve un número de punto flotante, así que nunca se desborda como pasa con la aritmética de enteros.

¿La contraparte? TOTAL no es estándar, y el hecho de que siempre retorne REAL puede pillarte por sorpresa si esperabas un entero. Úsalo cuando "cero filas significa cero" sea la respuesta correcta para tu aplicación, y quédate con SUM cuando necesites el comportamiento del SQL estándar.

DISTINCT dentro de funciones de agregación

DISTINCT se puede usar dentro de cualquier función de agregación, no solo en COUNT. Elimina los valores duplicados antes de que se ejecute la agregación:

CREATE TABLE orders (id INTEGER PRIMARY KEY, customer TEXT, amount REAL);
INSERT INTO orders (customer, amount) VALUES
    ('Ada',   42.00),
    ('Ada',   42.00),
    ('Boris', 15.50),
    ('Carl',  10.00);

SELECT
    SUM(amount)          AS sum_all,
    SUM(DISTINCT amount) AS sum_unique,
    COUNT(DISTINCT customer) AS unique_customers
FROM orders;

SUM(amount) suma el amount de todas las filas. SUM(DISTINCT amount) suma cada valor único una sola vez, lo cual sirve para casos como "total de importes únicos de facturas", aunque casi nunca es lo que buscas. La que sí se usa a menudo es COUNT(DISTINCT customer).

FILTER: agregar solo un subconjunto

Cuando quieres agregar únicamente algunas filas, lo primero que se te ocurre es usar WHERE. El problema es que WHERE filtra toda la consulta, así que no puedes combinar "contar pedidos pagados" y "contar reembolsos" en la misma sentencia. Aquí es donde entra la cláusula FILTER en SQLite:

CREATE TABLE orders (id INTEGER PRIMARY KEY, amount REAL, status TEXT);
INSERT INTO orders (amount, status) VALUES
    (42.00, 'paid'),
    (15.50, 'paid'),
    (88.00, 'paid'),
    (10.00, 'refunded'),
    (25.00, 'pending');

SELECT
    COUNT(*) FILTER (WHERE status = 'paid')      AS paid_count,
    COUNT(*) FILTER (WHERE status = 'refunded')  AS refund_count,
    SUM(amount) FILTER (WHERE status = 'paid')   AS paid_revenue
FROM orders;

Cada cláusula FILTER (WHERE ...) aplica solo a ese agregado en concreto. Una sola pasada por la tabla, varios cortes resumidos. Antes de que existiera FILTER, había que escribir SUM(CASE WHEN status = 'paid' THEN amount END) — la misma idea, pero con más tecleo.

GROUP_CONCAT en SQLite: concatenar cadenas

GROUP_CONCAT es el bicho raro de la familia. En lugar de devolver un número, concatena los valores en una sola cadena:

CREATE TABLE tags (post_id INTEGER, tag TEXT);
INSERT INTO tags VALUES
    (1, 'sqlite'),
    (1, 'database'),
    (1, 'tutorial'),
    (2, 'python'),
    (2, 'sqlite');

SELECT
    post_id,
    GROUP_CONCAT(tag)        AS separador_predeterminado,
    GROUP_CONCAT(tag, ' | ') AS separado_por_barra
FROM tags
GROUP BY post_id;

El separador por defecto es la coma. Si quieres otro, pásalo como segundo argumento. El orden no está garantizado a menos que envuelvas la llamada como GROUP_CONCAT(tag ORDER BY tag) — muy útil cuando el resultado se muestra en una interfaz y necesitas que sea estable.

Agregaciones sin GROUP BY en SQLite

Todos los ejemplos anteriores que usaban funciones de agregación sin GROUP BY devolvieron exactamente una fila. Esa es la regla: un SELECT con agregaciones y sin GROUP BY es un resumen de una sola fila sobre toda la tabla (después de aplicar el WHERE).

Puedes combinar agregaciones sin problema:

CREATE TABLE orders (id INTEGER PRIMARY KEY, amount REAL, status TEXT);
INSERT INTO orders (amount, status) VALUES
    (42.00, 'paid'), (15.50, 'paid'), (88.00, 'paid'),
    (10.00, 'refunded'), (25.00, 'pending');

SELECT
    COUNT(*)    AS orders,
    SUM(amount) AS revenue,
    AVG(amount) AS average,
    MIN(amount) AS smallest,
    MAX(amount) AS largest
FROM orders
WHERE status = 'paid';

Lo que no puedes hacer es mezclar columnas no agregadas con funciones de agregación y esperar resultados coherentes:

-- Permitido por SQLite, pero el valor de `customer` es arbitrario.
SELECT customer, SUM(amount) FROM orders;

SQLite no te dará error aquí (otras bases de datos sí), pero mostrará el nombre de un cliente cualquiera junto al total. Si lo que quieres es un total por cliente, necesitas GROUP BY — y de eso va la siguiente página.

Siguiente: GROUP BY y HAVING en SQLite

Las funciones de agregación sobre toda la tabla responden a "cuánto hay en total". Las agregaciones por grupo — por cliente, por mes, por estado — son las que responden a las preguntas realmente interesantes. Con GROUP BY divides las filas en grupos antes de agregar, y con HAVING filtras sobre el resultado ya agregado. Vamos a ello.