¡Bienvenidos, muy buenos días tardes o noches , según donde me leas !

¡Bienvenidos a estere sumen sobre el curso Power Query sobre estructuras anidadas! , exploraremos diversas técnicas y funciones para trabajar con datos anidados utilizando Power Query/M, aprenderemos a expandir y extraer opciones, realizar operaciones con elementos anidados, acceder a campos, realizar búsquedas y proyecciones, entre otras habilidades clave.

En cada bloque , analizaremos ejemplos prácticos y explicaremos detalladamente el código utilizado (En pocas palabras lo que me llamaron la atención). Prepárate para descubrir nuevas formas de transformar y manipular datos anidados utilizando Power Query.

Curso de power query Power Query/M – Nested Structures

El curso me ha parecido genial , la verdad estuvo estupendo , la pase super cool repasando algunas funciones y viendo otras nuevas para mi así que super el contendio, hoy traigo el reviw de este curso, y unas anotaciones que realice sobre lo que más llamo la atención e mi parte.

Ahora Empecemos

Esta dividido en tres bloques el curso que realice el primero es:

Expand and Extract Options
let

Source = #table(

type table[Key=number, Nested list=list],

{{ 1, { 1, «Bob», «123-4567» }}, { 2, { 2, «Jim», «987-6543» }}, { 3, { 3, «Paul», «543-7890″ }}}

#»Extracted Values» = Table.TransformColumns(Source, {«Nested list», each Text.Combine(List.Transform(_, Text.From), «|»), type text}),

#»Split Column by Delimiter» = Table.SplitColumn(#»Extracted Values», «Nested list», Splitter.SplitTextByDelimiter(«|», QuoteStyle.Csv), {«ID», «Name», «Number»})

#»Split Column by Delimiter»

Define una tabla llamada «Source» con tres filas. Cada fila contiene un número clave (Key) y una lista anidada que contiene tres valores: un número, un nombre y un número de teléfono. La tabla se crea utilizando la función #table y se especifica su tipo y estructura.

Luego, se aplica una transformación a la columna «Nested list» de la tabla «Source» utilizando la función Table.TransformColumns. La transformación convierte la lista anidada en una cadena de texto concatenando sus elementos y separándolos por el carácter «|». La transformación utiliza las funciones List.Transform y Text.Combine para lograr esto.

A continuación, se divide la columna «Nested list» en tres columnas separadas («ID», «Name» y «Number») utilizando la función Table.SplitColumn. Se especifica el delimitador «|» para realizar la separación.

Finalmente, el código devuelve la tabla resultante con las columnas divididas.

En resumen, este código toma una tabla con una columna que contiene una lista anidada, la convierte en una cadena de texto y luego divide esa cadena en columnas separadas.

Tenemos este otro en este maravilloso cursos
let

Source = #table(

type table[Key=number, Nested list=list],

{{ 1, { 1, «Bob», «123-4567» }}, { 2, { 2, «Jim», «987-6543» }}, { 3, { 3, «Paul», «543-7890″ }} }

#»Replaced Value» = Table.ReplaceValue(Source,each [Nested list],each Record.FromList( [Nested list], {«ID», «Name», «Number»}),Replacer.ReplaceValue,{«Nested list»}),

#»Expanded Nested list» = Table.ExpandRecordColumn(#»Replaced Value», «Nested list», {«ID», «Name», «Number»}, {«ID», «Name», «Number»})

#»Expanded Nested list»

Se define una tabla llamada «Source» de la misma manera que en el código anterior, con tres filas que contienen un número clave y una lista anidada.

Se aplica una transformación a la columna «Nested list» de la tabla «Source» utilizando la función Table.ReplaceValue. Esta transformación reemplaza cada valor de la columna «Nested list» con un nuevo valor que se crea utilizando la función Record.FromList. La función Record.FromList toma la lista anidada y la convierte en un registro (record) con tres campos: «ID», «Name» y «Number». Se utiliza el parámetro Replacer.ReplaceValue para indicar que se deben reemplazar los valores en la columna «Nested list» con los registros creados.

