Das Tabment

Ein Tabment ist ein Kunstwort zusammengesetzt aus TABelle und dokuMENT. Es kann als eine semantische Präzisierung des XML-Dokuments angesehen werden, wobei die konkrete XML-Syntax nur eine von mehreren Darstellungsformen ist. Viele XML-Dokumente lassen sich beispielsweise sehr vorteilhaft als Tabellen darstellen. Bestimmte Tabellen kann man als Punktmengen, gegeben durch ihre Koordinaten eventuell mit einem Farbwert, interpretieren, weshalb man diese Tabmente auch grafisch darstellen kann. Das Tabment in der eingeschränkten Version als NF2-Relation (Non-First-Normal-Form-Relation) wurde zunächst in der Spezifikationssprache von Kaphengst Reichel algebraisch spezifiziert. Dann wurde der Ansatz in CAML-Light implementiert. Mit dem Aufkommen von XML wurde er verallgemeinert. Diese Verallgemeinerung wollen wir hier in OCAML-Notation (Objective CAML) vorstellen. Damit die Präzisierung übersichtlich bleibt, verzichten wir auf Verbesserungen, die „lediglich“ auf eine effizientere Implementation zielen.

1. Spezifikation des Tabmentbegriffs

Tabmente sind sehr allgemeine Objekte. Zahlen, Texte, ... ,Mengen, Multimengen und Listen sind Tabmente. Diese Objekte werden alle in einer Sorte (in einem Typ) tabment zusammengefasst. Dafür benötigen wir lediglich 4 einfache Hilfssorten: Kollektionssymbole für unterschiedliche Kollektionsarten; Namen als eine Menge von einfachen Tags (z.B. Spaltennamen), elementare Werte und Schemata, die den direkten Typ des Tabments beschreiben. Wird rekursiv auch noch jeder Name des Schemas beschrieben, so sprechen wir von einer TTD (TabmentTypDefinition) des Tabments. Für die TTD muss keine neue Sorte eingeführt werden, da sie vom Typ NAME,SCHEME l (l=Liste) ist. Wir führen 3 eigentliche Kollektionssymbole und ein Symbol für optionale Werte (S1) ein. S1-Kollektionen enthalten kein oder ein Element. Die Kollektionen mv, bv, lv sind nur für das Sortieren von Interesse. Die Möglichkeiten der Any-Kollektion im Rahmen von o++oPS sind bei weitem noch nicht ausgeschöpft. Ihre Elemente können verschiedene Typen besitzen. Daher ist dieser Typ insbesondere für NoSQL- Ansätze interessant.
type coll_sym =
  Set | Bag | List (* M, B, L *)
| Set_minus | Bag_minus | List_minus (* mv, bv, lv *)
| S1 (* ?: optionale Werte *)
| Any;; (* a *)
type name = string;; (* Spaltennamen, Tags *)
type big_int = Big_int.big_int
type value = (* elementare Werte)
  Bar (* | der Strich im unären Zahlensystem *)
| Int_v of big_int (* Jede Zahl ist ein Wert *)
| Float_v of float
| Bool_v of bool
| String_v of string
| Stringi_v of string;; (* bestimmte Texte sind Worte *)
type scheme =
  Empty_s (* leeres Schema *)
| Inj of name (* jeder Name ist ein Schema *)
| Coll_s of coll_sym * scheme (* Kollektionsschema *)
| Tuple_s of scheme list (* Tupelschema *)
| Alternate_s of scheme list;;(* Schema für Choice *)
type tabment =
  Empty_t (* leeres Tabment: Fehlerwert *)
| El_tab of value (* jeder Value ist ein Tabment *)
| Tuple_t of tabment list (* Tupel von Tabmenten *)
| Coll_t of (coll_sym * scheme * (tabment list))
    (* Coll_t (c,s,[t1;t2;...;tn]) ist Kollektion von n Tabmenten vom Typ s *)
| Tag0 of name * tabment
    (* Tag0(n,t): t wird in den Tag n eingeschlossen *)
| Alternate_t of (scheme list) * tabment;;
    (* Alternate_t([s1;s2;...;sn],t) t muss vom Typ s1 oder s2,... oder sn sein *)

2. Beispiele Zur Illustration der Tabmentspezifikation

t1 = El_tab(String_v “Ernst“) = <TEXT: Ernst>
   = <TEXT>Ernst</TEXT> = <TABM>Ernst</TABM>
t2 = Tag0("NAME", (El_tab(String_v “Clara“))) = <NAME: Clara>
   = <NAME>Clara</NAME>
t3 = Tag0("NAME", (El_tab(String_v “Josephine“)))
   = <NAME: Josephine>
t4 = Tuple_t [t2; t3] (eine Person)
   = NAME, NAME
     Clara Josephine
   = <NAME>Clara</NAME
     <NAME>Josephine</NAME
