Combinar/Buscar con Condiciones

Lo siento, realmente aprecio su ayuda, pero simplemente no estoy siguiendo lo que está pidiendo, he enviado todo el código que he utilizado, no sólo fragmentos

Después de hacer la combinación inicial, sin condiciones, lo siguiente se pega en la barra de fórmulas para agregar la condición

= Table.NestedJoin(
            #"Application_Versions", 
            {"state"}, 
            Table.SelectRows(#"LookupTable", each [CodeSet] = "TrueFalse"), 
            {"Value"}, 
            "LookupTable", 
            JoinKind.LeftOuter
        )

En este punto, el editor avanzado tiene lo siguiente

let
    Source     = 
        Table.NestedJoin(
            #"Application_Versions", 
            {"state"}, 
            Table.SelectRows(#"LookupTable", each [CodeSet] = "TrueFalse"), 
            {"Value"}, 
            "LookupTable", 
            JoinKind.LeftOuter
        )
in
    Source

A continuación, expando las columnas de la tabla combinada para seleccionar DisplayValue

Luego sigo adelante y hago otra combinación sin condiciones y una vez completado, pegar en el código ajustado para apptype codeset

= Table.NestedJoin(
            #"Application_Versions", 
            {"type"}, 
            Table.SelectRows(#"LookupTable", each [CodeSet] = "AppType"), 
            {"Value"}, 
            "LookupTable", 
            JoinKind.LeftOuter
        )

Estoy suponiendo que está sugiriendo que la primera fusión debe ajustarse para incluir la 2a condición, en lugar de hacer una 2a fusión en la nueva condición.

No sigo el código que enviaste o a dónde estás sugiriendo que esto debería ir, o de hecho qué punto en el proceso es que se utiliza (si es que en absoluto). es decir, hago una combinación normal y luego pego con ese código (como he estado haciendo, pero en su lugar con 2 condiciones), o es algo más que debería estar haciendo?

    #"Changed Type" = Table.TransformColumnTypes(Source,{{"Type", Int64.Type}, {"State", Int64.Type}}),
    #"Merged Queries" = 
        Table.NestedJoin(
            #"Changed Type", 
            {"Type"}, 
            Table.SelectRows(#"Lookup Table", each [Codeset] = "AppType"), 
            {"Value"}, 
            "Lookup Table", 
            JoinKind.LeftOuter
        ),
    #"Expanded Lookup Table" = Table.ExpandTableColumn(#"Merged Queries", "Lookup Table", {"DisplayValue"}, {"DisplayValue"}),
    #"Merged Queries1" = 
        Table.NestedJoin(
            #"Expanded Lookup Table", 
            {"State"}, 
            Table.SelectRows(#"Lookup Table", each [Codeset] = "TrueFalse"), 
            {"Value"}, 
            "Lookup Table", 
            JoinKind.LeftOuter
        ),
    #"Expanded Lookup Table1" = Table.ExpandTableColumn(#"Merged Queries1", "Lookup Table", {"DisplayValue"}, {"DisplayValue.1"})
in
    #"Expanded Lookup Table1"

Su código anterior

Retrocedamos un segundo @sprotson 😁

Permítanme publicar mi código M completo aquí:

let
    Source = Table.FromRows(Json.Document(Binary.Decompress(Binary.FromText("i45WciwoMFTSUQJhA6VYHbCAEbqAMZADEYQKmKALmAI5xhCBWAA=", BinaryEncoding.Base64), Compression.Deflate)), let _t = ((type nullable text) meta [Serialized.Text = true]) in type table [Name = _t, Type = _t, State = _t]),
    #"Changed Type" = Table.TransformColumnTypes(Source,{{"Type", Int64.Type}, {"State", Int64.Type}}),
    #"Merged Queries" = 
        Table.NestedJoin(
            #"Changed Type", 
            {"Type"}, 
            Table.SelectRows(#"Lookup Table", each [Codeset] = "AppType"), 
            {"Value"}, 
            "Lookup Table", 
            JoinKind.LeftOuter
        ),
    #"Expanded Lookup Table" = Table.ExpandTableColumn(#"Merged Queries", "Lookup Table", {"DisplayValue"}, {"DisplayValue"}),
    #"Merged Queries1" = 
        Table.NestedJoin(
            #"Expanded Lookup Table", 
            {"State"}, 
            Table.SelectRows(#"Lookup Table", each [Codeset] = "TrueFalse"), 
            {"Value"}, 
            "Lookup Table", 
            JoinKind.LeftOuter
        ),
    #"Expanded Lookup Table1" = Table.ExpandTableColumn(#"Merged Queries1", "Lookup Table", {"DisplayValue"}, {"DisplayValue.1"})
in
    #"Expanded Lookup Table1"

ANd el código para la tabla de búsqueda (lo anterior devuelve errores hasta que ambas tablas están en Power Query)

let
    Source = Table.FromRows(Json.Document(Binary.Decompress(Binary.FromText("i45WMlTSUXJxAhKOBQUhlQWpSrE60UpGQH5walFZahGahDFIdWpxdkl+AZqMAZAfEhTqCqKKSlPdEnOKIRIgC9wcfYLRZGIB", BinaryEncoding.Base64), Compression.Deflate)), let _t = ((type nullable text) meta [Serialized.Text = true]) in type table [Value = _t, DisplayValue = _t, Codeset = _t]),
    #"Changed Type" = Table.TransformColumnTypes(Source,{{"Value", Int64.Type}})
in
    #"Changed Type"

Por lo tanto, anteriormente, los pasos son los siguientes:

1. Origen y Tipo cambiado son sólo yo pegando datos en el modelo. Tendría un origen de datos real allí y puede o no tener ningún tipo modificado. SQL ServerSQL Server no requiere esto, por ejemplo.
2. Consultas combinadas es la primera combinación. Hice esto a través de la interfaz de usuario sin condiciones. THen, edité el código para eliminar la referencia a sólo la "Tabla de búsqueda" y lo reemplaqué con una tabla filtrada usando Table.SelectRows("Tabla de búsqueda", cada [Codeset] á "AppType")
3. Luego expandí la columna que quería, DisplayValue.
4. Luego creé otra combinación a través de la interfaz de usuario y creó la fórmula para mí. Una vez más, me des hice de la rfruta "Tabla de búsqueda" y lo reemplaqué con otra tabla filtrada - Table.SelectRows("Lookup Table", cada [Codeset] - "TrueFalse")
5. A continuación, expandí la columna DisplayColumns de nuevo.

Nada se pierde. sigue agregando las columnas.

Si está viendo que las cosas desaparecen, es probable que se deba a que está editando el código manualmente y no teniendo en cuenta el primer parámetro de todas las funciones Table.XXXX(). Si reemplazó mis 2a Consultas Combinadas anteriores con esto:

    #"Merged Queries1" = 
        Table.NestedJoin(
            #"Changed Type", 
            {"State"}, 
            Table.SelectRows(#"Lookup Table", each [Codeset] = "TrueFalse"), 
            {"Value"}, 
            "Lookup Table", 
            JoinKind.LeftOuter
        )

sería volver al paso #Changed Tipo omitiendo el primer paso Consultas combinadas, por lo que en ese caso, la primera combinación desaparecerá de los resultados, además de que saltó de nuevo a una tabla anterior. #Changed Pasos no es el nombre de un paso, es el nombre de la tabla de la que ha cambiado los tipos de datos. Consultas combinadas no es el nombre de un paso, es el nombre de una tabla que tiene una operación de combinación en ella.

Tenga en cuenta que los "nombres de paso" también pueden ser listas, registros y valores escalares en función de lo que esté haciendo, pero siempre son un objeto de algún tipo.

¿Eso ayuda?

Realmente aprecio toda su ayuda y especialmente el tiempo que ha pasado en esto, pero simplemente no sigo los pasos que está tomando y más específicamente el código exacto que está escribiendo en cada paso.

¿Es posible que usted haga un registro de pantalla corta para mostrarme el proceso ya que no estoy recibiendo esto, y detalla exactamente el código que está etering en cada paso.

Creo que verlo visualmente ayudaría mucho

Si usted no es capaz de hacer esto, y estoy seguro de que entiende que es una gran pregunta, entonces creo que probablemente voy a ir con la opción de duplicar la tabla de búsqueda, filtrar y fusionar varias veces

Gracias

Creo que este podría ser mi código M después de hacer la segunda fusión y luego ajustar la fórmula

// Application_Versions
let
    Source = Table.NestedJoin(ApplicationCME, {"Key"}, ConfigurationItemVersion, {"Key"}, "ConfigurationItemVersion", JoinKind.Inner),
    #"Expanded ConfigurationItemVersion" = Table.ExpandTableColumn(Source, "ConfigurationItemVersion", {"AddedDate", "UpdatedBy", "IsDeleted"}, {"ConfigurationItemVersion.AddedDate", "ConfigurationItemVersion.UpdatedBy", "ConfigurationItemVersion.IsDeleted"})
in
    #"Expanded ConfigurationItemVersion"

// LookupTable
let
    Source = Sql.Database("77.74.194.165,49000", "GK_Test_649_Spotlight_Demo1", [CreateNavigationProperties=false]),
    dbo_LookupTable = Source{[Schema="dbo",Item="LookupTable"]}[Data],
    #"Filtered Rows" = Table.SelectRows(dbo_LookupTable, each true)
in
    #"Filtered Rows"

// Merge1
let
    Source = Table.NestedJoin(
            #"Application_Versions", 
            {"type"}, 
            Table.SelectRows(#"LookupTable", each [CodeSet] = "AppType"), 
            {"Value"}, 
            "LookupTable", 
            JoinKind.LeftOuter
        ),
    #"Expanded LookupTable" = Table.ExpandTableColumn(Source, "LookupTable", {"DisplayValue"}, {"LookupTable.DisplayValue"}),
    #"Renamed Columns" = Table.RenameColumns(#"Expanded LookupTable",{{"LookupTable.DisplayValue", "AppType"}}),
    #"Merged Queries" = Table.NestedJoin(
            #"Application_Versions", 
            {"state"}, 
            Table.SelectRows(#"LookupTable", each [CodeSet] = "TrueFalse"), 
            {"Value"}, 
            "LookupTable", 
            JoinKind.LeftOuter
        ),
    #"Expanded LookupTable1" = Table.ExpandTableColumn(#"Merged Queries", "LookupTable", {"DisplayValue"}, {"LookupTable.DisplayValue"}),
    #"Renamed Columns1" = Table.RenameColumns(#"Expanded LookupTable1",{{"LookupTable.DisplayValue", "StateEnabled"}})
in
    #"Renamed Columns1"

Utilice este código M para Combinar 1.

// Merge1
let
    Source = Table.NestedJoin(
            #"Application_Versions", 
            {"type"}, 
            Table.SelectRows(#"LookupTable", each [CodeSet] = "AppType"), 
            {"Value"}, 
            "LookupTable", 
            JoinKind.LeftOuter
        ),
    #"Expanded LookupTable" = Table.ExpandTableColumn(Source, "LookupTable", {"DisplayValue"}, {"LookupTable.DisplayValue"}),
    #"Renamed Columns" = Table.RenameColumns(#"Expanded LookupTable",{{"LookupTable.DisplayValue", "AppType"}}),
    #"Merged Queries" = Table.NestedJoin(
            #"Renamed Columns", 
            {"state"}, 
            Table.SelectRows(#"LookupTable", each [CodeSet] = "TrueFalse"), 
            {"Value"}, 
            "LookupTable", 
            JoinKind.LeftOuter
        ),
    #"Expanded LookupTable1" = Table.ExpandTableColumn(#"Merged Queries", "LookupTable", {"DisplayValue"}, {"LookupTable.DisplayValue"}),
    #"Renamed Columns1" = Table.RenameColumns(#"Expanded LookupTable1",{{"LookupTable.DisplayValue", "StateEnabled"}})
in
    #"Renamed Columns1"

Ambas funciones De Table.NestedJoin() estaban utilizando "Versiones de la aplicación" como la primera tabla. Así que la segunda unión estaba ignorando la primera. La 2a unión debe basarse en la tabla "Columnas renombradas", el paso justo encima de ella.

Gracias - eso tiene sentido ahora

Cada vez que hago una nueva combinación (para agregar 1 columna más), necesito combinar como nuevo con la referencia de fórmula a la tabla combinada anterior. De esta manera, la columna agregada anteriormente (de la combinación anterior) permanece

Es una solución que usa fórmulas en lugar de filtrar, pero todavía significa tener varias tablas Merge, a diferencia de varias tablas LookUp (filtradas). Digamos que tengo 10 códigos de búsqueda distintos, así que tendría que hacer 10 combinaciones , lo que da el mismo número de consultas que cuando tengo 10 tablas de búsqueda filtradas separadas.

Creo que puedo optar por la solución original, ya que creo que es más fácil de administrar, y en realidad las tablas de búsqueda filtradas se pueden combinar con otras tablas en mi modelo si es necesario - ya que algunos de los códigos se utilizan en otro lugar

Idealmente, sería bueno tener una fórmula que me permita hacer 1 combinación y agregar múltiples columnas todas desde la misma tabla - es decir, AppType, State, etc. desde una sola fórmula/merge

No creo que sea una fusión, más como una búsqueda condicional de algún tipo

¿Hay algún tipo de fórmula que se pueda usar en una "Columna personalizada" que me permita tomar una columna de la tabla de búsqueda basada en una condición y, a continuación, agregar otra columna personalizada basada en otra condición?

¿Alguna idea de si podría usar una columna cusotm para recuperar los datos en lugar de una combinación?

Realmente no sé nada sobre M Code, así que soy bastante despistó por dónde empezar

Algunas cosas:

"Cada vez que hago una nueva combinación (para agregar 1 columna más), necesito combinar como nuevo con la referencia de fórmula a la tabla combinada anterior. De esta manera, la columna agregada anteriormente (de la combinación anterior) permanece

Es una solución que usa fórmulas en lugar de filtrar, pero todavía significa tener varias tablas Merge, a diferencia de varias tablas LookUp (filtradas). Digamos que tengo 10 códigos de búsqueda distintos, así que tendría que hacer 10 combinaciones, lo que da el mismo número de consultas que cuando tengo 10 tablas de búsqueda filtradas separadas."

Te fusionas como normal. A continuación, edite el código. Está tratando de hacer todo en el editor avanzado y así es como su 2nd Merge hizo referencia a la tabla original. Todo en M son fórmulas. Todo. Un filtro es la fórmula que utiliza la función Table.SelectRows(). Una combinación es una fórmula que utiliza la función Table.NestedJoin().

Puede hacer los 10 "códigos de búsqueda" en una combinación. Su Table.SelectRows se vería así:

Table.SelectRows(SourceTable, each ([Field1] = 1) and ([Field2] = 2) and ([Field3] = 3))

Y así sucesivamente.

Pero estoy de acuerdo, si pre-filtrar la mesa para otros usos tiene más sentido para usted, hálo de esa manera. Hay bien o mal, hay mejor o peor desde el punto de vista de que es más fácil de mantener con el tiempo, y que se mitiga la posibilidad de error mejor.

No sé por qué crees que lo que publiqué no es una fusión. Lo es, con una condición. Tengo una entrada de blog que sale en esto el 8 de septiembre en mi sitio, pero como spoiler, lo que publiqué pliegues, y se pliega como una fusión. Se trata de la instrucción SQL que Power Query se pliega en SQL Server. Pre-filtra la tabla, luego hace la combinación, en un paso. El servidor hace todo el trabajo. Todavía funciona para archivos planos y fuentes no plegables, así, sólo será más lento porque el 100% del trabajo tiene que ser realizado por Power Query - ese es el caso sin importar qué método utilice.

En mi opinión, no desea ir por la ruta de las "columnas de búsqueda" en Power Query. No es eficiente y las búsquedas en otras tablas, 10.000 filas? No hay problema. ¿1.000.000 de filas? Nunca terminará. Power Query no es Excel y VLOOKUP y sus equivalentes, aunque son posibles en Power Query, son generalmente muy ineficientes. Los evito en todos menos en los modelos más pequeños.

''Idealmente, sería bueno tener una fórmula que me permita hacer 1 combinación y agregar múltiples columnas todas desde la misma tabla - es decir, AppType, State etc desde una sola fórmula/merge"

No entiendo este comentario en absoluto. Siempre puede expandir cualquiera/todas las columnas de la tabla combinada (2a) siempre que la condción de combinación sea la misma. No se puede expandir la columna 1 si el campo 1 es "A" y la columna 2 si el campo 2 es "B", es decir, dos fusiones independientes, ya que no se pueden combinar ([Campo 1] a "A") y ([Campo 2] a "B") ya que esa lógica no es lo que desea. Está pensando en términos de Excel que tiene una fórmula compuesta con un montón de instrucciones IF() anidadas, o una instrucción IFS(). De nuevo, Power Query no es Excel. Podrías hacerlo en DAX usando un montón de IF() con funciones LOOKUPVALUE(), pero eso sería lento y difícil de mantener. Dudo que vaya por ese camino. Realice el modelado de datos en Power Query o en el sistema de origen, no en DAX.

Gracias - Creo que voy a hacer esto con múltiples tablas de búsqueda, cada

La razón por la que necesito hacer fusiones multipel, es que todos los datos que quiero exponer están en la misma columna de la tabla de búsqueda. Me fusiono en función de 1 condición, expongo la columna, la fusiono en otra condición y, a continuación, expongo la misma columna de nuevo.

A continuación se muestra una muestra de lo que estaría en la tabla de búsqueda, como ves, todos los valores que quiero recuperar y diaply en diferentes columnas están todos dentro de la columna "DisplayValue"

Aquí están los resultados finales de hacer 3 fusiones

1 es state-value y codeset - TrueFalse

2 es Tipo-valores y conjunto de códigos - AppType

3 es Server-value y codeset - FalseTrue

Las columnas 2, 3 y 4 son de la consulta original y las columnas 5,6 y 7 son las columnas DisplayValue expuestas de las fusiones 1, 2 y 3

Espero que tenga sentido por qué creo que necesito hacer múltiples fusiones, ya que los datos siempre están en la misma columna cada vez

Como dije anteriormente, tener varias tablas de búsqueda (cada una filtrada) es similar a lo que tendría que hacer en sql - así que voy a ir con ese methodologu

Gracias por tu ayuda