Skip to main content
SimilarExport ZIP
100%

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

✓ Published0🌍 Public
HHugoberry
Last edited Aug 17, 2017
Created on Aug 16, 2017

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.

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
85% 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
82% match
Loading thumbnail…

Gist fcc3b4c6bb3d32bd50e83052b67b9e23

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.

HHugoberry
78% 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
69% match
Loading thumbnail…

Power Query navigate the documentation of #shared functions. [M code]

This example visualizes the complete set of functions exposed by Power Query’s `#shared` namespace, organized into a navigable table. It shows each function’s name, module, category, example code, description, and signature. The M code uses `Record.ToTable` and `Table.SelectRow` to filter functions, then leverages `Value.Metadata` to extract documentation fields like `Documentation.Category` and `Documentation.Examples`. It also parses module names via `Text.Split` and builds signatures dynamically. The result is a self-documenting inventory, enabling users to browse and understand the entire Power Query function library directly from the environment.

HHugoberry
66% match
Loading thumbnail…

TMSL for processing a table in Analysis Services

This example shows how to refresh a specific table partition in an Analysis Services tabular model using a TMSL script. The code defines a `refresh` operation with a `full` type, targeting the `SharedExpressionTable` within the `Mcube` database. It specifies the exact partition to process, demonstrating a targeted data refresh rather than a full database reload. The JSON-based TMSL format is used directly, making the operation explicit and scriptable. This approach is useful for incremental processing scenarios where only a subset of data needs updating, as it avoids reprocessing unrelated tables or partitions.

HHugoberry
62% match
Loading thumbnail…

Matrix Multiplication in Power Query M. Test example = MatrixMultiplication(#table({"A","B"},{{1,2},{3,4}}), #table({"A","B"},{{1,2},{3,4}}))

This example demonstrates how to perform square matrix multiplication entirely within Power Query M, using two 2x2 tables with the values {1,2} and {3,4} as both inputs. It shows a custom function that multiplies two matrices and returns the resulting table. The implementation relies on core M language features, including `Table.ToRows`, `Table.ToColumns`, `List.Accumulate`, and `List.Zip`, to compute dot products for each row-column pair. The `dotProduct` helper iterates over zipped row and column vectors, accumulating the sum of element-wise products. The output is constructed via `Table.FromRows`, preserving the visual table format native to Power Query.

HHugoberry
59% 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
58% match