INTERLIS Transformer — Referenz

git clone https://github.com/edigonzales/ilitransformer.git
cd ilitransformer
./gradlew installDist

./build/install/ilitransformer/bin/ilitransformer validate-mapping \
  -m demo/01-hello-copy/profile.ilimap

./build/install/ilitransformer/bin/ilitransformer transform \
  -m demo/01-hello-copy/profile.ilimap

./build/install/ilitransformer/bin/ilitransformer transform \
  -m demo/01-hello-copy/profile.ilimap --validate

ilitransformer transform -m <path> [options]

ilitransformer transform -m mapping.ilimap

ilitransformer transform \
  -m profile.ilimap \
  --modeldir models/ \
  --validate

ilitransformer transform \
  -m mapping.yml \
  --report reports/ \
  --fail-policy lenient

ilitransformer validate-mapping -m <path> [options]

ilitransformer validate-mapping -m minimal.ilimap

ilitransformer validate-mapping \
  -m profile.ilimap \
  --modeldir /pfad/zu/modellen/

ilitransformer validate-transfer -f <file> --modeldir <dir>... --model <model>... [options]

ilitransformer validate-transfer \
  -f output.xtf \
  --modeldir models/ \
  --model HelloDemo

ilitransformer validate-transfer \
  -f output.xtf \
  --modeldir models/ \
  --model HelloDemo \
  --log validation.log

ilitransformer convert-mapping --from <yaml> --to <ilimap>

ilitransformer convert-mapping \
  --from mapping.yml \
  --to mapping.ilimap

ilitransformer inspect-model --model <name> [options]

ilitransformer inspect-model \
  --model HelloDemo \
  --modeldir models/ \
  --output hello
# Erzeugt: hello.json, hello.md

ilitransformer inspect-model \
  --model HelloDemo \
  --modeldir models/ \
  --format json

ilitransformer run-bundle --manifest <yaml> [options]

ilitransformer run-bundle \
  --manifest profiles/dm01-to-dmav/bundle.yml \
  --repo-root profiles/dm01-to-dmav/ \
  --validate

ilitransformer --help                      # Befehlsübersicht
ilitransformer transform --help           # Hilfe für transform
ilitransformer validate-mapping --help    # Hilfe für validate-mapping

ilitransformer --version
# ilitransformer 0.1.0 (commit: a1b2c3d)

./gradlew validateTransfer -Ptransfer=output.xtf -Pmodel=MyModel

mapping v2 {
  input src {
    path "input.xtf";
    model "HelloDemo";
  }

  output tgt {
    path "output.xtf";
    model "HelloDemo";
  }

  oid uuid;

  rule copy {
    target tgt class "HelloDemo.Persons.Target";
    source s from src class "HelloDemo.Persons.Source";
    assign {
      Name = s.Name;
    }
  }
}

job {
  name "Mein Mapping";
  description "Beschreibung des Mappings";
  direction dm01_to_dmav;
  failPolicy strict;
  compileMode strict;
  modeldir "https://models.interlis.ch/";
  modeldir "models/";
}

job {
  modeldir "https://models.interlis.ch/";
  modeldir "./lokale-modelle/";
}

input <id> {
  path "datei.xtf";
  model "Model.Topic";
  format xtf;
  option <key> <value>;
  connection { ... }      // nur JDBC
  query <id> { ... }      // nur JDBC, wiederholbar
}

output <id> {
  path "ausgabe.xtf";
  model "Model.Topic";
  format xtf;
  option <key> <value>;
}

input src {
  path "daten/input.xtf";
  model "HelloDemo";
}

input csv_data {
  path "daten/input.csv";
  model "HelloData";
  format csv;
  option separator ";";
  option encoding "ISO-8859-1";
}

output shp_out {
  path "output/gebaeude.shp";
  model "LV95_Gebaeude";
  format shp;
  option dbfEncoding "UTF-8";
  option fieldNameStrategy truncate;
}

// Einfache Form
oid uuid;

// Mit Namespace
oid deterministicUuid {
  namespace "ch.admin.geo";
}

basket preserve;

