FUNCIONES DAX

Suma todos los valores numéricos de una columna en el contexto de filtro actual.

SUM(<columna>)

Total Ventas = SUM(Ventas[Importe])

Evalúa una expresión fila a fila sobre una tabla y suma los resultados.

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

Margen = SUMX(Ventas,
    Ventas[Importe] - Ventas[Cantidad] * RELATED(Productos[Coste]))

Calcula la media aritmética de los valores de una columna.

AVERAGE(<columna>)

Ticket Medio = AVERAGE(Ventas[Importe])

Calcula la media de una expresión evaluada fila a fila sobre una tabla.

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

Venta Media por Cliente =
    AVERAGEX(VALUES(Clientes[Cliente]), [Total Ventas])

Cuenta las celdas de una columna que contienen números o fechas.

COUNT(<columna>)

Líneas con Importe = COUNT(Ventas[Importe])

Cuenta las celdas no vacías de una columna, sea cual sea su tipo de dato.

COUNTA(<columna>)

Clientes con Email = COUNTA(Clientes[Email])

Devuelve el número de filas de una tabla o de una expresión de tabla.

COUNTROWS(<tabla>)

Nº Pedidos = COUNTROWS(Ventas)

Cuenta los valores distintos de una columna, sin repetir.

DISTINCTCOUNT(<columna>)

Clientes Activos = DISTINCTCOUNT(Ventas[ID Cliente])

Cuenta las celdas vacías de una columna.

COUNTBLANK(<columna>)

Sin Teléfono = COUNTBLANK(Clientes[Teléfono])

Devuelve el valor más alto de una columna o el mayor de dos valores.

MAX(<columna>)  |  MAX(<valor1>, <valor2>)

Venta Máxima = MAX(Ventas[Importe])

Devuelve el valor más bajo de una columna o el menor de dos valores.

MIN(<columna>)  |  MIN(<valor1>, <valor2>)

Primera Venta = MIN(Ventas[Fecha])

Devuelve el mayor resultado de una expresión evaluada fila a fila.

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

Mejor Mes = MAXX(VALUES(Calendario[Mes]), [Total Ventas])

Devuelve el menor resultado de una expresión evaluada fila a fila.

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

Peor Mes = MINX(VALUES(Calendario[Mes]), [Total Ventas])

Cuenta los valores distintos de una columna ignorando los vacíos.

DISTINCTCOUNTNOBLANK(<columna>)

Ciudades con Cliente = DISTINCTCOUNTNOBLANK(Clientes[Ciudad])

Comprueba una condición y devuelve un valor si es verdadera y otro si es falsa.

IF(<prueba>, <si_verdadero> [, <si_falso>])

Objetivo = IF([Total Ventas] >= 50000, "Cumplido", "Pendiente")

Devuelve un valor alternativo si la expresión produce un error.

IFERROR(<valor>, <valor_si_error>)

Margen % = IFERROR([Margen] / [Total Ventas], 0)

Compara una expresión con una lista de valores y devuelve el resultado del primero que coincide.

SWITCH(<expresión>, <valor1>, <resultado1> [, <valor2>, <resultado2>] ... [, <otro>])

Zona = SWITCH(Clientes[Ciudad],
    "Madrid", "Centro",
    "Sevilla", "Sur",
    "Otras")

Patrón para evaluar varias condiciones en orden, como un IF anidado pero más legible.

SWITCH(TRUE(), <condición1>, <resultado1> [, <condición2>, <resultado2>] ... [, <otro>])

Tramo = SWITCH(TRUE(),
    [Total Ventas] < 1000, "Bajo",
    [Total Ventas] < 5000, "Medio",
    "Alto")

Devuelve verdadero si las dos condiciones son verdaderas.

AND(<lógico1>, <lógico2>)

Rentable = IF(AND([Margen] > 0, [Total Ventas] > 1000), "Sí", "No")

Devuelve verdadero si al menos una de las dos condiciones es verdadera.

OR(<lógico1>, <lógico2>)

Tamaño = IF(OR(Ventas[Cantidad] > 100, Ventas[Importe] > 10000),
    "Grande", "Normal")

Invierte un valor lógico: verdadero pasa a falso y viceversa.

NOT(<lógico>)

Sin Descuento = NOT(Ventas[Descuento] > 0)

Devuelve el primer argumento que no esté vacío.

COALESCE(<expresión1>, <expresión2> [, ...])

