Skip to main content
SimilarExport ZIP
100%

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

✓ Published0🌍 Public
HHugoberry
Last edited Apr 27, 2017
Created on Apr 25, 2017

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.

AI-generated description

Similar vizzes

Loading thumbnail…

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

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.

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

PowerQuery List functions with unicode examples

This cheat sheet visually maps Power Query's list functions using geometric unicode symbols as both data and output markers. It organizes functions into categories like Generators, Selection, and Ordering, with each entry showing a call and its returned list. The examples highlight type-specific behaviors, such as `List.Zip` combining symbols into pairs, `List.Sort` deduplicating while ordering, and generator functions producing date, time, and numeric sequences. Unicode shapes make the transformations immediately legible, turning the snippet into a compact reference for list operations.

HHugoberry
67% match
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
67% 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
67% 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
66% match