enum meine_enum_map {
  #aktiv => #aktiv;
  #inaktiv => #inaktiv;
  #unbekannt => #andere;
  _ => #andere;    // Default-Wert
}

defaults {
  Beschreibung = "Standardtext";
  Status = #aktiv;
}

rule copy {
  defaults {
    Beschreibung = "Kopiert von " + s.Name;
  }
  ...
}

rule <id> {
  target <outputId> class "<Model.Topic.Class>";
  source <alias> from <inputId>[, <inputId>...] class "<Model.Topic.Class>" [where <expr>];

  [where <expression>;]
  [join (inner|left) <alias> to <alias> on <expression>;]
  [identity <alias.attr>, ...;]

  assign {
    <targetAttr> = <expression>;
    ...
  }

  [defaults { ... }]
  [bag <name> { ... }]
  [ref <name> { ... }]
  [create class "..." { ... }]
  [loss { ... }]
  [metadata { ... }]
}

target tgt class "HelloDemo.Persons.Target";

source s from src class "HelloDemo.Persons.Source";
source s from src, other class "Shared.Info" where s.Status == #aktiv;

rule combine {
  target tgt class "Target.Combined";
  source p from src1 class "Source.Person";
  source a from src2 class "Source.Address" where p.AdressId == a.Id;

  assign {
    Name = p.Name;
    Ort = a.Ort;
  }
}

assign {
  <zielAttribut> = <expression>;
  ...
}

assign {
  Name = s.Name;                          // Direkt übernehmen
  Beschreibung = "Standard";              // Konstanter String
  Anzahl = 42;                            // Konstanter Zahlenwert
  Aktiv = true;                           // Boolescher Wert
  Status = #aktiv;                        // Enum-Wert
}

assign {
  Name = trim(s.Name);                    // String trimmen
  NameGross = upper(trim(s.Name));        // Verschachtelte Aufrufe
  Wert = round(s.Wert, 2);               // Auf 2 Stellen runden
  Datum = toXmlDateTime(s.Datum);        // Typkonvertierung
  StatusNeu = enumMap(s.StatusAlt,      // Enum-Mapping
    meine_map);
  Bezug = if(defined(s.Referenz),         // Bedingung
    s.Referenz, null);
}

assign {
  Label = trim(
    upper(s.Name)
  );
}

bag adressen {
  from a in src class "Source.Adresse" where a.PersonId == p.OID;
  target Adressen;
  structure "Target.Adresse";
  mode embed;
  maxItems 5;
  parentRef attribute "PersonId" parent p;

  assign {
    Strasse = a.Strasse;
    PLZ = a.PLZ;
    Ort = a.Ort;
  }

  bag dokumente {     // verschachtelter Bag
    ...
  }
}

ref gebaeude_ref {
  association "Target.GebaeudeRef";
  role "Gebaeude";
  required;
  target rule gebaeude_rule sourceRef s.GebaeudeRef;
}

create class "Target.Metadaten" {
  assign {
    Quelle = "ilitransformer";
    Timestamp = now();
  }
}

loss {
  sourcePath s.AlteGeometrie;
  reasonCode "GEOM_VEREINFACHT";
  description "Die Geometrie wurde für das Zielmodell vereinfacht. " +
              "Detailsiehe Transformationsbericht.";
  when defined(s.AlteGeometrie);
}

metadata {
  direction dm01_to_dmav;
  roundtrip lossy;
  lossiness partial;
}

// Zeilenkommentar
/* Block-Kommentar
   über mehrere Zeilen */

"Ein String mit Umlauten: äöü"
""

42
3.14
-5
0

true
false
null

#aktiv
#inaktiv
#unbekannt

assign {
  Name = "Text; mit Semikolon";   // OK: in String
  Wert = if(a == b; b; a);         // NICHT OK: ; in Klammern beendet Ausdruck nicht
}

job:
  name: "DM01 nach DMAV"
  description: "Vollständige Transformation"
  direction: dm01-to-dmav
  failPolicy: strict
  modeldir:
    - "https://models.interlis.ch/"
    - "./lokale-modelle/"
  inputs:
    - id: dm01
      path: "eingabe.xtf"
      model: "DM01"
  outputs:
    - id: dmav
      path: "ausgabe.xtf"
      model: "DMAV"