Contacto = COALESCE(Clientes[Móvil], Clientes[Teléfono], "Sin contacto")

Comprueba si un valor pertenece a una lista o a una columna de tabla.

<valor> IN { <valor1>, <valor2> ... }

Ventas Capitales = CALCULATE([Total Ventas],
    Clientes[Ciudad] IN { "Madrid", "Barcelona", "Valencia" })

Evalúa una expresión en un contexto de filtro modificado por los filtros que indiques.

CALCULATE(<expresión> [, <filtro1> [, <filtro2>] ...])

Ventas Madrid = CALCULATE([Total Ventas], Clientes[Ciudad] = "Madrid")

Igual que CALCULATE, pero evalúa una expresión de tabla en lugar de un valor.

CALCULATETABLE(<tabla> [, <filtro1> [, <filtro2>] ...])

Líneas Accesorios = COUNTROWS(
    CALCULATETABLE(Ventas, Productos[Categoría] = "Accesorios"))

Devuelve las filas de una tabla que cumplen una condición evaluada fila a fila.

FILTER(<tabla>, <condición>)

Ventas Clientes Top = CALCULATE([Total Ventas],
    FILTER(Clientes, [Total Ventas] > 20000))

Quita los filtros de una tabla o de columnas concretas; también devuelve todas sus filas.

ALL([<tabla> | <columna> [, <columna>] ...])

% sobre Total Ciudades = DIVIDE([Total Ventas],
    CALCULATE([Total Ventas], ALL(Clientes[Ciudad])))

Quita todos los filtros de una tabla excepto los de las columnas indicadas.

ALLEXCEPT(<tabla>, <columna> [, <columna>] ...)

Ventas del Año = CALCULATE([Total Ventas],
    ALLEXCEPT(Calendario, Calendario[Año]))

Quita los filtros del contexto de fila pero conserva los que el usuario ha aplicado en segmentaciones.

ALLSELECTED([<tabla> | <columna>])

% Visible = DIVIDE([Total Ventas],
    CALCULATE([Total Ventas], ALLSELECTED(Productos[Categoría])))

Elimina filtros dentro de CALCULATE; más claro que ALL cuando solo quieres quitar filtros.

REMOVEFILTERS([<tabla> | <columna> [, <columna>] ...])

Total Global = CALCULATE([Total Ventas], REMOVEFILTERS())

Añade un filtro respetando los existentes en lugar de sustituirlos.

KEEPFILTERS(<expresión>)

Solo Madrid = CALCULATE([Total Ventas],
    KEEPFILTERS(Clientes[Ciudad] = "Madrid"))

Devuelve los valores distintos visibles de una columna (o las filas únicas de una tabla) en el contexto actual.

VALUES(<tabla o columna>)

Ciudades Visibles = COUNTROWS(VALUES(Clientes[Ciudad]))

Devuelve los valores únicos de una columna o las filas únicas de una tabla.

DISTINCT(<tabla o columna>)

Productos Vendidos = COUNTROWS(DISTINCT(Ventas[ID Producto]))

Devuelve el valor de una columna si solo hay uno visible; si no, un valor alternativo.

SELECTEDVALUE(<columna> [, <alternativa>])

Categoría Elegida = SELECTEDVALUE(Productos[Categoría], "Varias")

Indica si una columna tiene un único valor visible en el contexto actual.

HASONEVALUE(<columna>)

Título = IF(HASONEVALUE(Calendario[Año]),
    "Año " & SELECTEDVALUE(Calendario[Año]),
    "Varios años")

Indica si una columna o tabla está siendo filtrada directamente.

ISFILTERED(<tabla o columna>)

Hay Filtro de Ciudad = ISFILTERED(Clientes[Ciudad])

Aplica el resultado de una expresión de tabla como filtro sobre columnas de otra tabla.

TREATAS(<tabla>, <columna> [, <columna>] ...)

Ventas Lista = CALCULATE([Total Ventas],
    TREATAS({ "Madrid", "Bilbao" }, Clientes[Ciudad]))

Activa una relación inactiva solo durante el cálculo.

USERELATIONSHIP(<columna1>, <columna2>)

Ventas por Fecha de Envío = CALCULATE([Total Ventas],
    USERELATIONSHIP(Ventas[Fecha Envío], Calendario[Fecha]))

Devuelve la fecha de hoy (sin hora).