A continuación, se expande la columna «Nested list» utilizando la función Table.ExpandRecordColumn. Esta función toma la columna «Nested list» y expande los campos del registro en columnas separadas en la tabla. Se especifican los nombres de los campos («ID», «Name» y «Number») y se proporcionan nuevos nombres para las columnas resultantes.

Tenemos el segundo bloque que es Item, Field Access, Lookup, Selection and Projection

En el cual encontraremos código y explicamos maravillosas como estos :

let

Source = #table(

type table [ID=number, Nested list=list],

{{ 1, {{{ 1, «Bob», «123-4567» }, {}}, {}, {}}}, { 2, {{{ 2, «Jim», «987-6543» }, {}}, {}, {}}}, { 3, {{{ 3, «Paul», «543-7890″ }, {}}, {}, {}} }}

#»Added Custom» = Table.AddColumn(Source, «Custom», each [Nested list]{0}{0}{1} )

#»Added Custom»

Explicandolo un poco más

Se define una tabla llamada «Source» de la misma manera que en los códigos anteriores, con tres filas que contienen un número de identificación (ID) y una lista anidada.

Se agrega una columna personalizada llamada «Custom» a la tabla «Source» utilizando la función Table.AddColumn. Esta columna personalizada se crea utilizando una expresión lambda (la parte each [Nested list]{0}{0}{1}), que se evalúa para cada fila de la tabla. La expresión each se refiere a la fila actual en el contexto de la expresión lambda. La expresión [Nested list]{0}{0}{1} accede a elementos específicos de la lista anidada en cada fila: el primer elemento ({0}) de la lista anidada, luego el primer elemento ({0}) de ese subconjunto, y finalmente el segundo elemento ({1}) de ese subconjunto. En resumen, la columna «Custom» contendrá el segundo elemento de la lista anidada en la posición [0][0][1] de cada fila.

Vamos con otra explicación que me paracio super itersante es let

Source = #table(

type table [Nested record=record],

{

{ [ID =1, Contact ID =1, Name =»Bob», Number =»123-4567″] },

{ [ID =2, Contact ID =1, Name =»Jim», Number =»987-6543″] },

{ [ID =2, Contact ID =2, Name =»Paula», Number =»987-6544″] },

{ [ID =3, Contact ID =1, Name =»Paul», Number =»543-7890″, Likes =»Dogs»] },

{ [ID =3, Contact ID =2, Name =»Rose», Number =»543-7891″, Likes =»Cats»] },

{ [ID =3, Contact ID =3, Name =»Sue», Number =»543-7892″, Likes =»Big bird»] }

}

#»Added Custom» = Table.AddColumn(Source, «Custom», each [Nested record][Name]),

#»Added Custom1″ = Table.AddColumn(#»Added Custom», «Custom.1″, each [Nested record][[Name]]),

#»Added Custom2″ = Table.AddColumn(#»Added Custom1», «Custom.2″, each [Nested record][[Name], [Name2]]),

#»Added Custom3″ = Table.AddColumn(#»Added Custom2», «Custom.3″, each [Nested record][[Name], [Name2]]?),

#»Added Custom4″ = Table.AddColumn(#»Added Custom3», «Custom.4», each Record.SelectFields( [Nested record], { «Name», «Name2″ })),

#»Added Custom5″ = Table.AddColumn(#»Added Custom4», «Custom.5», each Record.SelectFields( [Nested record], { «Name», «Name2″ }, MissingField.UseNull))

#»Added Custom5»

Se define una tabla llamada «Source» con una columna llamada «Nested record» que contiene registros anidados. Cada fila de la tabla tiene un registro anidado con diferentes campos, como «ID», «Contact ID», «Name», «Number», «Likes», entre otros.

Se agrega una columna personalizada llamada «Custom» a la tabla «Source» utilizando la función Table.AddColumn. Esta columna personalizada se crea utilizando una expresión lambda (la parte each [Nested record][Name]), que se evalúa para cada fila de la tabla. La expresión each se refiere a la fila actual en el contexto de la expresión lambda. La expresión [Nested record][Name] accede al campo «Name» dentro del registro anidado en cada fila. En resumen, la columna «Custom» contendrá el valor del campo «Name» de cada registro anidado.

