Zum Inhalt

Datendefinitionsmodell - Fortgeschrittene Elemente

Dieses Dokument behandelt fortgeschrittene Funktionen und Elemente in den Datendefinitionsmodellen von DATAMIMIC. Stelle sicher, dass Du mit den Kern-Elementen der Datendefinition vertraut bist, bevor Du in diese fortgeschrittenen Funktionen eintauchst.

Komplexe Datenstrukturen

<nestedKey>

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 Wörterbücher (dict) oder Listen (list), und deren Inhalt dynamisch zu steuern.

Siehe die detaillierte nestedKey Referenz.

<reference>

Das <reference>-Element ermöglicht die Abbildung von Ziel-Feldern auf Werte aus einer Referenzquelle. Nutze einen <reference>-Knoten sowohl für Single-Column- als auch für Composite-Beziehungen. Bei der Modellerstellung in der Datenbankansicht bedeutet reference_source_mode=database, dass DB-Quellen genutzt werden, während reference_source_mode=weighting_files synthetische Weighting-Dateien unter data/ verwendet.

Attribute

  • name: Name der Referenzanweisung.
  • source: Source-Client-ID (Datenbankquelle) oder Pfad zu einer Weighting-Datei.
  • sourceType: Quell-Entität/-Tabelle. Für datenbankgestützte Referenzen erforderlich, für Weighting-Dateien optional.
  • sourceKey: Legacy-Shortcut nur für Single-Field-Mapping. Nicht mit <field>-Kindelementen kombinieren.
  • unique: Erzwingt eindeutige Ziehungen innerhalb eines Sampling-Batches.
  • weightColumn: Optionaler Name der Gewichtungsspalte für gewichtete Quellen.

Kindelemente

  • <field target="..." sourceKey="..."/>: Explizites Source-to-Target-Mapping. Für Multi-Column-Mappings mehrfach verwendbar.

Mapping-Priorität

  1. Explizite <field>-Kindelemente.
  2. sourceKey-Shortcut (nur ein Ziel-Feld).
  3. Auto-Mapping über .wgt.ent.csv-Header, wenn weder sourceKey noch <field> gesetzt ist.

Beispiel 1: Single-Column DB-Referenz (empfohlene <field>-Form)

1
2
3
4
5
<reference name="fk_order_customer"
           source="sourceDB"
           sourceType="sales.customer">
    <field target="customer_id" sourceKey="CUSTOMER_ID"/>
</reference>

Beispiel 2: Composite DB-Referenz

1
2
3
4
5
6
<reference name="fk_line_order"
           source="sourceDB"
           sourceType="sales.order_header">
    <field target="order_id" sourceKey="ORDER_ID"/>
    <field target="tenant_id" sourceKey="TENANT_ID"/>
</reference>

Beispiel 3: Single-Field Weighting-Quelle (.wgt.csv)

1
2
3
<reference name="order_state"
           source="data/order_state_pref.wgt.csv"
           sourceKey="order_state"/>

Beispiel 4: Multi-Field Weighting-Quelle (.wgt.ent.csv) mit Header-Auto-Mapping

1
2
3
<reference name="fk_site"
           source="data/site_pref.wgt.ent.csv"
           weightColumn="sample_weight"/>

Beispiel 5: Multi-Field Weighting-Quelle (.wgt.ent.csv) mit explizitem Mapping-Override

1
2
3
4
5
6
7
<reference name="fk_site"
           source="data/site_pref.wgt.ent.csv"
           weightColumn="sample_weight">
    <field target="site_ref" sourceKey="site_id"/>
    <field target="region_ref" sourceKey="region_code"/>
    <field target="slot_ref" sourceKey="slot_no"/>
</reference>

Leitplanken

  • sourceKey und <field> nicht innerhalb derselben <reference> kombinieren.
  • .wgt.csv unterstützt nur ein Ziel-Feld.
  • Für Fehlersemantik und Lösungen siehe Error Codes Reference.

<list>

Das <list>-Element definiert eine Sammlung von Datenelementen, wobei jedes Element seine eigenen Attribute, Schlüssel und Arrays enthalten kann. Listen sind nützlich, um strukturierte Daten darzustellen, wie Zeilen in einer Tabelle oder Sammlungen von Objekten mit gemeinsamen Attributen. Das <list> kann mehrere <item>-Elemente enthalten, die einzelne Einträge darstellen.

