Zum Hauptinhalt springen

Join@1

Der Node Join@1 führt Inner-Join-Operationen zwischen Quelldaten und Lookup-Arrays basierend auf übereinstimmenden Schlüsselwerten durch. Er kombiniert Datensätze aus zwei Datensätzen ähnlich wie SQL-Joins und fügt jedem Quelldatensatz alle übereinstimmenden Datensätze aus dem Lookup-Array hinzu.

Adapter-Voraussetzungen​

  • Allgemeine Verfügbarkeit: Alle Adapter unterstützen diesen Node-Typ.

Node-Konfiguration​

Für die Felder path, targetPath, targetValueWriteMode und targetValueKind siehe Überblick.

transformations:
- type: Join@1
  path: $.orders[*]                # Path to the source objects to join
  keyPath: $.orderId              # Path to the key field in source objects
  joinPath: $.orderItems[*]       # Path to the array of objects to join with
  joinKeyPath: $.orderId          # Path to the key field in join objects
  itemPath: $.items               # Path where joined records will be stored

Parameter​

Erforderliche Parameter​

ParameterTypBeschreibung
pathstringJSON-Pfad zu den Quellobjekten, die die verknüpften Daten erhalten
keyPathstringRelativer Pfad zum Schlüsselfeld in den Quellobjekten, das für den Abgleich verwendet wird
joinPathstringJSON-Pfad zum Array von Objekten, mit denen die Quelldaten verknüpft werden
joinKeyPathstringRelativer Pfad zum Schlüsselfeld in den Join-Objekten, das für den Abgleich verwendet wird
itemPathstringRelativer Pfad in den Quellobjekten, an dem das Array der übereinstimmenden Datensätze gespeichert wird

Join-Operation​

Die Join-Operation folgt diesen Schritten:

  1. Quelldatensätze auswählen: Verwendet path, um Quellobjekte auszuwählen, die die verknüpften Daten erhalten
  2. Join-Datensätze auswählen: Verwendet joinPath, um das Array von Objekten auszuwählen, die für die Verknüpfung zur Verfügung stehen
  3. Quellschlüssel extrahieren: Extrahiert für jedes Quellobjekt den Schlüsselwert mithilfe von keyPath
  4. Übereinstimmungen finden: Durchsucht die Join-Objekte nach Datensätzen, bei denen joinKeyPath mit dem Quellschlüssel übereinstimmt
  5. Ergebnisse speichern: Erstellt ein Array aller übereinstimmenden Join-Datensätze und speichert es unter itemPath

Schlüsselabgleich​

  • Der String-Vergleich beachtet Groß-/Kleinschreibung und verwendet exakten Abgleich
  • Wenn für ein Quellobjekt keine übereinstimmenden Datensätze gefunden werden, wird ein leeres Array unter itemPath gespeichert
  • Mehrere Join-Datensätze können mit einem einzelnen Quelldatensatz übereinstimmen (Many-to-Many-Beziehung)

Fehlerbehandlung​

Der Node löst einen Fehler aus, wenn:

  • Der Eingabedatenkontext null ist
  • Am angegebenen path keine Quelldaten gefunden werden
  • Am angegebenen joinPath keine Join-Daten gefunden werden
  • Ein Quelldatensatz am angegebenen keyPath keinen Schlüsselwert hat

Beispiele​

Beispiel 1: Bestellungen mit Bestellpositionen​

Verknüpfen Sie Bestellungen mit ihren zugehörigen Bestellpositionen:

transformations:
- type: Join@1
  path: $.orders[*]
  keyPath: $.orderId
  joinPath: $.orderItems[*]
  joinKeyPath: $.orderId
  itemPath: $.items

Eingabe:

{
  "orders": [
    { "orderId": "123", "customerName": "John" },
    { "orderId": "456", "customerName": "Jane" }
  ],
  "orderItems": [
    { "orderId": "123", "productName": "Widget", "quantity": 2 },
    { "orderId": "123", "productName": "Gadget", "quantity": 1 },
    { "orderId": "456", "productName": "Tool", "quantity": 3 }
  ]
}

Ausgabe:

{
  "orders": [
    {
      "orderId": "123",
      "customerName": "John",
      "items": [
        { "orderId": "123", "productName": "Widget", "quantity": 2 },
        { "orderId": "123", "productName": "Gadget", "quantity": 1 }
      ]
    },
    {
      "orderId": "456",
      "customerName": "Jane",
      "items": [
        { "orderId": "456", "productName": "Tool", "quantity": 3 }
      ]
    }
  ],
  "orderItems": [
    { "orderId": "123", "productName": "Widget", "quantity": 2 },
    { "orderId": "123", "productName": "Gadget", "quantity": 1 },
    { "orderId": "456", "productName": "Tool", "quantity": 3 }
  ]
}

Beispiel 2: Kunden mit Adressen​

Verknüpfen Sie Kunden mit ihren mehreren Adressen:

transformations:
- type: Join@1
  path: $.customers[*]
  keyPath: $.customerId
  joinPath: $.addresses[*]
  joinKeyPath: $.customerId
  itemPath: $.customerAddresses

Eingabe:

{
  "customers": [
    { "customerId": "C001", "name": "Alice" },
    { "customerId": "C002", "name": "Bob" }
  ],
  "addresses": [
    { "customerId": "C001", "type": "home", "street": "123 Main St" },
    { "customerId": "C001", "type": "work", "street": "456 Oak Ave" },
    { "customerId": "C002", "type": "home", "street": "789 Pine Rd" }
  ]
}

Ausgabe:

{
  "customers": [
    {
      "customerId": "C001",
      "name": "Alice",
      "customerAddresses": [
        { "customerId": "C001", "type": "home", "street": "123 Main St" },
        { "customerId": "C001", "type": "work", "street": "456 Oak Ave" }
      ]
    },
    {
      "customerId": "C002",
      "name": "Bob",
      "customerAddresses": [
        { "customerId": "C002", "type": "home", "street": "789 Pine Rd" }
      ]
    }
  ],
  "addresses": [
    { "customerId": "C001", "type": "home", "street": "123 Main St" },
    { "customerId": "C001", "type": "work", "street": "456 Oak Ave" },
    { "customerId": "C002", "type": "home", "street": "789 Pine Rd" }
  ]
}

Beispiel 3: Produkte mit Kategorien​

Verknüpfen Sie Produkte mit Kategorieinformationen:

transformations:
- type: Join@1
  path: $.products[*]
  keyPath: $.categoryId
  joinPath: $.categories[*]
  joinKeyPath: $.id
  itemPath: $.categoryDetails

Eingabe:

{
  "products": [
    { "id": "P001", "name": "Laptop", "categoryId": "CAT1" },
    { "id": "P002", "name": "Mouse", "categoryId": "CAT1" },
    { "id": "P003", "name": "Book", "categoryId": "CAT2" }
  ],
  "categories": [
    { "id": "CAT1", "name": "Electronics", "department": "Tech" },
    { "id": "CAT2", "name": "Books", "department": "Media" }
  ]
}

Ausgabe:

{
  "products": [
    {
      "id": "P001",
      "name": "Laptop",
      "categoryId": "CAT1",
      "categoryDetails": [
        { "id": "CAT1", "name": "Electronics", "department": "Tech" }
      ]
    },
    {
      "id": "P002",
      "name": "Mouse",
      "categoryId": "CAT1",
      "categoryDetails": [
        { "id": "CAT1", "name": "Electronics", "department": "Tech" }
      ]
    },
    {
      "id": "P003",
      "name": "Book",
      "categoryId": "CAT2",
      "categoryDetails": [
        { "id": "CAT2", "name": "Books", "department": "Media" }
      ]
    }
  ],
  "categories": [
    { "id": "CAT1", "name": "Electronics", "department": "Tech" },
    { "id": "CAT2", "name": "Books", "department": "Media" }
  ]
}

Beispiel 4: Keine übereinstimmenden Datensätze​

Wenn keine übereinstimmenden Datensätze gefunden werden, wird ein leeres Array erstellt:

transformations:
- type: Join@1
  path: $.employees[*]
  keyPath: $.departmentId
  joinPath: $.departments[*]
  joinKeyPath: $.id
  itemPath: $.departmentInfo

Eingabe:

{
  "employees": [
    { "id": "E001", "name": "John", "departmentId": "DEPT99" }
  ],
  "departments": [
    { "id": "DEPT1", "name": "Engineering" },
    { "id": "DEPT2", "name": "Marketing" }
  ]
}

Ausgabe:

{
  "employees": [
    {
      "id": "E001",
      "name": "John",
      "departmentId": "DEPT99",
      "departmentInfo": []
    }
  ],
  "departments": [
    { "id": "DEPT1", "name": "Engineering" },
    { "id": "DEPT2", "name": "Marketing" }
  ]
}

Anwendungsfälle​

  • Auftragsverarbeitung: Verknüpfen Sie Bestellungen mit ihren Positionen, Versanddetails oder Zahlungsinformationen
  • Kundendaten: Kombinieren Sie Kundendatensätze mit Adressen, Präferenzen oder Transaktionshistorie
  • Produktkataloge: Verknüpfen Sie Produkte mit Kategorien, Spezifikationen oder Preisinformationen
  • Datenanreicherung: Fügen Sie Primärdatensätzen Referenzdaten aus Lookup-Tabellen hinzu
  • Hierarchische Daten: Kombinieren Sie übergeordnete Datensätze mit ihren untergeordneten Datensätzen
  • Berichterstellung: Aggregieren Sie verwandte Daten aus mehreren Quellen für Berichte

Hinweise​

  • Many-to-Many-Joins: Der Node unterstützt Many-to-Many-Beziehungen, bei denen ein Quelldatensatz mit mehreren Join-Datensätzen übereinstimmen kann
  • Array-Ergebnisse: Übereinstimmende Datensätze werden immer als Array gespeichert, auch wenn nur eine Übereinstimmung gefunden wird
  • Originaldaten bleiben erhalten: Sowohl das Quell- als auch das Join-Array bleiben in der Ausgabe unverändert
  • Pfadanforderungen: Alle Pfade (keyPath, joinKeyPath, itemPath) sind relativ zu ihrem jeweiligen Objektkontext
  • Performance: Große Datensätze können die Performance beeinträchtigen; erwägen Sie, die Daten vor dem Verknüpfen nach Möglichkeit zu filtern
  • Datentypen: Schlüsselwerte werden als Strings verglichen; stellen Sie daher konsistente Datentypen sicher

Verwandte Nodes​