Si trabajas con grandes volúmenes de datos desde SQL Server, seguramente usas Power Query en Excel o Power BI para conectar, transformar y visualizar esa información. Pero, ¿te has encontrado modificando una y otra vez tu consulta SQL para cambiar un rango de fechas, un código de producto o el nombre de un cliente? Es un proceso repetitivo y propenso a errores.

¡Hay una forma mucho mejor de hacerlo! Hoy te mostraré cómo usar parámetros para crear consultas SQL dinámicas que puedes actualizar sin tocar una sola línea de código M.

¿Por Qué Usar Consultas Dinámicas?

Mira el video

Imagina que tienes un informe de ventas y tu jefe te pide los datos de diferentes rangos de productos y fechas varias veces al día. La forma tradicional sería:

1. Abrir el Editor Avanzado de Power Query.
2. Buscar la línea WHERE en tu código SQL.
3. Cambiar los valores manualmente.
4. Probar que no rompiste nada.
5. Repetir.

Con una consulta dinámica, simplemente cambias los valores en una tabla o un menú de parámetros y Power Query hace el resto. Los beneficios son claros:

• Ahorro de tiempo: Actualiza tus filtros en segundos.
• Menos errores: Evitas romper el código SQL por un error de sintaxis.
• Flexibilidad: Permites que otros usuarios (incluso sin conocimientos de SQL) puedan filtrar los informes.

Creando la Magia: Value.NativeQuery y Parámetros

La clave para lograr esto es la función Value.NativeQuery. A diferencia de simplemente pegar un SQL en el asistente, esta función nos permite pasar parámetros de forma segura y eficiente, una técnica conocida como query folding.

Veamos un ejemplo práctico. Supongamos que queremos obtener las ventas de la base de datos de ejemplo AdventureWorksDW2022 filtrando por un rango de ProductKey y una OrderDate específica.

Este sería el código M que usarías en el Editor Avanzado de Power Query:

Fragmento de código

let
    Source = Sql.Database(".\SQLEXPRESS", "AdventureWorksDW2022"),
    min=parametros[MIN]{0},
    max=parametros[MAX]{0},
    fecha=parametros[FECHA]{0},
    query_sql=
    Value.NativeQuery(Source,
        "
        select top 10 *
        from FactInternetSales s
        where s.ProductKey>@Min and s.ProductKey<@Max and s.OrderDate = @Date
        ",
        [Min=min,Max=max,Date=fecha])
in
    query_sql

Explicación del Código

Analicemos qué hace cada parte de este script:

1. Source = Sql.Database(...) Esta línea es simple: establece la conexión con nuestro servidor SQL Server (.\SQLEXPRESS) y la base de datos específica (AdventureWorksDW2022).
2. min=parametros[MIN]{0}, max=parametros[MAX]{0} y fecha=parametros[FECHA]{0} Aquí es donde definimos nuestras variables locales en Power Query. Estamos asumiendo que existe una tabla o consulta llamada parametros que contiene los valores que queremos usar.
   • parametros[MIN]{0} busca la columna MIN en la tabla parametros y toma el valor de la primera fila ({0}).
   • Hacemos lo mismo para MAX y FECHA. Esta tabla parametros puede ser una tabla que creaste manualmente en Power Query o incluso un rango de celdas de tu hoja de Excel.
3. query_sql = Value.NativeQuery(...) Esta es la función principal. Recibe tres argumentos:
   • El origen de datos (Source): Nuestra conexión a la base de datos que definimos en el primer paso.
   • El texto de la consulta SQL: Fíjate bien en el WHERE. Usamos @Min, @Max y @Date como marcadores de posición (placeholders). Estos no son variables de Power Query, sino parámetros estándar de SQL.
   • El registro de parámetros ([Min=min, Max=max, Date=fecha]): Este es el puente que conecta todo. Aquí le decimos a Power Query cómo “rellenar” los placeholders del SQL.
     • Min=min: Asigna el valor de nuestra variable min (de Power Query) al parámetro @Min del SQL.
     • Max=max: Asigna el valor de max al parámetro @Max.
     • Date=fecha: Asigna el valor de fecha al parámetro @Date.
4. in query_sql Finalmente, esta línea le dice a Power Query que el resultado final de esta consulta es el que se obtiene en el paso query_sql.

Conclusión: Un Flujo de Trabajo Más Inteligente

Al adoptar este método, transformas tus informes estáticos en herramientas de análisis dinámicas y reutilizables. La próxima vez que necesites filtrar tus datos, en lugar de sumergirte en el código, simplemente actualizarás los valores en tu tabla de parámetros, refrescarás la consulta y ¡listo!

Es una técnica sencilla que marca una gran diferencia en la eficiencia y robustez de tus proyectos con Power Query y SQL Server.