📊

Funciones de Tabla (Table.*)

El corazón del Lenguaje M. Las funciones Table.* son las que más usarás en cualquier consulta de Power Query: añadir columnas, filtrar filas, agrupar, combinar tablas, pivotar y mucho más.

Intermedio Avanzado

➕

Añadir y Modificar Columnas

Sintaxis

Table.AddColumn(
    tabla as table,
    nombreNuevaColumna as text,
    funcionColumna as function,
    optional tipoColumna as nullable type
) as table

¿Qué hace?

Añade una nueva columna calculada a una tabla. La función se ejecuta para cada fila, permitiéndote crear valores basados en otras columnas de esa misma fila mediante each.

Parámetros

tabla: La tabla a la que añadir la columna
nombreNuevaColumna: Nombre de la columna nueva (tipo text)
funcionColumna: Función que calcula el valor de cada celda. Usa each para acceder a las columnas de cada fila con [NombreColumna]
tipoColumna (opcional): Tipo de dato: type text, type number, type date, etc.

Ejemplo 1: Columna calculada

let
    Ventas = #table(
        {"Producto", "Precio", "Cantidad"},
        {{"Mouse", 15, 10}, {"Teclado", 45, 5}, {"Monitor", 200, 2}}
    ),

    // Añadir columna Total = Precio * Cantidad
    ConTotal = Table.AddColumn(
        Ventas,
        "Total",
        each [Precio] * [Cantidad],
        type number
    )
in
    ConTotal
// Resultado: columna "Total" con valores 150, 225, 400

Ejemplo 2: Columna condicional

Table.AddColumn(
    Ventas,
    "Segmento",
    each if [Precio] > 100 then "Premium"
         else if [Precio] > 30 then "Estándar"
         else "Básico",
    type text
)

💡 Tip kawaii: Especifica siempre el tipoColumna. Ayuda a Power Query a optimizar la consulta y evita conversiones automáticas incorrectas.

Sintaxis

Table.TransformColumns(
    tabla as table,
    transformaciones as list,
    optional defaultTransformation as nullable function,
    optional missingField as nullable number
) as table

¿Qué hace?

Aplica transformaciones a columnas existentes. Es más eficiente que AddColumn + RemoveColumn cuando solo quieres modificar el valor de una columna que ya existe.

Parámetros

tabla: La tabla de origen
transformaciones: Lista de listas con la forma {"NombreColumna", función, tipoOpcional}
defaultTransformation (opcional): Función aplicada a todas las columnas no especificadas
missingField (opcional): Comportamiento si la columna no existe (MissingField.Error, MissingField.Ignore, MissingField.UseNull)

Ejemplo: Transformar múltiples columnas

Table.TransformColumns(
    MiTabla,
    {
        // Poner Nombre en mayúsculas
        {"Nombre", Text.Upper, type text},
        // Redondear Precio a 2 decimales
        {"Precio", each Number.Round(_, 2), type number},
        // Extraer solo el año de Fecha
        {"Fecha", Date.Year, Int64.Type}
    }
)

📌 Buena práctica: Usa Table.TransformColumns cuando quieres modificar columnas ya existentes. Usa Table.AddColumn cuando quieres crear columnas nuevas sin perder las originales.

🔍

Filtrar Filas

Sintaxis

Table.SelectRows(
    tabla as table,
    condicion as function
) as table

¿Qué hace?

Filtra las filas de una tabla manteniendo solo las que cumplen la condición. Es el equivalente en M al WHERE de SQL o al filtro en la interfaz de Power Query.

Ejemplo 1: Filtro simple

// Mantener solo ventas con importe > 1000
Table.SelectRows(
    Ventas,
    each [Importe] > 1000
)

Ejemplo 2: Filtro compuesto

// Ventas de 2024 en España
Table.SelectRows(
    Ventas,
    each Date.Year([Fecha]) = 2024 and [Pais] = "España"
)

// Excluir nulos y valores vacíos
Table.SelectRows(
    Clientes,
    each [Email] <> null and [Email] <> ""
)

