Freigeben über

Vereinfachungstransformation im Zuordnungsdatenfluss

GILT FÜR: Azure Data Factory Azure Synapse Analytics

Tipp

Testen Sie Data Factory in Microsoft Fabric, eine All-in-One-Analyselösung für Unternehmen. Microsoft Fabric deckt alle Aufgaben ab, von der Datenverschiebung bis hin zu Data Science, Echtzeitanalysen, Business Intelligence und Berichterstellung. Erfahren Sie, wie Sie kostenlos eine neue Testversion starten!

Datenflüsse sind sowohl in Azure Data Factory-Pipelines als auch in Azure Synapse Analytics-Pipelines verfügbar. Dieser Artikel gilt für Datenflusszuordnungen. Wenn Sie mit Transformationen noch nicht fertig sind, lesen Sie den einführungsartikel Transformieren von Daten mithilfe von Zuordnungsdatenflüssen.

Verwenden Sie die Vereinfachungstransformation, um Arraywerte in hierarchischen Strukturen wie JSON auszuwählen und in einzelne Zeilen aufzulösen. Dieser Prozess wird als „Denormalisierung“ bezeichnet.

Konfiguration

Die Vereinfachungstransformation enthält die folgenden Konfigurationseinstellungen.

Screenshot: Einstellungen für die Vereinfachung

Auflösen

Wählen Sie ein Array aus, das aufgelöst werden soll. Die Ausgabedaten enthalten eine Zeile pro Element in jedem Array. Wenn das Array „Auflösen“ in der Eingabezeile NULL oder leer ist, gibt es eine einzige Ausgabezeile mit nicht aufgelösten Werten als NULL. Sie haben die Möglichkeit, mehr als ein Array pro Vereinfachungstransformation aufzulösen. Klicken Sie auf das Pluszeichen (+), um mehrere Arrays in eine einzige Flattening-Transformation einzubeziehen. Sie können hier ADF-Datenfluss-Metafunktionen nutzen, einschließlich name und type, und Mustererkennung nutzen, um Arrays, die diesen Kriterien entsprechen, aufzulösen. Wenn Sie mehrere Arrays in eine einzige Vereinfachungstransformation einbeziehen, ist das Ergebnis ein kartesisches Produkt aus allen möglichen Arraywerten.

Screenshot: Ergebnisse der Vereinfachung

Stamm auflösen

Standardmäßig löst die Vereinfachungstransformation ein Array an den Anfang der Hierarchie auf, in der es sich befindet. Sie können optional ein Array als Unroll-Root auswählen. „Stamm auflösen“ muss ein Array komplexer Objekte sein, dass entweder das Array „Auflösen“ ist oder dieses Array enthält. Wenn „Stamm auflösen“ ausgewählt wird, enthalten die Ausgabedaten mindestens eine Zeile pro Elemente im aufgelösten Stamm. Wenn die Eingabezeile keine Elemente im „Unroll-Root“ enthält, wird sie aus den Ausgabedaten entfernt. Wenn Sie „Stamm auflösen“ auswählen, wird immer eine Anzahl von Zeilen ausgegeben, die kleiner als das Standardverhalten oder mit ihm identisch ist.

Vereinfachen der Zuordnung

Wählen Sie ähnlich wie bei der Auswahltransformation die Projektion der neuen Struktur aus eingehenden Feldern und dem denormalisierten Array aus. Wenn ein denormalisiertes Array zugeordnet wird, stimmt der Datentyp der Ausgabespalte mit demjenigen des Arrays überein. Wenn das Array „Auflösen“ ein Array komplexer Objekte ist, das Subarrays enthält, wird bei der Zuordnung eines Elements aus diesem Subarray ein Array ausgegeben.

Überprüfen Sie Ihre Mapping-Ergebnisse auf der Registerkarte „Inspect“ und in der Datenvorschau.

Regelbasierte Zuordnung

Die Transformation zur Vereinfachung unterstützt die regelbasierte Zuordnung, sodass Sie dynamische und flexible Transformationen erstellen können, die Arrays basierend auf Regeln und Strukturen basierend auf Hierarchieebenen vereinfachen.

Muster vereinfachen

Vergleichsbedingung

Geben Sie eine Musterabgleichsbedingung für die Spalte oder Spalten ein, die Sie unter Verwendung von exakten Übereinstimmungen oder Mustern abflachen möchten. Beispiel: like(name,'cust%')

Tiefer Spaltendurchlauf

Diese optionale Einstellung weist den Dienst an, alle Unterspalten eines komplexen Objekts einzeln zu verarbeiten, statt das komplexe Objekt als ganze Spalte zu behandeln.

Hierarchieebene

Wählen Sie die Hierarchieebene aus, die Sie erweitern möchten.

Namensübereinstimmungen (RegEx)

Optional können Sie ihren Namensabgleich als regulären Ausdruck in diesem Feld ausdrücken, anstatt die obige Vergleichsbedingung zu verwenden.

Beispiele

Sehen Sie sich das folgende JSON-Objekt für die nachstehenden Beispiele der Flattening-Transformation an.

