Combinar/Buscar con Condiciones

[sprotson]

Soy un novato completo de Power BI, pero tengo algunos conocimientos SQL limitados, así que por favor desnuda conmigo

Mi escenario es el siguiente

Table1 contiene una columna llamada type (1,2,3 etc.)

Table2 contiene 3 columnas, Value (1,2,3 etc), DisplayValue (a, b, c, etc.) y Code (Code1, Code2, Code3, etc.)

Básicamente quiero buscar la columna de tipo de Table1 en la tabla 2 y devolver la columna DisplayValue si coinciden y si el código es un valor determinado. Sería preferible si el tipo se reemplazara con DisplayValue, pero podría hacer frente a tener ambas columnas. Quiero hacerlo en Power Query, así que puedo despocupar la fecha

En SQL haría algo como lo siguiente para unir las tablas y luego seleccionar qué columnas quería mostrar

Seleccione tipo, Valor, Valor de visualización, Código

De la Tabla 1

Combinación interna Table2 en Table1.type-Table2.value y Table2.Code á 'Code1'

No veo ninguna opción en Power Query para combinar tablas en condiciones.

Espero que alguien se haya encontrado con esto antes y pueda ofrecer una solución

Gracias

[edhans · Accepted solution]

@sprotson La forma de hacerlo es

1. Filtre la primera tabla para la condición que desee.
2. A continuación, combínese con la otra tabla.

Si no desea que la primera tabla se filtre de esta manera, cree una referencia a ella y, a continuación, realice la combinación con la 2a tabla en la consulta a la que se hace referencia.

Si desea más ayuda, por favor dénos algunos datos reales para que podamos trabajar a través del código y mostrarle qué hacer.

Cómo obtener una buena ayuda rápidamente. Ayúdanos a ayudarte.
Cómo obtener respuestas a su pregunta rápidamente
Cómo proporcionar datos de ejemplo en el foro de Power BI

[sprotson]

Gracias por el consejo - que es en realidad lo primero que intenté antes de publicar, lo conseguí para trabajar, pero esperaba que hubiera tal vez una solución más elegante utilizando la funcionalidad incorporada, fórmulas o código

Tabla 2 es probable que tenga aproximadamente 100 + códigos y creo que tal vez 10 de estos pueden estar posiblemente en la tabla 1.

En mi ejemplo, dije que la combinación estaría en table1.type-table2.value y table2.code', pero habrá más combinaciones, como table1.state-table2.value y table2.code' 'code2'.

Esto significa que necesitaré crear 10 duplicados o tablas de referencia, filtrar cada una de manera diferente y luego unir cada una a la tabla 1. Esto es realmente la misma manera que lo haría en sql, pero esperaba de alguna manera tirar de los datos de nuevo en nuevas columnas con una acción basada en múltiples condiciones en las combinaciones para ahorrar tener tantas tablas - pero hey ho

La solución sql con 2 códigos sería

SELECT App.name, App.type, LT1. DisplayValue, App.state, LT2. Estado DisplayValue AS
DE dbo. Aplicación como aplicación INNER JOIN
dbo. LookupTable AS LT1 ON App.type - LT1. Valor y LT1. Código: 'AppType' INNER JOIN
dbo. LookupTable AS LT2 ON App.state á LT2. Valor Y LT2. Código : 'TrueFalse'

Agradezco su pronta respuesta y solución.

[edhans]

Si funciona, esa puede ser la solución. Está integrado en No se puede pensar en código SQL y vaya "ok, ¿cómo implemento este código en Power Query." Power Query funciona muy parecido a SQL, pero no es SQL y, como herramienta de transformación principal, tiene diferentes características.

Una vez más, si puede proporcionar datos, podemos ayudar más.

Cómo obtener una buena ayuda rápidamente. Ayúdanos a ayudarte.
Cómo obtener respuestas a su pregunta rápidamente
Cómo proporcionar datos de ejemplo en el foro de Power BI

[sprotson]

Aprecio que no puedo seguir pensando en cómo hacerlo en SQL, pero esencialmente la solución Merge/Filter es la misma que se haría en Excel, así que pensar que de esa manera me ha servido bien en términos de este escenario

La razón por la que hice la pregunta fue para tratar de obtener una solución que era más limpia y no como sql

A continuación se muestran algunos datos de muestra con 2 códigos, si tiene tiempo para buscar más

Tabla de aplicaciones

Nombre	Tipo	Estado
App1	1	0
App2	1	0
App3	2	1
App4	2	1
App5	3	1

LookupTable

Valor	DisplayValue	Codeset
1	Db	AppType
2	Servidor	AppType
3	Escritorio	AppType
0	Verdad	TrueFalse
1	Falso	TrueFalse

Resultados que me gustaría

Nombre	Tipo	Estado
App1	Db	Verdad
App2	Db	Verdad
App3	Servidor	Falso
App4	Servidor	Falso
App5	Escritorio	Falso

Salud

[edhans]

Hey @sprotson , esto es interesante. Nunca he pensado en probar esto. Aquí está el código de un Join - este exterior izquierdo, pero interno, anti, lo que sea, esta es la fórmula básica. El parámetro "Tabla de búsqueda" es una referencia a la tabla de búsqueda. Eso es a lo que te estás uniendo.

