Zum Inhalt
← Zurück zum Blog

2026-04-14 11 Min. Lesezeit

ER-Diagramme aus DAX — Power BI Datenmodelle mit einem einzigen Measure dokumentieren

Wie man ein Live-Entity-Relationship-Diagramm für jedes Power BI Semantic Model mit einer DAX User-Defined Function und dem kostenlosen Markdown / Mermaid Renderer Visual erzeugt.

published on 2026-04-14


In einem früheren Artikel habe ich den Markdown / Mermaid Renderer vorgestellt — ein kostenloses, quelloffenes Power BI Visual, das Markdown-Inhalte und Mermaid-Diagramme direkt im Bericht rendert. Dieser Artikel baut darauf auf und zeigt einen konkreten Anwendungsfall: automatische ER-Diagramme für Power BI Datenmodelle.

Power BI Desktop hat zwar eine eingebaute Beziehungsansicht: die Modellansicht. Aber wer schon einmal mit einem größeren Modell darin gearbeitet hat, kennt die Grenzen — sie ist nicht konfigurierbar, wird bei vielen Tabellen langsam und verwandelt sich schnell in ein unlesbares Liniengewirr. Es gibt keine Möglichkeit, nach aktiven Beziehungen zu filtern, Spalten auszublenden oder das Ergebnis in einen Bericht einzubetten, den andere sehen können.

Dieser Artikel zeigt eine Alternative: Eine einzige DAX User-Defined Function, die die Modell-Metadaten abfragt, ein Mermaid-ER-Diagramm erstellt und es live im Bericht rendert — konfigurierbar, leichtgewichtig und immer aktuell.


Die Idee

Seit April 2024 liefert Power BI Desktop INFO.VIEW.*-Funktionen mit, die Modell-Metadaten zur Abfragezeit bereitstellen — Tabellen, Spalten, Measures, Beziehungen. In Kombination mit DAX User-Defined Functions (UDFs), eingeführt mit Kompatibilitätsebene 1604, lassen sich diese Metadaten direkt im Modell zu strukturiertem Text umwandeln.

Der Ansatz:

flowchart LR
    A["INFO.VIEW.RELATIONSHIPS()"] --> B["DAX UDF: mermaid_relationships"]
    C["INFO.VIEW.COLUMNS()"] --> B
    B --> D["Mermaid erDiagram Code"]
    D --> E["Markdown / Mermaid Renderer"]
    E --> F["Live ER-Diagramm im Bericht"]
  1. INFO.VIEW.RELATIONSHIPS() gibt jede im Modell definierte Beziehung zurück — Von-/Bis-Tabelle, Von-/Bis-Spalte, Kardinalität, Kreuzfilterrichtung, Aktiv-/Inaktiv-Status.
  2. INFO.VIEW.COLUMNS() liefert alle Spalten mit ihren Datentypen.
  3. Eine DAX-UDF namens mermaid_relationships kombiniert beides, formatiert die Ausgabe als Mermaid-erDiagram-Codeblock und gibt einen einzelnen Textstring zurück.
  4. Das Markdown / Mermaid Renderer Visual rendert diesen String als interaktives SVG-Diagramm.

Das Ergebnis: Ein lebendiges, immer aktuelles Entity-Relationship-Diagramm direkt im Power BI Bericht — eines, das sich automatisch aktualisiert, wenn sich das Modell ändert.


Was man bekommt

Das generierte Diagramm zeigt:

  • Jede Tabelle im Modell — einschließlich isolierter Tabellen ohne Beziehungen
  • Spalten, die als Beziehungsschlüssel verwendet werden (oder optional alle Spalten mit Datentypen)
  • Kardinalität: Many-to-One (}o--||), One-to-One (||--||), Many-to-Many (}o--o{)
  • Aktive vs. inaktive Beziehungen: durchgezogene Linien (aktiv) vs. gepunktete Linien (inaktiv)
  • Kreuzfilterrichtung: bidirektionale Beziehungen werden mit ⇄ markiert

Ein kleines Beispiel der gerenderten Ausgabe:

erDiagram
    Calendar {
        DateTime Date
    }
    Products {
        Int64 ProductKey
    }
    Sales {
        DateTime OrderDate
        Int64 ProductKey
    }
    Sales }o--|| Calendar : "OrderDate → Date"
    Sales }o--|| Products : "ProductKey → ProductKey"

