Excel Advanced Data Destination (Vorschau)

Wenn Sie an einem dateibasierten Ziel in Dataflow Gen2 arbeiten, haben Sie die Möglichkeit, Ihre Daten in verschiedenen Formaten zu speichern, einschließlich Excel. Excel-Dateien können mit einfachen tabellarischen Daten erstellt werden, aber Sie können auch komplexe Arbeitsmappen mit mehreren Blättern, Diagrammen und angepassten Formatierungen mithilfe von Navigationstabellen erstellen. Diese Navigationstabellen definieren die Struktur und den Inhalt des Excel-Dokuments programmgesteuert und bieten eine leistungsfähige Möglichkeit zum Generieren dynamischer Excel-Dateien.

In diesem Artikel wird erläutert, wie Sie diese Navigationstabellen erstellen, um Excel-Dokumente programmgesteuert aus Ihrem Dataflow zu generieren.

Voraussetzungen

Bevor Sie das Excel Advanced-Ziel verwenden können, müssen Sie Ihre Dataflow Gen2 mit der richtigen Konfiguration einrichten:

1. Erstellen Sie eine Navigationstabellenabfrage – Erstellen Sie in Ihrem Dataflow Gen2 eine Abfrage, die eine Navigationstabelle ausgibt, wie in diesem Artikel beschrieben. Die Abfrage sollte eine Tabelle mit den erforderlichen Spalten (PartType, Data) und optional (Sheet, Name und Properties) zurückgeben.

2. Hinzufügen eines Datenziels – Wählen Sie Ihre Navigationstabellenabfrage aus, und fügen Sie ein Datenziel hinzu, indem Sie im Kontextmenü der Abfrage oder im Menüband " Datenziel hinzufügen " auswählen.

3. Wählen Sie ein dateibasiertes Ziel aus– Wählen Sie ein dateibasiertes Ziel aus, z. B.:

   • SharePoint
   • Lakehouse Files
   • Azure Data Lake Storage Gen2
   • Azure Blob Storage (Speicherdienst von Azure für unstrukturierte Daten)

4. Legen Sie das Dateiformat auf Excel fest – Legen Sie in der Zielkonfiguration das Dateiformat auf Excel fest.

5. Wählen Sie "Erweitertes Format " aus. Wählen Sie im Dropdownmenü " Format " die Option "Erweitert" aus. Diese Option weist den Connector an, die Abfrageausgabe als Navigationstabelle zu interpretieren, die die Excel-Dokumentstruktur definiert.

   

Nach der Konfiguration liest das System beim Ausführen des Datenflusses Ihre Navigationstabelle und generiert die entsprechende Excel-Datei mit der von Ihnen definierten Struktur.

Übersicht

Excel-Dokumente in Power Query werden als Navigationstabellen dargestellt – Standardtabellen mit bestimmten Spalten, die die Dokumentstruktur beschreiben. Jede Zeile in der Navigationstabelle stellt einen Teil des Excel-Dokuments dar, z. B. ein Arbeitsblatt mit Daten oder ein Diagramm, das diese Daten visualisiert.

Wenn Sie ein Excel-Ausgabeziel in einem Dataflow konfigurieren, liest das System diese Navigationstabelle und generiert die entsprechende Excel-Datei. Dieser Ansatz bietet Flexibilität beim Definieren komplexer Arbeitsmappen mit mehreren Blättern, Diagrammen und Datenbeziehungen.

Kurzreferenz

Dieser Abschnitt enthält eine konsolidierte Ansicht von Teiltypen und deren wichtigsten Eigenschaften für die schnelle Suche. Informationen zu einsatzbereiten Codevorlagen finden Sie unter "Allgemeine Muster". Informationen zur Fehlerauflösung finden Sie unter "Problembehandlung".

Teiletypen auf einen Blick

Schlüsseleigenschaften nach Teiltyp

* Bei Diagrammen mit Inlinedaten steuern diese Eigenschaften die zugrunde stehenden Datentabelle.

Minimales Beispiel

Die einfachste Möglichkeit zum Erstellen eines Excel-Dokuments besteht darin, eine Navigationstabelle mit nur den Daten bereitzustellen, die Sie exportieren möchten. Alle Spalten außer Data und PartType optional – der Verbinder kann fehlende Eigenschaften ableiten und ein funktionales Dokument erstellen.

Im folgenden Beispiel wird eine SalesData Tabelle definiert, die in diesem Artikel verwendet wird:

let
    // Define your data with columns used throughout this article
    SalesData = #table(
        type table [
            Region = text, 
            Category = text, 
            Product = text, 
            Quarter = text,
            Revenue = number,
            Units = number
        ],
        {
            {"North", "Electronics", "Laptop", "Q1", 45000, 150},
            {"North", "Electronics", "Phone", "Q1", 32000, 400},
            {"North", "Furniture", "Desk", "Q1", 18000, 60},
            {"South", "Electronics", "Laptop", "Q1", 38000, 120},
            {"South", "Electronics", "Phone", "Q1", 28000, 350},
            {"South", "Furniture", "Chair", "Q1", 12000, 200},
            {"East", "Electronics", "Tablet", "Q2", 22000, 180},
            {"East", "Furniture", "Desk", "Q2", 15000, 50},
            {"West", "Electronics", "Phone", "Q2", 41000, 520},
            {"West", "Furniture", "Chair", "Q2", 9000, 150}
        }
    ),

    // Create the navigation table with minimal structure
    // Only Data and PartType are required
    excelDocument = #table(
        type table [PartType = nullable text, Data = any],
        {
            {"SheetData", SalesData}
        }
    )
in
    excelDocument

Wenn Sie keine Blattnamen oder Teilenamen angeben, generiert das System automatisch geeignete Standardwerte.

Verweisen auf andere Abfragen

In einem Datenfluss können Sie auf andere vorhandene Abfragen in Ihrer Navigationstabelle verweisen. Die Data Spalte akzeptiert einen beliebigen Tabellenwert, einschließlich Verweise auf Abfragen, die an anderer Stelle in Ihrem Dataflow definiert sind:

let
    // Reference existing queries named "MonthlySales" and "CurrentInventory"
    excelDocument = #table(
        type table [PartType = nullable text, Data = any],
        {
            {"SheetData", MonthlySales},
            {"SheetData", CurrentInventory}
        }
    )
in
    excelDocument

Navigationstabellenstruktur

Die Navigationstabelle folgt einem bestimmten Schema mit den folgenden Spalten:

Unterstützte Teiletypen