TODAY()

Días de Antigüedad = DATEDIFF(MIN(Ventas[Fecha]), TODAY(), DAY)

Devuelve la fecha y la hora actuales.

NOW()

Última Carga = "Datos a " & FORMAT(NOW(), "dd/mm/yyyy hh:mm")

Crea una fecha a partir de año, mes y día.

DATE(<año>, <mes>, <día>)

Inicio de Ejercicio = DATE(YEAR(TODAY()), 1, 1)

Devuelve el año de una fecha.

YEAR(<fecha>)

Año = YEAR(Ventas[Fecha])

Devuelve el número de mes (1 a 12) de una fecha.

MONTH(<fecha>)

Nº Mes = MONTH(Ventas[Fecha])

Devuelve el día del mes (1 a 31) de una fecha.

DAY(<fecha>)

Día = DAY(Ventas[Fecha])

Devuelve el trimestre (1 a 4) de una fecha.

QUARTER(<fecha>)

Trimestre = "T" & QUARTER(Ventas[Fecha])

Devuelve el día de la semana como número; el tipo 2 empieza en lunes = 1.

WEEKDAY(<fecha> [, <tipo>])

Es Fin de Semana = WEEKDAY(Calendario[Fecha], 2) > 5

Devuelve el número de semana del año; el tipo 21 usa el estándar ISO.

WEEKNUM(<fecha> [, <tipo>])

Semana ISO = WEEKNUM(Ventas[Fecha], 21)

Devuelve el último día del mes, desplazado el número de meses indicado.

EOMONTH(<fecha>, <meses>)

Fin de Mes = EOMONTH(Ventas[Fecha], 0)

Devuelve la fecha situada un número de meses antes o después de otra.

EDATE(<fecha>, <meses>)

Vencimiento = EDATE(Ventas[Fecha], 3)

Calcula la diferencia entre dos fechas en la unidad indicada (DAY, MONTH, YEAR...).

DATEDIFF(<inicio>, <fin>, <intervalo>)

Días de Entrega = DATEDIFF(Ventas[Fecha], Ventas[Fecha Envío], DAY)

Convierte un texto con formato de fecha en una fecha.

DATEVALUE(<texto>)

Fecha Importada = DATEVALUE("2026-03-15")

Genera una tabla con una columna de fechas entre dos fechas.

CALENDAR(<fecha_inicio>, <fecha_fin>)

Calendario = CALENDAR(DATE(2024, 1, 1), DATE(2026, 12, 31))

Genera una tabla de fechas que cubre automáticamente todos los datos del modelo, por años completos.

CALENDARAUTO([<mes_fin_ejercicio>])

Calendario Auto = CALENDARAUTO()

Acumula una expresión desde el inicio del año hasta la fecha actual del contexto.

TOTALYTD(<expresión>, <fechas> [, <filtro>] [, <fin_ejercicio>])

Ventas Acumuladas Año = TOTALYTD([Total Ventas], Calendario[Fecha])

Acumula una expresión desde el inicio del trimestre.

TOTALQTD(<expresión>, <fechas> [, <filtro>])

Ventas Acumuladas Trimestre = TOTALQTD([Total Ventas], Calendario[Fecha])

Acumula una expresión desde el inicio del mes.

TOTALMTD(<expresión>, <fechas> [, <filtro>])

Ventas Acumuladas Mes = TOTALMTD([Total Ventas], Calendario[Fecha])

Devuelve las fechas desde el 1 de enero hasta la última fecha visible; se usa dentro de CALCULATE.

DATESYTD(<fechas> [, <fin_ejercicio>])

Ventas YTD = CALCULATE([Total Ventas], DATESYTD(Calendario[Fecha]))

Devuelve las fechas desde el inicio del mes hasta la última fecha visible.

DATESMTD(<fechas>)

Ventas MTD = CALCULATE([Total Ventas], DATESMTD(Calendario[Fecha]))

Devuelve las fechas desde el inicio del trimestre hasta la última fecha visible.

DATESQTD(<fechas>)

Ventas QTD = CALCULATE([Total Ventas], DATESQTD(Calendario[Fecha]))

Devuelve las mismas fechas del año anterior.

SAMEPERIODLASTYEAR(<fechas>)

Ventas Año Anterior = CALCULATE([Total Ventas],
    SAMEPERIODLASTYEAR(Calendario[Fecha]))