inputs:
  - id: csv_data
    path: "daten/input.csv"
    model: "MyModel"
    format: csv
    options:
      firstLineIsHeader: true
      separator: ";"
      delimiter: '"'
      encoding: "UTF-8"

inputs:
  - id: gpkg_data
    path: "daten/gebaeude.gpkg"
    model: "MyModel"
    format: gpkg
    options:
      table: "gebaeude"
      fetchSize: 5000

inputs:
  - id: db_data
    model: "MyModel"
    format: jdbc
    connection:
      url: "jdbc:postgresql://localhost/mydb"
      driver: "org.postgresql.Driver"
      user: "app"
      password: "secret"
    queries:
      - class: "MyModel.Topic.MyClass"
        sql: "SELECT * FROM my_table"
        topic: "Topic"
        basketId: "b1"
        oidColumn: "t_id"
        columns:
          attr1: "col_a"
          attr2: "col_b"
        geometry:
          geom_attr:
            column: "geom_col"
            type: "surface"
            srid: 2056

inputs:
  - id: shp_data
    path: "daten/gebaeude.shp"
    model: "MyModel"
    format: shp
    options:
      class: "MyModel.Topic.Gebaeude"
      dbfEncoding: "ISO-8859-1"
      geometryType: "surface"

outputs:
  - id: out
    path: "output.xtf"
    model: "TargetModel"
    format: xtf

outputs:
  - id: out
    path: "output.xtf"
    model: "TargetModel"
    format: xtf
    options:
      pretty: true

outputs:
  - id: shp_out
    path: "output/gebaeude.shp"
    model: "TargetModel"
    format: shp
    options:
      dbfEncoding: "UTF-8"
      fieldNameStrategy: "truncate"
      prj: "PROJCS[\"CH1903+ / LV95\",...]"

mapping:
  oidStrategy:
    type: uuid

mapping:
  oidStrategy:
    type: deterministicUuid
    namespace: "ch.admin.geo"

mapping:
  basketStrategy:
    type: generateUuid

mapping:
  enums:
    status_map:
      aktiv: aktiv
      inaktiv: inaktiv
      unbekannt: andere

mapping:
  defaults:
    Beschreibung: "Standardtext"
    Status: "#aktiv"

target:
  output: out
  class: "TargetModel.Topic.TargetClass"

sources:
  - input: src
    alias: s
    class: "SourceModel.Topic.SourceClass"
    where: "s.Status == #aktiv"

rules:
  - id: "copy_gebaeude"
    target:
      output: out
      class: "LV95.Gebaeude"
    sources:
      - input: src
        alias: g
        class: "AV.Gebaeude"
    assign:
      Name: "trim(g.Name)"
      Nummer: "g.Nummer"
      Geometrie: "ref g.Geometrie"
    bags:
      adressen:
        from:
          input: src
          alias: a
          class: "AV.Adresse"
          where: "a.GebaeudeId == g.OID"
        target: "Adressen"
        structure: "LV95.Adresse"
        assign:
          Strasse: "a.Strasse"
          Ort: "a.Ort"
    refs:
      - association: "LV95.GebaeudeRef"
        role: "Gebaeude"
        sourceRef: "g.RefOID"
        targetRule: "gebaeude_rule"
    loss:
      - sourcePath: "g.AlteGeometrie"
        reasonCode: "GEOM_VEREINFACHT"
        description: "Geometrie vereinfacht"
        when: "defined(g.AlteGeometrie)"
    metadata:
      direction: "av_to_lv95"
      roundtrip: "lossy"
      lossiness: "minimal"

from:
  input: src          # Input-ID
  alias: a            # Alias
  class: "Model.Topic.SourceClass"
  where: "a.ParentId == p.OID"

parentRef:
  attribute: "GebaeudeId"   # oder role: "..."
  parent: g                 # Parent-Alias

