Freigeben über

Vereinfachungstransformation im Zuordnungsdatenfluss

  • Artikel

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 als auch in Azure Synapse-Pipelines verfügbar. Dieser Artikel gilt für Zuordnungsdatenflüsse. Wenn Sie noch nicht mit Transformationen arbeiten, lesen Sie den Einführungsartikel Transformieren von Daten mit einem Zuordnungsdatenfluss.

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 that shows flatten settings.

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 Vereinfachungstransformation einzubeziehen. Sie können ADF-Datenflussmetafunktionen wie name und Typ type und mithilfe eines Musterabgleichs Arrays auflösen, die diesen Kriterien entsprechen. Wenn Sie mehrere Arrays in eine einzige Vereinfachungstransformation einbeziehen, ist das Ergebnis ein kartesisches Produkt aus allen möglichen Arraywerten.

Screenshot that shows flatten results.

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 auswählen, bei dem der Stamm aufgelöst werden soll. „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 in „Stamm auflösen“ enthält, wird sie aus den Ausgabedaten gelöscht. 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 Ausgabe der Zuordnung auf der Registerkarte „Überprüfen“ 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.

Flatten pattern

Vergleichsbedingung

Geben Sie eine Musterabgleichsbedingung für die Spalte oder Spalten ein, die mithilfe von exakten Übereinstimmungen oder Mustern vereinfacht werden sollen. 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.

Name stimmt überein (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 nachstehende JSON-Objekt im Zusammenhang mit den folgenden Beispielen zur Vereinfachungstransformation 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 Stamm auflösen Projektion
goods.customers Keine Namen
customer = 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 Stamm auflösen Projektion
goods.orders.shipped.orderItems Keine Namen
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 Stamm auflösen Projektion
goods.orders goods.orders Namen
goods.orders.shipped.orderItems.itemName
goods.customers
location

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 goods.orders Namen
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