Desplaza las fechas del contexto un número de días, meses, trimestres o años.

DATEADD(<fechas>, <n>, <intervalo>)

Ventas Mes Anterior = CALCULATE([Total Ventas],
    DATEADD(Calendario[Fecha], -1, MONTH))

Devuelve periodos completos desplazados respecto a las fechas actuales.

PARALLELPERIOD(<fechas>, <n>, <intervalo>)

Ventas Trimestre Anterior = CALCULATE([Total Ventas],
    PARALLELPERIOD(Calendario[Fecha], -1, QUARTER))

Devuelve todas las fechas del mes anterior.

PREVIOUSMONTH(<fechas>)

Ventas Mes Previo = CALCULATE([Total Ventas],
    PREVIOUSMONTH(Calendario[Fecha]))

Devuelve todas las fechas del año anterior.

PREVIOUSYEAR(<fechas> [, <fin_ejercicio>])

Ventas Año Previo = CALCULATE([Total Ventas],
    PREVIOUSYEAR(Calendario[Fecha]))

Devuelve todas las fechas del mes siguiente.

NEXTMONTH(<fechas>)

Pedidos Mes Siguiente = CALCULATE(COUNTROWS(Ventas),
    NEXTMONTH(Calendario[Fecha]))

Devuelve las fechas comprendidas entre una fecha inicial y una final.

DATESBETWEEN(<fechas>, <inicio>, <fin>)

Ventas Verano = CALCULATE([Total Ventas],
    DATESBETWEEN(Calendario[Fecha], DATE(2026, 6, 21), DATE(2026, 9, 22)))

Devuelve las fechas de un periodo que empieza en una fecha y se extiende hacia delante o hacia atrás.

DATESINPERIOD(<fechas>, <inicio>, <n>, <intervalo>)

Ventas 12 Meses = CALCULATE([Total Ventas],
    DATESINPERIOD(Calendario[Fecha], MAX(Calendario[Fecha]), -12, MONTH))

Devuelve la primera fecha visible del contexto actual.

FIRSTDATE(<fechas>)

Primer Día del Periodo = FIRSTDATE(Calendario[Fecha])

Devuelve la última fecha visible del contexto actual.

LASTDATE(<fechas>)

Última Venta del Periodo = CALCULATE(SUM(Ventas[Importe]),
    LASTDATE(Calendario[Fecha]))

Devuelve la última fecha del mes en el contexto actual.

ENDOFMONTH(<fechas>)

Cierre de Mes = ENDOFMONTH(Calendario[Fecha])

Evalúa una expresión en la última fecha del mes: útil para saldos.

CLOSINGBALANCEMONTH(<expresión>, <fechas> [, <filtro>])

Saldo al Cierre = CLOSINGBALANCEMONTH(SUM(Bancos[Saldo]),
    Calendario[Fecha])

Evalúa una expresión en el último día del mes anterior: el saldo de apertura.

OPENINGBALANCEMONTH(<expresión>, <fechas> [, <filtro>])

Saldo Inicial = OPENINGBALANCEMONTH(SUM(Bancos[Saldo]),
    Calendario[Fecha])

Une dos textos en uno (para más de dos, usa el operador &).

CONCATENATE(<texto1>, <texto2>)

Nombre Completo = CONCATENATE(Clientes[Nombre], Clientes[Apellido])

Une los resultados de una expresión evaluada sobre una tabla, con un separador.

CONCATENATEX(<tabla>, <expresión> [, <separador>] [, <orden>] [, <dirección>])

Lista de Ciudades = CONCATENATEX(VALUES(Clientes[Ciudad]),
    Clientes[Ciudad], ", ", Clientes[Ciudad], ASC)

Devuelve los primeros caracteres de un texto.

LEFT(<texto> [, <n>])

Prefijo = LEFT(Productos[Referencia], 3)

Devuelve los últimos caracteres de un texto.

RIGHT(<texto> [, <n>])

Sufijo = RIGHT(Productos[Referencia], 2)

Devuelve una parte del texto a partir de una posición.

MID(<texto>, <inicio>, <n>)

Serie = MID(Productos[Referencia], 4, 2)

Devuelve el número de caracteres de un texto.

LEN(<texto>)

Largo del Nombre = LEN(Clientes[Cliente])

Convierte un texto a mayúsculas.

UPPER(<texto>)

Ciudad MAYÚS = UPPER(Clientes[Ciudad])