Mit dem Markdown / Mermaid Renderer Visual lässt sich das interaktiv erkunden: Vollbildmodus mit Zoom und Schwenken steht für komplexe Modelle zur Verfügung.


Der DAX-Code

Die UDF mermaid_relationships akzeptiert zwei Parameter:

Parameter Optionen Wirkung
ShowColumns "No_Cols" Nur Tabellennamen — sauberes, minimales Diagramm
"Key_Cols" Zeigt Spalten, die als Beziehungsschlüssel dienen (mit Datentypen)
"All_Cols" Zeigt alle Spalten jeder Tabelle
ShowRelationships "All_Rels" Aktive und inaktive Beziehungen
"Active_Rels" Nur aktive Beziehungen (durchgezogene Linien)

Vollständige DAX-Abfrage

Den gesamten Block unten in die DAX-Abfrageansicht in Power BI Desktop kopieren und ausführen. Das Ergebnis ist eine einzelne Zelle mit dem Mermaid-Codeblock.

Nach der Ausführung mit Rechtsklick auf die Measure-Definition in der Abfrage "Zum Modell hinzufügen" wählen, um es als Measure zu speichern.

DEFINE
    // Helper: replace Mermaid-unsafe characters with underscores.
    FUNCTION mermaid_safe = (txt) =>
        SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(
        SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(
        SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(
        SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(
            txt,
            " ", "_"), "(", "_"), ")", "_"), "-", "_"), ".", "_"),
            ",", "_"), "'", "_"), "/", "_"), "\", "_"), ":", "_"),
            ";", "_"), "[", "_"), "]", "_"), "+", "_"), "=", "_"),
            "%", "_"), "&", "_"), "#", "_"), "@", "_"), "!", "_")

    FUNCTION mermaid_relationships =
    (ShowColumns, ShowRelationships) =>
    // ShowColumns      : "No_Cols" | "Key_Cols" | "All_Cols"
    // ShowRelationships: "All_Rels" | "Active_Rels"
    VAR _NL = UNICHAR(10)

    // ------------------------------------------------------------------
    // Guard: validate both input parameters.
    // ------------------------------------------------------------------
    VAR _ValidInput =
        (ShowColumns = "No_Cols" || ShowColumns = "Key_Cols" || ShowColumns = "All_Cols")
        && (ShowRelationships = "All_Rels" || ShowRelationships = "Active_Rels")

    // ------------------------------------------------------------------
    // Base relationships — filtered by ShowRelationships.
    // ------------------------------------------------------------------
    VAR _BaseRels =
        FILTER(
            INFO.VIEW.RELATIONSHIPS(),
            ShowRelationships = "All_Rels" || [IsActive] = TRUE()
        )

    // ------------------------------------------------------------------
    // Step 1: Add derived columns to each relationship row.
    // ------------------------------------------------------------------
    VAR _Rels =
        ADDCOLUMNS(
            _BaseRels,

            // ER connector (active, solid line)
            "Connector",
                SWITCH(
                    TRUE(),
                    [FromCardinality] = "Many" && [ToCardinality] = "Many",  "}o--o{",
                    [FromCardinality] = "One"  && [ToCardinality] = "One",   "||--||",
                    "}o--||"          // Many-to-One or One-to-Many
                ),

            "IsActiveBool", [IsActive] = TRUE()
        )

    VAR _RelsWithConnector =
        ADDCOLUMNS(
            _Rels,
            "FinalConnector",
                IF(
                    [IsActiveBool],
                    [Connector],
                    SUBSTITUTE([Connector], "--", "..")
                ),

            // Label: optional "⇄ " prefix + "FromColumn → ToColumn"
            "Label",
                VAR _arrow = UNICHAR(8594)   // →
                VAR _bidir = UNICHAR(8644)   // ⇄
                VAR _base  = [FromColumn] & " " & _arrow & " " & [ToColumn]
                RETURN
                    IF(
                        [CrossFilteringBehavior] = "BothDirections",
                        _bidir & " " & _base,
                        _base
                    )
        )

    // ------------------------------------------------------------------
    // Step 2: Add Mermaid-safe node IDs for [FromTable] and [ToTable].
    // ------------------------------------------------------------------
    VAR _RelsWithSafeIDs =
        ADDCOLUMNS(
            _RelsWithConnector,
            "FromSafe", mermaid_safe([FromTable]),
            "ToSafe",   mermaid_safe([ToTable])
        )

    // ------------------------------------------------------------------
    // Step 3: Column data from INFO.VIEW.COLUMNS() (only when needed).
    // ------------------------------------------------------------------
    VAR _KeyColPairs =
        DISTINCT(
            UNION(
                SELECTCOLUMNS(_BaseRels, "TN", [FromTable], "CN", [FromColumn]),
                SELECTCOLUMNS(_BaseRels, "TN", [ToTable],   "CN", [ToColumn])
            )
        )

    VAR _AllViewCols =
        SELECTCOLUMNS(
            INFO.VIEW.COLUMNS(),
            "TN", [Table],
            "CN", [Name],
            "CT", [DataType]
        )

    VAR _ColsToShow =
        FILTER(
            _AllViewCols,
            ShowColumns = "All_Cols" || CONTAINSROW(_KeyColPairs, [TN], [CN])
        )

    // ------------------------------------------------------------------
    // Step 3b: Isolated tables — tables that appear in
    // INFO.VIEW.COLUMNS() but are not part of any (filtered)
    // relationship. Rendered as standalone entity blocks.
    // ------------------------------------------------------------------
    VAR _RelTableNames =
        DISTINCT(
            UNION(
                SELECTCOLUMNS(_BaseRels, "TN", [FromTable]),
                SELECTCOLUMNS(_BaseRels, "TN", [ToTable])
            )
        )

    VAR _AllTableNames =
        DISTINCT(SELECTCOLUMNS(_AllViewCols, "TN", [TN]))

    VAR _IsolatedNodes =
        SELECTCOLUMNS(
            EXCEPT(_AllTableNames, _RelTableNames),
            "NodeSafe",  mermaid_safe([TN]),
            "NodeLabel", [TN]
        )

    // ------------------------------------------------------------------
    // Step 4: Node table — safe ID + original name, one row per table.
    //   Includes tables from relationships AND isolated tables.
    // ------------------------------------------------------------------
    VAR _NodeTable =
        DISTINCT(
            UNION(
                SELECTCOLUMNS(_RelsWithSafeIDs, "NodeSafe", [FromSafe], "NodeLabel", [FromTable]),
                SELECTCOLUMNS(_RelsWithSafeIDs, "NodeSafe", [ToSafe],   "NodeLabel", [ToTable]),
                _IsolatedNodes
            )
        )

    // ------------------------------------------------------------------
    // Step 5: Node block lines.
    // ------------------------------------------------------------------
    VAR _NodeLines =
        CONCATENATEX(
            _NodeTable,
            VAR _tSafe  = [NodeSafe]
            VAR _tLabel = [NodeLabel]
            VAR _colLines =
                CONCATENATEX(
                    FILTER(_ColsToShow, [TN] = _tLabel),
                    "        " & mermaid_safe([CT]) & " " & mermaid_safe([CN]),
                    _NL,
                    [CN]
                )
            RETURN
                IF(
                    ShowColumns = "No_Cols" || ISBLANK(_colLines),
                    "    " & _tSafe,
                    "    " & _tSafe & " {" & _NL & _colLines & _NL & "    }"
                ),
            _NL,
            [NodeLabel]
        )

    // ------------------------------------------------------------------
    // Step 6: Edge lines.
    // ------------------------------------------------------------------
    VAR _EdgeLines =
        CONCATENATEX(
            _RelsWithSafeIDs,
            "    " & [FromSafe] & " " & [FinalConnector] & " " & [ToSafe] & " : """ & [Label] & """",
            _NL
        )

    // ------------------------------------------------------------------
    // Step 7: Assemble the fenced Mermaid code block.
    // ------------------------------------------------------------------

    // Isolated tables get a subtle dashed-border style so they
    // visually stand out from tables that participate in relationships.
    VAR _IsolatedClassAssignment =
        CONCATENATEX(_IsolatedNodes, [NodeSafe], ",", [NodeLabel])

    VAR _StyleLines =
        IF(
            ISBLANK(_IsolatedClassAssignment),
            "",
            _NL &
            "    classDef isolated fill:#f5f5f5,stroke:#bbb,color:#666" & _NL &
            "    class " & _IsolatedClassAssignment & " isolated"
        )

    RETURN
        IF(
            NOT _ValidInput,
            ERROR("mermaid_relationships: ShowColumns must be ""No_Cols""/""Key_Cols""/""All_Cols"", ShowRelationships must be ""All_Rels""/""Active_Rels"""),
            "```mermaid" & _NL &
            "erDiagram" & _NL &
            _NodeLines & _NL &
            _EdgeLines &
            _StyleLines & _NL &
            "```"
        )

