Structured Data Exchange Format

Structured Data eXchange Format (SDXF) ist ein hierarchisch strukturiertes Datenformat.

Mit diesem Format sollen fast beliebig strukturierte Daten zwecks Austauschs aufgenommen werden können. Dieses Format ist gleichermaßen geeignet als Dateiformat als auch als Networking-Message-Format.

SDXF lässt eine Strukturierung in beliebiger Tiefe zu; die einzelnen Datenelemente sind selbstbeschreibend. Das Format ist bewusst einfach gehalten, trotzdem soll es transparent sein, das heißt, dass die Programme über Grundfunktionen und Tools auf die Datenelemente zugreifen können und der Programmierer als Anwender sich um den genauen Aufbau der Datenstruktur nicht zu kümmern braucht.

SDXF unterstützt auch den Datenaustausch über verschiedene Rechnerarchitekturen hinweg durch eine transparente Umsetzung der Daten.

SDXF ist unter der RFC 3072 definiert und veröffentlicht.

Strukturierte Daten sind Strukturen, die von den beteiligten Programmen als solche erkannt und verarbeitet werden. Ein normaler Text ist zwar in Zeilen, Absätze und so weiter „strukturiert“, gilt aber als nicht strukturiert im Sinne dieser Definition.

Beispiel

Zwei Firmen, die in einer geschäftlichen Beziehung stehen, beschließen ihre Rechnungsstellung elektronisch abzuwickeln. Eine „Rechnung“ ist dann ein elektronisches Dokument mit folgender hierarchisch verschachtelter Struktur.

RECHNUNG
 │
 ├─ RECHNUNGS_NR
 ├─ DATUM
 ├─ ANSCHRIFT_SENDER
 │    ├─ NAME
 │    ├─ NAME
 │    ├─ STRAßE
 │    ├─ PLZ
 │    ├─ ORT
 │    └─ LAND
 ├─ ANSCHRIFT_EMPFÄNGER
 │    ├─ NAME
 │    ├─ NAME
 │    ├─ STRAßE
 │    ├─ PLZ
 │    ├─ ORT
 │    └─ LAND
 ├─ RECHNUNGS_SUMME
 ├─ EINZELPOSTEN_ALLE
 │    ├─ EINZELPOSTEN
 │    │    ├─ ANZAHL
 │    │    ├─ ARTIKELNUMMER
 │    │    ├─ ARTIKELTEXT
 │    │    ├─ PREIS
 │    │    └─ SUMME
 │    └─ …
 ├─ KONDITIONEN
 …

Ähnliche und komplexere Strukturen gilt es in SDXF abzudecken. Das grundlegende Konstruktionselement ist das „Chunk“. Die gesamte SDXF-Struktur ist ein Chunk und ein Chunk kann aus mehreren Chunks bestehen.

Ein Chunk ist sehr einfach aufgebaut. Er besteht aus einem Vorspann (Header) von sechs Bytes, gefolgt von den eigentlichen Daten. Im Header ist eine Bezeichnung des Chunks als eine 2-Byte Binärzahl (Chunk-ID) untergebracht, außerdem die Länge der nachfolgenden Daten und eine Kennzeichnung über den Typ der Daten und eventuelle zusätzliche Informationen (Komprimierung, Verschlüsselung und andere).

Der Daten-Typ informiert darüber, ob die Daten aus Text bestehen, ob sie eine Binärzahl darstellen (Ganzzahl oder Gleitkomma) oder ob die Daten sich aus einer Reihe von weiteren Chunks zusammensetzen (strukturierter Chunk).

Die Existenz der strukturierten Chunks ermöglicht es auf einfache Art und Weise, hierarchische Konstruktionen wie obige RECHNUNG in eine SDXF-Struktur zu packen. Zunächst muss jedem der genannten Begriffe (RECHNUNG, RECHNUNGS_NR, DATUM, ANSCHRIFT_SENDER etc.) eine eindeutige Nummer (Chunk-ID) aus dem Zahlenbereich 1 bis 65535 zugeordnet werden. Dann ist als erster Chunk der strukturierte Chunk RECHNUNG (Stufe 1) zu konstruieren, welcher aus einer Reihe weitere Chunks der Stufe 2 bestehen: RECHNUNGS_NR, DATUM, ANSCHRIFT_SENDER, ANSCHRIFT_EMPFÄNGER, RECHNUNGS_SUMME, EINZELPOSTEN_ALLE, KONDITIONEN. Manche dieser Chunks der 2. Stufe sind wiederum strukturiert: die beiden ANSCHRIFTen und EINZELPOSTEN_ALLE. Beim Datum hat man die Möglichkeit dieses in Textformat anzugeben, zum Beispiel in der form JJJJ-MM-TT (ISO 8601) oder auch als Struktur, bestehend aus den 3 numerischen Chunks JAHR, MONAT, TAG.

