Zum Inhalt

nestedKey Element

Das <nestedKey>-Element definiert verschachtelte Schlüsselfelder und deren Generierungsmethoden innerhalb einer Datengenerierungsaufgabe. Es ermöglicht dir, komplexe Daten in einem hierarchischen Format zu strukturieren, wie zum Beispiel Wörterbücher (dict) oder Listen (list), und deren Inhalt dynamisch zu steuern.

Attribute

  • name: Gibt den Namen des verschachtelten Schlüssels an. Dies ist obligatorisch.
  • type: Definiert den Typ des verschachtelten Schlüssels. Es kann list oder dict sein.
  • count: Gibt die Anzahl der zu generierenden Elemente für verschachtelte Schlüssel an, anwendbar für list-Typen.
  • source: Gibt die Datenquelle für den verschachtelten Schlüssel an.
  • sourceScripted: Bestimmt, ob die Quelle skriptgesteuert ist (optional).
  • cyclic: Aktiviert oder deaktiviert zyklisches Verhalten für die Datengenerierung (optional).
  • separator: Definiert einen Trenner, der zwischen mehreren Schlüsselwerten verwendet wird (optional).
  • condition: Gibt eine Bedingung für die Einbeziehung des verschachtelten Schlüssels an.
  • defaultValue: Setzt einen Standardwert, wenn die Bedingung falsch ist.
  • script: Gibt ein Skript an, um dynamische Inhalte für den verschachtelten Schlüssel zu generieren.
  • minCount und maxCount: Definieren die minimale und maximale Anzahl für die Generierung von Schlüsseln.
  • distribution: Steuert, wie Daten aus der Quelle verteilt werden (random, ordered). Standard ist random.
  • converter: Gibt einen Konverter an, um die Werte der Kinder des nestedKey zu transformieren.
  • variablePrefix: Konfigurierbares Attribut, das das Präfix für die Variablensubstitution in dynamischen Zeichenketten definiert (Standard ist __).
  • variableSuffix: Konfigurierbares Attribut, das das Suffix für die Variablensubstitution in dynamischen Zeichenketten definiert (Standard ist __).

Kinder

  • key: Definiert Schlüssel-Wert-Paare innerhalb der verschachtelten Struktur.
  • variable: Variablen können innerhalb der verschachtelten Struktur verwendet werden.
  • nestedKey: Ermöglicht zusätzliche Verschachtelung innerhalb eines verschachtelten Schlüssels.
  • execute: Führt Operationen innerhalb der verschachtelten Struktur aus.
  • if: Definiert bedingte Logik innerhalb des verschachtelten Schlüssels.
  • list: Bindet Listen innerhalb des verschachtelten Schlüssels ein.
  • echo: Gibt Daten für Logging/Debugging aus.
  • element: Gibt Kinderelemente für die XML-Generierung an.
  • array: Bindet Arrays innerhalb des verschachtelten Schlüssels ein.

Beispiel 1: Verschachteltes Wörterbuch

Warning

Die bereitgestellten Beispiele sollen die Syntax und Struktur von DATAMIMIC-Modellen und -Funktionen demonstrieren. Sie funktionieren möglicherweise nicht direkt aus der Box. Für voll funktionsfähige Beispiele sieh bitte im Demo-Bereich in unserem Demo-Store nach, wenn du dich anmeldest. Wenn dir spezifische Anwendungsfälle oder Szenarien fehlen, zögere nicht, uns zu kontaktieren – wir helfen gerne weiter.

Das folgende Beispiel erstellt ein verschachteltes Wörterbuch (dict) mit Schlüsseln wie street, city und zip.

1
2
3
4
5
<nestedKey name="address" type="dict">
    <key name="street" script="person.street"/>
    <key name="city" script="person.city"/>
    <key name="zip" script="person.zip"/>
</nestedKey>

Ausgabe:

1
2
3
4
5
6
7
{
    "address": {
        "street": "123 Hauptstr.",
        "city": "Springfield",
        "zip": "12345"
    }
}

Beispiel 2: Verschachtelte Liste

Dieses Beispiel generiert eine verschachtelte Liste (list) mit zwei Elementen, die jeweils die Schlüssel brand und manufacturing_date enthalten.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
<nestedKey name="cars" type="list">
    <item>
        <key name="brand" constant="Tesla"/>
        <key name="manufacturing_date" constant="23-FEB-2023"/>
    </item>
    <item>
        <key name="brand" constant="BMW"/>
        <key name="manufacturing_date" constant="11-MAR-2022"/>
    </item>