t5 = Coll_t (List, Inj“NAME“, [t2; t3] ) (zwei Personen)
   = NAMEl
     Clara
     Josephine
   = NAMEl
     Clara Josephine
   = <NAME>Clara</NAME
     <NAME>Josephine</NAME
t6 = Tuple_t[Coll_t((S1,Inj “A1”),[Tag0(“A1”,El_tab(Int_v 10))]);Coll_t((S1,Inj “B1”),[])]
   = A1?, B1?
     10
   = <A1>10</A1>
Die Schemata der einzelnen Tabmente:
type_t (t1) = Inj “TEXT”= TEXT
type_t (t2) = type_t(t3) = Inj “NAME” = NAME
type_t (t4) = Tuple_s[(Inj “NAME”); (Inj “NAME”)] = (NAME, NAME)
type_t (t5) = L(NAME)
type_t (t6) = Tuple_s[Coll_s(S1,Inj”A1”),Coll_s(S1,Inj”B1”)] = (A1?, B1?)
Die TTD's der einzelnen Tabmente:
ttd_t (t1) = [“TABMENT“, Inj“TEXT“]
ttd_t (t2) = [“TABMENT“, Inj “NAME“; “NAME“, Inj “TEXT“]
ttd_t (t3) = ttd_t (t2)
ttd_t (t4) = [”TABMENT“,Tuple_s[(Inj “NAME”);(Inj “NAME”)];“NAME“, Inj ”TEXT“]
ttd_t (t5) = [”TABMENT“, Coll_s(List, Inj”NAME”);“NAME”,Inj”TEXT”]
ttd_t (t6) = [”TABMENT“,Tuple_s[Coll_s(S1,Inj”A1”);Coll_s(S1,Inj”B1”)]; “A1”,Inj “ZAHL”]

3. Tabmente in der Praxis

Eine flache Relation im Sinne des Relationalen Datenmodells ist ein Tabment vom Typ
   A1,A2,...,An m.
Vom praktischen Standpunkt kann man das Mengensymbol auch durch ein Multimengen- oder Listensymbol ersetzen. Die meisten csv-Dateien sind vom gleichen Typ.
NF2-Relationen enthalten Wiederholgruppen in beliebiger Verschachtelung und sind daher vom Typ
   A1,A2,...,(B1,B2,...(C1,C2,...m),(...m)m),(...m)...m,
wobei alle genannten Ai, Bi, Ci,... elementare Typen besitzen. Eine Datenbank ist vom Typ
   DATEI1,DATEI2,...,DATEIn,
wobei jede Datei entsprechend vom oben genannten Typ ist. Ein XML-Dokument mit DTD (Document Type Definition) ist ein Tabment. Der Unterschied zwischen Kollektion und Tupel wird in der DTD beschrieben, ist im XML-Dokument aber nicht mehr sichtbar. Daher hat der Tabmentansatz Probleme XML-Dokumente ohne DTD zu verarbeiten. Durch das allgemeine Verständnis von XML können wir Wikipediadokumente ebenfalls als Tabmente auffassen. Dadurch können in Zukunft auch anspruchsvolle Anfragen an die Wikipedia gestellt werden. Die Tabmente von o++oPS werden im Arbeitsspeicher verarbeitet. Wenn versucht wird Arbeitsspeicherplatz, mit dem durch die vielen Pointer und die redundanten Tagdaten relativ großzügig umgegangen wird, einzusparen, können wir bei der Implementation von o++oPS bereits von einer In-Memory-Datenbank sprechen.

4. Tabmentoperationen

Ein Datentyp ist nicht nur eine Menge von Elementen, sondern eine Menge mit zugehörigen Operationen. Da der Begriff des Tabments sehr allgemein gefasst ist, kann man vielfältige Operationen hierüber definieren. Einzelne Werte sind Tabmente also kann man auch die gewöhnlichen arithmetischen Operationen (+,*,...) und Textoperationen auf Tabmente verallgemeinern. Das Gleiche trifft auf Vektor- und Matrixoperationen zu. Die mengentheoretischen Operationen der Relationen Algebra (Vereinigung, Durchschnitt, Mengendifferenz) lassen sich selbstverständlich verallgemeinern. Sie haben aber im Fall von Tabmenten mit Wiederholgruppen geringe praktische Bedeutung. Die Selektion kann verallgemeinert werden. Es sind jedoch positionsselektierende Operationen definierbar und viele zusätzliche und auch spitzfindigere Bedingungen. In o++oPS wird die Projektion durch eine sehr allgemeine Umstrukturierungs-operation (gib-Klausel) und durch eine simple forget-Operation (weg-Klausel) ersetzt. Das kartesische Produkt ist aus der Menge der Operationen verschwunden, kann aber relativ leicht durch die Extension (ext) und die Umstrukturierungsoperation dargestellt werden. Durch ext werden neue (komplexe) Spalten eingeführt. Die Operationen werden in „28ottoPSBeispiele“ illustriert.