bags:
  adressen:
    from:
      input: src
      alias: a
      class: "AV.Adresse"
      where: "a.GebaeudeId == g.OID"
    structure: "LV95.Adresse"
    mode: embed
    maxItems: 10
    parentRef:
      attribute: "GebaeudeId"
      parent: g
    assign:
      Strasse: "a.Strasse"
      Hausnummer: "a.Hausnummer"
      PLZ: "a.PLZ"
      Ort: "a.Ort"
    bag:
      dokumente:
        from:
          input: src
          alias: d
          class: "AV.Dokument"
          where: "d.AdresseId == a.OID"
        structure: "LV95.Dokument"
        assign:
          Dateiname: "d.Dateiname"
          Typ: "d.Typ"

refs:
  - association: "TargetModel.Topic.AssocRef"
    role: "ZielRolle"
    sourceRef: "s.RefOID"
    targetRule: "ziel_regel"

create:
  - class: "TargetModel.Topic.Metadaten"
    assign:
      Quelle: '"ilitransformer"'
      Timestamp: "now()"

loss:
  - sourcePath: "s.AlteGeometrie"
    reasonCode: "GEOM_VEREINFACHT"
    description: "Geometrie wurde vereinfacht"
    when: "defined(s.AlteGeometrie)"

metadata:
  direction: "dm01_to_dmav"
  roundtrip: "lossy"
  lossiness: "partial"

identity:
  sourceKey:
    - "s.Nummer"
    - "s.Name"

job:
  inputs:
    - id: dm01
      path: "eingabe.xtf"
      model: "DM01"
  outputs:
    - id: dmav
      path: "ausgabe.xtf"
      model: "DMAV"

mapping v2 {
  input dm01 {
    path "eingabe.xtf";
    model "DM01";
  }

  output dmav {
    path "ausgabe.xtf";
    model "DMAV";
  }

  rule lfp3 {
    target dmav class "DMAV.LFP3";
    source s from dm01 class "DM01.LFP3";
    ...
  }
}

ilitransformer transform -m profiles/dm01-to-dmav/mapping.yml

