Counting the number of cores in Azure Analysis Services

Stress testing Azure Analysis Services. Run as AzureASLoadTest 5 (#number of parallel executions)

This example demonstrates a stress test for Azure Analysis Services, showing how the system handles multiple simultaneous queries against a tabular model. The code defines a PowerShell workflow that launches a specified number of parallel executions, each sending a complex DAX query that performs a crossjoin of two date tables to generate a large result set. The script uses the `Invoke-ASCmd` cmdlet to connect to the Azure Analysis Services instance and authenticate with credentials, while the `foreach -parallel` construct distributes the workload across concurrent connections. The visualization highlights the performance impact of increasing connection counts on the service's responsiveness and throughput.

59% match

Gist ed4042b20f9bcfc3ee801039049ad47f

This example shows the port number on which the SQL Server Analysis Services process (msmdsrv.exe) is listening by extracting it from live TCP connection data. It first identifies the process ID using the Windows `tasklist` command, then filters `netstat -ano` output for established connections matching that PID, and finally parses the local address to isolate the port. The visualization is implemented in Power Query’s M language, which invokes an embedded R script via the `R.Execute` function to perform the system calls and string processing. The result is a single value displayed as a table cell, demonstrating a system-monitoring query rendered through the Power BI data pipeline.

55% match

Gist 44e95c5ae2e212c1b41485ea7e31e0c4

This example shows a Power Query function that connects to an embedded Power BI Desktop tabular model and retrieves session information from the `$SYSTEM.DISCOVER_SESSIONS` dynamic management view. The function first locates the most recently accessed user profile folder, reads the `msmdsrv.port.txt` file to obtain the local port number, then uses that port to list available databases via the `AnalysisServices.Databases` API. It selects the first database and executes the provided DAX query using `AnalysisServices.Database`. The code demonstrates dynamic file system traversal, port discovery, and parameterized Analysis Services queries within the Power Query M language.

47% match

Gist f90e0dcc12099646652c5dcbc8400a24

This example visualizes the live query log of a Power BI tabular model by monitoring the Analysis Services workspace’s in-memory engine. It shows the most recent command and its start time, appending each new entry to a running history. The code uses the Power Query M language, calling `AnalysisServices.Database` to query the `$SYSTEM.DISCOVER_SESSIONS` DMV and `Folder.Files` to locate the `msmdsrv.port.txt` file that defines the dynamic port. The rendered output is a table combining previous and new log records via `Table.Combine`, with no external charting library involved.

47% match

Fetching the Mandelbrot Set from the execution of Azure Functions

This example visualizes the Mandelbrot set by fetching precomputed JSON blobs from an Azure Storage container. The Power Query code uses the `AzureStorage.Blobs` API to connect to the storage account, filters the blobs by a folder named "ZZZ", and retrieves their content. Each blob is parsed with `Json.Document` to extract the set’s data, which is then combined into a single table via `Table.FromRecords` and `List.Combine`. The visualization shows how distributed execution of Azure Functions can fragment and reassemble complex mathematical data, presenting the classic fractal shape through a straightforward data-fetching pipeline.

KMeans clustering call in DAX Power BI desktop 3D

This example demonstrates a 3D KMeans clustering visualization built directly in DAX for Power BI, using the Iris dataset’s numeric columns (Column6, Column7, Column8). It shows how raw table columns are summarized and then passed into the custom `KMeansClustering` DAX function, which assigns each data point to a cluster and returns a cluster ID alongside the original attributes. The code explicitly constructs a DAX query with `SUMMARIZECOLUMNS` and `SELECTCOLUMNS` to shape the data, then calls `KMeansClustering` with parameter lists defining attribute roles and output columns. The rendering approach is not visible here, but the focus is on the algorithmic clustering step within Power BI’s DAX engine.

Power Query finding port number of the running embeded tabular instance

This example shows how to locate the port number of a running embedded tabular instance in Power BI Desktop by reading a specific file from the user’s local workspace. It demonstrates a Power Query M function that dynamically identifies the current user by sorting folders in `C:\Users` by their `Date accessed` property, then navigates to the corresponding `AnalysisServicesWorkspaces` subfolder. The code uses the `Folder.Contents` and `Folder.Files` APIs to traverse the filesystem, filters for the file named `msmdsrv.port.txt`, and extracts its content using `Lines.FromBinary` with a specific code page. The result is the port number, presented as a text value.

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.