</nestedKey>

Ausgabe:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
{
    "cars": [
        {
            "brand": "Tesla",
            "manufacturing_date": "23-FEB-2023"
        },
        {
            "brand": "BMW",
            "manufacturing_date": "11-MAR-2022"
        }
    ]
}

Beispiel 3: Verwendung von condition und defaultValue

Dieses Beispiel zeigt, wie Bedingungen und Standardwerte beim Generieren von verschachtelten Schlüsseln angewendet werden.

1
2
3
4
5
6
7
8
<nestedKey name="list" type="list" count="2" condition="True" defaultValue="[]">
    <key name="id" type="int"/>
</nestedKey>
<nestedKey name="list2" type="list" count="2" condition="False" defaultValue="[]"/>
<nestedKey name="dict" type="dict" condition="True" defaultValue="{}">
    <key name="id" type="int"/>
</nestedKey>
<nestedKey name="dict2" type="dict" condition="False" defaultValue="{}"/>

Ausgabe:

1
2
3
4
5
6
7
8
9
{
  "list": [
    { "id": 0 },
    { "id": 50 }
  ],
  "list2": [],
  "dict": { "id": 75 },
  "dict2": {}
}

Beispiel 4: Anreicherung oder Überschreibung verschachtelter Schlüssel aus einer Vorlage

Du kannst verschachtelte Schlüssel aus einer vorhandenen Vorlage anreichern oder überschreiben. Hier ist, wie du ein Feld (country) zu einem bestehenden address-Schlüssel hinzufügst, ohne den Typ anzugeben:

1
2
3
4
5
<generate name="datamimic_user_dict" source="script/address.json" target="JSON">
    <nestedKey name="address">
        <key name="country" constant="USA"/>
    </nestedKey>
</generate>

Ausgabe:

1
2
3
4
5
6
7
8
{
    "address": {
        "street": "123 Hauptstr.",
        "city": "Springfield",
        "zip": "12345",
        "country": "USA"
    }
}

Um einen verschachtelten Schlüssel komplett aus einer Vorlage zu überschreiben:

1
2
3
4
5
6
7
<generate name="datamimic_user_dict" source="script/address.json" target="JSON">
    <nestedKey name="address" type="dict">
        <key name="custom-street" script="person.street"/>
        <key name="custom-city" script="person.city"/>
        <key name="custom-zip" script="person.zip"/>
    </nestedKey>
</generate>

Ausgabe:

1
2
3
4
5
6
7
{
    "address": {
        "custom-street": "123 Hauptstr.",
        "custom-city": "Springfield",
        "custom-zip": "12345"
    }
}

Beispiel 5: Verwendung von source, um Daten in nestedKey einzufügen

Das folgende Beispiel holt Daten aus einer Quelle und fügt sie in nestedKey ein, wobei der richtige type der Eingabedaten angegeben werden muss.

1
2
3
4
5
6
<setup>
    <generate name="people1" target="JSON" count="1">
        <nestedKey name="people_csv" count="1" type="list" source="data/person.ent.csv" separator=","/>
        <nestedKey name="pet_json" type="dict" source="data/pet.json" distribution="ordered"/>
    </generate>
</setup>
data/person.ent.csv
1
2
3
4
name,pet_file
Alice,alice_pet
Bob,bob_pet
Cathay,cathay_pet
data/pet.json
1
2
3
4
5
{
    "name":"Bob",
    "age":34,
    "notes":null
}

Ausgabe: 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
[
  {
    "people_csv": [
      {
        "name": "Alice",
        "pet_file": "alice_pet"
      }
    ],
    "pet_json": {
      "name": "Bob",
      "age": 34,
      "notes": null
    }
  }
]

Beispiel 6: Verwendung von source mit sourceScripted für dynamischen Wert in der Quelle

Das folgende Beispiel holt Daten aus einer Quelle, und bestimmte Werte in der Quelle werden durch generierte Werte ersetzt. Wir nennen sie dynamische Variablen.