• Arbeitsmappe: Konfiguration auf Dokumentebene. Muss die erste Zeile sein, wenn sie verwendet wird. Enthält keine Daten.
• SheetData: Ein Arbeitsblatt mit tabellarischen Daten. Dieser Teil ist datengebunden. SheetData-Teile müssen Inlinedaten enthalten und dürfen keine Tabellenverweise verwenden. Erstellt einen einzelnen Datenbereich ab Zelle A1.
• Tabelle: Eine Excel-Tabelle (mit Tabellenstil formatiert). Dieser Teil ist datengebunden. Unterstützt die explizite Positionierung über StartCell und die automatische Positionierung. Mehrere Tabellenteile können auf demselben Blatt vorhanden sein, wenn sie sich nicht überlappen.
• Bereich: Ein Datenbereich ohne Excel-Tabellenformatierung. Dieser Teil ist datengebunden. Unterstützt die explizite Positionierung über StartCell und die automatische Positionierung. Mehrere Bereichsteile können auf demselben Blatt vorhanden sein, wenn sie sich nicht überlappen.
• Diagramm: Eine Diagrammvisualisierung. Kann auf einem eigenen Blatt platziert oder mit Daten kombiniert werden. Dieser Teil ist datengebunden , wenn er Inlinedaten enthält, oder es kann auf Daten aus einem anderen Teil verweisen.

Auswählen des richtigen Teiltyps

Verwenden Sie dieses Entscheidungshandbuch, um den geeigneten Teiltyp für Ihr Szenario auszuwählen:

Verwenden Sie SheetData wenn:

• Sie benötigen eine einfache, einzelne Datenregion pro Blatt.
• Daten sollten in Zelle A1 beginnen
• Sie benötigen keine Excel-Tabellenfeatures (Filter, strukturierte Verweise)
• Sie exportieren einfache tabellarische Daten

Verwenden Sie Table wenn:

• Sie möchten die Excel-Tabellenformatierung mit Dropdowns für Filter
• Sie benötigen strukturierte Verweise für Formeln.
• Sie platzieren mehrere Datenbereiche auf einem Blatt
• Sie benötigen präzise Kontrolle über die Positionierung mit StartCell
• Sie möchten Tabellenformatvorlagen (TableStyleMedium1usw.) anwenden.

Verwenden Sie Range wenn:

• Sie benötigen Rohdaten ohne Excel-Tabellenformatierung
• Sie möchten Kopfzeilen weglassen (SkipHeader = true)
• Sie platzieren mehrere Datenbereiche auf einem Blatt
• Die Daten werden von anderen Systemen genutzt, die einfache Datenbereiche erwarten.

Verwenden Sie Chart wenn:

• Sie benötigen Datenvisualisierung
• Mit Inlinedaten: Diagramm und Daten werden auf demselben Blatt zusammen angezeigt
• Mit Verweisen: Diagramme und Daten können auf separaten Blättern vorhanden sein, und mehrere Diagramme können eine Datenquelle gemeinsam nutzen.

Beispiel mit vollständiger Struktur

let
    // Helper function to create a reference to another part
    buildReference = (name as text) => #table({}, {}) meta [Name = name],

    excelDocument = #table(
        type table [Sheet = nullable text, Name = nullable text, PartType = nullable text, Properties = nullable record, Data = any],
        {
            {"Workbook", "Workbook", "Workbook", [ChartInferenceFunction = Office.InferChartPropertiesGenerator()], null},
            {"DataSheet", "SalesTable", "SheetData", [], SalesData},
            {"ChartSheet", "SalesChart", "Chart", [ChartType = "Column"], buildReference("SalesTable")}
        }
    )
in
    excelDocument

Diagramme und Datenplatzierung

Wenn Sie ein Diagrammteil erstellen, können Sie steuern, wo das Diagramm und die zugehörigen Daten in der Arbeitsmappe angezeigt werden.

Diagramm mit separatem Datenblatt

Wenn ein Diagramm mit der meta [Name = "..."] Syntax auf Daten aus einem anderen Teil verweist, werden die Daten und das Diagramm auf separaten Blättern platziert.

let
    // Helper function to create a reference to another part
    buildReference = (name as text) => #table({}, {}) meta [Name = name],

    excelDocument = #table(
        type table [Sheet = nullable text, Name = nullable text, PartType = nullable text, Properties = nullable record, Data = any],
        {
            {"Workbook", "Workbook", "Workbook", [ChartInferenceFunction = Office.InferChartPropertiesGenerator()], null},
            // Data on its own sheet
            {"DataSheet", "SalesTable", "SheetData", [], SalesData},
            // Chart on a different sheet, referencing the data
            {"ChartSheet", "SalesChart", "Chart", [ChartType = "Line"], buildReference("SalesTable")}
        }
    )
in
    excelDocument

Diagramm mit Inlinedaten

Wenn ein Diagrammteil Daten direkt enthält (ohne auf einen anderen Teil zu verweisen), werden sowohl die Daten als auch das Diagramm auf demselben Blatt erstellt:

let
    excelDocument = #table(
        type table [Sheet = nullable text, Name = nullable text, PartType = nullable text, Properties = nullable record, Data = any],
        {
            {"Workbook", "Workbook", "Workbook", [ChartInferenceFunction = Office.InferChartPropertiesGenerator()], null},
            // Data and chart appear together on the same sheet
            {"SalesSheet", "SalesChart", "Chart", [ChartType = "Column"], SalesData}
        }
    )
in
    excelDocument

Dieser Ansatz ist praktisch, wenn Benutzer die Daten zusammen mit der Visualisierung anzeigen möchten.

Mehrere Diagramme mit Inlinedaten auf demselben Blatt

Wenn mehrere Diagrammteile Inlinedaten enthalten (keine Verweise), erstellt jedes Diagramm eine eigene Sicherungsdatentabelle auf demselben Blatt. Das System positioniert diese Sicherungstabellen automatisch, um Überschneidungen mithilfe der automatischen Positionierung zu vermeiden. Sie können die Darstellung der zugrunde liegenden Tabelle steuern, indem Sie TableStyle, AutoPositionColumnOffset und AutoPositionRowOffset im Diagrammteil angeben.