// Adjust arguments as needed:
//   ShowColumns      : "No_Cols" | "Key_Cols" | "All_Cols"
//   ShowRelationships: "All_Rels" | "Active_Rels"
EVALUATE
    { mermaid_relationships("Key_Cols", "Active_Rels") }

So funktioniert es

Die Funktion durchläuft folgende Schritte:

  1. Beziehungen filtern — entweder alle oder nur aktive, abhängig vom Parameter ShowRelationships.
  2. Kardinalität auf Konnektoren abbilden — Many-to-One wird zu }o--||, One-to-One zu ||--|| usw. Inaktive Beziehungen erhalten gepunktete Konnektoren (}o..||).
  3. Bezeichner bereinigen — Mermaid erlaubt keine Leerzeichen oder Sonderzeichen in Entity-Namen. Die Hilfsfunktion mermaid_safe ersetzt 20 gängige Sonderzeichen durch Unterstriche.
  4. Spalten-Metadaten sammeln — aus INFO.VIEW.COLUMNS(), gefiltert auf Schlüsselspalten oder alle Spalten, je nach Parameter ShowColumns.
  5. Isolierte Tabellen erkennen — Tabellen, die im Modell existieren, aber keine Beziehungen haben (oder keine, die zum aktuellen Filter passen). Sie werden als eigenständige Entity-Blöcke mit subtiler visueller Hervorhebung dargestellt.
  6. Entity-Blöcke erstellen — ein Block pro Tabelle (einschließlich isolierter Tabellen), optional mit Spalten und Datentypen.
  7. Beziehungslinien erstellen — eine Zeile pro Beziehung, beschriftet mit den Schlüsselspaltennamen und der Richtung.
  8. Zusammensetzen — alles wird in einen umzäunten Mermaid-Codeblock (```mermaid ... ```) verpackt, bereit zum Rendern durch das Visual. Isolierte Tabellen erhalten eine eigene CSS-Klasse zur visuellen Unterscheidung.