Siehe die detaillierte Listenelement-Referenz.

<item>

Siehe die detaillierte Item-Element-Referenz.

<array>

Das <array>-Element definiert Arrays von Datenelementen, die entweder statisch definiert oder dynamisch mit Skripten generiert werden können. Arrays sind unerlässlich, wenn Du mehrere Elemente desselben Datentyps generieren musst, wie Listen von Werten, und können mit anderen Elementen wie <list>, <key> und <nestedKey> kombiniert werden, um komplexe Datenstrukturen zu erstellen.

Siehe die detaillierte Array-Element-Referenz.

Steuerelemente

<condition>

Das <condition>-Element wird verwendet, um eine Reihe von untergeordneten Tags (<if>, <else-if> und <else>) basierend auf spezifischen logischen Bedingungen auszuführen. Es bietet eine Möglichkeit, den Datengenerierungsprozess zu steuern, indem Bedingungen angewendet werden, die bestimmen, welche Elemente in der Ausgabe enthalten sein werden.

Struktur

  • Das <if>-Tag ist immer das erste Kind eines <condition>-Elements und definiert die primäre Bedingung.
  • Null oder mehr <else-if>-Tags können auf das <if> folgen, wobei jedes zusätzliche Bedingungen angibt, die ausgewertet werden, wenn die vorherigen Bedingungen nicht erfüllt sind.
  • Das <else>-Tag ist optional und bietet eine Ausweichaktion, wenn keine der vorherigen Bedingungen erfüllt sind.

Regeln

  • Ein <condition>-Element muss ein <if>-Tag haben.
  • Es kann null oder mehr <else-if>-Tags geben.
  • Nur ein <else>-Tag ist erlaubt und es muss als letztes Kind des <condition>-Elements erscheinen.

Kindelemente

  • if: Definiert die primäre Bedingung zur Auswertung.
  • else-if: Definiert zusätzliche Bedingungen zur Überprüfung, wenn die vorherigen Bedingungen falsch sind.
  • else: Ausweichaktion, wenn keine der Bedingungen erfüllt ist.

Attribute

  • condition: Ein Python-ähnlicher Ausdruck, der zu True oder False ausgewertet wird. Das Ergebnis bestimmt, ob der Inhalt innerhalb des entsprechenden Tags ausgeführt wird.

Beispiel 1: Einfache Bedingung mit If-Else-Logik

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
<condition>
    <if condition="category_id == 'DRNK/ALCO'">
        <echo>Kategorie: DRNK/ALCO</echo>
    </if>
    <else-if condition="category_id == 'FOOD/CONF'">
        <echo>Kategorie: FOOD/CONF</echo>
    </else-if>
    <else>
        <echo>Kategorie nicht gefunden</echo>
    </else>
</condition>

In diesem Beispiel wird basierend auf dem Wert von category_id die entsprechende Nachricht gedruckt.

  • Wenn category_id 'DRNK/ALCO' ist, wird der erste <if>-Block ausgeführt.
  • Wenn category_id 'FOOD/CONF' ist, wird der <else-if>-Block ausgeführt.
  • Wenn keine Bedingung erfüllt ist, wird der <else>-Block ausgeführt.

Beispiel 2: Komplexe Bedingung mit verschachtelten Schlüsseln und Standardwerten

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
<setup>
    <generate name="group_name_not_override" count="10">
        <variable name="ifVar" generator="BooleanGenerator"/>
        <variable name="elseIfVar" generator="BooleanGenerator"/>

        <condition>
            <if condition="ifVar">
                <key name="if_true" constant="true"/> <!-- Generiert, wenn ifVar = True -->
            </if>
            <else-if condition="elseIfVar">
                <key name="else_if_true" constant="true"/> <!-- Generiert, wenn ifVar = False und elseIfVar = True -->
            </else-if>
            <else>
                <key name="else_true" constant="true"/> <!-- Generiert, wenn ifVar = False und elseIfVar = False -->
            </else>
        </condition>
    </generate>
</setup>

In diesem Beispiel werden zwei Variablen (ifVar und elseIfVar) mit einem Boolean-Generator generiert, und abhängig von ihren Werten wird eines der <key>-Elemente (if_true, else_if_true oder else_true) generiert.

  • Wenn ifVar True ist, wird if_true generiert.
  • Wenn ifVar False und elseIfVar True ist, wird else_if_true generiert.
  • Wenn beide Bedingungen False sind, wird else_true generiert.