💡 Tip kawaii: Table.SelectRows soporta query folding cuando se aplica cerca del origen de datos (SQL, SharePoint, etc.). Esto significa que el filtro se ejecuta en el servidor, no en Power Query — ¡mucho más rápido!

📦

Agrupar y Agregar

Sintaxis

Table.Group(
    tabla as table,
    columnasClave as any,
    agregaciones as list,
    optional groupKind as nullable number,
    optional comparer as nullable function
) as table

¿Qué hace?

Agrupa filas por una o más columnas y aplica funciones de agregación (suma, conteo, promedio…). Es el equivalente al GROUP BY de SQL. Cada grupo puede tener múltiples agregaciones.

Ejemplo 1: Agrupación simple

// Ventas totales por país
Table.Group(
    Ventas,
    "Pais",                    // columna clave
    {
        {"TotalVentas", each List.Sum([Importe]), type number},
        {"NumOperaciones", Table.RowCount, Int64.Type}
    }
)

Ejemplo 2: Agrupación múltiple con varias métricas

// Ventas por país y año con múltiples métricas
Table.Group(
    Ventas,
    {"Pais", "Año"},          // varias columnas clave
    {
        {"Total", each List.Sum([Importe]), type number},
        {"Promedio", each List.Average([Importe]), type number},
        {"Max", each List.Max([Importe]), type number},
        {"Filas", Table.RowCount, Int64.Type}
    }
)

⚠️ Ojo con esto: Table.Group no soporta query folding en la mayoría de conectores. Si tienes millones de filas, considera agregar en la fuente (vista SQL, stored procedure) antes de traer los datos.

🔗

Combinar Tablas

Sintaxis

Table.NestedJoin(
    tabla1 as table,
    columnasClave1 as any,
    tabla2 as any,
    columnasClave2 as any,
    nombreNuevaColumna as text,
    optional tipoJoin as nullable number
) as table

¿Qué hace?

Combina dos tablas mediante una clave común (como un JOIN de SQL). El resultado contiene una columna nueva con la tabla relacionada anidada, que luego puedes expandir.

Tipos de Join disponibles

JoinKind.Inner — Solo filas con coincidencia en ambas tablas
JoinKind.LeftOuter — Todas las filas de tabla1, con NULLs de tabla2
JoinKind.RightOuter — Todas las filas de tabla2, con NULLs de tabla1
JoinKind.FullOuter — Todas las filas de ambas tablas
JoinKind.LeftAnti — Solo filas de tabla1 SIN coincidencia en tabla2

Ejemplo: Left Join con expansión

let
    // Join de Ventas con Clientes por ID
    ConClientes = Table.NestedJoin(
        Ventas,
        "ClienteID",
        Clientes,
        "ID",
        "DatosCliente",
        JoinKind.LeftOuter
    ),

    // Expandir las columnas que necesitamos
    Expandido = Table.ExpandTableColumn(
        ConClientes,
        "DatosCliente",
        {"Nombre", "Email", "Ciudad"},
        {"Cliente.Nombre", "Cliente.Email", "Cliente.Ciudad"}
    )
in
    Expandido

💡 Tip kawaii: Si solo necesitas traer columnas de una tabla relacionada (lookup), considera Table.AddColumn con Table.SelectRows y List.First — a veces es más legible que un NestedJoin + ExpandTableColumn.

Sintaxis

Table.Combine(
    tablas as list,
    optional columnas as any
) as table

¿Qué hace?

Concatena verticalmente una lista de tablas (como UNION ALL en SQL). Las columnas se alinean por nombre. Las columnas que no existen en alguna tabla aparecen como null.

Ejemplo: Combinar tablas de distintos años

let
    Ventas2022 = Excel.Workbook(File.Contents("ventas2022.xlsx")){0}[Data],
    Ventas2023 = Excel.Workbook(File.Contents("ventas2023.xlsx")){0}[Data],
    Ventas2024 = Excel.Workbook(File.Contents("ventas2024.xlsx")){0}[Data],

    // Combinar las tres tablas en una sola
    Todas = Table.Combine({Ventas2022, Ventas2023, Ventas2024})