Convierte un texto a minúsculas.

LOWER(<texto>)

Email Normalizado = LOWER(Clientes[Email])

Elimina los espacios sobrantes de un texto, dejando uno entre palabras.

TRIM(<texto>)

Nombre Limpio = TRIM(Clientes[Cliente])

Reemplaza un texto por otro dentro de una cadena.

SUBSTITUTE(<texto>, <viejo>, <nuevo> [, <ocurrencia>])

Teléfono Limpio = SUBSTITUTE(Clientes[Teléfono], " ", "")

Reemplaza una parte del texto indicando posición y longitud.

REPLACE(<texto>, <inicio>, <n>, <nuevo>)

Tarjeta Oculta = REPLACE(Clientes[Tarjeta], 5, 8, "XXXXXXXX")

Busca un texto dentro de otro sin distinguir mayúsculas de minúsculas y devuelve la posición.

SEARCH(<buscar>, <en_texto> [, <inicio>] [, <valor_si_no_existe>])

Posición de @ = SEARCH("@", Clientes[Email], 1, 0)

Busca un texto dentro de otro distinguiendo mayúsculas de minúsculas.

FIND(<buscar>, <en_texto> [, <inicio>] [, <valor_si_no_existe>])

Posición de "Pro" = FIND("Pro", Productos[Producto], 1, 0)

Convierte un valor en texto aplicando un formato numérico o de fecha.

FORMAT(<valor>, <formato>)

Importe en Texto = FORMAT(Ventas[Importe], "#,0.00 €")
Mes en Texto = FORMAT(Ventas[Fecha], "mmmm yyyy")

Repite un texto el número de veces indicado.

REPT(<texto>, <n>)

Valoración = REPT("*", Valoraciones[Nota])

Convierte un texto que representa un número en un número.

VALUE(<texto>)

Importe Numérico = VALUE(Importaciones[Importe Texto])

Une valores en un solo texto con un delimitador, útil para crear claves.

COMBINEVALUES(<delimitador>, <expresión> [, <expresión>] ...)

Clave = COMBINEVALUES("-", Ventas[ID Cliente], Ventas[ID Producto])

Indica si un texto contiene otro, sin distinguir mayúsculas.

CONTAINSSTRING(<texto>, <buscar>)

Es Línea Pro = CONTAINSSTRING(Productos[Producto], "pro")

Compara dos textos distinguiendo mayúsculas y minúsculas.

EXACT(<texto1>, <texto2>)

Es Abitic = EXACT(Clientes[Cliente], "Abitic")

Divide dos números y evita el error si el divisor es cero, devolviendo un valor alternativo.

DIVIDE(<numerador>, <denominador> [, <alternativa>])

Margen % = DIVIDE([Margen], [Total Ventas], 0)

Devuelve el valor absoluto de un número (sin signo).

ABS(<número>)

Desviación = ABS([Total Ventas] - [Objetivo])

Redondea un número al número de decimales indicado.

ROUND(<número>, <decimales>)

Precio Redondeado = ROUND(Productos[Precio], 1)

Redondea un número siempre hacia arriba.

ROUNDUP(<número>, <decimales>)

Precio Techo = ROUNDUP(Productos[Precio], 0)

Redondea un número siempre hacia abajo.

ROUNDDOWN(<número>, <decimales>)

Precio Suelo = ROUNDDOWN(Productos[Precio], 0)

Redondea un número hacia abajo hasta el entero más cercano.

INT(<número>)

Euros Enteros = INT(Ventas[Importe])

Elimina la parte decimal de un número sin redondear.

TRUNC(<número> [, <decimales>])

Sin Céntimos = TRUNC(Ventas[Importe])

Devuelve el resto de una división.

MOD(<número>, <divisor>)

Es Par = MOD(Ventas[ID Pedido], 2) = 0

Devuelve la parte entera de una división.

QUOTIENT(<numerador>, <denominador>)

Docenas Completas = QUOTIENT(Ventas[Cantidad], 12)

Eleva un número a una potencia.

POWER(<número>, <potencia>)

Capital a 5 Años = 1000 * POWER(1 + 0.03, 5)

Devuelve la raíz cuadrada de un número.

SQRT(<número>)

Raíz de Cantidad = SQRT(Ventas[Cantidad])

Redondea hacia arriba al múltiplo más cercano indicado.

CEILING(<número>, <múltiplo>)