Beispiel 3: Bedingungen mit verschachtelten Strukturen

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
<setup>
    <generate name="bike" count="10">
        <key name="id" type="int" generator="IncrementGenerator"/>
        <key name="year" type="int" values="1970, 2023"/>

        <!-- Bedingte verschachtelte Schlüsselgenerierung -->
        <nestedKey name="condition_true" type="dict" condition="True">
            <key name="serial" type="int" condition="id % 2 == 1"/>
            <key name="count" type="int" generator="IncrementGenerator"/>
        </nestedKey>

        <condition>
            <if condition="True">
                <nestedKey name="if_true" type="dict">
                    <key name="id" type="int"/>
                </nestedKey>
            </if>
            <else-if condition="False">
                <nestedKey name="if_false" type="dict">
                    <key name="id" type="int"/>
                </nestedKey>
            </else-if>
        </condition>
    </generate>
</setup>

In diesem Beispiel:

  • Der condition_true verschachtelte Schlüsselblock wird immer ausgeführt, weil seine Bedingung True ist.
  • Der bedingte Block innerhalb von <condition> führt den <if>-Block aus, weil seine Bedingung True ist, während der <else-if> ignoriert wird, da er False auswertet.

Beispiel 4: Bedingungen mit Standardwerten

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<setup>
    <generate name="condition" count="10">
        <key name="id" generator="IncrementGenerator"/>

        <condition>
            <if condition="id == 1">
                <echo>Bedingung erfüllt: id ist 1</echo>
                <key name="if_true" constant="1"/>
            </if>
            <else-if condition="id == 3">
                <echo>Bedingung erfüllt: id ist 3</echo>
                <key name="else_if_3_true" constant="3"/>
            </else-if>
            <else-if condition="id == 4">
                <echo>Bedingung erfüllt: id ist 4</echo>
                <key name="else_if_4_true" constant="4"/>
            </else-if>
            <else>
                <echo>Bedingung nicht erfüllt, Fortsetzung mit Standardwerten</echo>
                <key name="else_true" constant="else_value"/>
            </else>
        </condition>
    </generate>
</setup>

Hier überprüft die bedingte Logik den Wert von id:

  • Wenn id 1 ist, wird der Schlüssel if_true generiert.
  • Wenn id 3 oder 4 ist, wird der entsprechende else_if-Block ausgeführt.
  • Wenn keine Bedingungen übereinstimmen, wird der Schlüssel else_true mit einem Fallback-Wert generiert.

Beispiel 5: Bedingte Entfernung von Elementen

1
2
3
4
5
<setup>
    <generate name="group_name_not_override" count="10">
        <key name="removeElement" script="" defaultValue="{}" condition="False"/>
    </generate>
</setup>

In diesem Fall wird der Schlüssel removeElement nicht generiert, weil die condition auf False gesetzt ist.

Beispiel 6: Verwendung von Standardwerten in bedingten NestedKeys

1
2
3
4
5
6
7
<setup>
    <generate name="bike" count="10">
        <nestedKey name="condition_false" type="dict" condition="False" defaultValue="None">
            <key name="serial" type="int" condition="id % 2 == 1"/>
        </nestedKey>
    </generate>
</setup>
  • Da die condition False ist, nimmt der verschachtelte Schlüssel condition_false den defaultValue von None.

Best Practices für die Verwendung von <condition>

  1. Verwende Bedingungen zur Steuerung der Ausgabe: Bedingungen sind eine hervorragende Möglichkeit, die Generierung von Datenelementen dynamisch auf der Grundlage des aktuellen Zustands von Variablen zu steuern.

  2. Fallbacks mit Standardwerten: Verwende Standardwerte, wenn Du einen Fallback bereitstellen möchtest, falls eine Bedingung zu False ausgewertet wird.

  3. Kombiniere mit verschachtelten Strukturen: Du kannst Bedingungen mit verschachtelten Schlüsseln, Listen und Arrays verwenden, um komplexe, logikgesteuerte Datenmodelle zu erstellen.

  4. Verwende else-if für mehrere Bedingungen: Um mehrere mögliche Zustände zu behandeln, verwende eine Kombination aus <if>, <else-if> und <else>, um alle Szenarien abzudecken.

<echo>