let
    ProductData = #table(
        type table [Product = text, Sales = number],
        {{"Widget", 100}, {"Gadget", 200}, {"Gizmo", 150}}
    ),

    RegionData = #table(
        type table [Region = text, Revenue = number],
        {{"North", 5000}, {"South", 3000}, {"East", 4000}}
    ),

    excelDocument = #table(
        type table [Sheet = nullable text, Name = nullable text, PartType = nullable text, Properties = nullable record, Data = any],
        {
            // First chart with inline data - backing table auto-positioned
            {"Dashboard", "ProductChart", "Chart",
                [
                    Bounds = "B2:H15",
                    ChartType = "Column",
                    ChartTitle = "Product Sales",
                    DataSeries = [AxisColumns = {"Product"}, ValueColumns = {"Sales"}]
                ],
                ProductData
            },
            // Second chart with inline data - backing table auto-positioned after first
            {"Dashboard", "RegionChart", "Chart",
                [
                    Bounds = "J2:P15",
                    ChartType = "Pie",
                    ChartTitle = "Revenue by Region",
                    TableStyle = "TableStyleLight1",  // Style for the backing table
                    AutoPositionRowOffset = 2,        // Add extra row gap from previous table
                    DataSeries = [AxisColumns = {"Region"}, ValueColumns = {"Revenue"}]
                ],
                RegionData
            }
        }
    )
in
    excelDocument

Tabellen- und Bereichskomponenten

Table und Range Teile bieten mehr Kontrolle über die Datenplatzierung als SheetData. Verwenden Sie sie, wenn Sie mehrere Datenbereiche auf demselben Blatt benötigen oder eine bestimmte Positionierung erfordern.

Tabellenteil

Der Table Teil erstellt eine Excel-Tabelle mit Formatierung, Filterdropdowns und strukturierten Verweisen. Verwenden Sie sie, wenn Sie Excel-Tabellenfeatures verwenden möchten.

let
    excelDocument = #table(
        type table [Sheet = nullable text, Name = nullable text, PartType = nullable text, Properties = nullable record, Data = any],
        {
            // Table with explicit position and custom style
            {"Sales", "SalesTable", "Table",
                [StartCell = "B3", TableStyle = "TableStyleMedium9"],
                SalesData
            }
        }
    )
in
    excelDocument

Bereichsteil

Der Range Teil erstellt einen Datenbereich ohne Excel-Tabellenformatierung. Verwenden Sie sie, wenn Sie Rohdaten ohne Tabellenfeatures benötigen.

let
    excelDocument = #table(
        type table [Sheet = nullable text, Name = nullable text, PartType = nullable text, Properties = nullable record, Data = any],
        {
            // Range at a specific position
            {"Data", "DataRange", "Range",
                [StartCell = "D5"],
                SalesData
            }
        }
    )
in
    excelDocument

Mehrere Tabellen auf demselben Blatt

Sie können mehrere Table Oder Range Teile auf demselben Blatt platzieren, solange sie nicht überlappen.

let
    SummaryData = #table(type table [Metric = text, Value = number], {{"Total", 50000}, {"Average", 5000}}),

    excelDocument = #table(
        type table [Sheet = nullable text, Name = nullable text, PartType = nullable text, Properties = nullable record, Data = any],
        {
            // Two tables side by side
            {"Report", "DetailTable", "Table",
                [StartCell = "A1", TableStyle = "TableStyleMedium9"],
                SalesData
            },
            {"Report", "SummaryTable", "Table",
                [StartCell = "I1", TableStyle = "TableStyleLight15"],
                SummaryData
            }
        }
    )
in
    excelDocument

Automatische Positionierung

Wenn Sie StartCell nicht angeben (oder auf "auto" festlegen), positioniert das System Teile automatisch vertikal untereinander in der Reihenfolge, in der sie in der Navigationstabelle angezeigt werden. Dies ist nützlich, wenn Sie über mehrere Datenbereiche verfügen und keine genaue Kontrolle benötigen.

let
    DataA = #table(type table [X = number], {{1}, {2}, {3}}),
    DataB = #table(type table [Y = number], {{10}, {20}}),
    DataC = #table(type table [Z = number], {{100}}),

    excelDocument = #table(
        type table [Sheet = nullable text, Name = nullable text, PartType = nullable text, Properties = nullable record, Data = any],
        {
            // First table: starts at B2 (column offset 1, row offset 1)
            {"AutoSheet", "Table1", "Table", [], DataA},
            // Second table: starts at B + (3 data rows + 1 header + 1 gap) = B7
            {"AutoSheet", "Table2", "Table", [], DataB},
            // Third table: continues below Table2
            {"AutoSheet", "Table3", "Table", [], DataC}
        }
    )
in
    excelDocument

So ändern Sie das Positionierungsverhalten:

let
    DataA = #table(type table [X = number], {{1}, {2}, {3}}),
    DataB = #table(type table [Y = number], {{10}, {20}}),

    excelDocument = #table(
        type table [Sheet = nullable text, Name = nullable text, PartType = nullable text, Properties = nullable record, Data = any],
        {
            // Start at column C (offset 2), row 4 (offset 3)
            {"CustomOffset", "Table1", "Table",
                [AutoPositionColumnOffset = 2, AutoPositionRowOffset = 3],
                DataA
            },
            // Start at column A (offset 0), with 2 row gap
            {"CustomOffset", "Table2", "Table",
                [AutoPositionColumnOffset = 0, AutoPositionRowOffset = 2],
                DataB
            }
        }
    )
in
    excelDocument

Überschneidungen

Das System erkennt und meldet überlappende Bereiche. Wenn zwei Komponenten in dieselben Zellen schreiben würden, wird ein Fehler ausgegeben.

So vermeiden Sie Überlappungen:

• Automatische Positionierung verwenden und das System Teile vertikal anordnen lassen
• Stellen Sie bei Verwendung expliziter StartCell Werte sicher, dass Teile keine Zellen teilen
• Berücksichtigen Sie beim Berechnen von Positionen die Kopfzeile (Tabellen enthalten immer eine Kopfzeile, in Bereichen ist sie optional)

Spaltenbreiten

Spaltenbreiten werden automatisch basierend auf Inhalten und Datentypen berechnet. Wenn mehrere Bereiche die gleichen Spalten teilen, bestimmt die oberste Zeile (durch die erste Zeile) die Spaltenbreite für diese gemeinsamen Spalten.

ShowGridlines-Eigenschaft

Die ShowGridlines Eigenschaft steuert, ob die Gitternetzlinien von Excel für ein Blatt sichtbar sind. Diese Eigenschaft kann auf SheetData, Table, Range oder Chart Teile festgelegt werden und wirkt sich auf das gesamte Blatt aus. Wenn true (Standard) sichtbar sind, werden die Gitternetzlinien angezeigt. Wenn false, Gitternetzlinien ausgeblendet sind.

Wenn auf einem Blatt ein Teil explizit ShowGridlines auf false festlegt, blendet das gesamte Blatt Gitternetzlinien aus.

let
    excelDocument = #table(
        type table [Sheet = nullable text, Name = nullable text, PartType = nullable text, Properties = nullable record, Data = any],
        {
            // Hide gridlines for this sheet
            {"CleanReport", "DataTable", "Table",
                [ShowGridlines = false, StartCell = "B2"],
                SalesData
            }
        }
    )