Cajas Necesarias = CEILING(Ventas[Cantidad] / 12, 1)

Redondea hacia abajo al múltiplo más cercano indicado.

FLOOR(<número>, <múltiplo>)

Unidades en Cajas Completas = FLOOR(Ventas[Cantidad], 12)

Devuelve 1 si el número es positivo, 0 si es cero y -1 si es negativo.

SIGN(<número>)

Sentido = SIGN([Total Ventas] - [Objetivo])

Devuelve el logaritmo de un número en la base indicada.

LOG(<número> [, <base>])

Orden de Magnitud = LOG(Ventas[Importe], 10)

Devuelve un entero aleatorio entre dos valores.

RANDBETWEEN(<inferior>, <superior>)

Sorteo = RANDBETWEEN(1, 100)

Devuelve la mediana de los valores de una columna.

MEDIAN(<columna>)

Venta Mediana = MEDIAN(Ventas[Importe])

Devuelve la mediana de una expresión evaluada fila a fila.

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

Mediana por Cliente = MEDIANX(VALUES(Clientes[Cliente]), [Total Ventas])

Devuelve el percentil k de una columna (k entre 0 y 1, inclusive).

PERCENTILE.INC(<columna>, <k>)

Percentil 90 = PERCENTILE.INC(Ventas[Importe], 0.9)

Devuelve el percentil de una expresión evaluada fila a fila.

PERCENTILEX.INC(<tabla>, <expresión>, <k>)

P75 por Cliente = PERCENTILEX.INC(VALUES(Clientes[Cliente]),
    [Total Ventas], 0.75)

Desviación estándar de una muestra de valores.

STDEV.S(<columna>)

Desviación Importe = STDEV.S(Ventas[Importe])

Desviación estándar de una expresión evaluada fila a fila.

STDEVX.S(<tabla>, <expresión>)

Desviación Mensual = STDEVX.S(VALUES(Calendario[Mes]), [Total Ventas])

Varianza de una muestra de valores.

VAR.S(<columna>)

Varianza Importe = VAR.S(Ventas[Importe])

Clasifica el valor de una expresión dentro de una tabla, con criterio de orden y empates.

RANKX(<tabla>, <expresión> [, <valor>] [, <orden>] [, <empates>])

Ranking Clientes = RANKX(ALL(Clientes[Cliente]),
    [Total Ventas], , DESC, DENSE)

Media geométrica de los valores de una columna: adecuada para tasas de crecimiento.

GEOMEAN(<columna>)

Crecimiento Medio = GEOMEAN(Crecimiento[Factor])

Devuelve una tabla resumen agrupada por columnas, con columnas calculadas opcionales.

SUMMARIZE(<tabla>, <columna> [, <columna>] ... [, <nombre>, <expresión>] ...)

Resumen = SUMMARIZE(Ventas, Productos[Categoría],
    "Ventas", SUM(Ventas[Importe]))

Resume datos agrupando por columnas de distintas tablas; es la base de las consultas de los informes.

SUMMARIZECOLUMNS(<columna> [, <columna>] ... [, <filtro>] ... [, <nombre>, <expresión>] ...)

Ventas por Año y Segmento = SUMMARIZECOLUMNS(
    Calendario[Año], Clientes[Segmento],
    "Ventas", [Total Ventas])

Añade columnas calculadas a una tabla.

ADDCOLUMNS(<tabla>, <nombre>, <expresión> [, <nombre>, <expresión>] ...)

Productos con Ventas = ADDCOLUMNS(VALUES(Productos[Producto]),
    "Ventas", [Total Ventas])

Devuelve una tabla con solo las columnas que indiques, ya sean originales o calculadas.

SELECTCOLUMNS(<tabla>, <nombre>, <expresión> [, <nombre>, <expresión>] ...)

Lista de Clientes = SELECTCOLUMNS(Clientes,
    "Cliente", Clientes[Cliente],
    "Ciudad", Clientes[Ciudad])

Devuelve las n primeras filas de una tabla según una expresión de orden.

TOPN(<n>, <tabla> [, <expresión>] [, <orden>])

Ventas Top 5 = SUMX(
    TOPN(5, VALUES(Productos[Producto]), [Total Ventas], DESC),
    [Total Ventas])

Une varias tablas con las mismas columnas, una a continuación de otra.

UNION(<tabla1>, <tabla2> [, <tabla3>] ...)