Das <echo>-Element gibt Text, Variablen oder Ausdrücke für Protokollierung, Debugging oder Überwachungszwecke aus. Dies kann hilfreich sein, um den Fortschritt der Datengenerierung zu verfolgen oder die Werte von Variablen während der Laufzeit zu inspizieren. Es akzeptiert dynamische Inhalte, einschließlich Variablen und Ausdrücke, die in {} eingeschlossen sind.

Attribute

  • text: Der statische oder dynamische Inhalt, der gedruckt werden soll. Dynamische Werte sind in {} eingefasst, was es Dir ermöglicht, Variablen, Ausdrücke oder Ergebnisse von Funktionen während der Ausführung auszugeben.

Verwendung

  • Verwende <echo>, um die Werte von Variablen auszudrucken oder den Ablauf des Setup-Prozesses zu verfolgen.
  • Es kann Text auf die Konsole oder in Logdateien ausgeben, abhängig vom Ziel, das im Setup definiert ist.

Beispiel 1: Grundlegende Verwendung für Debugging

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
<setup>
    <variable name="user" source="dbPostgres" cyclic="False"
              selector="SELECT id, text FROM public.db_postgres_test_query_setup_context_variable"
              distribution="ordered"/>

    <variable name="all_users" source="dbPostgres" cyclic="False"
              iterationSelector="SELECT id, text FROM public.db_postgres_test_query_setup_context_variable"/>

    <echo>user ist ein DotableDict: {user}</echo>
    <echo>all_users ist eine Liste von Dicts: {all_users}</echo>
</setup>

In diesem Beispiel:

  • Das <echo>-Tag druckt den aktuellen Wert der Variable user, die ein DotableDict ist.
  • Es druckt auch die Variable all_users, die eine Liste von Wörterbüchern ist, die aus der Datenbank abgerufen wurden.

Beispiel 2: Verwendung von Echo zum Debuggen von skriptgesteuerten Variablen

1
2
3
4
5
6
7
<setup>
    <variable name="random_number" generator="RandomNumberGenerator(min=1, max=100)"/>
    <echo>Generierte Zufallszahl: {random_number}</echo>

    <key name="status" script="random_number > 50 ? 'High' : 'Low'"/>
    <echo>Der Status basierend auf random_number ist: {status}</echo>
</setup>

In diesem Beispiel:

  • Eine Zufallszahl wird generiert und zum Debuggen ausgegeben.
  • Der Status wird dann basierend auf der Zufallszahl berechnet, und das Ergebnis wird mit <echo> gedruckt.

Best Practices für die Verwendung von <echo>

  1. Debugge komplexe Logik: Verwende <echo>, um Variablen und komplexe Ausdrücke zu debuggen, insbesondere wenn Du Skripte oder Datenbankquellen verwendest, um Daten dynamisch zu generieren.
  2. Überwache die Datengenerierung: Verfolge den Fortschritt Deiner Datengenerierung, indem Du Werte an Schlüsselpunkten in Deinem Setup ausgibst.
  3. Kombiniere mit Variablen: Du kannst Variablen und Ausdrücke innerhalb des Textes von <echo> verwenden, um dynamische Inhalte während des Generierungsprozesses auszugeben.

<generator>

Das <generator>-Element gibt benutzerdefinierte Generatoren für die Datengenerierung an.

Attribute

  • name: Gibt den Namen des Generators an.
  • generator: Gibt Deinen benutzerdefinierten Generator an.

Beispiel

1
2
3
4
5
6
7
8
<setup>
    <generator name="my_custom_date_gen" generator="DateTimeGenerator(min='2010-08-01', max='2020-08-31', input_format='%Y-%m-%d')"/>
    <generate name="product">
        <key name="product_name" type="string"/>
        <key name="import_date" generator="my_custom_date_gen"/>
        <key name="export_date" generator="my_custom_date_gen"/>
    </generate>
</setup>

<element>

Das <element>-Element gibt untergeordnete Elemente innerhalb eines XML-Knotens an, was es nützlich macht, um verschachtelte XML-Strukturen zu generieren. Der Name des <element>-Tags wird zu einem XML-Attribut, und der generierte Inhalt wird zum Wert des Attributs.

Attribute

  • name: Gibt den Namen des untergeordneten XML-Elements oder Attributs an. Dies ist obligatorisch.
  • script: Gibt ein Skript an, um den Wert des Elements dynamisch zu generieren.
  • constant: Ein konstanter Wert für das Element, falls keine dynamische Generierung erforderlich ist.
  • values: Eine Liste möglicher Werte, aus denen zufällig ausgewählt werden kann, falls zutreffend.