in
    excelDocument

Arbeitsmappeneigenschaften

Mit dem Workbook Teiltyp können Sie Einstellungen auf Dokumentebene konfigurieren. Wenn sie verwendet wird, muss sie die erste Zeile in der Navigationstabelle sein.

Beispiel für Arbeitsmappeneigenschaften

let
    excelDocument = #table(
        type table [Sheet = nullable text, Name = nullable text, PartType = nullable text, Properties = nullable record, Data = any],
        {
            // Workbook configuration (must be first)
            {"Workbook", "Workbook", "Workbook", 
                [
                    ChartInferenceFunction = Office.InferChartPropertiesGenerator([
                        Allow3DCharts = false,
                        PreferMultilevelChartInference = true
                    ]),
                    StrictNameHandling = false
                ], 
                null
            },
            // Data and charts follow
            {"Sales", "SalesTable", "SheetData", [], SalesData}
        }
    )
in
    excelDocument

Mehrere Diagramme mit gemeinsam genutzten Daten

Diagramme können auf dieselbe Datenquelle verweisen, sodass Sie mehrere Visualisierungen desselben Datasets erstellen können, ohne die Daten in der Arbeitsmappe zu duplizieren.

Verwenden Sie die meta [Name = "..."] Syntax, um Verweise zu erstellen. Die Name Spalte muss für den Datenteil angegeben werden, damit Diagramme den Verweis auflösen können.

let
    // Helper function to create a reference
    buildReference = (name as text) => #table({}, {}) meta [Name = name],

    excelDocument = #table(
        type table [Sheet = nullable text, Name = nullable text, PartType = nullable text, Properties = nullable record, Data = any],
        {
            // Single data source - Name is required for reference resolution
            {"Data", "SalesTable", "SheetData", [], SalesData},
            
            // Multiple charts referencing the same data
            // Each chart must specify DataSeries with AxisColumns and ValueColumns
            {"LineChart", "TrendChart", "Chart", 
                [
                    ChartType = "Line", 
                    ChartTitle = "Sales Trend",
                    DataSeries = [AxisColumns = {"Quarter"}, ValueColumns = {"Revenue"}]
                ],
                buildReference("SalesTable")
            },
            {"PieChart", "DistributionChart", "Chart",
                [
                    ChartType = "Pie", 
                    ChartTitle = "Sales Distribution",
                    DataSeries = [AxisColumns = {"Region"}, ValueColumns = {"Revenue"}]
                ],
                buildReference("SalesTable")
            },
            {"BarChart", "ComparisonChart", "Chart",
                [
                    ChartType = "Bar", 
                    ChartTitle = "Product Comparison",
                    DataSeries = [AxisColumns = {"Product"}, ValueColumns = {"Revenue", "Units"}]
                ],
                buildReference("SalesTable")
            }
        }
    )
in
    excelDocument

Verweise funktionieren sowohl in Vorwärts- als auch in Rückwärtsrichtung – ein Diagramm kann später in der Tabelle definierten Daten verweisen, und mehrere Diagramme können auf dieselbe Datenquelle verweisen.

Typ-Facetten und Zellformatierung

Power Query-Datentypen und ihre Facets beeinflussen direkt, wie Zellen in der generierten Excel-Datei formatiert werden. Das Typsystem bietet umfangreiche Formatierungsfunktionen, die in geeignete Excel-Zahlenformate übersetzt werden.

Grundlegende Typzuordnungen

Verwendung von Typfacetten für präzise Formatierung

Mit Typfacetten können Sie die Präzision und Skalierung für numerische Werte festlegen.

let
    // Define types with specific facets
    currencyType = Type.ReplaceFacets(Currency.Type, 
        [NumericPrecisionBase = 10, NumericPrecision = 19, NumericScale = 4]),
    
    percentageType = Type.ReplaceFacets(Percentage.Type, 
        [NumericPrecisionBase = 10, NumericPrecision = 5, NumericScale = 2]),
    
    decimalType = Type.ReplaceFacets(Decimal.Type, 
        [NumericPrecisionBase = 10, NumericPrecision = 10, NumericScale = 4]),

    // Create table with typed columns
    tableType = type table [
        Product = Text.Type,
        Price = currencyType,           // Displays as currency with 4 decimal places
        Discount = percentageType,       // Displays as percentage with 2 decimal places
        TaxRate = decimalType           // Displays as number with 4 decimal places
    ],

    pricingData = #table(tableType, {
        {"Widget", 29.9999, 0.15, 0.0825},
        {"Gadget", 49.9500, 0.20, 0.0825}
    }),

    // Create navigation table with the typed data
    excelDocument = #table(
        type table [PartType = nullable text, Data = any],
        {
            {"SheetData", pricingData}
        }
    )
in
    excelDocument

DateTime-Genauigkeit

Mit dem DateTimePrecision Facet können Sie die Genauigkeit von Zeitkomponenten steuern:

let
    // Time with millisecond precision
    timeWithMs = Type.ReplaceFacets(Time.Type, [DateTimePrecision = 3]),
    
    // DateTime with microsecond precision (Excel maximum is 3 digits)
    dateTimeWithPrecision = Type.ReplaceFacets(DateTime.Type, [DateTimePrecision = 7]),

    tableType = type table [
        EventName = Text.Type,
        EventTime = timeWithMs,
        Timestamp = dateTimeWithPrecision
    ],

    eventsData = #table(tableType, {
        {"Start", #time(9, 30, 15.123), #datetime(2025, 1, 15, 9, 30, 15.1234567)},
        {"End", #time(17, 45, 30.456), #datetime(2025, 1, 15, 17, 45, 30.9876543)}
    }),

    // Create navigation table with the typed data
    excelDocument = #table(
        type table [PartType = nullable text, Data = any],
        {
            {"SheetData", eventsData}
        }
    )
in
    excelDocument

Diagrammkonfiguration

Diagramme werden über den Properties Datensatz konfiguriert. Sie können explizit Diagrammeinstellungen angeben oder auf das Ableitungsmodul zurückgreifen, um geeignete Werte zu ermitteln.

Diagrammeigenschaften

Diagrammpositionierung

Die Bounds Eigenschaft steuert, wo ein Diagramm platziert wird und dessen Größe. Sie können Grenzen als Textwert mithilfe der Excel-Bereichssyntax oder als Datensatz mit detaillierten Positionierungsoptionen angeben.

Standardpositionierung

Wenn Bounds nicht angegeben, werden Diagramme an einer Standardposition ab Zelle H8 mit einer Standardgröße von 8 Spalten breit und 16 Zeilen hoch positioniert. Mehrere Diagramme auf demselben Blatt werden sich ohne eine explizite Bounds Position an dieser Standardposition überlappen.