Clientes Totales = UNION(Clientes2025, Clientes2026)

Devuelve las filas que están en las dos tablas.

INTERSECT(<tabla1>, <tabla2>)

Clientes Repetidores = INTERSECT(Clientes2025, Clientes2026)

Devuelve las filas de la primera tabla que no están en la segunda.

EXCEPT(<tabla1>, <tabla2>)

Clientes sin Compras = EXCEPT(
    VALUES(Clientes[ID Cliente]), VALUES(Ventas[ID Cliente]))

Devuelve todas las combinaciones posibles de filas de varias tablas.

CROSSJOIN(<tabla1>, <tabla2> [, <tabla3>] ...)

Combinaciones = CROSSJOIN(VALUES(Productos[Categoría]),
    VALUES(Calendario[Año]))

Genera una tabla con una serie de números entre dos límites.

GENERATESERIES(<inicio>, <fin> [, <paso>])

Descuentos = GENERATESERIES(0, 0.5, 0.05)

Devuelve una tabla de una sola fila con las columnas calculadas indicadas.

ROW(<nombre>, <expresión> [, <nombre>, <expresión>] ...)

Resumen = ROW("Ventas", [Total Ventas],
    "Pedidos", COUNTROWS(Ventas))

Crea una tabla escribiendo sus datos directamente en la fórmula.

DATATABLE(<nombre>, <tipo> [, <nombre>, <tipo>] ..., { {<fila1>}, {<fila2>} ... })

Zonas = DATATABLE("Ciudad", STRING, "Zona", STRING, {
    {"Madrid", "Centro"},
    {"Sevilla", "Sur"}
})

Agrupa una tabla por columnas y calcula agregaciones sobre cada grupo con CURRENTGROUP.

GROUPBY(<tabla> [, <columna>] ... [, <nombre>, <expresión>] ...)

Total por Cliente = GROUPBY(Ventas, Ventas[ID Cliente],
    "Total", SUMX(CURRENTGROUP(), Ventas[Importe]))

Indica si un valor está vacío.

ISBLANK(<valor>)

Sin Envío = ISBLANK(Ventas[Fecha Envío])

Indica si un valor es un error.

ISERROR(<valor>)

Importe con Error = ISERROR(VALUE(Importaciones[Importe Texto]))

Indica si un valor es numérico.

ISNUMBER(<valor>)

Es Número = ISNUMBER(Importaciones[Código])

Indica si un valor es de tipo texto.

ISTEXT(<valor>)

Es Texto = ISTEXT(Importaciones[Código])

Indica si un número es par.

ISEVEN(<número>)

Fila Par = ISEVEN(Ventas[ID Pedido])

Indica si una tabla no tiene filas en el contexto actual.

ISEMPTY(<tabla>)

Sin Ventas = ISEMPTY(Ventas)

Indica si una tabla contiene una fila con los valores indicados.

CONTAINS(<tabla>, <columna>, <valor> [, <columna>, <valor>] ...)

Ha Comprado = CONTAINS(Ventas, Ventas[ID Cliente],
    Clientes[ID Cliente])

Busca en una tabla el valor de una columna que cumpla las condiciones indicadas.

LOOKUPVALUE(<columna_resultado>, <columna_búsqueda>, <valor> [, <columna_búsqueda>, <valor>] ...)

Ciudad del Cliente = LOOKUPVALUE(Clientes[Ciudad],
    Clientes[ID Cliente], Ventas[ID Cliente])

Indica si una columna es el nivel actual de una jerarquía dentro de una matriz.

ISINSCOPE(<columna>)

Solo Detalle = IF(ISINSCOPE(Productos[Producto]), [Total Ventas])

Devuelve el nombre de usuario (correo) de quien ve el informe; se usa en seguridad por filas.

USERPRINCIPALNAME()

Usuario Actual = USERPRINCIPALNAME()

Trae un valor de la tabla del lado "uno" de una relación, desde la tabla del lado "muchos".

RELATED(<columna>)

Categoría = RELATED(Productos[Categoría])

Devuelve las filas de la tabla del lado "muchos" relacionadas con la fila actual.

RELATEDTABLE(<tabla>)

Nº Pedidos del Cliente = COUNTROWS(RELATEDTABLE(Ventas))

Cambia la dirección del filtro de una relación durante el cálculo.

CROSSFILTER(<columna1>, <columna2>, <dirección>)