Im RFC wird ein Chunk auf Seite 3 genau beschrieben:^[1]

Die Definition des SDXF-Konzepts sieht vor, dass ein Programmierer mit einem genau definierten Satz von Bearbeitungsfunktionen mit den SDXF-Strukturen arbeitet.

Grundfunktionen

Beispiel eines Erstellungsprogramms

Für das Rechnungs-Beispiel könnte ein Erstellungsprogramm in etwa so aussehen:

init (sdx, buffersize=1000);   // initialisieren der SDXF Parameterstruktur sdx
create (sdx, ID=RECHNUNG, datatype=STRUCTURED); // beginn der Hauptstruktur
create (sdx, ID=RECHNUNGS_NR, datatype=NUMERIC, value=123456); // elementares Chunk
create (sdx, ID=DATUM, datatype=CHAR, value="2005-06-17"); // elementares Chunk
create (sdx, ID=ANSCHRIFT_SENDER, datatype=STRUCTURED); // Unterstruktur
create (sdx, ID=NAME, datatype=CHAR, value="Karl Napp"); // Unterstruktur
…
create (sdx, ID=LAND, datatype=CHAR, value="Schweiz"); // Unterstruktur
leave; // abschließen der Unterstruktur ANSCHRIFT_SENDER
…
leave; // abschließen der Hauptstruktur RECHNUNG

Die Syntax ist hier der Einfachheit halber fiktiv, ein vollständiges Beispiel in C findet sich auf der PINPI-Website.^[2]

Beispiel eines Ausleseprogramms

Das Auslesen folgt der vorgegebenen Struktur:

init (sdx, container=Adr. SDXF-Struktur);   // initialisieren der SDXF Parameterstruktur sdx
enter (sdx); // "Einstieg" in die RECHNUNGs-Struktur

do while (sdx.rc == SDX_RC_ok)
{
    switch (sdx.Chunk_ID)
   {
       case RECHNUNGS_NR:
         extract (sdx);
         rechnr = sdx.value;  // ganzzahlige numerische Werte werden in value abgelegt
         break;
         //
       case DATUM:
         extract (sdx);
         strcpy (rechdate, sdx.data); // data ist ein Zeiger auf die extrahierte Zeichenkette
         break;
         //
       case ANSCHRIFT_SENDER:
         enter (sdx);  // da die ANSCHRIFT eine Struktur ist
         do while (sdx.rc == SDX_RC_ok)
          …
         break;
      …
   }
}

Die einzelnen SDXF Elemente (Chunks) werden Stück für Stück erstellt. Das mag zunächst umständlich erscheinen, aber:

1. spiegelt dies genau die Wirklichkeit des Programmieralltags wider: Die einzelnen Elemente liegen in verschiedenen Programmvariablen oder Datenbankfeldern vor, beziehungsweise müssen in diese eingelesen werden.
2. nur so ist gewährleistet, dass bei einer Struktur mit gemischten Datentypen, diese so aufbereitet (normiert) wird, dass diese ohne Anpassung von einem Rechner auf den anderen (via Dateiübertragung oder Netzwerk) übertragen werden kann. Und zwar unabhängig von der Rechnerarchitektur. Das berücksichtigt die Problematik der unterschiedlichen Darstellung von Daten bei der Zeichendarstellung^[3] und dem Byte Swapping.^[4] Diese Problematik wird dem Anwendungsprogrammierer von den vorgestellten SDXF-Funktionen vollständig abgenommen.
3. Verschlüsselung (unter anderem nach AES) und Komprimierung (zip) werden ebenso von den SDXF-Funktionen übernommen (so können auch einzelne Teile komprimiert und/oder verschlüsselt werden.) Beim Auslesen wird automatisch entkomprimiert und entschlüsselt (Passwort muss natürlich stimmen).

Soll die gesamte Struktur als editierbare Textdatei bearbeitet werden können, kann das SDEF-Format^[5] verwendet werden.

Fußnoten

1. ↑ RFC 3072 Seite 3, Beschreibung eines Chunks
2. ↑ SDXF Beispiel auf der PINPI-Website
3. ↑ http://www.pinpi.com/de/SDXF_4.htm
4. ↑ http://www.pinpi.com/de/SDXF_5.htm
5. ↑ http://www.pinpi.com/de/sdef.htm

Weblinks

• http://www.pinpi.com/de/SDXF_0.htm Projektseite