Table.NestedJoin(#"Changed Type", {"Type"}, #"Lookup Table", {"Value"}, "Lookup Table", JoinKind.LeftOuter)

Entonces, ¿qué pasa si reemplazamos eso con un Table.SelectRows?

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

Ahora solo combina datos de la tabla de búsqueda si Codeset es AppType.

No estoy seguro de que haya seguido su necesidad de empezar a terminar como algunos de sus nombres de columna cambiaron. Tenías Tipo en una tabla, Valor en otra, etc.

Pero hacer una combinación regular (función superior) devuelve esto, que no es lo que desea.

Mi código modificado, aunque devuelve esto:

Los conjuntos de códigos TRUE/FALSE no están en esto.

Por lo tanto, no creo que esto sea diferente en segundo plano en cuanto a cómo recomendé en primer lugar, pero ahora está en una línea de código y no necesita una consulta de referencia para hacer referencia.

Pero, usted tiene que editar manualmente el código M para hacer esto. No se puede hacer a través de las herramientas de interfaz de usuario.

Avísame si eso es un poco más punto para ti.

[sprotson]

Gracias - que funciona perfectamente cuando hago la fusión una vez - por ejemplo en el tipo -valor & conjunto de códigos " 'AppType'

Tan pronto como intente hacer otra combinación con la tabla de búsqueda, esta vez en state-value & codeset á 'TrueFalse'. a continuación, pierdo el DisplayValue anterior (cuando expando las columnas de la tabla de búsqueda) de la primera combinación. incluso si hago Combinar como nuevo.

Supongo que sólo se puede fusionar a la misma mesa una vez

Creo que voy a ir con la metodología de la tabla de búsqueda duplicada / referencia

Apreciamos toda tu ayuda - aplausos

[edhans]

Funciona bien. Sospecho que su última declaración de "in" llamó al paso equivocado.

    #"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"

Puedes hacer tantos como quieras. No se perderá nada de un paso anterior.

[sprotson]

Gracias por su respuesta de nuevo, pero no estoy seguro de estar siguiendo

Como dije, soy un completo novato, así que por favor disculpe mi ignorancia

El proceso que sigo es usar la función de interfaz de usuario Combinar como nuevo con las tablas siguientes - Application_Versions con LookupTable en el tipo .

Esto crea una nueva consulta llamada "Merge1"

A continuación, ajusto lo que está en la barra formaual con lo siguiente para que la combinación sea condicional

• Table.NestedJoin(
"Application_Versions",
"tipo",
Table.SelectRows('LookupTable'", cada [CodeSet] á "AppType"),
"Valor",
"LookupTable",
JoinKind.LeftOuter
)

Si entonces miro el editor avanzado, tiene lo siguiente

Dejar
Fuente ?
Table.NestedJoin(
"Application_Versions",
"tipo",
Table.SelectRows('LookupTable'", cada [CodeSet] á "AppType"),
"Valor",
"LookupTable",
JoinKind.LeftOuter
)
En
Fuente

A continuación, puedo decidir qué columnas de LookupTable incluir en la nueva consulta.

El siguiente paso que sigo es hacer otra combinación, esta vez Merge1 con LookupTable en state-value. A continuación, me ajustaría como antes para agregar la condición de conjunto de códigos en la fórmula como tal

"Application_Versions",
"estado",
Table.SelectRows('LookupTable'", cada [CodeSet] á "TrueFalse"),
"Valor",
"LookupTable",
JoinKind.LeftOuter
)

Antes de ajustar el foral puedo ver las columnas de LookuTable previamente seleccionadas, pero después del ajuste se han ido. Esto tiene sentido, ya que seguramente no sería capaz de seleccionar la misma columna de la misma tabla de nuevo

No estoy seguro de dónde va su código, en qué momento se utiliza en mi proceso o si necesito hacer cualquiera de los pasos en mi proceso

Salud

[edhans]

Muéstrame el código M de consulta completo y usa el cuadro de código si es posible - el icono </>.

Pero creo que el problema son las dos últimas líneas de su consulta completa son:

in
   Source

Debe ser:

in
    #"Application_Versions"

pero necesitaría ver la consulta M completa para estar seguro. Sólo veo snippits.

[sprotson]

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

[edhans]

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?

[sprotson]

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

[sprotson]

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"

[edhans]

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.

[sprotson]

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?

[edhans]

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.

[sprotson]

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"

Valor	DisplayValue	Codeset
0	Habilitado	TrueFalse
1	Deshabilitado	TrueFalse
2	Chat	AppType
3	Correo electrónico	AppType
1	Verdad	FalseTrue
0	Falso	FalseTrue

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

BCID	Estado	Tipo	Servidor	State_Readable	Type_Readable	Server_Readable
1	0	2	1	Habilitado	Chat	Verdad
2	0	2	1	Habilitado	Chat	Verdad
3	0	3	1	Habilitado	Correo electrónico	Verdad
4	1	3	0	Deshabilitado	Correo electrónico	Falso
5	1	3	0	Deshabilitado	Correo electrónico	Falso

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

[sprotson]

¿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

[amitchandak]

@sprotson , en la consulta de energía tiene que combinar y, a continuación, quitar o realizar alguna operación.

recomienda

https://eriksvensen.wordpress.com/2019/02/28/powerquery-replicate-doing-an-excel-vlookup-in-m/

https://www.myonlinetraininghub.com/excel-power-query-vlookup

[Greg_Deckler]

@sprotson- No está seguro acerca de la Power Query aunque parece una situación Table.Join @ImkeF @edhans

En DAX solo usaría LOOKUPVALUE o MAXX(FILTER(...),...)