Se repiten los pasos 2-5 para agregar más columnas personalizadas llamadas «Custom.1», «Custom.2», «Custom.3», «Custom.4» y «Custom.5». Cada columna personalizada utiliza diferentes enfoques para acceder y seleccionar campos del registro anidado en cada fila:

«Custom.1» accede al campo «Name» utilizando la sintaxis [[Name]].

«Custom.2» accede a los campos «Name» y «Name2» utilizando la sintaxis [[Name], [Name2]].

«Custom.3» intenta acceder a los campos «Name» y «Name2» utilizando la sintaxis [[Name], [Name2]]?, que devuelve un valor nulo si alguno de los campos no está presente en el registro.

«Custom.4» utiliza la función Record.SelectFields para seleccionar explícitamente los campos «Name» y «Name2» del registro anidado.

«Custom.5» es similar a «Custom.4», pero utiliza el parámetro MissingField.UseNull para reemplazar cualquier campo faltante por un valor nulo.

Como interés generalestuve recopilando las funciones que he usado personalmente y que son interesnates
En Power Query (también conocido como M), hay varias funciones disponibles para trabajar con listas. Estas funciones permiten realizar diversas operaciones y transformaciones en los elementos de una lista. Aquí tienes una explicación de algunas de las funciones más comunes para trabajar con listas en Power Query:

List.Accumulate: Esta función aplica una acumulación a los elementos de una lista. Toma una lista y una función acumuladora como argumentos y devuelve el resultado acumulado.

List.Combine: Combina varias listas en una sola lista. Toma múltiples listas como argumentos y devuelve una lista que contiene todos los elementos de las listas combinadas.

List.Contains: Comprueba si un valor dado está presente en una lista. Toma una lista y un valor como argumentos y devuelve un valor lógico que indica si el valor está presente en la lista.

List.Count: Devuelve el número de elementos en una lista. Toma una lista como argumento y devuelve un número entero que representa la cantidad de elementos en la lista.

List.Distinct: Devuelve una lista que contiene solo los elementos únicos de una lista dada. Elimina los duplicados y conserva el orden original de los elementos.

List.FirstN: Devuelve los primeros n elementos de una lista. Toma una lista y un número entero n como argumentos y devuelve una nueva lista que contiene los primeros n elementos de la lista original.

List.Generate: Genera una lista utilizando una función generadora. Toma una función generadora, una función condicional y una función de transformación como argumentos y devuelve una lista generada según las reglas definidas en las funciones.

List.Max: Devuelve el valor máximo de una lista numérica. Toma una lista numérica como argumento y devuelve el valor máximo encontrado en la lista.

List.Min: Devuelve el valor mínimo de una lista numérica. Toma una lista numérica como argumento y devuelve el valor mínimo encontrado en la lista.

List.Range: Genera una lista de números en un rango dado. Toma un número inicial, un número final y un incremento como argumentos y devuelve una lista que contiene los números en el rango especificado.

Estas son solo algunas de las funciones de tipo lista disponibles en Power Query. Hay muchas más funciones que permiten filtrar, transformar, ordenar y realizar diversas operaciones en las listas. Puedes consultar la documentación oficial de Power Query para obtener una lista completa de las funciones disponibles y sus descripciones detalladas.

Y el ultimo bloque de contenido del curso es :

Transforming Nested Values

let