Einrichtung in Power BI

Voraussetzungen

  • Power BI Desktop (April 2024 oder neuer) — erforderlich für INFO.VIEW.*-Funktionen
  • Kompatibilitätsebene 1604 oder höher — erforderlich für DAX User-Defined Functions
  • Markdown / Mermaid Renderer Visual — kostenlos verfügbar über AppSource oder GitHub

Schritt für Schritt

  1. Die .pbix-Datei in Power BI Desktop öffnen
  2. DAX-Abfrageansicht öffnen (Ansicht → DAX-Abfrageansicht)
  3. Die vollständige DAX-Abfrage von oben einfügen und ausführen
  4. Rechtsklick auf die mermaid_relationships-Funktionsdefinition → "Zum Modell hinzufügen"
  5. Ein neues Measure erstellen, das die Funktion aufruft, z.B.:
ER Diagram =
    mermaid_relationships("Key_Cols", "Active_Rels")
  1. Das Markdown / Mermaid Renderer Visual auf eine Berichtsseite platzieren
  2. Das ER Diagram-Measure in das Feld "Markdown Content" ziehen

Das Diagramm wird sofort gerendert. Ab diesem Zeitpunkt bleibt es mit dem Modell synchron — eine Tabelle hinzufügen, eine Beziehung ändern, und das Diagramm aktualisiert sich von selbst.

Den richtigen Anzeigemodus wählen

Beide Parameter lassen sich kombinieren, um das Diagramm an die Größe des Modells und den gewünschten Detailgrad anzupassen.

Die drei Spaltenmodi dienen unterschiedlichen Zwecken:

Modus Geeignet für Diagramm-Komplexität
"No_Cols" Schneller Überblick, Präsentationen, große Modelle (20+ Tabellen) Minimal
"Key_Cols" Entwicklung & Review — sehen, welche Spalten die Joins bilden Mittel
"All_Cols" Vollständige Dokumentation, kleine Modelle (< 10 Tabellen) Hoch

Der Beziehungsfilter ergänzt eine weitere Dimension:

Filter Wirkung
"Active_Rels" Nur aktive Beziehungen — saubereres Diagramm, besonders wenn inaktive Beziehungen visuelles Rauschen erzeugen
"All_Rels" Aktive (durchgezogene Linien) + inaktive (gepunktete Linien) — vollständiges Bild aller definierten Beziehungen

Für große Modelle ist ein guter Startpunkt "No_Cols" mit "Active_Rels" — minimales Durcheinander, Fokus auf die Kernstruktur des Modells. Im Vollbildmodus (⛶) des Visuals kann man zoomen und schwenken. Auf "Key_Cols" oder "All_Rels" wechseln, wenn man bestimmte Join-Pfade prüfen oder inaktive Beziehungen debuggen möchte.


Was das Ganze leichtgewichtig macht

Kein Python-Skript, kein externes Tool, keine exportierte Metadaten-Datei. Der gesamte Workflow lebt im Power BI Modell:

  • Eine DAX-Funktion liest die Modell-Metadaten
  • Ein Measure ruft diese Funktion mit den gewünschten Parametern auf
  • Ein Visual rendert das Ergebnis

Das Diagramm ist live. Es veraltet nicht. Es erfordert nicht, dass jemand daran denkt, einen Screenshot nach einer Modelländerung neu zu exportieren. Es aktualisiert sich jedes Mal, wenn der Bericht geöffnet oder aktualisiert wird.

Das macht es ideal für:

  • Ad-hoc-Dokumentation während der Entwicklung — schnell sehen, wie das Modell aussieht
  • Onboarding — einen Bericht mit eingebautem Modellüberblick übergeben
  • Review-Sessions — Beziehungen und Kardinalitäten direkt im Bericht diskutieren
  • Präsentationen — ein sauberes, interaktives Architekturdiagramm zeigen

Weitergedacht: Die Flexibilität des Markdown / Mermaid Renderers

Das ER-Diagramm ist nur ein Anwendungsfall. Weil das Visual beliebiges Markdown und Mermaid rendert, funktioniert derselbe Ansatz auch für andere Diagrammtypen, die per DAX erzeugt werden:

  • Flowcharts — Datenpipelines oder ETL-Logik visualisieren
  • Sequenzdiagramme — Aktualisierungsabhängigkeiten oder API-Aufrufsequenzen darstellen
  • Gantt-Diagramme — Projekt-Timelines aus Datentabellen anzeigen
  • Measure-Dokumentation — mit INFO.VIEW.MEASURES() eine vollständige Measure-Referenz generieren (siehe den Begleitartikel)

Mehrere Measures lassen sich in einem einzigen Visual kombinieren — das ER-Diagramm neben einer Measure-Referenz, einer Prozessbeschreibung oder KPI-Definitionen platzieren. Jedes Measure wird als eigener Abschnitt gerendert.


Wenn es mehr sein darf

Der DAX-Ansatz ist bewusst leichtgewichtig. Er eignet sich gut für schnelle Übersichten und selbstdokumentierende Berichte. Aber er hat Grenzen:

  • Keine Tabellenbeschreibungen oder Dokumentation auf Spaltenebene (die Metadaten-Funktionen liefern diese nicht)
  • Kein Lineage-Tracking (woher kommt jede Spalte?)
  • Keine Formatierungskontrolle über das hinaus, was Mermaid bietet
  • Keine versionierte Historie oder Änderungsverfolgung

Für Teams, die umfassende, strukturierte Dokumentation benötigen — mit Beschreibungen, Lineage, Berechnungslogik, Datentypen und Qualitätsprüfungen — generiert Fennibi vollständige Markdown-Dokumentation für Power BI Semantic Models. Es nutzt dieselben Mermaid-Diagramme für Beziehungen und Architektur, dargestellt durch dasselbe Visual, aber mit deutlich mehr Tiefe und Detail.

Die DAX-Funktion in diesem Artikel ist ein guter Einstiegspunkt. Wenn der Umfang wächst, setzt Fennibi dort an, wo sie aufhört.


💬 Diskussion & Feedback

Fragen, Ideen oder Anmerkungen zum Mermaid Power BI Visual oder der hier vorgestellten Dax Funktion? Ich freue mich über jeden Kommentar — hinterlasse gerne eine Nachricht direkt unter dem LinkedIn-Beitrag zu diesem Artikel.