Beispiel 1: Einfache XML-Generierung

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
<setup>
    <generate name="generate_xml" count="2" target="XML">
        <variable name="person" entity="Person"/>
        <key name="author" script="None">
            <element name="name" script="person.name"/>
            <element name="gender" script="person.gender"/>
            <element name="birthdate" script="person.birthdate"/>
        </key>
    </generate>
</setup>

In diesem Beispiel:

  • Der Schlüssel author erstellt einen XML-Knoten, und jedes <element> darin definiert Attribute (wie name, gender, birthdate), die mit den Werten der person-Entität gefüllt werden.

Beispiel 2: NestedKey mit Elementen und Attributen

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
<setup>
    <generate name="part_list" count="1" target="XML">
        <nestedKey name="book" type="list" count="4">
            <element name="title" values="'Book 1', 'Book 2', 'Book 3', 'Book 4'"/>
            <element name="language" values="'de', 'en'"/>
            <element name="pages" generator="IntegerGenerator(min=100,max=800)"/>
            <element name="release_date" generator="DateTimeGenerator(min='2020-01-01', max='2023-12-31', input_format='%Y-%m-%d')"/>
        </nestedKey>
    </generate>
</setup>

Hier:

  • Die book Liste erzeugt mehrere XML-Elemente (title, language, pages, release_date), jedes mit Attributen für verschiedene Bücher.
  • Der Inhalt für jedes Element wird dynamisch basierend auf Werten oder Generatoren erzeugt.

Beispiel 3: Generierung von XML mit verschachtelten Listen und Wörterbüchern

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
<setup>
    <generate name="part_dict" count="1" target="XML">
        <nestedKey name="book" type="dict">
            <key name="title" values="'Book 1', 'Book 2'">
                <element name="language" values="'de', 'en'"/>
            </key>
            <key name="pages" generator="IntegerGenerator(min=100,max=800)"/>
            <key name="release_date" generator="DateTimeGenerator(min='2020-01-01', max='2023-12-31', input_format='%Y-%m-%d')"/>
        </nestedKey>
        <nestedKey name="magazine" type="dict">
            <key name="title" values="'Magazine #1', 'Magazine #2'"/>
            <key name="language" values="'de', 'en'"/>
            <key name="pages" generator="IntegerGenerator(min=30,max=70)"/>
        </nestedKey>
    </generate>
</setup>

In diesem Fall:

  • Sowohl Bücher als auch Magazine werden als XML-Elemente mit dynamisch generierten Attributen wie language, pages und release_date erzeugt.

Beispiel 4: Generierung von XML mit Arrays und Listen

1
2
3
4
5
6
<setup>
    <generate name="array_xml" count="2" target="XML">
        <array name="random_string" type="string" count="3"/>
        <array name="random_number" type="int" count="3"/>
    </generate>
</setup>

In diesem Beispiel:

  • Zwei Arrays (random_string und random_number) werden als XML-Elemente generiert, wobei jedes Array 3 Elemente enthält.
  • Dies demonstriert, wie Arrays in den XML-Generierungsprozess integriert werden können.

Beispiel 5: Komplexes XML mit Listen und NestedKeys

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
<setup>
    <generate name="list_xml" count="1" target="XML">
        <list name="detail">
            <item>
                <key name="number" type="int" constant="2"/>
            </item>
            <item>
                <key name="text" type="string"/>
            </item>
            <item>
                <nestedKey name="employees" type="list" count="2">
                    <key name="code" type="string"/>
                    <key name="age" values="25, 30, 28, 45"/>
                </nestedKey>
            </item>
        </list>
    </generate>
</setup>

Dieses Beispiel zeigt, wie man eine Liste von Elementen generiert, wobei jedes Element zusätzliche verschachtelte Schlüssel und Unterelemente enthalten kann, was eine hierarchische Struktur in XML demonstriert.