Source = Table.FromRows(

Json.Document(Binary.Decompress(Binary.FromText(«lZRRS8MwFIX/SunzILk3Sdv4VlAfBlPBx7GHbVYdbG5MJ/jvTZM1rfOEKoRLOelZvnt7lvk8n562GUsy+SQvRSHax4z4Skq3snrmZVJYZ5nQS6S7RfliMs/vTrtVc8z2z9nDcvOU3ewO2/1X07y7F1iXvrKv5KsceuvTS4dbCYhVCYJYTodYlWCNdUVI59EeVOUr9ZWNf5bR/tgcPro+rIBcVhDksoIhl9OrxNjVKDL7sfMQXA699+uI66Zr0DlOJ05t2MQGw8S5pceR7QA81OKHd/8Zkd3AIAAJDEaCIFj7QzB0bkPB1JnxPvzQKXSj/Oi1r2W0Xzfr2ArjtDgdx6X9JjAv7UYqMMX4/5T7pGsTXNE4Xb61vO3nIOGpisvDBVFCr7DOBuntdfMvVmWHd0rw3jarDtdNER3DAlK5tyGVmywndIv06o8tnKuPhy5iDfbZ8rh+7fpQISWXB6lzSH7rDPtW54iAsdtRZuOvO+MjbUy83KO3Phw32w5Y45zoRE50Iic6nROS41PuKdmEqnvz4hs=», BinaryEncoding.Base64), Compression.Deflate)), let _t = ((type nullable text) meta [Serialized.Text = true]) in type table [Description = _t, #»Week Ending» = _t, #»Week Ending_1″ = _t, #»Week Ending_2″ = _t, #»Week Ending_3″ = _t, #»Week Ending_4″ = _t, Index = _t]),

#»Grouped Rows» = Table.Group(Source, {«Index»}, {{«AllRows», each _, type table [Description=nullable text, Week Ending=nullable text, Week Ending_1=nullable text, Week Ending_2=nullable text, Week Ending_3=nullable text, Week Ending_4=nullable text, Index=nullable text]}}),

#»Added Custom» = Table.AddColumn(#»Grouped Rows», «Custom», each

let

#»Removed Columns» = Table.RemoveColumns([AllRows],{«Description», «Index»}),

#»Transposed Table» = Table.Transpose(#»Removed Columns»),

#»Filtered Rows» = Table.SelectRows(#»Transposed Table», each ([Column2] <> «»))

#»Filtered Rows»

#»Removed Other Columns» = Table.SelectColumns(#»Added Custom»,{«Custom»}),

#»Expanded Custom» = Table.ExpandTableColumn(#»Removed Other Columns», «Custom», {«Column1», «Column2»}, {«Column1», «Column2″})

#»Expanded Custom»

En este caso hice un explicación , esta fue una de varias que me llamo la atención :

Se crea una tabla llamada «Source» utilizando la función Table.FromRows. La tabla se construye a partir de datos en formato comprimido (utilizando compresión Deflate) que se convierten a texto y luego se descomprimen. La estructura de la tabla incluye columnas como «Description», «Week Ending», «Week Ending_1», «Week Ending_2», «Week Ending_3», «Week Ending_4» y «Index».

La tabla «Source» se agrupa utilizando la función Table.Group. Se agrupa por la columna «Index» y se crea una nueva columna llamada «AllRows» que contiene todas las filas agrupadas en una tabla.

Se agrega una columna personalizada llamada «Custom» a la tabla resultante de la agrupación. La columna personalizada realiza varias transformaciones en la columna «AllRows»:

Se eliminan las columnas «Description» y «Index» utilizando la función Table.RemoveColumns.

Se realiza una transposición de la tabla utilizando la función Table.Transpose, intercambiando filas por columnas.

Se filtran las filas de la tabla transpuesta para incluir solo aquellas donde el valor de la columna «Column2» no es vacío, utilizando la función Table.SelectRows.

Se selecciona solo la columna «Custom» de la tabla resultante utilizando la función Table.SelectColumns.

Se expande la columna «Custom» utilizando la función Table.ExpandTableColumn para mostrar los valores de las columnas «Column1» y «Column2» en columnas separadas.

Este curso de Power Query sobre estructuras anidadas ha sido una experiencia enriquecedora y emocionante. Hemos explorado diversas técnicas y funciones que nos permiten trabajar de manera eficiente con datos anidados en Power Query/M. A lo largo del curso, hemos revisado ejemplos prácticos y realizado diferentes transformaciones en los datos, desde expandir y extraer opciones hasta acceder a campos, realizar búsquedas y proyecciones.

Estas habilidades nos brindan un mayor control y flexibilidad a la hora de manipular datos complejos y nos ayudan a obtener los resultados deseados de manera más eficiente. ¡Espero que hayas disfrutado de este curso y que puedas aplicar lo aprendido en tus propios proyectos de Power Query!

Vicente Antonio Juan Magallanes

Business Intelligence Technical.