Textformat (Excel-Bereichssyntax)

Verwenden Sie einen einzelnen Zellenbezug für die obere linke Ecke (Standardgröße von 8 Spalten x 16 Zeilen) oder einen Bereich für explizite Dimensionen:

// Single cell: chart starts at B2 with default size
[Bounds = "B2"]

// Range: chart fills the area from G6 to N21
[Bounds = "G6:N21"]

Datensatzformat mit Breite und Höhe

Geben Sie die obere linke Ecke und abmessungen an:

[Bounds = [
    FromColumn = "B",   // or 1 for column B
    FromRow = 1,        // Row 2 (0-based)
    Width = 8,          // 8 columns wide
    Height = 16         // 16 rows tall
]]

Datensatzformat mit expliziten Ecken

Alternativ können Sie beide Ecken des Diagrammbereichs angeben:

[Bounds = [
    FromColumn = "A",
    FromRow = 0,
    ToColumn = "H",
    ToRow = 16
]]

Hilfsfunktion des Rasterlayouts

Wenn Sie mehrere Diagramme auf einem Blatt platzieren, können Sie eine Hilfsfunktion verwenden, um Rasterpositionen zu berechnen:

let
    // Helper function to calculate chart bounds in a grid layout
    GetGridBounds = (
        chartNumber as number,       // 1-based chart number
        gridColumns as number,       // Number of columns in the grid
        optional width as number,    // Chart width (default: 8)
        optional height as number,   // Chart height (default: 16)
        optional hPadding as number, // Horizontal padding (default: 1)
        optional vPadding as number  // Vertical padding (default: 1)
    ) as record =>
        let
            w = width ?? 8,
            h = height ?? 16,
            hp = hPadding ?? 1,
            vp = vPadding ?? 1,
            cols = if gridColumns < 1 then 1 else gridColumns,

            x = Number.Mod(chartNumber - 1, cols) * (w + hp),
            y = Number.IntegerDivide(chartNumber - 1, cols) * (h + vp)
        in
            [FromColumn = x, FromRow = y, ToColumn = x + w, ToRow = y + h],

    buildReference = (name as text) => #table({}, {}) meta [Name = name],

    excelDocument = #table(
        type table [Sheet = nullable text, Name = nullable text, PartType = nullable text, Properties = nullable record, Data = any],
        {
            {"Data", "SalesTable", "SheetData", [], SalesData},
            // 2x2 grid of charts
            {"Dashboard", "Chart1", "Chart",
                [ChartType = "Column", Bounds = GetGridBounds(1, 2),
                 DataSeries = [AxisColumns = {"Region"}, ValueColumns = {"Revenue"}]],
                buildReference("SalesTable")},
            {"Dashboard", "Chart2", "Chart",
                [ChartType = "Line", Bounds = GetGridBounds(2, 2),
                 DataSeries = [AxisColumns = {"Region"}, ValueColumns = {"Revenue"}]],
                buildReference("SalesTable")},
            {"Dashboard", "Chart3", "Chart",
                [ChartType = "Pie", Bounds = GetGridBounds(3, 2),
                 DataSeries = [AxisColumns = {"Region"}, ValueColumns = {"Revenue"}]],
                buildReference("SalesTable")},
            {"Dashboard", "Chart4", "Chart",
                [ChartType = "Bar", Bounds = GetGridBounds(4, 2),
                 DataSeries = [AxisColumns = {"Region"}, ValueColumns = {"Revenue"}]],
                buildReference("SalesTable")}
        }
    )
in
    excelDocument

Erweiterte Positionierung mit EMU-Offsets

Verwenden Sie offset-Eigenschaften, um eine präzise Positionierung innerhalb von Zellen zu erreichen. Offsets sind in EMUs (Englisch Metrische Einheiten), wobei 914400 EMUs 1 Zoll entspricht.

[Bounds = [
    FromColumn = "C",
    FromColumnOffset = 352425,
    FromRow = 6,
    FromRowOffset = 142874,
    ToColumn = "R",
    ToColumnOffset = 142875,
    ToRow = 22,
    ToRowOffset = 171449
]]

Unterstützte Diagrammtypen

DataSeries-Konfiguration

Der DataSeries Datensatz definiert, wie Ihre Daten Diagrammelementen zugeordnet werden:

* Erforderlich, es sei denn, in den Eigenschaften der Arbeitsmappe ist ein ChartInferenceFunction konfiguriert. Ohne Rückschluss löst das AxisColumns Auslassen einen Fehler "Keine Achsenspalten bereitgestellt" aus, und das Auslassen ValueColumns löst einen Fehler "Keine Wertespalten bereitgestellt" aus.

Beispiel mit expliziter Diagrammkonfiguration

let
    // Quarterly data by region
    quarterlyData = #table(
        type table [Quarter = text, North = number, South = number, East = number, West = number],
        {
            {"Q1", 95000, 78000, 37000, 50000},
            {"Q2", 102000, 85000, 42000, 58000}
        }
    ),

    excelDocument = #table(
        type table [Sheet = nullable text, Name = nullable text, PartType = nullable text, Properties = nullable record, Data = any],
        {
            {"SalesChart", "QuarterlySales", "Chart",
                [
                    ChartType = "StackedColumn",
                    ChartTitle = "Quarterly Revenue by Region",
                    DataSeries = [
                        AxisColumns = {"Quarter"},
                        ValueColumns = {"North", "South", "East", "West"}
                    ]
                ],
                quarterlyData
            }
        }
    )
in
    excelDocument

Diagramme mit mehrstufigen Achsen

Bei hierarchischen Rubrikendaten können Sie mehrere Achsenspalten angeben:

let
    excelDocument = #table(
        type table [Sheet = nullable text, Name = nullable text, PartType = nullable text, Properties = nullable record, Data = any],
        {
            {"ProductChart", "Sales", "Chart",
                [
                    ChartType = "Column",
                    ChartTitle = "Product Sales by Category",
                    DataSeries = [
                        AxisColumns = {"Category", "Product"},
                        ValueColumns = {"Revenue"},
                        PrimaryAxisColumn = "Product"  // Use Product as the label
                    ]
                ],
                SalesData
            }
        }
    )
in
    excelDocument

Verwenden von Office.InferChartPropertiesGenerator

Die Office.InferChartPropertiesGenerator Funktion erstellt ein Rückschlussmodul, das automatisch Diagrammeigenschaften basierend auf Ihren Daten bestimmt. Diese Funktion ist nützlich, wenn Sie vernünftige Standardwerte verwenden möchten, ohne jedes Diagrammkonfigurationsdetail anzugeben.

