📊

Funciones de Agregación

SUM, COUNT, AVERAGE, MIN, MAX y todas sus variantes, los cimientos de cualquier modelo DAX

Principiante Intermedio

🔍

¿Qué son las funciones de agregación? 🤔

Las funciones de agregación toman una columna (o una expresión evaluada fila a fila) y devuelven un único valor escalar. Son el primer tipo de función que aprende cualquier persona en DAX porque son imprescindibles para construir medidas.

La distinción más importante desde el principio: funciones simples vs iteradoras X

SUM([Ventas]), agrega directamente una columna numérica
SUMX(Tabla, Expresión), itera fila a fila, calcula la expresión, y luego agrega

Analogía kawaii 🌸
SUM es como pedirle a alguien que cuente el dinero en una caja. SUMX es como pedirle que por cada factura calcule (precio × cantidad × descuento) y luego lo sume todo. Mucho más flexible pero también más trabajo.

La regla de oro 🏆
Si necesitas hacer un cálculo por fila antes de agregar → usa la versión X (SUMX, AVERAGEX, MAXX...). Si solo necesitas agregar una columna que ya existe → usa la versión simple (SUM, AVERAGE, MAX...).

➕

SUM, La función más usada en DAX

SUM(<columna>)

Principiante

Suma todos los valores de una columna numérica en el contexto de filtro actual. La medida más habitual en cualquier modelo.

Ejemplo básico:

// Medida básica de ventas totales
Total Ventas = SUM('Ventas'[Importe])

// En un visual filtrado por "España" → suma solo las ventas de España
// En un visual sin filtro → suma TODAS las ventas

Ejemplo con contexto:

// SUM siempre respeta el contexto de filtro automáticamente
// Si tienes un slicer de País seleccionado en "Francia":
Total Ventas = SUM('Ventas'[Importe])  -- devuelve solo ventas de Francia
// No hace falta escribir nada especial, CALCULATE hace eso automáticamente

⚠️ Importante
SUM solo funciona con columnas numéricas. Para sumar en base a una expresión por fila (ej: precio × cantidad), necesitas SUMX. Y nunca uses SUM dentro de CALCULATE como primer argumento, ahí va una medida o expresión.

SUMX(<tabla>, <expresión>)

Intermedio

Itera cada fila de la tabla, evalúa la expresión en el contexto de esa fila, y suma todos los resultados. Imprescindible cuando no tienes una columna con el importe ya calculado.

Ejemplo, cuando no existe columna de importe:

// Tabla Ventas tiene: Cantidad y PrecioUnitario, pero NO Importe
// ❌ Esto NO funciona:
Total Ventas WRONG = SUM('Ventas'[Cantidad] * 'Ventas'[PrecioUnitario])

// ✅ Esto SÍ funciona:
Total Ventas = SUMX('Ventas', 'Ventas'[Cantidad] * 'Ventas'[PrecioUnitario])
// Por cada fila: calcula Cantidad × PrecioUnitario → suma todo

Ejemplo con descuento:

// Precio con descuento aplicado fila a fila
Total Ventas Neto =
SUMX(
    'Ventas',
    'Ventas'[Cantidad] * 'Ventas'[PrecioUnitario] * (1 - 'Ventas'[Descuento])
)

Ejemplo con tabla filtrada:

// Suma solo las ventas de productos con margen > 20%
Ventas Alto Margen =
SUMX(
    FILTER('Ventas', 'Ventas'[Margen] > 0.20),
    'Ventas'[Importe]
)

🏆 Best Practice
SUMX con una tabla grande puede ser lento. Si el cálculo fila a fila es simple (precio × cantidad), suele ser eficiente. Pero si la expresión es compleja, considera crear una columna calculada en el modelo y usar SUM sobre esa columna.

🔢

COUNT y familia, contar con criterio

Tabla rápida de referencia:

FUNCIÓN	QUÉ CUENTA	IGNORA BLANCOS	TIPO DE COLUMNA
COUNT	Valores numéricos	✅ Sí	Solo números
COUNTA	Cualquier valor no vacío	✅ Sí	Cualquier tipo
COUNTBLANK	Celdas vacías/BLANK	N/A	Cualquier tipo
COUNTROWS	Filas de una tabla	N/A	Tabla completa
COUNTX	Expresión no vacía por fila	✅ Sí	Expresión iterada
COUNTAX	Expresión no vacía (cualquier tipo)	✅ Sí	Expresión iterada

COUNT(<columna>) | COUNTA(<columna>)

Principiante

Ejemplo COUNT:

// Cuenta cuántas ventas tienen importe registrado (número)
Nº Ventas = COUNT('Ventas'[Importe])
// ¡OJO! Si alguna fila tiene BLANK en Importe, NO la cuenta

// Para contar filas con cualquier dato (texto, fecha, número):
Nº Registros = COUNTA('Ventas'[ID_Venta])

COUNTBLANK(<columna>)

