Tabment

Aus MARJORIE-WIKI
Wechseln zu: Navigation, Suche

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.

Spezifikation des Tabments[Bearbeiten]

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 3 einfache Hilfssorten: Kollektionssymbole für unterschiedliche Kollektionsarten; Namen als eine Menge von einfachen Tags (z.B. Spaltennamen) 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 L(NAME,SCHEME) (L=Liste) ist. Das Besondere an Tabmenten und der Programmiersprache O++oPS ist, dass sie unabhänig vom Kartesischen Produkt ist. O++oPS basiert auf Tabmenten. Sie verfügt insbesondere über eine Umstrukturierungsoperation bei der man lediglich ein Schema oder eine TTD vorgeben kann, und das System realisiert die Umstrukturierung ohne die "nest" und "unnest" der NF2-Relationenalgebra. Wir führen 3 eigentliche Kollektionssymbole und ein Symbol für optionale Werte (S1) ein. S1-Kollektionen enthalten kein oder ein Element. Die Kollektionen M-, B-, L- 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;;  (* M-, B-, L- *)
      | 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 *)

Beispiele Zur Illustration der Tabmentspezifikation[Bearbeiten]

 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)
    = <<L(NAME)::     
          Clara 
          Josephine>>
    = <<L(NAME)::
          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”]

Tabmente in der Praxis[Bearbeiten]

Eine flache Relation im Sinne des Relationalen Datenmodells ist ein Tabment vom Typ 

 M(A1,A2,...,An).

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 

 M(A1,A2,...,M(B1,B2,...M(C1,C2,...),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.

Tabmentoperationen[Bearbeiten]

Ein Datentyp ist nicht nur eine Menge, 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 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 Umstrukturierungsoperation (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 O++oPS illustriert.


Siehe auch[Bearbeiten]

Weblinks[Bearbeiten]

o++oQL

Einzelnachweise[Bearbeiten]

Info Sign.svg Dieser Wikipedia-Artikel wurde, gemäß GFDL, CC-by-sa mit der kompletten History importiert.
Abgerufen von „https://marjorie-wiki.de/w/index.php?title=Tabment&oldid=1400294“