Grundlegende Nutzung

let
    excelDocument = #table(
        type table [Sheet = nullable text, Name = nullable text, PartType = nullable text, Properties = nullable record, Data = any],
        {
            {"Workbook", "Workbook", "Workbook",
                [ChartInferenceFunction = Office.InferChartPropertiesGenerator()],
                null
            },
            // Charts without explicit ChartType will use inference
            {"Chart1", "AutoChart", "Chart", [], SalesData}
        }
    )
in
    excelDocument

Rückschlussoptionen

Office.InferChartPropertiesGenerator akzeptiert einen optionalen Datensatz mit den folgenden Optionen:

Beispiel mit Rückschlussoptionen

let
    chartInference = Office.InferChartPropertiesGenerator([
        Allow3DCharts = true,
        PreferMultilevelChartInference = true
    ]),

    excelDocument = #table(
        type table [Sheet = nullable text, Name = nullable text, PartType = nullable text, Properties = nullable record, Data = any],
        {
            {"Workbook", "Workbook", "Workbook",
                [ChartInferenceFunction = chartInference],
                null
            },
            {"Sales", "SalesChart", "Chart", 
                [DataSeries = [AxisColumns = {"Region"}, ValueColumns = {"Revenue"}]],
                SalesData
            }
        }
    )
in
    excelDocument

Funktionsweise von Rückschlüssen

Das Rückschlussmodul gibt einen Datensatz mit drei Funktionen zurück:

• ChartType: Analysiert das Datenschema und bestimmt den optimalen Diagrammtyp basierend auf:

  • Anzahl der Datenreihen
  • Anzahl der Kategorien
  • Gibt an, ob Achsenspalten Datumszeit, numerisch oder kategorisch sind.
  • Zeilenanzahl

• ChartTitle: Generiert einen beschreibenden Titel basierend auf dem Diagrammtyp und den Spaltennamen.

• DataSeries: Leitet Achsen- und Wertspalten aus dem Tabellenschema ab:

  • Datetime-Spalten werden als Achsenspalten bevorzugt.
  • Kategorische Spalten (Text) werden als Achsenspalten berücksichtigt.
  • Numerische Spalten werden zu Wertspalten

Diagrammtyp-Auswahl-Logik

Das Ableitungsmodul wählt Diagrammtypen basierend auf Datenmerkmalen aus:

Benutzerdefinierte Ableitungsfunktion

Sie können eine eigene Rückschlussfunktion bereitstellen, die auf dieselbe Schnittstelle folgt:

let
    customInference = () as record => [
        ChartType = (partName, columns, dataSeries, rowCount) => 
            if rowCount < 10 then "Pie" else "Column",
        
        ChartTitle = (partName, chartType, dataSeries) => 
            partName & " Chart",
        
        DataSeries = (partName, columns) => [
            AxisColumns = {"Category"},
            ValueColumns = {"Revenue"}
        ]
    ],

    excelDocument = #table(
        type table [Sheet = nullable text, Name = nullable text, PartType = nullable text, Properties = nullable record, Data = any],
        {
            {"Workbook", "Workbook", "Workbook",
                [ChartInferenceFunction = customInference],
                null
            },
            {"Data", "CustomChart", "Chart", [], SalesData}
        }
    )
in
    excelDocument

Erweiterte Szenarien

In diesem Abschnitt werden programmgesteuerte Ansätze zum dynamischen Generieren von Navigationstabellen behandelt.

Partitionieren von Daten in mehrere Blätter

Sie können die Listen- und Tabellenfunktionen von Power Query verwenden, um Blätter basierend auf Datenwerten dynamisch zu erstellen.

Verwenden von "Table.Group"

Gruppieren Sie Daten nach einer Spalte, und erstellen Sie ein Blatt für jede Gruppe:

let
    groupedData = Table.Group(
        SalesData, 
        {"Region"}, 
        {{"RegionData", each _, type table}}
    ),

    excelDocument = Table.FromRecords(
        List.Transform(
            Table.ToRecords(groupedData),
            (row) => [
                Sheet = row[Region],
                PartType = "SheetData",
                Data = row[RegionData]
            ]
        )
    )
in
    excelDocument

Verwenden von Table.Partition

Partitionieren Sie eine Tabelle basierend auf einer benutzerdefinierten Hashfunktion in Gruppen. In diesem Beispiel werden Umsatzdaten in Umsatz-Buckets unterteilt:

let
    Low_Revenue_Group_Index = 0,
    Medium_Revenue_Group_Index = 1,
    High_Revenue_Group_Index = 2,
    NumberOfPartitions = 3,

    RevenueRangeHash = (revenue as number) as number => 
        if revenue >= 40000 then High_Revenue_Group_Index
        else if revenue >= 25000 then Medium_Revenue_Group_Index
        else Low_Revenue_Group_Index,
    
    PartitionedList = Table.Partition(
        SalesData, 
        "Revenue", 
        NumberOfPartitions, 
        RevenueRangeHash 
    ),
    
    BucketNames = {
        "Low Revenue (< $25K)",      
        "Medium Revenue ($25K - $40K)", 
        "High Revenue (> $40K)"    
    },
    
    NamedPartitions = Table.FromColumns(
        {BucketNames, PartitionedList},
        type table [Sheet = text, Data = table]
    ),

    excelDocument = Table.AddColumn(NamedPartitions, "PartType", each "SheetData", type text)
in
    excelDocument

Benutzerdefinierte Partitionierungsfunktion

Verwenden Sie für mehr Kontrolle eine benutzerdefinierte Partitionierungsfunktion:

let
    partitionByColumn = (table as table, columnName as text, maxPartitions as number) as table =>
        let
            distinctValues = List.Distinct(Table.Column(table, columnName)),
            limitedValues = List.FirstN(distinctValues, maxPartitions),
            partitionedTable = Table.FromRecords(
                List.Transform(
                    limitedValues, 
                    (value) => [
                        Sheet = columnName & " - " & Text.From(value),
                        PartType = "SheetData",
                        Data = Table.SelectRows(table, each Record.Field(_, columnName) = value)
                    ]
                )
            )
        in
            partitionedTable,

    // Create sheets for each unique Region value (up to 10)
    excelDocument = partitionByColumn(SalesData, "Region", 10)
in
    excelDocument

Dynamische Diagramme für partitionierte Daten

Kombinieren Sie die Partitionierung mit Diagrammen, um Visualisierungen für jede Gruppe zu erstellen:

let
    buildReference = (name as text) => #table({}, {}) meta [Name = name],

    createPartitionWithChart = (table as table, columnName as text) as table =>
        let
            distinctValues = List.Distinct(Table.Column(table, columnName)),
            partitionRows = List.Transform(
                distinctValues,
                (value) => 
                    let
                        partitionData = Table.SelectRows(table, each Record.Field(_, columnName) = value),
                        sheetName = Text.From(value),
                        dataName = "Data_" & sheetName,
                        chartName = "Chart_" & sheetName
                    in
                        {
                            {sheetName, dataName, "SheetData", [], partitionData},
                            {sheetName & " Chart", chartName, "Chart", 
                                [ChartType = "Column", ChartTitle = sheetName & " Analysis"],
                                buildReference(dataName)}
                        }
            ),
            workbookRow = {{"Workbook", "Workbook", "Workbook", [ChartInferenceFunction = Office.InferChartPropertiesGenerator()], null}}
        in
            #table(
                type table [Sheet = nullable text, Name = nullable text, PartType = nullable text, Properties = nullable record, Data = any],
                List.Combine({workbookRow} & partitionRows)
            ),

    excelDocument = createPartitionWithChart(SalesData, "Region")
in
    excelDocument

Allgemeine Muster

Dieser Abschnitt enthält einsatzbereite Vorlagen für häufige Szenarien. Kopieren Sie diese Muster, und passen Sie sie an Ihre Bedürfnisse an.

Muster: Einfacher Datenexport

Exportieren Einer einzelnen Tabelle nach Excel mit minimaler Konfiguration:

let
    excelDocument = #table(
        type table [PartType = nullable text, Data = any],
        {{"SheetData", YourDataTable}}
    )
in
    excelDocument

Muster: Mehrere Blätter aus einer Liste

Erstellen Eines Blatts pro Element in einer Liste:

let
    // Assume you have a list of {Name, Table} pairs
    dataSets = {
        {"Sales", SalesTable},
        {"Inventory", InventoryTable},
        {"Customers", CustomersTable}
    },
    
    excelDocument = #table(
        type table [Sheet = text, PartType = text, Data = table],
        List.Transform(dataSets, each {_{0}, "SheetData", _{1}})
    )
in
    excelDocument

Muster: Daten mit Diagramm auf demselben Blatt

Erstellen Sie ein Blatt mit Daten und deren Visualisierung:

let
    excelDocument = #table(
        type table [Sheet = nullable text, Name = nullable text, PartType = nullable text, Properties = nullable record, Data = any],
        {
            {"Workbook", "Workbook", "Workbook", [ChartInferenceFunction = Office.InferChartPropertiesGenerator()], null},
            {"Report", "SalesChart", "Chart", 
                [ChartType = "Column", Bounds = "F2:M18"], 
                YourDataTable
            }
        }
    )
in
    excelDocument

Muster: Dashboard mit mehreren Diagrammen, die Daten teilen

Erstellen Sie ein Dashboardblatt mit mehreren Diagrammen, die auf eine Datenquelle verweisen:

let
    ref = (name as text) => #table({}, {}) meta [Name = name],
    
    excelDocument = #table(
        type table [Sheet = nullable text, Name = nullable text, PartType = nullable text, Properties = nullable record, Data = any],
        {
            {"Data", "SourceData", "SheetData", [], YourDataTable},
            {"Dashboard", "Chart1", "Chart", 
                [ChartType = "Column", Bounds = "A1:H16", 
                 DataSeries = [AxisColumns = {"Category"}, ValueColumns = {"Value1"}]], 
                ref("SourceData")},
            {"Dashboard", "Chart2", "Chart", 
                [ChartType = "Line", Bounds = "J1:Q16", 
                 DataSeries = [AxisColumns = {"Category"}, ValueColumns = {"Value2"}]], 
                ref("SourceData")}
        }
    )
in
    excelDocument

Muster: Nebeneinander angeordnete Tabellen

Platzieren Sie zwei Tabellen nebeneinander auf demselben Blatt:

let
    excelDocument = #table(
        type table [Sheet = nullable text, Name = nullable text, PartType = nullable text, Properties = nullable record, Data = any],
        {
            {"Report", "MainData", "Table", 
                [StartCell = "A1", TableStyle = "TableStyleMedium2"], 
                MainTable},
            {"Report", "Summary", "Table", 
                [StartCell = "H1", TableStyle = "TableStyleLight15"], 
                SummaryTable}
        }
    )
in
    excelDocument

Muster: Gestapelte Tabellen mit automatischer Positionierung

Stapeln Sie mehrere Tabellen vertikal mit automatischem Abstand:

let
    excelDocument = #table(
        type table [Sheet = nullable text, Name = nullable text, PartType = nullable text, Properties = nullable record, Data = any],
        {
            {"Report", "Section1", "Table", [], Table1},
            {"Report", "Section2", "Table", [AutoPositionRowOffset = 2], Table2},
            {"Report", "Section3", "Table", [AutoPositionRowOffset = 2], Table3}
        }
    )
in
    excelDocument

Muster: Bericht ohne Gitternetzlinien bereinigen

Erstellen Sie einen ansprechenden Bericht mit ausgeblendeten Gitternetzlinien:

let
    excelDocument = #table(
        type table [Sheet = nullable text, Name = nullable text, PartType = nullable text, Properties = nullable record, Data = any],
        {
            {"Report", "Data", "Table", 
                [StartCell = "B2", ShowGridlines = false, TableStyle = "TableStyleMedium9"], 
                YourDataTable}
        }
    )
in
    excelDocument

Hinweise und Einschränkungen

Excel-Grenzwerte

Excel hat inhärente Einschränkungen, die sich auf die Dokumentgenerierung auswirken:

• Maximale Zeilen pro Arbeitsblatt: 1.048.576 Zeilen
• Maximale Spalten pro Arbeitsblatt: 16.384 Spalten
• Maximale Zeichen pro Zelle: 32.767 Zeichen
• Maximale Länge des Blattnamens: 31 Zeichen
• Blattnamen dürfen nicht enthalten: \ / ? * [ ] oder beginnen/enden mit '

Wenn Ihre Daten diese Grenzwerte überschreiten, sollten Sie sie auf mehreren Blättern partitionieren.

Fehlerbehandlung

Fehler auf Zellenebene in Ihren Daten führen dazu, dass die Dokumentgenerierung fehlschlägt. Der Connector überprüft Daten, während er jede Zeile verarbeitet, und beim Auftreten eines Fehlerwerts (z. B. eine Division durch Null oder ein Typkonvertierungsfehler) wird eine Ausnahme ausgelöst.

So verhindern Sie Fehler:

• Verwenden von try...otherwise Ausdrücken zum Behandeln potenzieller Fehler vor dem Exportieren
• Ersetzen von Fehlerwerten durch entsprechende Standardwerte oder Nullwerte
• Überprüfen der Datenqualität vor dem Erstellen der Navigationstabelle