Principiante

Ejemplo:

// Cuántos productos no tienen precio asignado
Productos Sin Precio = COUNTBLANK('Productos'[Precio])
// Útil para auditorías de calidad de datos

COUNTROWS(<tabla>)

Principiante

La más usada para contar filas, no depende del tipo de dato.

Ejemplos:

// Contar todas las filas de la tabla
Nº Pedidos = COUNTROWS('Pedidos')

// Con filtro:
Pedidos Pendientes = COUNTROWS(FILTER('Pedidos', 'Pedidos'[Estado] = "Pendiente"))

// Contar clientes únicos que han comprado (patrón muy común)
Clientes Activos = COUNTROWS(VALUES('Ventas'[ID_Cliente]))

COUNTX(<tabla>, <expresión>)

Intermedio

Ejemplo:

// Contar filas donde el margen calculado es positivo
Ventas Rentables =
COUNTX(
    'Ventas',
    IF('Ventas'[PrecioVenta] > 'Ventas'[Coste], 1, BLANK())
)

Regla práctica para elegir la función de conteo 💡
¿Quieres contar FILAS de una tabla? → COUNTROWS. ¿Quieres contar VALORES no vacíos de una columna numérica? → COUNT. ¿Valores de cualquier tipo? → COUNTA. ¿Celdas vacías? → COUNTBLANK. ¿Con lógica fila a fila? → COUNTX.

🎯

DISTINCTCOUNT, Contar únicos

DISTINCTCOUNT(<columna>)

Principiante, Intermedio

Cuenta los valores únicos (distintos) de una columna, ignorando duplicados. Equivale a COUNT(DISTINCT columna) en SQL. Imprescindible para métricas como "número de clientes únicos" o "SKUs vendidos".

Ejemplo básico:

// Cuántos clientes diferentes han comprado
Clientes Únicos = DISTINCTCOUNT('Ventas'[ID_Cliente])
// Si el cliente 001 compró 5 veces → cuenta como 1

// Cuántos productos diferentes se han vendido
SKUs Vendidos = DISTINCTCOUNT('Ventas'[ID_Producto])

// Diferencia importante:
Nº Ventas = COUNTROWS('Ventas')           -- número de transacciones (filas)
Clientes Únicos = DISTINCTCOUNT('Ventas'[ID_Cliente])  -- número de compradores únicos
Ticket Medio Clientes = DIVIDE([Total Ventas], [Clientes Únicos])

DISTINCTCOUNTNOBLANK(<columna>)

Intermedio

Igual que DISTINCTCOUNT pero excluye explícitamente los valores BLANK. DISTINCTCOUNT sí incluye el BLANK como un valor distinto en algunos contextos.

Ejemplo:

// Si la columna Región tiene: "Norte", "Sur", BLANK, "Norte"
DISTINCTCOUNT('Ventas'[Región])        -- resultado: 3 (Norte, Sur, BLANK)
DISTINCTCOUNTNOBLANK('Ventas'[Región]) -- resultado: 2 (Norte, Sur)

📏

AVERAGE, Medias y promedios

AVERAGE(<columna>)

Principiante

Calcula la media aritmética de los valores numéricos de una columna. Ignora automáticamente los valores BLANK (no los trata como 0, los excluye del cálculo).

Ejemplo:

// Ticket medio por transacción
Ticket Medio = AVERAGE('Ventas'[Importe])
// Si hay 10 ventas con importes: 100, 200, BLANK, 300...
// AVERAGE ignora el BLANK → media de los 9 valores no vacíos

// ¡OJO! Diferencia importante:
Ticket Medio Real = AVERAGE('Ventas'[Importe])
// vs
Ticket Medio Con Ceros = DIVIDE(SUM('Ventas'[Importe]), COUNTROWS('Ventas'))
// El segundo divide entre TODAS las filas (incluyendo las que tienen BLANK)
// Elige según qué signifique un BLANK en tu contexto

AVERAGEA(<columna>)

Principiante

Como AVERAGE pero también procesa columnas no numéricas. Convierte TRUE=1, FALSE=0, texto=0. Raramente necesaria en Power BI, AVERAGE es suficiente para casi todo.

AVERAGEX(<tabla>, <expresión>)

Intermedio

Versión iteradora de AVERAGE. Calcula la expresión por fila y luego promedia los resultados.

Ejemplo, Margen medio por pedido:

// Media del margen de cada pedido (no el margen total / nº pedidos)
Margen Medio por Pedido =
AVERAGEX(
    'Pedidos',
    DIVIDE(
        SUMX(RELATEDTABLE('LineasPedido'), 'LineasPedido'[Margen]),
        SUMX(RELATEDTABLE('LineasPedido'), 'LineasPedido'[Importe])
    )
)

🎢

MIN y MAX, Valores extremos

Tabla de referencia:

FUNCIÓN	QUÉ HACE	TIPO
MIN	Mínimo de columna numérica/fecha	Simple
MINA	Mínimo incluyendo lógicos	Simple (raro)
MINX	Mínimo de expresión por fila	Iteradora
MAX	Máximo de columna numérica/fecha	Simple
MAXA	Máximo incluyendo lógicos	Simple (raro)
MAXX	Máximo de expresión por fila	Iteradora

MIN(<columna>) | MAX(<columna>)

Principiante

Ejemplo MIN/MAX básico:

// Fechas del primer y último pedido
Primera Venta = MIN('Ventas'[Fecha])
Última Venta = MAX('Ventas'[Fecha])

// Precio más bajo y más alto
Precio Mínimo = MIN('Productos'[Precio])
Precio Máximo = MAX('Productos'[Precio])

// Número de días activos (entre primera y última venta)
Días Activos = DATEDIFF(MIN('Ventas'[Fecha]), MAX('Ventas'[Fecha]), DAY)

MINX(<tabla>, <expresión>) | MAXX(<tabla>, <expresión>)

Intermedio

Ejemplo MINX/MAXX:

// El pedido de mayor importe (calculado como precio × cantidad)
Pedido Mayor Importe =
MAXX(
    'Pedidos',
    SUMX(RELATEDTABLE('LineasPedido'), 'LineasPedido'[Precio] * 'LineasPedido'[Cantidad])
)

// MIN con dos columnas (MIN con dos argumentos devuelve el menor de los dos valores):
Precio Aplicado = MIN('Productos'[Precio], 'Productos'[PrecioOferta])

✖️

PRODUCT y PRODUCTX, Multiplicación acumulada

PRODUCT(<columna>) | PRODUCTX(<tabla>, <expresión>)

Intermedio, Avanzado

Multiplica todos los valores de una columna (o expresión). Poco usada en business intelligence general, pero muy útil en finanzas para cálculos de rendimientos compuestos.

Ejemplo, Rendimiento compuesto:

// Si tienes una tabla con la variación mensual en %:
// Enero +5%, Febrero +3%, Marzo -2%...
// El rendimiento compuesto acumulado es el PRODUCTO de (1 + variación)
Rendimiento Compuesto =
PRODUCTX(
    'Rendimientos',
    1 + 'Rendimientos'[Variacion_Mensual]
) - 1

// Resultado: el rendimiento total del período considerando el interés compuesto

⚡

APPROXIMATEDISTINCTCOUNT, Velocidad vs Precisión

APPROXIMATEDISTINCTCOUNT(<columna>)

Avanzado

Versión aproximada (pero muy rápida) de DISTINCTCOUNT. Usa el algoritmo HyperLogLog para estimar el conteo distinto con un margen de error de ~2%. Ideal para tablas con millones de filas donde la velocidad importa más que la precisión exacta.

Ejemplo:

// En una tabla con 50 millones de filas:
// ❌ Lento en DirectQuery o tablas enormes:
Visitantes Únicos EXACT = DISTINCTCOUNT('WebLogs'[UserID])

// ✅ Mucho más rápido, ~2% de error (aceptable para dashboards):
Visitantes Únicos APPROX = APPROXIMATEDISTINCTCOUNT('WebLogs'[UserID])

💡 Cuándo usarla
Para la mayoría de casos de negocio donde un error de ±2% es aceptable (conteo de visitantes, usuarios activos, IDs únicos en big data), APPROXIMATEDISTINCTCOUNT puede ser 10-100x más rápido que DISTINCTCOUNT. ¡Úsala sin miedo en métricas de alto volumen!

🧐

Errores típicos y cómo evitarlos

Error 1, Usar SUM donde debería ir SUMX:

// ❌ Error: no puedes multiplicar columnas dentro de SUM
Total = SUM('Ventas'[Precio] * 'Ventas'[Cantidad])  -- ERROR de sintaxis

// ✅ Correcto:
Total = SUMX('Ventas', 'Ventas'[Precio] * 'Ventas'[Cantidad])

Error 2, AVERAGE no es lo mismo que Total/Conteo cuando hay blancos:

// Si el 30% de tus filas tienen BLANK en Importe:
AVERAGE('Ventas'[Importe])  -- divide entre el 70% de filas (las no vacías)
DIVIDE(SUM('Ventas'[Importe]), COUNTROWS('Ventas'))  -- divide entre el 100%

// ¿Cuál es correcta? Depende de tu lógica de negocio. ¡Decídelo conscientemente!

Error 3, DISTINCTCOUNT incluye BLANK:

// Si quieres solo IDs reales sin contar filas sin ID:
DISTINCTCOUNTNOBLANK('Ventas'[ID_Cliente])  -- más seguro

🚀 Siguiente paso
¡Ya dominas las agregaciones! Son la base de todo. El siguiente gran salto es entender cómo CALCULATE modifica el contexto en el que se evalúan estas funciones, eso es lo que hace DAX único y potente.