Beispiel 6: Generierung von XML aus einer Vorlage

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
<setup>
    <generate name="product" source="data/user.template.xml" target="ConsoleExporter, XML">
        <nestedKey name="xga:dgu.gewerbemeldung.0230">
            <element name="new_key" constant="new_key_value"/>
            <nestedKey name="bn-g2g:nachrichtenkopf.g2g">
                <element name="new_key2" constant="new_key_value2"/>
                <key name="bn-g2g:identifikation.nachricht" constant="abc"/>
            </nestedKey>
        </nestedKey>
        <key name="additionalTag" constant="extra">
            <element name="new_key" constant="new_key_value"/>
            <element name="new_key1" constant="new_key_value1"/>
        </key>
        <list name="array">
            <item>
                <key name="additionalTag" constant="extra">
                    <element name="new_key" constant="new_key_value"/>
                </key>
            </item>
        </list>
    </generate>
</setup>

In diesem Fall:

  • Die XML-Generierung basiert auf einer vordefinierten Vorlage (data/user.template.xml), und die Struktur wird dynamisch erweitert mit nestedKey, key und list Elementen.
  • Dies demonstriert, wie man bestehende XML-Strukturen mit neuen Elementen und Attributen erweitern kann.

Best Practices für die Verwendung von <element>

  1. Verwende <element>, um strukturiertes XML zu erstellen: Das <element>-Tag ist eine flexible Möglichkeit, strukturierte XML-Dokumente zu bauen, bei denen jedes Element und seine Attribute dynamisch generiert oder statisch definiert werden können.
  2. Kombiniere <element> mit anderen Elementen: Verwende das <element>-Tag in Kombination mit <list>, <array> und <nestedKey>, um komplexe XML-Strukturen zu erstellen.
  3. Nutze dynamische Skripte: Nutze das script-Attribut, um Werte für die Elemente dynamisch zu generieren, basierend auf komplexer Logik oder externen Variablen.
  4. Verwende constant für feste Werte: In Fällen, in denen der Wert eines Elements nicht ändern soll, verwende das constant-Attribut.

<sourceConstraints>

Das <sourceConstraints>-Element wird zusammen mit dem Kindelement <rule> verwendet. Es sorgt dafür, dass nur Datensätze aus der Eingabequelle verwendet werden, die bestimmten Regeln entsprechen. Korrekt angewandt verbessert es Genauigkeit, Qualität und Zuverlässigkeit der generierten Ausgabe.

Struktur

  • Die <rule>-Elemente sind Kinder von <sourceConstraints>
  • <sourceConstraints> folgt der Syntax <rule if="Bedingung" then="Aktion">.

Regeln

  • <sourceConstraints> ist NUR als direktes Kindelement von <generate> oder <nestedKey> erlaubt.
  • Ein <generate>- oder <nestedKey>-Element darf nur ein <sourceConstraints>-Element enthalten.
  • Ein <sourceConstraints> kann viele <rule>-Elemente enthalten.
  • <rule> muss die Attribute if und then besitzen.
  • Es ist gute Praxis, das <sourceConstraints>-Element als erstes Unterelement von <generate> zu platzieren.

Kindelemente

  • rule: Definiert die Regel, um Quelldaten zu akzeptieren.

Attribute:

  • <sourceConstraints> besitzt keine Attribute.
  • <rule> besitzt die Attribute if und then.
  • if: Ein Python-ähnlicher Ausdruck, der zu True oder False ausgewertet wird. Das Ergebnis bestimmt, ob die Regelprüfung ausgeführt wird.
  • then: Ein Python-ähnlicher Ausdruck, der zu True oder False ausgewertet wird. Ist das Ergebnis True, werden die Daten behalten, andernfalls entfernt.

Beispiel 1: Einfache sourceConstraints für ein generate-Element

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
<setup>
    <generate name="synthetic_customers" count="10000" pageSize="1000"
              source="script/person_data.json" cyclic="True">
        <sourceConstraints>
          <rule if="credit_score &lt; 600" then="risk_profile == 'High'"/>
          <rule if="credit_score &gt;= 600 and credit_score &lt; 750" then="risk_profile == 'Medium'"/>
          <rule if="credit_score &gt;= 750" then="risk_profile == 'Low'"/>
        </sourceConstraints>
        <key name="id" generator="IncrementGenerator"/>
    </generate>
</setup>

Struktur der person_data-Datei:

1
2
3
4
5
6
7
8
{
  "firstname": "Charlie",
  "lastname": "Brown",
  "age": 61,
  "city": "New York",
  "credit_score": 707,
  "risk_profile": "Low"
}