{
  "name":"MSFT","location":"Redmond", "satellites": ["Bay Area", "Shanghai"],
  "goods": {
    "trade":true, "customers":["government", "distributer", "retail"],
    "orders":[
        {"orderId":1,"orderTotal":123.34,"shipped":{"orderItems":[{"itemName":"Laptop","itemQty":20},{"itemName":"Charger","itemQty":2}]}},
        {"orderId":2,"orderTotal":323.34,"shipped":{"orderItems":[{"itemName":"Mice","itemQty":2},{"itemName":"Keyboard","itemQty":1}]}}
    ]}}
{"name":"Company1","location":"Seattle", "satellites": ["New York"],
  "goods":{"trade":false, "customers":["store1", "store2"],
  "orders":[
      {"orderId":4,"orderTotal":123.34,"shipped":{"orderItems":[{"itemName":"Laptop","itemQty":20},{"itemName":"Charger","itemQty":3}]}},
      {"orderId":5,"orderTotal":343.24,"shipped":{"orderItems":[{"itemName":"Chair","itemQty":4},{"itemName":"Lamp","itemQty":2}]}}
    ]}}
{"name": "Company2", "location": "Bellevue",
  "goods": {"trade": true, "customers":["Bank"], "orders": [{"orderId": 4, "orderTotal": 123.34}]}}
{"name": "Company3", "location": "Kirkland"}

Kein „Stamm auflösen“ bei Zeichenfolgenarray

Auflösen Wurzel entrollen Projektion
goods.customers Keine Name
Kunde = goods.customer

Ausgabe

{ 'MSFT', 'government'}
{ 'MSFT', 'distributer'}
{ 'MSFT', 'retail'}
{ 'Company1', 'store'}
{ 'Company1', 'store2'}
{ 'Company2', 'Bank'}
{ 'Company3', null}

Kein „Stamm auflösen“ bei komplexem Array

Auflösen Wurzel entrollen Projektion
goods.orders.shipped.orderItems Keine Name
orderId = goods.orders.orderId
itemName = goods.orders.shipped.orderItems.itemName
itemQty = goods.orders.shipped.orderItems.itemQty
location = location

Ausgabe

{ 'MSFT', 1, 'Laptop', 20, 'Redmond'}
{ 'MSFT', 1, 'Charger', 2, 'Redmond'}
{ 'MSFT', 2, 'Mice', 2, 'Redmond'}
{ 'MSFT', 2, 'Keyboard', 1, 'Redmond'}
{ 'Company1', 4, 'Laptop', 20, 'Seattle'}
{ 'Company1', 4, 'Charger', 3, 'Seattle'}
{ 'Company1', 5, 'Chair', 4, 'Seattle'}
{ 'Company1', 5, 'Lamp', 2, 'Seattle'}
{ 'Company2', 4, null, null, 'Bellevue'}
{ 'Company3', null, null, null, 'Kirkland'}

Dasselbe Stammverzeichnis wie „Array auflösen“

Auflösen Wurzel entrollen Projektion
Warenbestellungen Waren.Bestellungen Name
goods.orders.shipped.orderItems.itemName
goods.customers
Standort

Ausgabe

{ 'MSFT', ['Laptop','Charger'], ['government','distributer','retail'], 'Redmond'}
{ 'MSFT', ['Mice', 'Keyboard'], ['government','distributer','retail'], 'Redmond'}
{ 'Company1', ['Laptop','Charger'], ['store', 'store2'], 'Seattle'}
{ 'Company1', ['Chair', 'Lamp'], ['store', 'store2'], 'Seattle'}
{ 'Company2', null, ['Bank'], 'Bellevue'}

„Stamm auflösen“ bei komplexem Array

Auflösen Stamm auflösen Projektion
goods.orders.shipped.orderItem Waren.Bestellungen name
orderId = goods.orders.orderId
itemName = goods.orders.shipped.orderItems.itemName
itemQty = goods.orders.shipped.orderItems.itemQty
location = location

Ausgabe

{ 'MSFT', 1, 'Laptop', 20, 'Redmond'}
{ 'MSFT', 1, 'Charger', 2, 'Redmond'}
{ 'MSFT', 2, 'Mice', 2, 'Redmond'}
{ 'MSFT', 2, 'Keyboard', 1, 'Redmond'}
{ 'Company1', 4, 'Laptop', 20, 'Seattle'}
{ 'Company1', 4, 'Charger', 3, 'Seattle'}
{ 'Company1', 5, 'Chair', 4, 'Seattle'}
{ 'Company1', 5, 'Lamp', 2, 'Seattle'}
{ 'Company2', 4, null, null, 'Bellevue'}

Datenflussskript

Syntax

<incomingStream>
foldDown(unroll(<unroll cols>),
    mapColumn(
        name,
        each(<array>(type == '<arrayDataType>')),
        each(<array>, match(true())),
        location
    )) ~> <transformationName>

Beispiel

source foldDown(unroll(goods.orders.shipped.orderItems, goods.orders),
    mapColumn(
        name,
        orderId = goods.orders.orderId,
        itemName = goods.orders.shipped.orderItems.itemName,
        itemQty = goods.orders.shipped.orderItems.itemQty,
        location = location
    ),
    skipDuplicateMapInputs: false,
    skipDuplicateMapOutputs: false)

Zugehöriger Inhalt

  • Last updated on