in
    Todas

🔀

Pivotar y Despivotar

Sintaxis

Table.Pivot(
    tabla as table,
    valoresPivot as list,
    columnaPivot as text,
    columnaValores as text,
    optional agregacion as nullable function
) as table

¿Qué hace?

Convierte filas en columnas: los valores únicos de columnaPivot se convierten en nombres de columna, y los valores de columnaValores rellenan las celdas. Útil para convertir datos en formato largo a formato ancho.

Ejemplo: Convertir meses de filas a columnas

// Datos originales:
// Producto | Mes    | Ventas
// Mouse    | Enero  | 150
// Mouse    | Febrero| 200
// Teclado  | Enero  | 80

Table.Pivot(
    MiTabla,
    {"Enero", "Febrero", "Marzo"},  // valores que se convierten en columnas
    "Mes",                           // columna que contiene esos valores
    "Ventas",                        // columna con los valores a mostrar
    List.Sum                         // función de agregación (si hay duplicados)
)
// Resultado:
// Producto | Enero | Febrero | Marzo
// Mouse    |  150  |   200   | null
// Teclado  |   80  |  null   | null

Sintaxis

Table.UnpivotOtherColumns(
    tabla as table,
    columnasAMantener as list,
    nombreAtributo as text,
    nombreValor as text
) as table

¿Qué hace?

Convierte columnas en filas (unpivot). Mantiene las columnas especificadas como identificadores y "derrite" todas las demás. Fundamental para normalizar datos anchos.

Ejemplo: Normalizar datos de meses

// Datos originales (formato ancho):
// Producto | Enero | Febrero | Marzo
// Mouse    |  150  |   200   |  180

Table.UnpivotOtherColumns(
    MiTabla,
    {"Producto"},   // columnas que se mantienen como están
    "Mes",          // nombre de la nueva columna de atributos
    "Ventas"        // nombre de la nueva columna de valores
)
// Resultado (formato largo):
// Producto | Mes     | Ventas
// Mouse    | Enero   | 150
// Mouse    | Febrero | 200
// Mouse    | Marzo   | 180

💡 Tip kawaii: Usa Table.UnpivotOtherColumns (mantener las columnas ID y despivotar el resto) en lugar de Table.Unpivot (especificar qué columnas despivotar). Es más robusto cuando el número de columnas puede cambiar.

🗂️

Ordenar y Deduplicar

Sintaxis

Table.Distinct(
    tabla as table,
    optional columnasClave as any
) as table

¿Qué hace?

Elimina filas duplicadas. Sin parámetro opcional, compara todas las columnas. Con columnasClave, elimina duplicados basándose solo en esas columnas.

Ejemplo

// Eliminar filas completamente duplicadas
Table.Distinct(MiTabla)

// Eliminar duplicados por una columna (mantiene la primera ocurrencia)
Table.Distinct(MiTabla, "ClienteID")

// Eliminar duplicados por varias columnas
Table.Distinct(MiTabla, {"Pais", "Ciudad"})

Sintaxis

Table.Sort(
    tabla as table,
    criterios as any
) as table

¿Qué hace?

Ordena las filas de la tabla según uno o más criterios. Cada criterio puede ser ascendente (Order.Ascending) o descendente (Order.Descending).

Ejemplo

// Ordenar por una columna (ascendente por defecto)
Table.Sort(MiTabla, "Nombre")

// Ordenar por fecha descendente, luego por importe descendente
Table.Sort(
    MiTabla,
    {
        {"Fecha", Order.Descending},
        {"Importe", Order.Descending}
    }
)

⚠️ Ojo con esto: En la mayoría de casos, el orden de las filas en Power BI no importa (DAX no depende del orden de las tablas). Evita Table.Sort si no es estrictamente necesario — añade tiempo de procesamiento sin beneficio real.

🚀 ¡Vas genial! Las funciones de tabla son el core de M. El siguiente paso natural son las Funciones de Lista, que se usan constantemente dentro de las funciones de tabla para agregar y transformar valores. ¡Vamos allá!