assign {
  // coalesce: erstes nicht-null
  Name = coalesce(s.Name1, s.Name2, "Unbekannt");

  // defined / default
  Optional = default(s.Optional, "Kein Wert");

  // Bedingung
  Status = if(s.Aktiv == true, #aktiv, #inaktiv);

  // Logische Verknüpfung
  Gueltig = defined(s.Name) and defined(s.Geometrie);

  // Vergleich
  Gross = s.Anzahl > 100;
}

assign {
  // Trimmen und Grossschreibung
  Name = upper(trim(s.Rohname));

  // Substring: erstes Zeichen
  Initial = substring(s.Name, 1, 1);

  // Ersetzung
  Bereinigt = replace(s.Text, "  ", " ");

  // Kürzen auf 60 Zeichen
  Kurz = truncate(s.Langtext, 60);

  // Verkettung
  FullName = concat(s.Vorname, " ", s.Nachname);
}

assign {
  // Einheiten umrechnen
  FlaecheM2 = round(mul(s.FlaecheHa, 10000), 2);

  // Prozentuale Anpassung
  PreisNeu = round(mul(s.PreisAlt, 1.08), 2);

  // Begrenzung
  Anzahl = min(s.Anzahl, 9999);

  // Text → Zahl
  Wert = toNumber(s.TextWert);
}

assign {
  // DATE → XMLDateTime
  Erfassung = toXmlDateTime(s.Erfassungsdatum);

  // XMLDateTime → INTERLIS 1 (YYYY-MM-DD)
  DatumAlt = toInterlis1Date(s.ModernesDatum);

  // Aktueller Zeitstempel
  ImportZeit = now();
}

// enum-Block im Mapping:
enum status_map {
  #aktiv => #aktiv;
  #inaktiv => #inaktiv;
  _ => #unbekannt;
}

assign {
  // Standard-Mapping
  StatusNeu = enumMap(s.StatusAlt, status_map);

  // Mit Fallback
  StatusNeu = enumMapDefault(s.StatusAlt, status_map, #unbekannt);

  // Strikt (Fehler bei unbekanntem Wert)
  StatusNeu = enumMapStrict(s.StatusAlt, status_map);

  // Optional mit Default
  Status = enumDefault(s.Status, #aktiv);

  // Enum-Name als Text
  StatusText = enumName(s.Status);
}

assign {
  // OID aus Referenz extrahieren
  RefId = refOid(s.GebaeudeRef);

  // Referenzen vergleichen
  GleichesObjekt = refEquals(s.Ref1, s.Ref2);
}

assign {
  // OID des Quellobjekts
  SourceOid = oid(s);

  // Erstes Element aus einem Bag
  ErsteAdresse = bagFirst(g, Adressen, Strasse);

  // Lookup über alle Inputs
  Ort = lookup("AV.Ortschaft", "PLZ", s.PLZ, "Ortsname");

  // Leiser Lookup (keine Warnung)
  Ort = lookupOptional("AV.Ortschaft", "PLZ", s.PLZ, "Ortsname");

  // Lookup in bestimmtem Input
  Region = lookupIn(src, "AV.Region", "BFS_Nr", s.BFS, "Name");

  // Existenz-Prüfung
  HatAdresse = existsIn(src, "AV.Adresse", "GebaeudeId", oid(g));
}

assign {
  // Koordinatenvergleich mit Toleranz
  GleicherPunkt = coordEquals(s.Koord1, s.Koord2, 0.001);

  // Label-Punkt aus Fläche
  LabelPunkt = pointOnSurface(s.Geometrie);
}

// a and b or c                    → (a and b) or c
// a and not b                     → a and (not b)
// a == b and c > d               → (a == b) and (c > d)
// not a and b                     → (not a) and b

input src {
  path "daten/input.xtf";
  model "MyModel";
  // format xtf;  ← optional, wird aus Endung erraten
}

output tgt {
  path "daten/output.xtf";
  model "MyModel";
  format xtf;
  option pretty true;
}

input csv_src {
  path "daten/gebaeude.csv";
  model "MyModel";
  format csv;
  option separator ";";
  option firstLineIsHeader true;
  option encoding "UTF-8";
}

input gpkg_src {
  path "daten/gebaeude.gpkg";
  model "MyModel";
  format gpkg;
  option table "gebaeude";
}

connection {
  driver "org.postgresql.Driver";
  url "jdbc:postgresql://localhost/mydb";
  user "app";
  password "secret";        // Klartext
  userEnv "DB_USER";       // Umgebungsvariable
  passwordEnv "DB_PASS";   // Umgebungsvariable
  property "key" "value";
}

query gebauede_query {
  topic "Gebaeude";
  class "MyModel.Topic.Gebaeude";
  basketId "b1";
  oidColumn "t_id";
  sql "SELECT t_id, name, nummer, geom FROM gebaeude";
  column "t_id" "OID";
  column "name" "Name";
  column "nummer" "Nummer";
  geometry geom_attr {
    column "geom";
    encoding wkb;
    type surface;
    srid 2056;
  }
}

input shp_src {
  path "daten/gebaeude.shp";
  model "AV";
  format shp;
  option class "AV.Gebaeude";
  option dbfEncoding "ISO-8859-1";
  option geometryType surface;
}

output shp_out {
  path "output/gebaeude.shp";
  model "LV95";
  format shp;
  option dbfEncoding "UTF-8";
  option fieldNameStrategy truncate;
  option prj "PROJCS[\"CH1903+ / LV95\",GEOGCS[...]]";
}

inputs:
  - id: xtf_in
    path: "input.xtf"
    model: "MyModel"
    format: xtf

  - id: csv_in
    path: "input.csv"
    model: "MyModel"
    format: csv
    options:
      separator: ";"

  - id: jdbc_in
    model: "MyModel"
    format: jdbc
    connection:
      url: "jdbc:postgresql://localhost/db"
      userEnv: "DB_USER"
      passwordEnv: "DB_PASS"
    queries:
      - class: "MyModel.Topic.MyClass"
        sql: "SELECT * FROM my_table"

oid deterministicUuid {
  namespace "ch.admin.geo";
}