Gist adad8e220a1e17f2d97fbabd7315d685

100%

Gist adad8e220a1e17f2d97fbabd7315d685

✓ Published0🌍 Public

Last edited Aug 16, 2017

Created on Aug 16, 2017

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.

AI-generated description

Similar vizzes

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

73% match

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

71% 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

71% 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

69% 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

59% match

Loading thumbnail…

Gist be32a2ac117700d3dbde6b0824367ba5

This example demonstrates how to create a simple database table visualization from a SQL schema definition. The code defines a `Demo` table with three columns—`ID`, `Key`, and `Value`—and shows how to map those column types and constraints into a visual entity-relationship style diagram. Using the provided `CREATE TABLE` statement as the data source, the visualization renders each column as a node, with the primary key and nullable attributes indicated through distinct visual encodings. The implementation leverages `d3.forceSimulation` for the node layout and `d3.geoPath` for any geometric rendering, while relying on standard DOM elements for interactivity. No additional behavior beyond the table’s structural representation is implied.

HHugoberry

59% match

Loading thumbnail…

Gist d2f55e96546318a1e8e393d423ea36e9

This example shows a SQL query that transfers data from one Excel sheet to another, creating a new table in a separate workbook file. The visualization demonstrates how data can be exported or copied between spreadsheet locations using an embedded query. The code uses the `SELECT * INTO` syntax with an `[Excel 8.0;DATABASE=...]` connection string, specifying the destination file path and sheet name. The query pulls all records from the source sheet and writes them to the target workbook, illustrating a straightforward data-migration pattern. The rendering approach relies on the database driver’s handling of the Excel file format, with no additional charting or graphics libraries involved.

HHugoberry

58% 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

57% match