Skip to main content
SimilarExport ZIP
100%

[PowerBI/PowerQuery] This script works in combination with doc2markdown(fn) to load the documentation from #shared functions into the Model

✓ Published0🌍 Public
HHugoberry
Last edited Mar 7, 2018
Created on Feb 12, 2018

This example shows how to generate Markdown documentation for all functions defined in Power Query’s `#shared` namespace, organizing them by category and module. It uses the `doc2markdown` helper to produce a Markdown table of functions, excluding the helper itself and the `Signature` function. The script leverages `Record.ToTable` to enumerate shared items, `Table.SelectRows` with `Type.Is` to filter for functions, and `Value.Metadata` to extract `Documentation.Category` attributes. It then adds columns for category, module, and subcategory using `Text.BeforeDelimiter` and `Text.AfterDelimiter`, culminating in a `dox` table with function names and their generated documentation.

AI-generated description

Similar vizzes

Loading thumbnail…

[PowerBI/PowerQuery/PowerShell] Retrieve the documentation that has been nicely packaged by dox query into the tabular Model

This example retrieves documentation from Power BI’s embedded tabular model and writes it into markdown files organized by module and subcategory. It shows how to extract metadata from the model’s internal `dox` table using an XMLA query, then sorts and groups the results by module and name. The script uses PowerShell with the `Invoke-ASCmd` cmdlet from the SQLServer module, reading the localhost port from `msmdsrv.port.txt`, and writes each documentation row’s `doc` value to a `.md` file, escaping `{{` and `}}` for template compatibility. The output folder structure mirrors the module and subcategory hierarchy, with folders created on demand.

HHugoberry
81% match
Loading thumbnail…

[PowerBI/PowerQuery] Function that translates the documentation attached to a function definition into Markdown text

This example demonstrates a Power Query function that converts the documentation embedded in a function’s type metadata into a Markdown-formatted text block. It first retrieves the function from Power BI’s shared namespace, then extracts fields such as description, long description, category, and examples from the `Value.Metadata` of the function’s type. The code handles missing fields with `try`/`otherwise`, and uses `Text.Trim`, `Lines.ToText`, and `List.Transform` to assemble a template with headers and code fences. The final output is a Markdown document suitable for gallery display, relying solely on the function’s own metadata as the data source.

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

Gist 8e3363becb45788f796a2b31aaa4c6b3

This example shows how to programmatically generate Markdown documentation from Power Query’s metadata system, specifically pulling the name, description, category, and examples for the `SqlExpression.SchemaFrom` type. It works by reading the type’s metadata via `Value.Metadata` and `Value.Type`, then formatting the results into a structured document with headers, code blocks, and separators. The code uses the `Lines.ToText` and `List.Transform` functions to assemble the output, while `Documentation.Examples` iterates over sample entries to embed their code and results. The final output is a plain-text Markdown string, ready for use in a gallery or README.

HHugoberry
72% match
Loading thumbnail…

Power Query - get signature of a function as text. Use Signature(Table.Buffer) equals "function (table as table) as table". This is an M script

This example demonstrates how to extract and display the signature of a Power Query function as readable text, using the M language. It defines a custom function that takes a function as input and returns its type signature, such as `function (table as table) as table`. The code serializes type information into text form using the `Type.Is` and `Type.IsNullable` functions, then iterates over parameter names and their types via `Type.FunctionParameters` and `Record.FieldNames`. It assembles the final signature with `Text.Combine`, handling optional parameters and nullable types, and appends the return type using `Type.FunctionReturn`. The result is a string representation of the function's contract.

HHugoberry
63% match
Loading thumbnail…

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.

HHugoberry
60% match
Loading thumbnail…

Displays all of the Power Query M scripts from the opened instances of Power BI. (ignore the ts extension, this is an M script:)

This visualization displays every Power Query M script extracted from the currently open Power BI Desktop instances. It first locates the active Analysis Services workspace ports by scanning recently accessed files, then retrieves each connection string, decodes the embedded Mashup binary data, and decompresses the ZIP archive to isolate the “Formulas/Section1.m” file. The resulting M code is shown line by line, using the `Folder.Files`, `AnalysisServices.Database`, and `Binary.Decompress` APIs to reconstruct the scripts.

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