Clientes con Ventas = CALCULATE(COUNTROWS(Clientes),
    CROSSFILTER(Ventas[ID Cliente], Clientes[ID Cliente], BOTH))

Devuelve en una cadena la ruta completa de un elemento hasta la raíz de una jerarquía padre-hijo.

PATH(<id_elemento>, <id_padre>)

Ruta = PATH(Empleados[ID], Empleados[ID Jefe])

Devuelve el elemento situado en una posición concreta de una ruta.

PATHITEM(<ruta>, <posición> [, <tipo>])

Director = PATHITEM(Empleados[Ruta], 1)

Devuelve el número de niveles de una ruta.

PATHLENGTH(<ruta>)

Nivel Jerárquico = PATHLENGTH(Empleados[Ruta])

Indica si un elemento aparece en una ruta.

PATHCONTAINS(<ruta>, <elemento>)

Depende de 5 = PATHCONTAINS(Empleados[Ruta], 5)

Calcula la cuota periódica constante de un préstamo.

PMT(<tasa>, <nper>, <va> [, <vf>] [, <tipo>])

Cuota Mensual = PMT(0.045 / 12, 240, -150000)
// ≈ 949 € al mes

Calcula la parte de la cuota que corresponde a intereses en un periodo.

IPMT(<tasa>, <periodo>, <nper>, <va> [, <vf>] [, <tipo>])

Intereses Primer Mes = IPMT(0.045 / 12, 1, 240, -150000)
// ≈ 562,50 €

Calcula la parte de la cuota que corresponde a capital en un periodo.

PPMT(<tasa>, <periodo>, <nper>, <va> [, <vf>] [, <tipo>])

Capital Primer Mes = PPMT(0.045 / 12, 1, 240, -150000)
// ≈ 386,40 €

Calcula el valor futuro de una serie de aportes periódicos.

FV(<tasa>, <nper>, <pago> [, <va>] [, <tipo>])

Ahorro a 5 Años = FV(0.03 / 12, 60, -200)
// ≈ 12.930 €

Calcula el valor actual de una serie de pagos futuros.

PV(<tasa>, <nper>, <pago> [, <vf>] [, <tipo>])

Préstamo Asumible = PV(0.05 / 12, 120, -800)
// ≈ 75.425 €

Calcula el número de periodos necesarios para liquidar un préstamo o alcanzar un objetivo.

NPER(<tasa>, <pago>, <va> [, <vf>] [, <tipo>])

Meses para Liquidar = NPER(0.04 / 12, -500, 20000)
// ≈ 43 meses

Calcula el tipo de interés por periodo de un préstamo o una inversión.

RATE(<nper>, <pago>, <va> [, <vf>] [, <tipo>] [, <estimación>])

Tasa Mensual = RATE(36, -300, 9500)
// tipo por periodo; multiplícalo por 12 para el anual

Calcula el valor actual neto de flujos con fechas irregulares.

XNPV(<tabla>, <valores>, <fechas>, <tasa>)

VAN = XNPV(Flujos, Flujos[Importe], Flujos[Fecha], 0.08)

Calcula la tasa interna de retorno de flujos con fechas irregulares.

XIRR(<tabla>, <valores>, <fechas> [, <estimación>])

TIR = XIRR(Flujos, Flujos[Importe], Flujos[Fecha])

Calcula la amortización lineal de un activo por periodo.

SLN(<coste>, <valor_residual>, <vida>)

Amortización Anual = SLN(12000, 2000, 5)
// 2.000 € al año

Devuelve un valor vacío; los gráficos no muestran los puntos vacíos.

BLANK()

Solo con Ventas = IF([Total Ventas] > 0, [Total Ventas], BLANK())

Detiene el cálculo mostrando un mensaje de error personalizado.

ERROR(<mensaje>)

Validado = IF(ISBLANK(Ventas[ID Cliente]),
    ERROR("Falta el cliente"), Ventas[Importe])

Guarda resultados intermedios en variables para reutilizarlos: más legible y más rápido.

VAR <nombre> = <expresión>
[VAR <nombre> = <expresión>] ...
RETURN <resultado>

Crecimiento % =
VAR Actual = [Total Ventas]
VAR Previo = CALCULATE([Total Ventas],
    SAMEPERIODLASTYEAR(Calendario[Fecha]))
RETURN DIVIDE(Actual - Previo, Previo)