Skip to main content
SimilarExport ZIP
100%

TMSL for processing a table in Analysis Services

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

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.

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
63% 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
62% 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
59% match
Loading thumbnail…

Parallel processing of Tabular SSAS 2016 PowerShell vs JSON versions

This example compares two approaches to processing tabular data in SQL Server Analysis Services (SSAS) 2016: a PowerShell script and a JSON definition file, both targeting the same parallel refresh operation. The visualization contrasts the imperative PowerShell API—using `RequestRefresh` and `SaveChanges` with `MaxParallelism` set to 5—against the declarative JSON `sequence` object that specifies the same refresh and calculate steps. It highlights how the two syntaxes map to identical table refresh actions on "Internet Sales" and "Reseller Sales," followed by a model-wide calculate pass, while the parallel execution logic differs in representation. The data source is the AdventureWorks database, and the example uses Microsoft.AnalysisServices.Tabular and the JSON sequence format.

HHugoberry
58% 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
57% 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
55% match
Loading thumbnail…

Hidden Tabular SSAS specific DMVs

This visualization exposes the hidden structure of a tabular SSAS (SQL Server Analysis Services) model by issuing a series of `Discover` requests for TMSCHEMA metadata, including models, tables, columns, and measures. The code queries a specific database GUID via XMLA and presents the resulting schema objects as an interactive graph. Using D3.js, the example renders nodes and links that map out relationships between tables, hierarchies, and KPIs, revealing how the model is organized behind the scenes. The visualization relies on D3's force-directed layout to position elements, making the otherwise invisible metadata hierarchy tangible and explorable.

HHugoberry
50% match
Loading thumbnail…

Power BI desktop tabular mining model

This example demonstrates a Power BI Desktop tabular mining model, exposing the structure of Data Mining Extensions (DMX) schema queries used to retrieve model metadata. The visualization shows how the model defines expressions, variations, sets, and extended properties, with the underlying code failing to access the referenced mining model due to permission errors. The implementation relies on Power BI’s tabular engine and DAX, while directly embedding DMX queries like `select* from $tmschema_expressions` to inspect the model’s internal schema. The rendering approach is native to Power BI’s table visual, displaying the raw query results and error states without external libraries such as D3 or Three.js, focusing instead on the interaction between DAX and the mining model’s metadata layer.

HHugoberry
50% match