In diesem Beispiel:

  • Die XML holt Daten aus der Quelle "script/person_data.json" zur Generierung.
  • <sourceConstraints> filtert diese Quelldaten vor der Generierung.
  • Die erste <rule> greift, wenn das Feld credit_score in den Quelldaten kleiner als 600 ist. Ist das Feld risk_profile dann "High", werden die Daten behalten, andernfalls entfernt.
  • Die zweite <rule> greift, wenn credit_score zwischen 600 und 750 liegt. Daten werden entfernt, wenn risk_profile nicht "Medium" ist.
  • Die dritte <rule> greift, wenn credit_score größer oder gleich 750 ist. Daten werden entfernt, wenn risk_profile nicht "Low" ist.
  • Am Ende erfüllen die Quelldaten alle in sourceConstraints definierten Regeln.

Beispiel 2: Constraints in Kaskadenstruktur

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
<setup>
    <generate name="container" count="1">
        <generate name="synthetic_customers" count="10000" pageSize="1000"
                  source="script/person_data.json" cyclic="True">
            <sourceConstraints>
              <rule if="credit_score &lt; 600" then="risk_profile == 'High'"/>
              <rule if="credit_score &gt;= 600 and credit_score &lt; 750" then="risk_profile == 'Medium'"/>
              <rule if="credit_score &gt;= 750" then="risk_profile == 'Low'"/>
            </sourceConstraints>
            <key name="id" generator="IncrementGenerator"/>
        </generate>
    </generate>
</setup>

In diesem Fall:

  • Die sourceConstraints wirken sich nur auf das direkte Elternelement <generate> mit dem Namen "synthetic_customers" aus.

Beispiel 3: Constraints für ein nestedKey-Element

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
<setup>
    <generate name="container" count="1">
        <nestedKey name="cyclic_true" source="script/person_data.json"
                   type="list" count="1000" cyclic="True">
            <sourceConstraints>
              <rule if="credit_score &lt; 600" then="risk_profile == 'High'"/>
              <rule if="credit_score &gt;= 600 and credit_score &lt; 750" then="risk_profile == 'Medium'"/>
              <rule if="credit_score &gt;= 750" then="risk_profile == 'Low'"/>
            </sourceConstraints>
            <key name="id" generator="IncrementGenerator"/>
        </nestedKey>
    </generate>
</setup>

In diesem Fall:

  • Die sourceConstraints wirken sich nur auf das direkte Elternelement <nestedKey> mit dem Namen "cyclic_true" aus.
  • Diese Struktur ist nützlich, um Daten innerhalb tief verschachtelter Listen oder Strukturen zu filtern.

Best Practices für die Verwendung von <sourceConstraints>

  1. Unerwünschte Daten früh filtern: Verwende <sourceConstraints>, um sicherzustellen, dass nur relevante oder gültige Daten aus der Quelldatei verwendet werden. Das hilft, Fehler zu reduzieren und die Datenqualität während der Generierung zu verbessern.

<targetConstraints>

Das <targetConstraints>-Element wird am Ende angewendet, um die Ausgabedaten zu validieren und zu finalisieren. Es prüft die final generierten Daten und kann zusätzliche Attribute basierend auf den generierten Werten hinzufügen.

Verwendung

Die Verwendung von <targetConstraints> ist ähnlich wie bei <sourceConstraints>, wirkt sich aber auf die generierten Ausgabedaten aus.

Beispiel 1: targetConstraints für ein generate-Element

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
<setup>
    <generate name="container" count="1">
        <generate name="synthetic_customers" count="1000" pageSize="100"
            source="script/person_data.json" cyclic="True">
            <key name="id" generator="IncrementGenerator" />

            <!-- Target Constraints: Finale Validierung -->
            <targetConstraints>
                <rule if="credit_limit &gt;= 25000 and interest_rate &lt;= 0.08" then="approval_status = 'Approved'" />
                <rule if="credit_limit &lt; 25000 or interest_rate &gt; 0.08" then="approval_status = 'Review'" />
                <rule if="credit_limit &lt;= 5000 and interest_rate &gt;= 0.12" then="approval_status = 'Denied'" />
            </targetConstraints>
        </generate>
    </generate>
</setup>

In diesem Fall:

  • Die Regeln von <targetConstraints> wirken sich auf die generierten Daten aus, ändern Attribute oder fügen sie hinzu (falls nicht vorhanden), sodass die Ausgabe mit then übereinstimmt.
  • Der Wert von approval_status ist immer Approved, wenn credit_limit >= 25000 und interest_rate <= 0.08. Entsprechend gilt das auch für die anderen Regeln.