let
    RawData = #table(
        type table [Product = text, Amount = text],
        {
            {"Laptop", "1250.50"},
            {"Phone", "N/A"},
            {"Tablet", "850.00"}
        }
    ),
    
    cleanData = Table.TransformColumns(
        RawData,
        {{"Amount", each try Number.From(_) otherwise null, type nullable number}}
    ),
    
    excelDocument = #table(
        type table [PartType = nullable text, Data = any],
        {{"SheetData", cleanData}}
    )
in
    excelDocument

Namensverarbeitung

Blatt- und Teilenamen werden automatisch bereinigt, um den Excel-Benennungsregeln zu entsprechen. Ungültige Zeichen werden entfernt, und Namen werden auf 31 Zeichen abgeschnitten. Wenn StrictNameHandling in den Arbeitsmappeneigenschaften aktiviert ist, wird anstatt der automatischen Bereinigung ein Fehler ausgelöst.

Doppelte Blattnamen werden automatisch durch Anfügen eines numerischen Suffixes eindeutig gemacht.

Problembehandlung

In diesem Abschnitt werden häufig auftretende Fehler behandelt, die beim Erstellen von Navigationstabellen auftreten können, und wie sie behoben werden können.

Fehlerreferenz

Häufig auftretende Probleme

Probleme mit der Navigationstabellenstruktur

Problem: Fehler bei der Dokumentgenerierung mit "Fehlender Wert" oder Schemafehlern.

Ursache: In der Navigationstabelle fehlen erforderliche Spalten oder falsche Spaltentypen.

Lösung: Überprüfen Sie, ob Die Navigationstabelle die richtigen Spalten mit den richtigen Typen enthält:

type table [
    Sheet = nullable text,        // Optional: worksheet name
    Name = nullable text,         // Unique identifier for the part
    PartType = nullable text,     // "Workbook", "SheetData", "Table", "Range", or "Chart"
    Properties = nullable record, // Configuration options
    Data = any                    // Table, table reference, or null
]

Diagrammanalyse funktioniert nicht

Problem: Diagramme können aufgrund des Fehlers „Keine Achsen-/Wertspalten bereitgestellt“ nicht generiert werden.

Ursache: Es fehlen keine ChartInferenceFunction konfigurierten und expliziten Spaltenzuordnungen.

Lösung: Fügen Sie entweder einen Arbeitsmappenteil mit der Ableitungsfunktion als erste Zeile hinzu:

{"Workbook", "Workbook", "Workbook", [ChartInferenceFunction = Office.InferChartPropertiesGenerator()], null}

Oder geben Sie explizit für jedes Diagramm an DataSeries :

[DataSeries = [AxisColumns = {"Category"}, ValueColumns = {"Revenue", "Profit"}]]

Tabellenverweise, die nicht aufgelöst werden

Problem: Fehler "Referenzierte Tabelle wurde nicht gefunden", wenn Tabellenverweise verwendet werden.

Ursache: Die Name Metadaten für den Verweis stimmen nicht mit einem Datenteil überein.

Lösung: Stellen Sie sicher, dass der Metadatenname exakt übereinstimmt:

let
    // Data part with name "SalesData"
    dataRow = {"Sales", "SalesData", "SheetData", [], actualTable},
    
    // Chart referencing the data - name must match
    chartRow = {"Chart", "SalesChart", "Chart", [], #table({}, {}) meta [Name = "SalesData"]}
in
    ...

Datentypfehler in Zellen

Problem: Fehler bei der Dokumentgenerierung beim Verarbeiten bestimmter Zeilen.

Ursache: Ihre Daten enthalten Fehlerwerte (z. B. Division durch Null oder Typkonvertierungsfehler).

Lösung: Bereinigen Sie Fehlerwerte vor dem Exportieren:

Table.TransformColumns(
    YourTable,
    {{"ColumnName", each try _ otherwise null}}
)

Nicht unterstützte Datums- oder Uhrzeitwerte

Problem: Fehler "Der angegebene Wert ist in Excel nicht repräsentiert" beim Exportieren von Datums-/Uhrzeitdaten.

Ursache: Excel kann keine Datumsangaben vor dem 1. Januar 1900 oder die Dauer außerhalb des unterstützten Bereichs darstellen.

Lösung: Herausfiltern nicht unterstützter Werte oder Transformieren:

Table.SelectRows(YourTable, each [DateColumn] >= #date(1900, 1, 1))

SheetData- und Table/Range-Mischfehler

Problem: Fehler "Container verfügt bereits über einen SheetData-Teil" oder "Container verfügt bereits über Bereichs- oder Tabellenelemente".

Ursache: Sie können SheetData nicht mit Table oder Range Teilen auf demselben Blatt kombinieren.

Lösung: Verwenden Sie entweder SheetData allein für ein Blatt, oder verwenden Sie Table/Range Teile zusammen:

// Option 1: Use SheetData alone
{"Sheet1", "Data", "SheetData", [], myTable}

// Option 2: Use Table/Range parts for multiple regions
{"Sheet1", "Table1", "Table", [StartCell = "A1"], firstTable},
{"Sheet1", "Table2", "Table", [StartCell = "F1"], secondTable}

Konflikte bei der automatischen Positionierung

Problem: Fehler "Element gibt AutoPositionColumnOffset oder AutoPositionRowOffset an, hat aber eine explizite StartCell".

Ursache: Sie können bei expliziter Festlegung keine Offsets StartCell für die automatische Positionierung verwenden.

Lösung: Entfernen Sie entweder StartCell zur automatischen Positionierung, oder entfernen Sie die Offseteigenschaften.

// Auto positioning with custom offsets (no StartCell)
{"Sheet1", "Table1", "Table", [AutoPositionColumnOffset = 2, AutoPositionRowOffset = 1], myTable}

// Or explicit positioning (no offset properties)
{"Sheet1", "Table1", "Table", [StartCell = "C2"], myTable}

Ungültige Blattnamen

Problem: Fehler beim Erwähnen eines ungültigen Containernamens oder der automatischen Bereinigung des Namens.

Ursache: Blattnamen enthalten ungültige Zeichen (\ / ? * [ ]) oder überschreiten 31 Zeichen.

Lösung: Präsanitieren Sie Ihre Blattnamen:

sanitizeName = (name as text) as text =>
    let
        cleaned = Text.Replace(Text.Replace(name, "/", "-"), "\", "-"),
        truncated = Text.Start(cleaned, 31)
    in
        truncated

Verwandte Inhalte

• Power Query M-Sprachspezifikation
• Referenz zu Tabellenfunktionen
• Power Query-Datenflüsse