Beim Verwenden von dynamischen Variablen, um Werte in einem Quelldatensatz zu ersetzen, gibt es zwei Möglichkeiten, Variablen darzustellen: {var} und __var__ ('__' kann durch Einstellen von 'variablePrefix' und 'variableSuffix' geändert werden).

Beide ermöglichen dynamischen Ersatz, unterscheiden sich jedoch in Funktionalität, Umfang und dem Typ des zurückgegebenen Werts.

Verwendung von {var}:

  • Die {} müssen den gesamten Wert umschließen, innerhalb von {} ist nur der Variablenname erlaubt, keine zusätzlichen Zeichen innen oder außen.
  • Der ersetzte Wert behält den Datentyp der generierten Variablen bei. Wenn die Variable zum Beispiel eine Ganzzahl ist, wird auch der ersetzte Wert eine Ganzzahl sein.
1
"age": "{random_age}"

Verwendung von variablePrefix und variableSuffix:

  • Die Variable muss vom Präfix und Suffix umschlossen sein (Standard ist __).
  • Es unterstützt die Kombination mehrerer Variablen und Text in der Zeichenkette, die __var__ enthält.
  • Der ersetzte Wert ist immer eine Zeichenkette, unabhängig vom ursprünglichen Datentyp der Variablen.
1
"address": "120, __street_name__ St"

Beispiel:

datamimic.xml
1
2
3
4
5
6
7
<setup>
    <generate name="json_data" source="script/data.json" sourceScripted="True" target="JSON">
        <variable name="random_age" generator="IntegerGenerator(min=18, max=65)"/>
        <variable name="street_name" generator="StreetNameGenerator"/>
        <variable name="address_number" generator="IntegerGenerator"/>
    </generate>
</setup>

Quelldaten:

script/data.json
1
2
3
4
5
6
7
8
9
[
    {
        "id": 1,
        "name": "Alice",
        "age": "{random_age}",
        "address_number": "__address_number__",
        "address": "__address_number__, __street_name__ St"
    }
]

Ausgabe (sowohl age als auch address_number Original sind Nummern, aber mit __var__ Ausgabe ist String und {var} Ausgabe ist Nummer)

1
2
3
4
5
6
7
8
9
[
  {
    "id": 1, 
    "name": "Alice", 
    "age": 50, 
    "address_number": "729625",
    "address": "729625, Hauptstraße St"
  }
]

Wichtig:

  • In den Quelldaten kannst du keinen 'key' oder 'header column' mit demselben Namen wie der dynamischen Variablennamen haben (z.B. kannst du nicht "random_age": "__random_age__" verwenden).

Beispiel 7: Verwendung von script, um Wert in nestedKey zu bekommen

Das folgende Beispiel holt Daten aus dem script-Attribut, nestedKey 'type' wird basierend auf dem Eingabewert gesetzt. Beachte, dass der Eingabewerttyp 'dict' oder eine 'list' von 'dict' sein muss.

1
2
3
4
5
6
7
8
<setup>
    <generate name="json_data" count="1" target="JSON">
        <variable name="random_age" script="[{'age':10},{'age':20},{'age':30}]"/>
        <variable name="address" script="{'address_number':1023,'street_name':'Hauptstraße'}"/>
        <nestedKey name="ages" script="random_age"/>
        <nestedKey name="my_address" script="address"/>
    </generate>
</setup>

Ausgabe 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
[
  {
    "ages": [
      {"age": 10},
      {"age": 20},
      {"age": 30}
    ],
    "my_address": {
      "address_number": 1023,
      "street_name": "Hauptstraße"
    }
  }
]

Best Practices für die Verwendung von <nestedKey>

  1. Bedingungen und Standardwerte verwenden: Nutze Bedingungen, um dynamisch zu steuern, ob ein verschachtelter Schlüssel generiert wird, und verwende Standardwerte, wenn die Bedingung zu False ausgewertet wird.
  2. Verschachtelung für komplexe Daten: Nutze verschachtelte Schlüssel, um komplexe hierarchische Strukturen wie Wörterbücher und Listen zu generieren.
  3. Vorlagen anreichern oder überschreiben: Verwende <nestedKey>, um verschachtelte Daten aus vordefinierten Vorlagen zu verbessern oder vollständig zu überschreiben.
  4. Effiziente Verteilung: Verwende das Attribut distribution, um zu steuern, wie Daten aus der Quelle angewendet werden (random, ordered).