<mapping>

Das <mapping>-Element wird während der Verarbeitung angewendet, um ausgewählte Datensätze zu transformieren.

Verwendung

  • Die Verwendung von <mapping> ist ähnlich wie bei <sourceConstraints>, wird aber verwendet, um den Datenwert zu ändern.
  • Wenn das Attribut die if-Bedingung erfüllt, transformiert <mapping> das Attribut gemäß then.

Beispiel 1: mapping für ein generate-Element

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
<setup>
    <generate name="container" count="1">
        <generate name="synthetic_customers" count="1000" pageSize="100"
            source="script/person_data.json" cyclic="True">
            <!-- Mapping: Transformation von Attributen basierend auf sourceConstraints -->
            <mapping>
                <rule if="risk_profile == 'High'" then="interest_rate = 0.15"/>
                <rule if="risk_profile == 'Medium'" then="interest_rate = 0.10"/>
                <rule if="risk_profile == 'Low'" then="interest_rate = 0.05"/>
                <!-- Zusätzliche Regeln für Kreditlimits -->
                <rule if="income &gt; 100000" then="credit_limit = 50000" />
                <rule if="income &gt; 50000 and income &lt;= 100000" then="credit_limit = 25000" />
                <rule if="income &gt; 30000 and income &lt;= 50000" then="credit_limit = 10000" />
                <rule if="income &lt;= 30000" then="credit_limit = 5000" />
            </mapping>
        </generate>
    </generate>
</setup>

In diesem Fall:

  • Wenn risk_profile "High" ist, fügt <mapping> das neue Attribut interest_rate mit dem Wert 0.15 hinzu.

<ml-train>

Das <ml-train>-Element wird verwendet, um Machine-Learning-Modelle mit Eingabedaten zu trainieren. Diese trainierten Modelle können dann als Quellen in <generate>-Elementen für die Datengenerierung verwendet werden.

Attribute:

  • name: Gibt den Namen des Modells nach dem Training an. Dies ist verpflichtend und wird zur Referenzierung in anderen Elementen verwendet.
  • source: Gibt die Datenquelle an (z.B. data/active.ent.csv, mongo).
  • type: Gibt den Typ der zu generierenden Daten an.
  • mode: Gibt den Trainingsmodus an. Aktuell gibt es 'default' und 'persist'. 'default' entfernt das Modell nach Abschluss aller Aufgaben, 'persist' behält das Modell bei.
  • maxTrainingTime: Gibt die maximale Trainingszeit in Minuten an (z.B. 1, 5, 10)
  • separator: Gibt den Trenner der Quelldatei an (z.B. ',' für CSV-Dateien).

Beispiel 1: Einfaches Modelltraining

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
<setup>
    <ml-train name="customer_csv_gen"
            source="data/customer.ent.csv"
            maxTrainingTime="1"
            separator=","/>

    <generate name="csv_customer" count="10000" pageSize="1000" source="customer_csv_gen" target="CSV">
        <key name="id" generator="IncrementGenerator"/>
    </generate>
</setup>

In diesem Beispiel: - Das Modell "customer_csv_gen" wird mit Daten aus "data/customers.csv" trainiert. - Der Modus ist nicht explizit angegeben, daher wird das Modell nach Abschluss entfernt. - Die CSV-Datei verwendet Komma als Trenner. - "generate" verwendet das trainierte Modell als Quelle zur Datengenerierung.

Beispiel 2: Training mit Persistenzmodus

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
<setup numProcess="2">

    <ml-train name="customer_csv_gen"
              source="data/customer.ent.csv"
              mode="persist"
              maxTrainingTime="1"/>

    <!-- Generiere synthetische CUSTOMER-Datensätze mit dem ML-Generator -->
    <generate name="csv_customer" count="10000" pageSize="1000" source="customer_csv_gen" target="CSV">
        <key name="id" generator="IncrementGenerator"/>
    </generate>
</setup>

In diesem Beispiel: - Der Modus ist auf "persist" gesetzt, das Modell bleibt nach Abschluss erhalten. - Es kann später ohne erneutes Training verwendet werden.

1
2
3
4
5
<setup numProcess="2">
    <generate name="csv_customer" count="10000" pageSize="1000" source="customer_csv_gen" target="CSV">
        <key name="id" generator="IncrementGenerator"/>
    </generate>
</setup>