Gist fcc3b4c6bb3d32bd50e83052b67b9e23

100%

Gist fcc3b4c6bb3d32bd50e83052b67b9e23

✓ Published0🌍 Public

Last edited Aug 16, 2017

Created on Aug 16, 2017

The example shows an XMLA (Analysis Services) script that creates a shared expression named “SharedExpression” in a tabular model database. The file, `CreateMExpression.xmla`, uses the `Create` command with a `Batch` transaction to define the expression’s metadata, including its `Name` and `Kind` fields. The expression’s `Expression` property is set to `#shared`, which references Power Query’s shared M function namespace. The code relies on the XMLA protocol for Analysis Services, specifically the `http://schemas.microsoft.com/analysisservices/2014/engine` schema, and includes a rowset definition for the expression’s properties. No data source or rendering is involved; it is a metadata definition for tabular modeling.

AI-generated description

Similar vizzes

Loading thumbnail…

Exposing #shared construct in Azure Analysis Services (change DatabaseID accordingly)

This example shows how to expose the contents of Power Query's `#shared` intrinsic constant inside an Azure Analysis Services tabular model, turning the built-in M function and value registry into a queryable table. The workflow uses three XMLA/TMSL scripts: first, an XMLA `Create` command injects a shared expression named `SharedExpression` that returns `#shared`; second, a TMSL `create` operation defines a table with `Name` and `Value` string columns, pulling data through an M partition expression that references the injected shared expression; finally, a TMSL `refresh` command processes the new table. The result is then viewed with a DAX `evaluate` statement against the `SharedExpressionTable`, demonstrating a round-trip from M metadata to a usable relational structure. The code relies on the XMLA protocol, TMSL JSON APIs, and the M expression engine, with no external visualization library involved.

HHugoberry

83% match

Loading thumbnail…

Create an Azure Analysis Services cube [Mcube] with a single expression [SharedExpression] that is exposed through which contents is exposed through [SharedExpressionTable] table. All for the sake of reaching for the #shared construct

This example demonstrates a self-referential use of the Power Query M formula language inside an Azure Analysis Services tabular model, exposing the `#shared` construct as a table. The TMSL file defines a database named "Mcube" with an M expression called `SharedExpression` that simply returns `#shared`, listing all available M functions and constants. A table named `SharedExpressionTable` then queries this expression via `#sections[main][SharedExpression]` in its partition source, rendering the shared metadata as columns "Name" and "Value." This effectively turns the engine’s own namespace into queryable data, showing how TMSL and M can introspect the environment.

HHugoberry

78% match

Loading thumbnail…

Create an empty cube with contents of #shared

This example demonstrates how to build a cube from scratch by evaluating Power BI’s `#shared` expression, which exposes all available functions and constants. It shows the process of creating a table named `SharedExpressionTable` with `Name` and `Value` columns, populating it via a TMSL script that uses a `#shared` expression as its data source. The workflow then refreshes the table to materialize the data and finally queries it with DAX’s `EVALUATE` statement. The code relies on TMSL and DAX APIs—no external visualization libraries—highlighting the direct interplay between Tabular Model Scripting Language and Power BI’s expression engine.

HHugoberry

75% match

Loading thumbnail…

Gist adad8e220a1e17f2d97fbabd7315d685

This example shows how to create a Tableau data extract from a shared expression table, mapping source columns `Name` and `Value` into a two-column table within the `tab` database. The code uses the Tableau `.tmsl` metadata format, specifically the `create` and `partitions` APIs, to define the table structure and pull data from the `#sections[main][SharedExpression]` expression. The table is named `SharedExpressionTable` and is built with a full data view, demonstrating how to programmatically generate a Tableau data model from an embedded expression source.

HHugoberry

73% match

Loading thumbnail…

Gist ba39cf5b6349b2131c577e2e046e8654

This example demonstrates a data-driven approach to XML serialization within the Power Query language, showing how database queries can be wrapped in a custom function. The code defines a let expression that calls the `Value.NativeQuery` function, targeting a SQL Server database named "QueryPower" and executing a stored procedure called `usp_InsertDemoXML` with a binary parameter. The procedure receives an XML payload stored in a variable named `dummy2XML`, which is passed as the `xmlBin` argument. This illustrates a pattern for embedding XML data into SQL Server stored procedures through Power Query, highlighting how native database queries can be integrated into data transformation workflows. The example focuses on the parameter-passing mechanism rather than visual rendering.

HHugoberry

63% match

Loading thumbnail…

Gist f3a61a41e6832de955bdf750f4c54ba3

This example demonstrates a custom Power Query function that multiplies its input by a metadata value retrieved from a previously invoked function. The visualization shows how dynamic metadata can influence computed results within a data transformation pipeline. The code uses the `Expression.Evaluate` API to access the `Value.Metadata` function, pulling the `[a]` field from shared context, then multiplies that value by the parameter `x`. The rendering approach is not visual; instead, it highlights programmatic data shaping in Power Query, with the function `fn.pq` serving as the core logic. The source is a single gist file authored by Hugoberry.

HHugoberry

62% match

Loading thumbnail…

Searializing a table into and XML string in Power Query

This example demonstrates how to flatten a tabular dataset into a single XML string using Power Query’s M language. It shows the transformation of a table’s records into nested `<row>` elements wrapped in a top-level `<table>` tag. The code relies on `Table.ToRecords`, `List.Accumulate`, and `Record.FieldNames` to iterate over rows and columns, dynamically generating tags with `Text.Format`. Field names and values are inserted into `<#0>` and `</#0>` placeholders, producing a structured XML output. The approach is purely functional, avoiding loops, and directly serializes the table’s content into a text-based hierarchical format.

HHugoberry

61% match

Loading thumbnail…

Power Query embedded in an excel odc connection file

This example shows how a Power Query formula is embedded inside an Excel ODBC connection file, specifically within a Mashup.xml document. It demonstrates the structure of a single query item that generates a simple list of numbers from 1 to 20 using the `let` and `in` syntax. The code, written in Power Query’s M language, defines a source as a list range and then outputs that list. The file includes metadata such as client type (EXCEL), version, and culture settings, and the query is stored as a CDATA block within the XML, allowing for direct execution by Excel’s data mashup engine.

HHugoberry

59% match