Leopold-Franzens-Universität Innsbruck. Institut für Informatik Datenbanken und Informationssysteme. Johannes Kessler

Leopold-Franzens-Universität Innsbruck Institut für Informatik Datenbanken und Informationssysteme Übungstool für relationale Algebra Bachelor-Arbeit Johannes Kessler betreut von Michael Tschuggnall, MSc Univ. Prof. Dr. Günther Specht Innsbruck, 16. Mai 2014

Zusammenfassung Die relationale Algebra ist eine prozedurale Abfragesprache und theoretisches Fundament eines relationalen Datenbanksystems. Sie bildet die Grundlage zum tieferen Verständnis der Arbeitsweise einer Datenbank und wird in Datenbank-Vorlesungen ausführlich behandelt. Im Gegensatz zu anderen Abfragesprachen wie SQL gibt es jedoch kaum Programme, die Abfragen in relationaler Algebra unterstützen. Meist wird sie eher theoretisch vermittelt und Beispiele müssen oft händisch berechnet werden. In dieser Arbeit wird ein Übungstool vorgestellt, das Studenten erlaubt, Abfragen in relationaler Algebra und SQL einzugeben und in relationaler Algebra auszuführen. Dadurch soll das Erlernen dieser fundamentalen Konzepte erleichtert und ein Einblick in die grundlegende Funktionsweise einer Datenbank gegeben werden. Das webbasierte Übungstool unterstützt alle Basisoperatoren der relationalen Algebra und viele der erweiterten Operatoren.

Abstract The relational algebra is a procedural query language and is the theoretial basis of a relational database system. It is taught in lectures at universities to build the foundation of understanding how database systems work. In the contrast to other query languages like SQL, there are very few programs that allow to run an arbitrary relational algebra statement. It is therefore often told very theoretically and examples have to be calculated manually. In this thesis a platform was developed, that allows students to formulate statements in either SQL or relational algebra. These statements are then translated into and are run as relational algebra. This should allow the users to learn the fundamental concepts more easily and should give them an insight of how a database works. The webbased tool supports all of the basic operators of the relational algrebra and many of the additional operators and concepts.

Inhaltsverzeichnis 1 Einleitung V 2 Relationale Algebra 3 2.1 Relationales Modell und relationale Algebra........ 3 2.1.1 Aufbau........................ 5 2.1.2 Union-Kompatibilität................ 6 2.2 Operatoren der relationalen Algebra............ 6 2.2.1 Selektion....................... 7 2.2.2 Projektion....................... 8 2.2.3 Umbenennung.................... 8 2.2.4 Vereinigung...................... 10 2.2.5 Schnittmenge..................... 11 2.2.6 Differenz....................... 11 2.2.7 Kreuzprodukt..................... 12 2.2.8 Theta-Join...................... 12 2.2.9 Equi-Join....................... 13 2.2.10 Natural-Join..................... 14 2.2.11 Outer Joins...................... 15 2.2.12 Semi-Joins...................... 18 2.2.13 Anti-Join....................... 19 2.2.14 Division........................ 19 2.2.15 Sortieren....................... 20 2.2.16 Erweiterung der Projektion............. 21 2.2.17 Gruppierung und Aggregation............ 22 2.3 Sichtbarkeit.......................... 24 2.4 Operatorbaumdarstellung.................. 24 2.5 Präzedenz........................... 25 3 Übungstool 27 3.1 Relationale Algebra..................... 29 3.1.1 Syntax......................... 29 3.1.2 Kommentare..................... 34 3.1.3 Zuweisungen..................... 34 III

INHALTSVERZEICHNIS 3.1.4 Inline-Relationen................... 36 3.1.5 Präzedenz....................... 38 3.1.6 Plaintext Notation.................. 39 3.1.7 SQL.......................... 41 3.2 Berechnung.......................... 43 3.3 Server............................. 49 3.4 Geteilte Tabellen....................... 52 4 Grafische Benutzeroberfläche 55 4.1 Editor............................. 56 4.1.1 Syntax-Highlighting................. 57 4.1.2 Fehlermeldungen................... 58 4.1.3 Autovervollständigung................ 58 4.2 Operatorbaum........................ 59 4.3 Font.............................. 61 5 Zusammenfassung 65 Literaturverzeichnis 68 IV Johannes Kessler

Kapitel 1 Einleitung Das relationale Modell und die relationale Algebra (RA) wurden 1970 von E. F. Codd eingeführt [Cod70]. Sie bilden das theoretische Fundament jedes relationalen Datenbanksystems. Die relationale Algebra ist eine prozedurale Sprache, um Abfragen mit Relationen zu formulieren. Es werden hierfür Operationen definiert, die Relationen (vereinfacht Tabellen) verarbeiten können. Aufgrund ihrer fundamentalen Bedeutung für das Verständnis eines Datenbanksystems wird die relationale Algebra sowohl in den meisten Büchern behandelt, welche die Grundlagen einer Datenbank vermitteln, als auch in Datenbankvorlesungen an Universitäten vorgestellt. Im Gegensatz zu SQL, das den ISO-Standard für den Zugriff auf relationale Datenbanken darstellt, existiert für die relationale Algebra keine breite Unterstützung durch entsprechende Tools oder Backends. Meist wird sie eher theoretisch vermittelt und Beispiele werden oft händisch berechnet. Ziel dieser Bachelorarbeit ist die Entwicklung eines webbasierten Übungstools für relationale Algebra. Es soll die Berechnung von beliebigen RA-Statements auf vorgegebenen Daten ermöglichen. Einzelschritte der Berechnungen sollen in einem Operatorbaum visualisiert und deren Ergebnisse angezeigt werden können. Weiters soll es möglich sein, Statements in SQL eingeben zu können und diese in RA zu übersetzen. Ähnliche Projekte Interaktive Relationale Algebra (IRA) von Henrik Mühe ist ein webbasiertes Tool, um RA-Ausdrücke auf einem vordefinierten Schema zu formulieren und auszuwerten 1. Die Eingabe der Formel erfolgt durch Auswahl der entsprechenden Operatoren und Operanden. Ein bereits 1 http://www-db.in.tum.de/~muehe/ira/ und https://github.com/henrik-muehe/ira, zuletzt besucht am 29.04.2014 V

KAPITEL 1. EINLEITUNG eingegebener Teil kann dabei nicht direkt geändert werden, es steht jedoch eine Funktion zur Verfügung, die den jeweils letzten Schritt rückgängig macht. Die Darstellung der eingegebenen Formeln wurde durch serverseitiges Rendering von Latexcode realisiert. Die Berechnung des Ergebnisses erfolgt clientseitig in JavaScript. Relation Algebra Expression Evaluation ist eine Bachelorarbeit von Lucie Molkov an der Masaryk Universität [Mol09]. Die Arbeit behandelt das Parsen von RA-Ausdrücken und das Übersetzen der Statements in SQL. Hierfür wird eine alternative Klartextsyntax für die RA eingeführt und eine Operatorpräzedenz definiert. Eine Berechnung von RA-Statements ist durch ein in Perl implementiertes Programm möglich, das die eingegebenen Abfragen in SQL übersetzt und für die Berechnung an eine verbundene Datenbank weitergibt. select2obaum ist ein webasiertes Programm der Fachhochschule Köln, das vorgegebene oder frei formulierbare SQL-Statements in relationale Algebra übersetzt 2. Das Ergebnis ist ein RA-Ausdruck, der sowohl als Formel als auch als einfacher Operatorbaum dargestellt wird. Eine Auswertung der Abfrage auf echten Daten ist nicht möglich. Relational Algebra Translator (RAT) ist ein Programm, das eingegebene RA-Statements in SQL übersetzt und diese auf einem verbundenen relationalen Datenbanksystem ausführt 3. Neben dem übersetzten SQL-Statement wird das RA-Statement als Operatorbaum dargestellt. Die semantische Prüfung der eigegebenen Abfrage erfolgt indirekt durch das Ausführen des SQL-Statements. RAT wurde mit dem.net- Framework umgesetzt und benötigt eine Installation auf dem Zielrechner. Relational Algebra Evaluator ist ein interaktiver Interpreter von Nick Everitt 4. Er ist in Java implementiert und bietet dem User ein Textinterface zur Eingabe der RA-Statements. Relationen können dabei aus CSV-Dateien geladen werden. 2 http://edb.gm.fh-koeln.de/select_new/start.jsp?action=, zuletzt besucht am 29.04.2014 3 http://www.slinfo.una.ac.cr/rat/rat.html, zuletzt besucht am 29.04.2014 4 https://code.google.com/p/relational-algebra/, zuletzt besucht am 29.04.2014 VI Johannes Kessler

KAPITEL 1. EINLEITUNG Aufbau Kapitel 2 ist eine Einführung in relationale Algebra. Dabei werden alle im Programm unterstützten Operatoren vorgestellt und erklärt, sowie der grundlegende Aufbau von RA-Abfragen und die Gültigkeitsbereiche von Bezeichnern eingeführt. Weiterhin wird eine Operatorpräzedenz eingeführt, die es erlaubt, durch eine implizite Klammerung von Operatoren auf einen Großteil der expliziten Klammerung zu verzichten. In Kapitel 3 werden das umgesetzte Übungstool und dessen Kernkomponenten vorgestellt. Es wird dafür eine für einen Code-Editor geeignete RA-Syntax und deren Grammatik vorgestellt. Außerdem werden mehrere Erweiterungen wie Zuweisungen oder im Code eingebettete Relationen erklärt, die Übersetzung von SQL Statements nach RA eingeführt und das unterstützte SQL Subset definiert. In Kapitel 4 wird die grafische Benutzeroberfläche des umgesetzten Übungstools präsentiert. Dabei werden wichtige Komponenten wie der Editor und der Operatorbaum und die damit verbundenen Erweiterungen vorgestellt. Johannes Kessler 1

Kapitel 2 Relationale Algebra In diesem Kapitel wird die relationale Algebra und deren Operatoren vorgestellt. Hierbei werden alle im Übungstool unterstützen Operatoren im besonderen Hinblick auf die Verwendung von vollqualifizierten Attributnamen eingeführt. 2.1 Relationales Modell und relationale Algebra Das relationale Modell bildet die Grundlage heutiger relationaler Datenbanksysteme. Es wurde mit der relationalen Algebra (RA) Anfang der 70er Jahre von E. F. Codd eingeführt [Cod70]. Die relationale Algebra ist eine formale Sprache, mit der Abfragen formuliert werden können. Sie ist im Gegensatz zu den deklarativen Abfragesprachen, wie SQL, dem Relationen-Tupelkalkül oder dem Domänenkalkül, prozedural. Das bedeutet, dass sie aus einer Abfolge von Operationen besteht, die beschreiben, wie das Ergebnis berechnet wird. Die deklartiven Abfragesprachen beschreiben, welche Eigenschaften das Ergebnis haben soll, nicht aber, wie dieses berechnet werden soll. Das relationale Modell folgt einem einfachen Aufbau und besteht (grundsätzlich) aus Tabellen (Relationen), in denen die Daten zeilenweise gespeichert sind. Die Zeilen der Relationen (Tupel) haben keine feste Ordnung innerhalb der Relation. Duplikate (Zeilen mit gleichem Inhalt) sind innerhalb einer Relation nicht möglich. Alle Einträge einer Spalte haben denselben Datentyp (Domäne). Formal [KE11, GMUW09] ist eine Domäne ein bestimmter Wertebereich oder Typ, der nur atomare Werte wie beispielsweise die Menge der natürlichen Zahlen oder Zeichenketten enthält. Nicht zugelassen sind strukturierte Typen wie Mengen oder Multimengen. Eine Relation R wird als Teilmenge aus dem Kreuzprodukt aus n Do- 3

KAPITEL 2. RELATIONALE ALGEBRA mänen definiert [KE11, Seite 71]: R Ď D 1 ˆ ˆ D n n ě 1 Ein Element der Relation R wird als Tupel bezeichnet und besitzt die Stelligkeit n. Eine Relation ist eine Menge, welche daher keine Duplikate enthält und deren Elemente keine Ordnung besitzen. In dieser Arbeit werden Relationen als Tabellen dargestellt, was am Beispiel einer Kundentabelle Kunden Ď string ˆ string ˆ integer veranschaulicht werden soll: Kunden := Vorname Nachname Kundennummer Max Mustermann 100 Johann Meier 101 Eine Spalte wird als Attribut bezeichnet und dieser ein innerhalb der Relation eindeutiger Name zugewiesen. Im gegebenen Beispiel werden die Attribute Vorname, Nachname und Kundennummer verwendet. Die Menge der Attribute einer Relation wird als Schema bezeichnet. Attribut Tupel Relation Abbildung 2.1: Bezeichnungen einer Relation als Tabelle dargestellt. Quelle: http://en.wikipedia.org/wiki/file:relational_ database_terms.svg, zuletzt besucht am 29.04.2014. Das Schema einer Relation R (sch(r)) wird in dieser Arbeit wie folgt dargestellt: [Attributname 1 : Attributtyp 1,..., Attributname n : Attributtyp n ] Der Attributname ist ein vollqualifizierter Name in der Form Relationsname.Spaltenname und der Attributtyp der Bezeichner der jeweiligen Domäne. Das Schema der Relation Kunden wird somit als [Kunden.V orname : string, Kunden.N achname : string, Kunden.Kundennummer : integer] 4 Johannes Kessler

KAPITEL 2. RELATIONALE ALGEBRA dargestellt. Um die Attribute einer Relation eindeutig ansprechen zu können, kann entweder der Name des Attributs verwendet werden, oder dessen Index (1-basiert) in eckigen Klammern. Beiden Varianten muss, wenn anders nicht eindeutig, ein Qualifizierer vorangestellt werden, der durch einen Punkt getrennt wird. Somit kann die erste Spalte der Kundenrelation sowohl mit Vorname, Kunden.Vorname, [1] als auch mit Kunden.[1] angesprochen werden. In diesem Kapitel werden drei verschiedene Typen verwendet: integer, float und strings. Strings werden dabei analog zu SQL in einfachen Anführungszeichen notiert. 2.1.1 Aufbau In diesem Abschnitt wird der Aufbau einer Formel in relationaler Algebra erklärt. Eine benannte Relation ist eine Relation, der ein Name zugewiesen wurde und den Ausgangspunkt jedes RA-Ausdrucks bildet. Sie wird innerhalb der Formel durch ihren Namen, z.b. Kunden, angesprochen. Zusätzlich kann jeder Ausdruck, nach einer entsprechenden Zuweisung, über den neuen Variablennamen angesprochen werden: A = (Kunde) ρ x (Konto) π vorname,nachname,kontostand (A) Jede unäre Operation folgt der folgenden Syntax: α β (R) wobei α ein der Funktion entsprechendes Symbol (z.b. π für die Projektion), β das Argument und R eine Relation bezeichnet. Eine binäre Operation wird als (R)α β (S) notiert. Dabei stehen R und S für die übergebenen Relationen, α für die Funktion (z.b. für einen Natural-Join) und β für das Argument der Funktion. Für die Relationen R und S können entweder der Name einer benannten Relation oder ein beliebiger Ausdruck in RA eingesetzt werden. Die Klammerung kann entfallen, solange der Ausdruck weiterhin eindeutig definiert ist. Hierzu wird in Abschnitt 2.5 eine Operatorpräzedenz eingeführt. Johannes Kessler 5

KAPITEL 2. RELATIONALE ALGEBRA Das Statement π nachname σ vorname 1 Max 1Kunde ist auch ohne Präzedenzregeln eindeutig. Das Argument β ist nicht bei allen Operationen vorhanden, wobei sich die Semantik des Operators dabei ändern kann. Als Beispiel kann hierfür der Natural- und Theta-Join (siehe Abschnitt 2.2.10 und Abschnitt 2.2.8) genannt werden. Beide werden mit demselben Symbol bezeichnet. Die Unterscheidung erfolgt dadurch, dass ein Theta-Join R R.a=S.b S ein zusätzliches Argument β (hier R.a = S.b) besitzt, der Natural-Join hingegen nicht. 2.1.2 Union-Kompatibilität R S Bestimmte Operationen der relationalen Algebra wie Vereinigung, Schnitt und Differenz verlangen union-kompatibilität. union- Kompatibilität ist eine Eigenschaft des Schemas einer Relation. Zwei Relationen R und S sind genau dann union-kompatibel, wenn folgende Bedingungen erfüllt sind: 1. Die Relationen R und S besitzen dieselbe Stelligkeit n, d.h. sie haben die selbe Anzahl von Spalten. 2. Für alle Spalten der Relationen gilt, dass die Domäne der i-ten Spalte der Relation R mit dem Typ der i-ten Spalte der Relation S übereinstimmt (0 ă i ă n). Die Namen der Attribute spielen dabei keine Rolle. Die Schemata [a : string, b : integer, c : integer] und [d : string, e : integer, f : integer] sind somit union-kompatibel, da sie die selbe Anzahl von Attributen besitzen und die Typen der Spalten jeweils paarweise übereinstimmen. 2.2 Operatoren der relationalen Algebra In diesem Abschnitt werden die Operatoren der relationalen Algebra vorgestellt. Jeder Operation der RA werden eine oder zwei Relationen als Argumente übergeben. Der Rückgabewert ist jeweils eine neue Relation, welche das Ergebnis der Operation enthält. Die Argumentrelationen werden dabei nicht verändert. 6 Johannes Kessler

KAPITEL 2. RELATIONALE ALGEBRA Zur einfacheren Darstellung wird in diesem Kapitel teilweise davon gesprochen, dass eine Operation eine bestimmte Relation oder ein Schema verändert, wobei darunter immer die Erzeugung einer neuen Relation oder eines Schemas zu verstehen ist, welche die entsprechenden Änderungen enthält. 2.2.1 Selektion Die Selektion dient dazu, bestimmte Tupel (Zeilen) auszuwählen und wird mit σ bezeichnet. Die Selektion X = σ C (R) besteht aus einer Relation R und einer Selektionsbedingung C. Die Ergebnisrelation X hat dasselbe Schema und besteht aus jenen Tupeln, welche die Selektionsbedingung C erfüllen (siehe Beispiel 2.1). σ aď2_b= c R.a R.b 1 a 2 b 3 b = 6 c R.a R.b 1 a 2 b 6 c Beispiel 2.1: Selektion. Die Selektionsbedingung C ist ein bedingter Ausdruck, wie er auch in Programmiersprachen wie Java oder C verwendet wird und der folgenden Struktur entspricht: 1. Es werden die logischen Operatoren ^, _ und verwendet. 2. Die Operanden sind (a) boolsche Konstanten (true oder false) oder (b) Vergleiche von zwei Werten gleichen Typs mit den Operatoren =, ě, ď und. Die Werte stammen von Attributen der Relation oder sind konstante Werte der jeweiligen Domäne. Die Bedingung bezieht sich jeweils auf ein einzelnes Tupel und wird auch für andere Operationen wie den Theta-Join verwendet. Johannes Kessler 7

KAPITEL 2. RELATIONALE ALGEBRA 2.2.2 Projektion Die Projektion ist eine unäre Operation und wird als X = πa loooooomoooooon 1, a 2,..., a n (R) Attribute notiert, wobei a 1 bis a n Attribute der Relation R sind. Im Gegensatz zur Selektion werden bei der Projektion keine Zeilen, sondern bestimmte Spalten in die neue Relation X übernommen. Die Tupel der Ergebnisrelation enthalten nur jene Attribute, die als Argument angegeben wurden (siehe Beispiel Beispiel 2.2). π c,b R.a R.b R.c 1 a 1 2 b 1 3 b 1 R.c R.b = 1 a 1 b Beispiel 2.2: Projektion. 2.2.3 Umbenennung Attribute Um einzelnen Attributen einer Relation einen neuen Namen zuzuweisen, wird die Operation ρ verwendet, die als X = ρ b1 Ða 1,...,b n Ða n (R) notiert wird. R ist hierbei eine Relation, a 1 bis a n ist eine Teilmenge der Attribute aus R und b 1 bis b n sind die neuen Namen in der Ergebnisrelation X. Die Namen der Attribute, die nicht umbenannt werden, übernehmen den Namen aus der Relation R. Die Tupel der Relation R werden ohne Veränderung übernommen, verändert wird nur das Schema (siehe Beispiel 2.3). ρ xðb,yðc R.a R.b R.c 1 a 1 2 b 1 3 b 1 = R.a R.x R.y 1 a 1 2 b 1 3 b 1 Beispiel 2.3: Umbenennung von Attributen einer Relation. Zu beachten ist hierbei, dass die vollqualifizierten Namen der Attribute innerhalb des neuen Schemas der Relation X eindeutig sein müssen. 8 Johannes Kessler

KAPITEL 2. RELATIONALE ALGEBRA Es ist somit möglich, Spalten umzubenennen, wenn diese unterschiedliche Qualifizierer haben, wie in Beispiel 2.4 (a) zu sehen ist. Das Umbenennen ist jedoch nicht möglich, wenn die Attribute durch die Umbenennung nicht mehr eindeutig wären, wie in Beispiel 2.4 (b) zu sehen ist. ρ xða,xðb ρ xða,xðb R.a S.b 1 a 2 b R.a R.b 1 a 2 b = R.x S.x 1 a 2 b = Attribute nicht mehr eindeutig (a) (b) Beispiel 2.4: Umbenennung von Attributen mit gleichem und unterschiedlichem Qualifizierer innerhalb des Schemas. Relationen Der Qualifizierer von vollqualifizierten Attributnamen wird mit X = ρ Y (R) verändert. Dabei ist Y der neue Qualifizierer aller Attribute einer Relation R (siehe Beispiel 2.6). Um die Umbenennung durchführen zu können, müssen die unqualifizierten Namen des neuen Schemas eindeutig sein. Die Umbenennung einer Relation mit dem Schema [R.a, S.a], die aus einem Join der Relationen R und S entstehen kann, ist daher erst möglich wenn einer der Spalten ein neuer Name zugewiesen wird, wie in Beispiel 2.5 illustriert wird. ρ Y ρ xðr.a R.a S.a R.x 1 a = ρ Y 2 b S.a 1 a 2 b = Y.x Y.a 1 a 2 b Beispiel 2.5: Umbenennung von Relationen bei gleichnamigen Spalten. Johannes Kessler 9

KAPITEL 2. RELATIONALE ALGEBRA ρ NEW R.a R.b R.c 1 a 1 2 b 1 3 b 1 = NEW.a NEW.b NEW.c 1 a 1 2 b 1 3 b 1 Beispiel 2.6: Umbenennung von Relationen. ρ Y R.a R.b 1 3 Y.a=R.a R.a 2 4 Y.a Y.b R.a R.b 1 3 1 3 2 4 2 4 R.b 1 3 2 4 = Beispiel 2.7: Join von Relationen mit gleichnamigen Spalten. Durch die Umbenennung kann sichergestellt werden, dass Attribute zweier Relationen, die den selben vollqualifizierten Namen haben, eindeutig angesprochen werden können. Siehe dazu Beispiel 2.7. 2.2.4 Vereinigung Die Vereinigung (union) ist eine Mengenoperation und wird als X = R Y S notiert. Das Ergebnis ist eine neue Relation X mit allen Tupeln aus den Relationen R und S. Die Schemata der Relationen müssen dazu union-kompatibel zueinander sein (siehe Abschnitt 2.1.1). Das Schema wird wie in SQL von der (linken) Relation R übernommen, die Namen der Spalten von R und S müssen dabei nicht übereinstimmen. Wie in Beispiel 2.8 zu sehen ist, werden Duplikate (im Beispiel Zeile [1, b]) dabei nicht mehrfach übernommen. R.a R.b 1 a 2 b Y 3 b S.d S.e 1 b 3 b = R.a R.b 1 a 2 b 3 b 1 b Beispiel 2.8: Vereinigung. 10 Johannes Kessler

KAPITEL 2. RELATIONALE ALGEBRA 2.2.5 Schnittmenge Die Schnittmenge (intersection) wird als X = R X S notiert, wobei R und S Relationen mit union-kompatiblen Schemata sind (siehe Abschnitt 2.1.1). Die Ergebnisrelation X beinhaltet alle Tupel, die sowohl in R als auch in S enthalten sind. Das Schema wird wie bei der Vereinigung von der linken Relation (R) übernommen. R.a R.b 1 a S.d S.e 2 b X 1 b = 3 b 3 b R.a R.b 3 b Beispiel 2.9: Schnittmenge. 2.2.6 Differenz Für die Differenz gelten die selben Voraussetzungen und Regeln, wie für die Schnittmenge und die Vereinigung. Die Differenz wird als oder X = R S X = R z S notiert. Es werden all jene Tupel aus R in die Ergebnisrelation X übernommen, die nicht in S vorkommen. Siehe dazu Beispiel 2.10. R.a R.b 1 a S.d S.e 2 b 1 a = 2 b 3 b R.a R.b 3 b Beispiel 2.10: Differenz. Johannes Kessler 11

KAPITEL 2. RELATIONALE ALGEBRA 2.2.7 Kreuzprodukt Beim Kreuzprodukt (cross join) X = R S werden alle möglichen Kombinationen der Tupel aus R und S gebildet, die der Form (r, s) r P R und s P S entsprechen. Siehe dazu Beispiel 2.11. Das Schema ergibt sich aus der Konkatenation der Schemata von R und S. Das Kreuzprodukt mit einer Relation ohne Tupel ergibt eine leere Relation. R.a R.b 1 a 2 b 3 b S.d S.e 1 a 2 b = R.a R.b S.d S.e 1 a 1 a 1 a 2 b 2 b 1 a 2 b 2 b 3 b 1 a 3 b 2 b Beispiel 2.11: Kreuzprodukt. 2.2.8 Theta-Join Der Theta-Join X = R Θ S ist ein Kreuzprodukt mit einer zusätzlichen Joinbedingung. Von allen Tupeln des Kreuzprodukts werden nur jene übernommen, die die Bedingung Θ erfüllen. Siehe dazu Beispiel 2.12. R.a R.b 1 a 2 b R.aěS.a 3 b S.a S.b 1 a 2 b = R.a R.b S.a S.b 1 a 1 a 2 b 1 a 2 b 2 b 3 b 1 a 3 b 2 b Beispiel 2.12: Theta-Join. Jeder Theta-Join kann auch durch Kreuzprodukt und Selektion dargestellt werden: R Θ S = σ Θ (R S) 12 Johannes Kessler

KAPITEL 2. RELATIONALE ALGEBRA Siehe dazu Beispiel 2.13. R = R.a 1 2 S = S.a S.b 1 a 1 b 42 c X = R R.a=S.a S = σ R.a=S.a (R S) R.a S.a S.b 1 1 a 1 1 b = σ R.a=S.a 1 42 c = 2 1 a 2 1 b 2 42 c R.a S.a S.b 1 1 a 1 1 b Beispiel 2.13: Theta-Join als Kreuzprodukt und Selektion. 2.2.9 Equi-Join Der Equi-Join entspricht einem Theta-Join, wobei die Joinbedingung Θ auf einfache Vergleiche der Form a = b beschränkt ist. Diese Unterscheidung ist wichtig, da es für diese Untergruppe schnellere Join- Algorithmen wie z.b. den Hashjoin gibt 1. R.a R.b S.d S.e 1 a 2 b 1 x R.a R.b S.d S.e a=c 2 y = 1 a 1 x 2 b 2 y 3 b 4 z Beispiel 2.14: Equi-Join. 1 http://en.wikipedia.org/w/index.php?title=hash_join&oldid=591594122, zuletzt besucht am 29.04.2014 Johannes Kessler 13

KAPITEL 2. RELATIONALE ALGEBRA 2.2.10 Natural-Join Der Natural-Join X = (R) (S) besteht aus den folgenden zwei Schritten: 1. Einem Equi-Join mit allen Paaren von Spalten aus R und S, die denselben Namen haben und 2. einer Projektion, bei der alle Spalten mit gleichem Namen ausgeblendet werden. Die Gleichheit der Namen bezieht sich hierbei auf den unqualifizierten Attributnamen. Da diese zwei Schritte nicht sequenziell ausgeführt werden müssen, sondern eine neue atomare Operation bilden, kann das Schema der Ergebnisrelation X in einem Schritt erzeugt werden. Dies ermöglicht auch Relationen zu joinen, deren vollqualifizierte Attributnamen nicht disjunkt sind, da nur einer davon in das Schema der neuen Relation X übernommen wird. Dadurch ist der Natural-Join idempotent: R R = R R.a R.b 1 a S.a S.c 2 b 1 a = 2 b 3 b R.a R.b S.c 1 a a 2 b b Beispiel 2.15: Natural-Join. Im Beispiel 2.15 kommt der Spaltenname a sowohl in R als auch in S vor. Laut Definition [KE11, Seite 91] wird bei der impliziten Projektion nur eine der Spalten übernommen. Die Frage, welche der beiden Spalten übernommen wird, ist erst bei Betrachtung des vollqualifizierten Namens von Bedeutung, da die Spalte später entweder als R.a oder S.a ansprechbar ist. In dieser Arbeit wurde daher definiert, dass immer die Spalte der linken Relation (im Beispiel R.a) übernommen wird. Wenn keine gemeinsamen Attribute existieren, gibt es zwei verschiedene Möglichkeiten 2 : 1. Es wird verlangt, dass zumindest ein gemeinsames Attribut vorhanden ist. Der Natural-Join kann somit nicht auf zwei Relationen mit disjunkten Attributen angewendet werden. 2 https://en.wikipedia.org/w/index.php?title=relational_algebra&oldid= 603628483, zuletzt besucht am 29.04.2014 14 Johannes Kessler

KAPITEL 2. RELATIONALE ALGEBRA 2. Ohne gemeinsame Attribute verhält sich der Natural-Join genau wie ein Kreuzprodukt. In dieser Arbeit wurde die zweite Interpretation gewählt, da dies dem Verhalten in modernen Datenbanksystemen wie z.b. PostgreSQL entspricht (siehe [Pos, Kapitel 7.2.1.1]). 2.2.11 Outer Joins Bei Outer Joins können ein oder mehrere Werte eines Tupels fehlen. Dieser Zustand wird durch null ausgedrückt. Man spricht hierbei auch von einem null-wert, wobei null kein Wert einer bestimmten Domäne ist, sondern eine explizite Darstellung, dass das Tupel an dieser Position keinen Wert enthält und ist damit mit der leeren Menge vergleichbar. Left Outer Theta-Join Der Left Outer Join X = (R) Θ (S) ist einem Theta-Join sehr ähnlich. Die Werte eines Tupels der linken Relation R bleiben jedoch auf jeden Fall erhalten, auch wenn kein entsprechender Joinpartner in der Relation S gefunden wird, die Joinbedingung Θ also für r in Kombination mit allen Tupeln aus S false ergibt. Für jedes Tupel der Relation R wird mit allen Tupeln aus S ein Join-Paar gebildet, wenn die Joinbedingung Θ erfüllt ist. Wenn kein Joinpartner in S gefunden wurde, wird das Tupel der neuen Relation auf der rechten Seite mit null-werten aufgefüllt (siehe Beispiel 2.16). R.a R.b 1 a S.a S.b 2 b R.a=S.a 1 a = 2 b 3 b R.a R.b S.a S.b 1 a 1 a 2 b 2 b 3 b null null Beispiel 2.16: Left Outer Theta-Join. Um Bedingungen für Relationen zu formulieren, bei denen null-werte vorkommen können, muss eine dreiwertige Logik, analog zu SQL, verwendet werden. Dabei werden die logischen Zustände true und false um einen dritten Zustand unknown erweitert. Ein Vergleich von null mit einem nicht null-wert ergibt immer unknown. Bei zwei null-werten ergeben =, ě und ď true, ą, ă und false. Auch die Operatoren ^, _ und müssen, wie in Tabelle 2.1 gezeigt, erweitert werden, wobei die Präzedenz erhalten bleibt. Johannes Kessler 15

KAPITEL 2. RELATIONALE ALGEBRA ^ true false unknown true true false unknown false false false unknown unknown unknown false unknown _ true false unknown true true true true false true false unknown unknown true unknown unknown true false unknown false true unknown Tabelle 2.1: Wahrheitstabellen der Operatoren der dreiwertigen Logik. Quelle: [GMUW09, Seite 254]. Left Outer Natural-Join Der Left Outer Natural-Join vereint analog zum Natural-Join X = (R) (S) eine Projektion, bei der alle Spalten gleichen Namens ausgeblendet werden und einen Left Outer Theta-Join, bei dem die Joinbedingung Θ durch die Paare von Spalten mit gleichem Namen definiert ist. Bei der Projektion geht jeweils die Spalte gleichen Namens aus der rechten Relation S verloren. Siehe dazu Beispiel 2.17. R.a R.b 1 a S.b S.c 2 a a 5 = b 6 3 d R.a R.b S.c 1 a 5 2 a 5 3 d null Beispiel 2.17: Left Outer Natural-Join. Right Outer Joins Der Right Outer Natural-Join X = (R) (S) 16 Johannes Kessler

KAPITEL 2. RELATIONALE ALGEBRA und der Right Outer Theta-Join X = (R) Θ (S) verhalten sich analog zum jeweiligen Left Outer Join, nur dass hierbei die Werte der rechten Relation S bestehen bleiben und links mit null- Werten aufgefüllt wird, wenn kein Joinpartner in der linken Relation R vorhanden ist. Beim Right Outer Natural-Join geht jeweils die Spalte gleichen Namens aus der linken Relation R verloren. Siehe dazu Beispiel 2.18 und Beispiel 2.19. S.a S.c R.b R.a a 1 R.a=S.a 1 a 2 b = b 2 3 b R.b R.a S.a S.c a 1 1 a b 2 2 b null null 3 b Beispiel 2.18: Right Outer Theta-Join. R.b R.a a 1 b 2 S.a S.c 1 a 2 b 3 b = R.b S.a S.c a 1 a b 2 b null 3 b Beispiel 2.19: Right Outer Natural-Join. Full Outer Joins Der Full Outer Join und der Full Outer Theta-Join X = (R) (S) X = (R) Θ (S) vereinen die Eigenschaften des Left- und Right Outer Joins. Wenn kein Joinpartner für ein Tupel der linken Relation R gefunden wird, wird rechts mit null-werten aufgefüllt, und wenn keiner für ein Tupel der rechten Relation S gefunden wird, wird links aufgefüllt. Das Schema wird jeweils durch die Konkatenation der Schemata von R und S gebildet. Siehe dazu Beispiel 2.20. Der Full Outer Theta-Join kann auch durch eine Vereinigung von Leftund Right Outer Theta-Join dargestellt werden: R Θ S = (R Θ S) Y (R Θ S) Johannes Kessler 17

KAPITEL 2. RELATIONALE ALGEBRA R.a R.b 1 a 2 b S.b S.c b 42 d 42 = R.a R.b S.b S.c 1 a null null 2 b b 42 null null d 42 Beispiel 2.20: Full Outer Natural-Join. 2.2.12 Semi-Joins Der Left Semi-Join X = (R) (S) eliminiert alle Tupel der Relation R, für die kein Joinpartner in S gefunden wird. Beim Right Semi-Join X = (R) (S) werden alle Tupel aus S nicht übernommen, die in R keine Joinpartner haben. Joinbedingung ist analog zum Natural-Join, dass Spalten der Relationen R und S, die den gleichen Namen haben, idente Werte aufweisen müssen (siehe Abschnitt 2.2.10). Das Schema entspricht nach der Ausführung des Left Semi-Joins dem der linken Relation R, nach der Ausführung des Right Semi-Joins dem der rechten Relation S. sch(r S) = sch(r) sch(r S) = sch(s) Der Semi-Join kann daher auch als Theta-Join (R Θ S) mit nachfolgender Projektion auf die Attribute einer der Relationen angesehen werden, wobei die Joinbedingung Θ analog zum Natural-Join gebildet wird. Hierbei ist jedoch zu beachten, dass beim Theta-Join temporär eine neue Relation entsteht, deren Schema aus der Konkatenation der Schemata von R und S gebildet wird. Beim Semi-Join werden jedoch nur von einer der Relationen Zeilen entfernt bzw. nicht in die neue Relation X übernommen. Da innerhalb eines Schemas die voll qualifizierten Namen eindeutig sein müssen, kann ein Theta-Join nicht ausgeführt werden, wenn dieselben voll qualifizierten Namen in beiden Relationen vorkommen. Beim Semi- Join besteht diese Einschränkung nicht. Dies kann anhand eines Self-Joins (Join einer Relation mit sich selbst) veranschaulicht werden: 18 Johannes Kessler

KAPITEL 2. RELATIONALE ALGEBRA Der Self-Join mithilfe eines Semi-Joins R = R R = R R ist problemlos möglich, da die Schemata nicht konkateniert werden müssen. Der Self-Join mit einem Theta-Join R true R ist jedoch nicht möglich, da das neue Schema nicht gebildet werden kann. 2.2.13 Anti-Join Der Anti-Join oder Anti Semi-Join X = (R) (S) selektiert das Komplement des (Left) Semi-Joins. In der Relation X sind damit all jene Tupel aus R enthalten, die keinen Joinpartner in S haben. Der Anti-Join kann auch durch ausgedrückt werden. 2.2.14 Division Die relationale Division R S = R (R S) X = R S ist eine binäre Operation und kann folgendermaßen durch andere Operatoren ausgedrückt werden [KE11, Seite 97]: R = sch(r) S = sch(s) R 1 = R S R S = π R 1(R) π R 1((π R 1(R) S) R) S muss hierbei eine echte Teilmenge von R sein. Das Schema R 1 besteht aus jenen Attributen der Relation R, die nicht Attribut der Relation S sind. R 1 ist somit die Differenz der Schemata: R 1 = sch(x) = sch(r) sch(s) Die Tupel der Ergebnisrelation X bestehen aus einem Subset der Tupel aus R (definiert durch (R 1 )), bei denen alle Kombinationen mit allen Tupeln aus S in R enthalten sind. Die Kombinationen entsprechen hierbei der Form [t r, t s ], wobei t r ein Tupel der Relation R und t s ein Tupel der Relation S ist. Johannes Kessler 19

KAPITEL 2. RELATIONALE ALGEBRA R.a R.b R.c 1 a b 1 c d 1 e f 2 a b 2 c d 3 a b 4 c d 5 e f S.b a c S.c b d = R.a 1 2 Beispiel 2.21: relationale Division. 2.2.15 Sortieren Sortieren von Tupeln innerhalb einer Relation ist in der klassischen relationalen Algebra nicht möglich, da Relationen Mengen von Tupeln sind und die Tupel darin - per Definition - keine Ordnung haben. Der hier vorgestellte Sortieroperator [GMUW09, Seite 219] kann daher nur angewendet werden, wenn diese Einschränkung aufgehoben wird, wie in [GMUW09, Kapitel 5.1] erläutert wird. In dieser Arbeit wird ein zusätzlicher Sortieroperator vorgestellt, da dieser mehrere Vorteile bietet: 1. Durch eine sortierte Ausgabe können Ergebnisse verschiedener Abfragen einfacher verglichen werden, 2. er ermöglicht die Darstellung der SQL-order by-operation als eigene RA-Operation und 3. er ermöglicht die Ausgabe des Programms mit Beispielen aus Vorlesungsunterlagen oder Büchern einfacher zu vergleichen. Der Sortieroperator X = τ a1 asc,a 2 desc,...,a n (R) sortiert die Tupel der Relation R nach den übergebenen Attributen (a 1 bis a n ). Nach jedem Attribut kann zusätzlich eine optionale Sortierrichtung angegeben werden: asc für aufsteigend und desc für absteigend. Ohne explizite Angabe der Reihenfolge wird asc angenommen (siehe Spalte b in Beispiel 2.22). Das Schema wird dabei nicht verändert. sch(τ a1,...,a n (R)) = sch(r) 20 Johannes Kessler

KAPITEL 2. RELATIONALE ALGEBRA τ a desc,b R.a R.b R.c 1 a 42 1 c 0 2 b 128 2 d 4 = R.a R.b R.c 2 b 128 2 d 4 1 a 42 1 c 0 Beispiel 2.22: Sortieren einer Relation. 2.2.16 Erweiterung der Projektion Durch Einführung einer Ordnung der Tupel durch Lockerung des strikten Mengenbegriffs (wie in Abschnitt 2.2.15 beschieben wurde), liegt die Idee nahe, diese Ordnung für Abfragen nutzbar zu machen. In SQL besteht diese Möglichkeit je nach Datenbanksystem durch die Limit und Offset Klausel oder durch eine virtuelle Spalte rownum, welche den Zeilenindex jeder Zeile der Tabelle enthält. Damit sind Abfragen wie Top 10 Kunden mit den meisten Bestellungen möglich die auf einer horizontalen Partitionierung unter Ausnutzung der Ordnung beruhen. In dieser Arbeit wurde die Projektion dafür um einen virtuelle Spalte namens ROWNUM erweitert. Solange kein Attribut mit dem Namen ROWNUM im Schema enthalten ist, kann damit der Tupelindex (1-basiert) der Argumentrelation ausgegeben werden. Die dadurch entstehende neue Spalte mit Integerwerten kann in allen folgenden Operationen wie jede andere Spalte behandelt werden. In Beispiel 2.23 werden die besten drei Studenten einer Prüfung gesucht. Dazu wird die Relation zuerst nach den Noten sortiert um im nächsten Schritt den Tupelindex ROWNUM hinzuzufügen. Über diese neue Spalte werden bei der Selektion die fünf ersten Einträge ausgewählt. Für die Ausgabe könnte die Spalte ROWNUM über eine weitere Projektion ausgeblendet werden. Johannes Kessler 21

KAPITEL 2. RELATIONALE ALGEBRA MatrNr Note 42 1 43 3 σ ROW NUMă=3 (π ROW NUM,[1],[2] (τ Note asc 45 2 46 4 48 5 59 1 ROWNUM R.MatrNr R.Note 1 42 1 2 59 1 3 45 2 )) = Beispiel 2.23: Verwendung des Tupelindex innerhalb einer RA-Abfrage. 2.2.17 Gruppierung und Aggregation Bei der Gruppierung werden die Tupel einer Relation zu Gruppen zusammengefasst. Dabei sind all jene Tupel in einer gemeinsamen Gruppe die bei allen Gruppierungsattributen die selben Werte aufweisen. Auf alle Tupel einer Gruppe können Aggregationsfunktionen wie das Aufsummieren aller Werte angewandt werden. Die hier vorgestellte Aggregation entspricht einer Mischung aus den Definitionen in [KE11, Seite 97] und [GMUW09, Seite 214]. Durch die strikte Trennung von Gruppierung und Aggregation in der Syntax von [KE11] ist klarer ersichtlich, dass es sich dabei um zwei separate Schritte handelt. Die direkte Benennung der durch die Aggregation entstehenden Spalten in [GMUW09] ermöglicht eine einfache Weiterverwendung der Attribute über den zugewiesenen Namen. Die Attribute nach denen gruppiert wird, sind wie in [GMUW09] optional. Die Aggregation wird mit X = γ a1 loooomoooon,..., a n ;AGG looooooooooooooooooomooooooooooooooooooon 1 Ñ x 1,..., AGG n Ñ x n (R) Gruppierung Aggregation notiert. Wobei a 1 bis a n die Attribute sind nach denen gruppiert wird, AGG 1 bis AGG n sind die Aggregationsfunktionen die auf alle Tupel der Gruppen angewandt werden und x 1 bis x n sind die Namen der Aggregationsspalten in der Ergebnisrelation X. Die Angabe der Gruppierungsattribute ist optional. Wenn keine Gruppierung angegeben ist, gibt es eine einzelnen Gruppe welche alle Tupel der Relation R enthält (siehe Beispiel 2.24). Der Strichpunkt kann dabei entfallen. 22 Johannes Kessler

KAPITEL 2. RELATIONALE ALGEBRA γ SUM(b)Ñz,AV G(b)Ñy,MIN(a)Ñz R.a R.b 1 a 1 c 2 b 2 d = x y z 6 2 a Beispiel 2.24: Aggregation ohne explizite Angabe einer Gruppierung. Für die Aggregation stehen die in Tabelle 2.2 aufgelisteten Aggregationsfunktionen zur Verfügung. Die Beschreibung bezieht sich dabei immer auf die Werte einer Gruppe. Die Rückgabewerte der Funktionen COUNT ( ) und COUNT (Attribut) sind Integer. Die Funktion AV G(x) gibt einen Float-Wert zurück. Bei allen anderen entspricht der Typ der Rückgabe dem Typ des übergebenen Attributs. Funktion COUNT ( ) COUNT (x) MIN(x) M AX(x) SU M(x) AV G(x) Beschreibung Anzahl der Tupel der Gruppe Anzahl der nicht null-werte der Spalte x minimaler Wert der Spalte x maximaler Wert der Spalte x Summe aller nicht null-werte der Spalte x Durchschnitt aller nicht null-werte der Spalte x Tabelle 2.2: Aggregationsfunktionen in der relationalen Algebra. Johannes Kessler 23

KAPITEL 2. RELATIONALE ALGEBRA R = VorlNr MatrNr Note 1 42 1 1 43 2 1 45 4 2 42 3 2 43 2 2 46 5 3 42 2 3 43 1 γ V orlnr;count ( )Ñteilnehmer,AV G(Note)Ñdurchschnitt (R) = = R.VorlNr teilnehmer durchschnitt 1 3 2.33 2 3 3.33 3 2 1.5 Beispiel 2.25: Aggregation ohne explizite Angabe einer Gruppierung. Wie in Beispiel 2.25 zu sehen ist können durch Verwendung der Gruppierung und Aggregation somit Abfragen wie die durchschnittliche Note pro Fach sehr einfach formuliert werden. 2.3 Sichtbarkeit Unter dem Sichtbarkeitsbereich (scope) versteht man einen bestimmten Bereich, in dem ein Bezeichner sichtbar und ansprechbar ist. Eine benannte Relation ist global gültig. Ihr Name kann damit in der gesamten Abfrage verwendet werden und muss auch global eindeutig sein. Die Attribute einer Relation sind lokal gültig und müssen innerhalb des Schemas eindeutig sein. Es kann jedoch nötig sein, Attributnamen oder den qualifizierenden Relationsnamen zu ändern, um die Attribute bei binären Operationen eindeutig ansprechen zu können oder die Konkatenation von zwei Schemata zu ermöglichen, die sich Attributnamen teilen (siehe Abschnitt 2.2.3). 2.4 Operatorbaumdarstellung Beim Lesen komplexer Ausdrücke ist oft eine Darstellung der Formel als Operatorbaum hilfreich. Hierbei bilden die einzelnen Operatoren die Knoten eines Baumes, wobei die Argumentrelationen der Operatoren 24 Johannes Kessler

KAPITEL 2. RELATIONALE ALGEBRA jeweils als Kindelemente im Baum dargestellt werden. Die Auswertung des Ausdrucks erfolgt bottom-up. Die Abfrage ( ( π R.a,R.b,S.d π a,b σaąb_a=1 (R ρ S X) ) ( R.a=S.c σcą10 (S) )) kann somit als Operatorbaum dargestellt werden, wie in Abbildung 2.2 veranschaulicht ist.. π R.a,R.b,S.d R.a=S.c π a,b σ cą10 σ aąb_a=1 S R ρ S Abbildung 2.2: Operatorbaumdarstellung einer RA-Formel. X 2.5 Präzedenz Die Operatorpräzedenz legt die Ordnung fest, nach der die Operatoren ausgewertet werden, wenn diese nicht explizit geklammert sind. Ohne Präzedenz ist das Statement σ aą0 R S nicht eindeutig definiert, da es zwei mögliche Auswertungsreihenfolgen gibt (hier explizit geklammert): 1. σ aą0 (R S), wobei hier zuerst der Join ausgewertet wird oder 2. (σ aą0 (R)) S, bei der R zuerst selektiert wird. Johannes Kessler 25

KAPITEL 2. RELATIONALE ALGEBRA In der Literatur gibt es keine eindeutige Übereinkunft über die Wertigkeit der Operatoren [Mol09, Seite 24-25], [Ull04, slides5 Seite 21]. Gemeinsam ist den meisten Definitionen, dass die unären Operatoren die höchste Wertigkeit haben, gefolgt von den Joins und den Mengenoperatoren (X vor Y). Im Zweifel sollte daher immer explizit geklammert werden. Für diese Arbeit wurde die Operatorpräzedenz wie in Tabelle 2.3 ersichtlich definiert. Die Operatoren werden der Tabelle folgend, von oben nach unten und in jeder Zeile von links nach rechts ausgewertet. Die höchste Bindung hat die benannte Relation. Ein Relationsname gehört daher immer zur Operation. Bei den logischen Operatoren hat ^ (AND) die höchste Präzedenz, gefolgt von (XOR) und _ (OR). Präzedenz Operator Projektion, Selektion, 4 Umbenennung (Attribute), Umbenennung (Relationen), Gruppieren, Sortieren Kreuzprodukt, Theta-Join, Natural-Join, Left Outer Join, Right Outer Join, Full Outer Join, 3 Left Semi-Join, Right Semi-Join, Anti Semi-Join, Division 2 Schnitt 1 Vereinigung, Differenz Tabelle 2.3: Operatorpräzedenz. Durch die Definition der Präzedenz ist das Statement σ aą0 R S eindeutig bestimmt, da die unäre Operation σ eine höhere Präzedenz als der Join hat und daher zuerst ausgeführt wird. 26 Johannes Kessler

Kapitel 3 Übungstool Im Gegensatz zu SQL kann beim Erlernen der relationalen Algebra und der Kalküle nicht auf eine umfangreiche Unterstützung in modernen Datenbanksystemen zurückgegriffen werden. In der Literatur [GMUW09, KE11, AHV95, AHV95] und in vielen Vorlesungen an Universitäten wird für die RA eine Notation verwendet, welche der in Kapitel 2 vorgestellten sehr ähnlich ist. In den der Datenbankvorlesung zugehörigen Übungen werden die Aufgaben daher von Studenten handschriftlich verfasst oder müssen aufwändig als Formel gesetzt werden. Mangels Toolunterstützung werden die Berechnungen oft händisch ausgeführt. Für Übungsaufgaben in SQL können die nötigen Tabellen auf einer Datenbank zur Verfügung gestellt werden. Die Studenten können über eine webbasierte Abfrageoberfläche wie phpmyadmin 1 darauf zugreifen und ihre formulierten Abfragen direkt testen. Die Grundidee des Übungstools für relationale Algebra ist es, ein vergleichbares Angebot für RA zu schaffen, das die Möglichkeit bietet, Abfragen in der erlernten Notation zu verfassen und auf vorgegebenen Datensätzen auszuführen. Dies ermöglicht den Benutzern, Beispiele in der Literatur einfach nachzurechnen und zu erweitern. Die flexible Eingabe als Klartext-Statement (siehe Abschnitt 3.1.6 auf Seite 39) ermöglicht eine iterative Erarbeitung von Statements. Weiters soll den Benutzern eine experimentierfreundliche Umgebung geboten werden, die es ermöglicht, alternative Lösungswege zu erarbeiten. Das webbasierte Programm sollte daher mindestens folgende Anforderungen erfüllen: einfache Bedienung für die Benutzer ohne Installation zusätzlicher Software lauffähig 1 http://phpmyadmin.net/, zuletzt besucht am 29.04.2014 27

KAPITEL 3. ÜBUNGSTOOL die verwendete Syntax soll möglichst nahe an der klassischen Notation sein Visualisierung der Abfrage als Operatorbaum Anzeige von Zwischenergebnissen Die Anwendung besteht aus den folgenden Komponenten: Eine Grammatik für die relationale Algebra und SQL, aus diesen jeweils ein Parser generiert wird. Diese Parser erzeugen den Syntaxbaum eines eingegebenen Statements (siehe Abschnitt 3.1). Die Business-Logik ist eine Implementierung der relationalen Algebra und umfasst über 2000 Zeilen JavaScript Code (siehe Abschnitt 3.2). Eine Übersetzungsschicht übersetzt die Syntaxbäume in die relationale Algebra. Das Übungstool ist auf aktuellen Browsern lauffähig und wurde in den in Tabelle 3.1 aufgelisteten Versionen getestet. Microsofts Internet Explorer wird ab Version 10 unterstützt. Für alle älteren Versionen wird eine entsprechende Meldung eingeblendet. Browser Plattform lauffähig Google Chrome 35 (beta) Ubuntu 14.04 ja Mozilla Firefox 29 Ubuntu 14.04 ja Opera 12 Ubuntu 14.04 ja rekonq 2.4.2 Ubuntu 14.04 ja Google Chrome 34 OS X ja Mozilla Firefox 29 OS X ja Apple Safari 7 OS X ja Opera 20 OS X ja Google Chrome 34 Windows 8.1 ja Mozilla Firefox 29 Windows 8.1 ja Opera 20 Windows 8.1 ja Microsoft Internet Explorer 11 Windows 8.1 ja Microsoft Internet Explorer 10 Windows 8 ja Microsoft Internet Explorer 11 Windows 7 ja Microsoft Internet Explorer 10 Windows 7 ja Microsoft Internet Explorer 9 Windows 7 eingeschränkt 2 Tabelle 3.1: Liste der Browser, auf denen das Übungstool getestet wurde. 2 Das Laden von Tabellen von Github Gists (Seite 52) funktioniert nicht. 28 Johannes Kessler

KAPITEL 3. ÜBUNGSTOOL 3.1 Relationale Algebra Die relationale Algebra (RA) wird klassischerweise als Formel dargestellt (siehe Kapitel 2). In dieser Arbeit wird RA jedoch als Quelltext, vergleichbar mit SQL, aufgefasst. Dies ermöglicht Features wie das einfache Bearbeiten in einem Editor, Syntax-Highlighting und Autovervollständung, die in vielen SQL-Editoren (z.b. MySQL Workbench 3, pgadmin 4 ) enthalten sind, in einem RA-Übungstool anzuwenden. Für diesen Zweck wurde eine Grammatik definiert, die es ermöglicht, RA-Statements in der klassischen Notation fast unverändert zu verarbeiten. Weiters wurden mehrere Erweiterungen wie Kommentare oder Einführung einer alternativen Notation vorgenommen, die in diesem Kapitel vorgestellt werden. 3.1.1 Syntax Die Syntax für RA Statements folgt der in Kapitel 2 vorgestellten klassischen Notation. Die einzige Änderung besteht darin, dass die in Subscript notierten Argumente nicht tiefergestellt werden. Die Syntax ist nicht zeilenorientiert und die einzelnen Tokens können durch beliebigen Whitespace getrennt werden. Die Operatoren können durch das entsprechende Sonderzeichen oder durch eine Plaintext-Schreibweise notiert werden, die in Abschnitt 3.1.6 vorgestellt wird. Für die Operatoren werden die in Tabelle 4.1 dargestellten Unicode Symbole verwendet. Die RA-Formel π S.Name,S.Semester,P.Name ( (V orlesungen (ρ S Studenten ρ H hoeren)) gelesenv on=p ersnr (ρ P P rofessoren)) kann durch die neue Grammatik wie folgt eingegeben werden: 3 http://www.mysql.de/products/workbench/, zuletzt besucht am 29.04.2014 4 http://www.pgadmin.org/, zuletzt besucht am 29.04.2014 Johannes Kessler 29

KAPITEL 3. ÜBUNGSTOOL 1 π S.Name, S. Semester, P. Name ( 2 ( 3 Vorlesungen 4 ( 5 ρ S Studenten 6 7 ρ H hoeren 8 ) 9 ) 10 gelesenvon=persnr 11 ρ P Professoren 12 ) Mit der in Abschnitt 3.1.6 vorgestellten alternativen Operatorschreibweise kann auf die Verwendung von Sonderzeichen verzichtet werden: 1 pi S.Name, S. Semester, P. Name ( 2 ( 3 Vorlesungen 4 natural join ( 5 rho S Studenten 6 natural join 7 rho H hoeren 8 ) 9 ) 10 join gelesenvon=persnr 11 rho P Professoren 12 ) PEG.js PEG.js 5 ist ein von David Majda entwickelter freier Parsergenerator für JavaScript. Er kann direkt im Browser, über eine JavaScript API oder über die Kommandozeile verwendet werden und steht als node.js-modul 6 zur Verfügung. PEG.js verwendet eine sogenannte parsing expression grammar (PEG) [For04], die syntaktisch einer kontextfreien Grammatik (CFG) sehr ähnlich ist. Der Unterschied ist, dass bei PEGs die Produktionen geordnet sind und streng nach der Reihe angewandt werden. Sobald eine Regel anwendbar ist, wird diese verwendet. Der Syntaxbaum ist dadurch immer eindeutig, da Mehrdeutigkeiten in CFGs durch mehrere passende Produktionen entstehen. 1 rule1 2 = 'first parsing expression' 3 / 'second' 'parsing'? test:' expression' 4 { 5 /* action of the second expression */ 6 return { 5 http://pegjs.majda.cz/, zuletzt besucht am 29.04.2014 6 http://nodejs.org/, zuletzt besucht am 29.04.2014 30 Johannes Kessler

KAPITEL 3. ÜBUNGSTOOL 7 a: 'a value', 8 b: test -- variable from parsing expression 9 }; 10 } 11 12 integer 13 = [0-9]+ Die Grammatik besteht (vereinfacht) aus Regeln (rules), die durch eindeutige Namen identifiziert werden [Maj14]. Jeder Regel folgt eine geordnete Liste von parsing expressions, die auf den Eingabetext matchen. Sie bieten ähnlich zu regulären Ausdrücken die Möglichkeit, Literale, Klassen von Zeichen und Wiederholungen abzubilden. Jeder parsing expression kann eine action folgen, die von geschwungenen Klammern umfasst wird. Die action besteht aus JavaScript Code, der ausgeführt wird, wenn die expression matcht. Die Werte von Teilen der parsing expression, die als Variablen definiert wurden (im Beispiel test), stehen im JavaScript-Code zur Verfügung. Durch die geordneten expressions kann die Regel test2 in der Grammatik Beispiel 3.1 auf die Eingabe 123abc angewandt werden, nicht jedoch test1, da der Ausdruck in Zeile 2 auf den Teilstring 123 matcht. 1 test1 2 = [0-9]+ 3 / [0-9]+ [a-z]+ 4 5 test2 6 = [0-9]+ [a-z]+ 7 / [0-9]+ Beispiel 3.1: PEG.js Grammatik. Grammatik Die Grammatik für die in Abschnitt 3.1.1 eingeführte Syntax wurde mit dem Parsergenerator PEG.js umgesetzt. Die Ausgabe des Parsers ist ein Syntaxbaum, der in einem weiteren Schritt in den ausführbaren Code übersetzt wird. Diese Trennung ermöglicht das separate Testen und Entwickeln des Compilers bzw. der Grammatik und der Ausführungslogik. Weiters können Operationen wie die Ersetzung von Variablen direkt auf dem Syntaxbaum ausgeführt werden (siehe Abschnitt 3.1.3). Die umgesetzte Grammatik soll hier am Beispiel der Selektion und des Theta-Joins vereinfacht dargestellt werden. Die Schlüsselwörter sind jeweils als eigene Regeln ausgeführt, um die alternative Schreibweise zu unterstützen. Johannes Kessler 31

KAPITEL 3. ÜBUNGSTOOL 1 sigma 2 = 'σ' 3 / 'sigma' 4 5 inner 6 = ' ' 7 / ('inner' )? 'join' 1 selection 2 = sigma arg: boolean child: expression_precedence3 3 { 4 return { 5 type: 'selection', 6 arg: arg, 7 child: child, 8 9 codeinfo: getcodeinfo() 10 } 11 } 1 thetajoin 2 = child1: expression_precedence3 inner arg: boolean child2: expression 3 { 4 return { 5 type: 'thetajoin', 6 arg: arg, 7 child: child1, 8 child2: child2, 9 10 codeinfo: getcodeinfo() 11 }; 12 } Die Selektion beginnt mit dem Keyword sigma, das wie in den Zeilen 1 bis 3 ersichtlich ist, die verschiedenen alternativen Schreibweisen abdeckt. Die Regel wurde als beliebiger, aber nicht optionaler Whitespace definiert, expression_precedence3 steht für einen gültigen RA-Ausdruck und ist als die Gruppe aller unären Operatoren definiert. Dadurch wird die Selektion am stärksten an andere unäre Operatoren und an die benannte Relation als Basis gebunden, da diese früher gematcht werden. Die Regel boolean steht für einen beliebigen boolschen Ausdruck. Der Rückgabewert jeder Aktion eines Operators ist ein JavaScript- Objekt, das zumindest die Eigenschaft type besitzt, die zur Identifikation des Typs jedes Knotens im Syntaxbaum dient. Die Eigenschaften child und child2 enthalten die Subbäume der Operanden. Die Selektion als unärer Operator hat daher nur einen Operanden child. Das generische Objekt codeinfo enthält z.b die Position im Statementcode und wird verwendet, um in späteren Schritten Fehlermeldungen mit genauen Positionsangaben versehen zu können und diese im Editor an der richtigen Position anzeigen zu können. 32 Johannes Kessler

KAPITEL 3. ÜBUNGSTOOL Der Theta-Join als Beispiel für einen binären RA-Operator ist analog dazu aufgebaut. Der erste Operand bei binären Operatoren ist jeweils vom Typ der nächst höheren Präzedenzgruppe. Jeder Syntaxbaum einer RA-Abfrage beginnt mit einem Knoten vom Typ root, der alle Zuweisungen und die eigentliche Abfrage enthält. Die Abfrage 1 sigma a>0 R 2 inner join R.b=S.b 3 S ergibt somit den folgenden (vereinfacht dargestellten) Syntaxbaum: 1 { 2 "type": "root", 3 "assignments": [], 4 "child": { 5 "type": "thetajoin", 6 "arg": { 7 "type": "ConditionConst", 8 "value": true, 9 "codeinfo": {"line": 2, "column": 12, 10 "offset": 26, "text": "true"} 11 }, 12 "child": { 13 "type": "selection", 14 "arg": { 15 "type": "ConditionConst", 16 " value": false, 17 "codeinfo": {/*... */} 18 }, 19 "child": { 20 "type": "relation", 21 "name": "R", 22 "codeinfo": {"line": 1,"column": 13, 23 "offset": 12, "text": "R"} 24 }, 25 "codeinfo": {/*... */} 26 }, 27 "child2": { 28 "type": "relation", 29 "name": "S", 30 "codeinfo": {"line": 3, "column": 1, 31 "offset": 31, "text": "S"} 32 }, 33 "codeinfo": {/*... */} 34 }, 35 "codeinfo": {/*... */} 36 } Johannes Kessler 33

KAPITEL 3. ÜBUNGSTOOL 3.1.2 Kommentare Zum einfachen Kommentieren der Abfragen, auch im Hinblick auf die Abgabe der Lösung einer Übung, sind zwei Arten von Kommentaren verfügbar. Analog zu SQL [Pos, Kapitel 4.1.5] können einzeilige Kommentare mit -- eingeleitet werden. 1 π Name, Semester 2 σ semester <= 1 -- nur Erstsemestrige 3 Studenten Mehrzeilige Block-Kommentare werden mit /* und */ umschlossen. 1 π Name/*, Semester */ 2 σ semester <= 1 -- nur Erstsemestrige 3 Studenten Beide Arten von Kommentaren werden als Whitespace behandelt und sind daher gültige Trenner von zwei Tokens. Beim einzeiligen Kommentar muss den zwei Minuszeichen mindestens ein Whitespacezeichen folgen. Dieses beugt einem Problem vor, dass bei einer Einführung von arithmetischen Operationen folgen würde: Der arithmetische Ausdruck a--b wäre nicht gültig, da -- als Kommentar interpretiert würde und nicht als Minusoperator, gefolgt von einem Vorzeichen 7. Dies müsste somit als a-(-1), a - -1 oder a- -1 geschrieben werden. 3.1.3 Zuweisungen Für größere Abfragen in relationaler Algebra ist es nicht unüblich, Teile davon als Variable zu definieren und diese in der eigentlichen Abfrage zu verwenden. Diese Variablen können nach ihrer Definition wie benannte Relationen behandelt werden. Für das Übungstool wurde diese Möglichkeit übernommen. Die Syntax einer solchen Zuweisung ist: VARIABLE = RA_EXPRESSION RA_EXPRESSION ist dabei ein beliebiger Ausdruck in relationaler Algebra, VARIABLE ein freier Bezeichner (siehe Beispiel 3.2). Die Variablennamen teilen sich hierbei denselben globalen Namespace wie die benannten Relationen und müssen in diesem eindeutig sein. Die Zuweisung ist hier ein rechtsassoziativer Operator. Die Reihenfolge der Definitionen spielt keine Rolle. Es können auch Variablen innerhalb der Variablendefinition verwendet werden, solange dadurch keine zyklischen Abhängigkeiten entstehen. 7 https://dev.mysql.com/doc/refman/5.1/de/ansi-diff-comments.html, zuletzt besucht am 29.04.2014 34 Johannes Kessler

KAPITEL 3. ÜBUNGSTOOL 1 K = pi kundennr, vorname, nachname 2 Kunde 3 4 -- neue Bestellugen 5 B1 = sigma datum > 2014-01-01 6 pi kundennr,datum, gesamtpreis 7 Bestellungen 8 9 -- alte Bestellungen 10 B2 = sigma datum < 1970-01-01 11 pi kundennr,datum, gesamtpreis 12 Bestellungen 13 14 K natural join 15 (B1 union B2) Beispiel 3.2: Verwendung von Zuweisungen. Die Variablenersetzung erfolgt im Syntaxbaum. Für jede Zuweisung generiert der Parser einen eigenen Unterbaum, der die definierte Abfrage enthält. Im nächsten Schritt werden alle Positionen in den Bäumen der Zuweisungen gesucht, an denen diese Bezeichner verwendet werden. Mithilfe dieser Positionen wird mittels Tiefensuche sichergestellt, dass keine zyklischen Zuweisungen vorhanden sind, da ansonsten die Ersetzung nicht terminieren würde. Jede Verwendung einer Variable wird im letzten Schritt mit deren Definition ersetzt und die Ersetzung für die spätere Visualisierung im Operatorbaum (Abschnitt 4.2) in den Metadaten des Knotens gespeichert. Im Operatorbaum werden die einzelnen Teilbäume ausgezeichnet, die von einer bestimmten Zuweisung stammen. Verschiedene Variablen werden dabei zur besseren Übersicht farblich markiert, wie in Abbildung 3.1 ersichtlich ist. Johannes Kessler 35

KAPITEL 3. ÜBUNGSTOOL 1 S = sigma Semester > 8 Studenten 2 3 Prof = sigma Rang >'C3' Professoren 4 5 T = 6 hoeren 7 natural join Vorlesungen 8 join gelesenvon=persnr Prof 9 10 pi MatrNr ( 11 S natural join T 12 ) Abbildung 3.1: Beispiel Abfrage in RA mit Zuweisungen und der Visualisierung im Operatorbaum des Programms. 3.1.4 Inline-Relationen Für einzelne Abfragen kann es hilfreich sein, neben den vorgegebenen Relationen eigene definieren zu können, die innerhalb eines Statements gültig sind. PostgreSQL bietet dafür z.b. die VALUES-Notation (siehe [Pos, Kapitel 7.7]), mit der konstante Tabellen definiert werden können. Mit dieser Notation kann sehr kompakt eine neue lokale Tabelle in der Abfrage definiert werden, wie am folgenden Beispiel ersichtlich ist: 1 select * 2 from ( values 3 ('a', 1, 6), 4 ('b', 2, 7), 5 ('c', 3, 8), 6 ('d', 4, 9) 36 Johannes Kessler

KAPITEL 3. ÜBUNGSTOOL 7 ) as R (a, b, c) 8 where R.a!= 'b' Ohne die VALUES-Notation kann man in z.b MySQL dasselbe auch folgendermaßen ausdrücken: 1 select * 2 from ( 3 select 'a' as a, 1 as b, 6 as c 4 union 5 select 'b', 2, 7 6 union 7 select 'c', 3, 8 8 union 9 select 'd', 4, 9 10 ) as R 11 where R.a!= 'b' Für diese Arbeit wurde die RA-Grammatik um ein vergleichbares Feature erweitert, das es erlaubt, innerhalb einer Abfrage neue Relationen zu definieren. Diese Inline-Relationen stellen einen gültigen RA-Ausdruck dar und können daher in jeder Operation verwendet werden. Die Notation lehnt sich an die Schema- und Tupelschreibweise in [KE11, Seite 72] an, wobei auf die eckigen Klammern verzichtet wird. Die Syntax soll am folgenden Beispiel erklärt werden: 1 { 2 a: string, b: integer, X.c:date, d 3 word, 1, 1970-01-01, null 4 'long string', 0.5, 1970-01-02, 'test' 5 } Jede Inline-Relation wird von geschwungenen Klammern umgeben (Zeile 1 und 5). Die Daten sind zeilenweise strukturiert, wobei die erste Zeile (Zeile 2 im Beispiel) die Beschreibung des Schemas und alle weiteren Zeilen die Daten der einzelnen Tupel enthalten (Zeile 3 und 4). Die einzelnen Spalten können durch Leerzeichen und Tabulatoren, Kommas mit optionalen Leerzeichen und Tabulatoren oder Strichpunkte mit optionalen Leerzeichen und Tabulatoren getrennt werden. Die Definition des Schemas erfolgt als Liste von Attributnamen, denen bei Bedarf der jeweilige Spaltentyp, mit Doppelpunkt getrennt, nachgestellt werden kann. Die explizite Nennung des Typs kann entfallen, solange der Typ eindeutig aus den Werten bestimmen lässt (siehe Spalte d Johannes Kessler 37

KAPITEL 3. ÜBUNGSTOOL in Zeile 2). Der Typ wird dabei vom ersten nicht null-wert definiert. Bei jedem folgenden Wert anderen Typs wird eine Fehlermeldung ausgegeben. Gültige Typen sind number für integer- und float-werte, string für Zeichenketten und date für Kalenderdaten. Dem Attributnamen kann ein mit Punkt getrennter Qualifizierer vorangestellt werden. Diese Syntax entspricht dadurch weitgehend der in der Literatur [KE11, Seite 72] und in Abbildung 2.1 verwendeten Notation eines Schemas. Die Werte der Tupel werden jeweils in einer Zeile notiert. Es gelten dabei dieselben Separatoren zur Trennung der Spalten. Einfache Wörter ([a-za-z]+), numerische Werte, die Konstante null oder Kalenderdaten in der Form YYYY-MM-DD werden ohne Anführungszeichen notiert. Längere oder komplexere Strings werden in einfachen Hochkommas eingeschlossen. Mit dieser Syntax kann in der Abfrage eine Relation erzeugt werden, die dem SQL-Beispiel entspricht: 1 sigma R.a!= 'b' ({ 2 R.a, R.b, R.c 3 4 a, 1, 6 5 b, 2, 7 6 c, 3, 8 7 d, 4, 9 8 }) Ein minimales Beispiel würde aus einer Relation mit einer Spalte und keinen Zeilen bestehen: {a: number} Der Typ muss dabei explizit angegeben werden, da keine Werte für eine Typbestimmung vorhanden sind. 3.1.5 Präzedenz Eine Operator-Präzedenz, wie sie in Abschnitt 2.5 definiert wurde, kann in einer PEG direkt abgebildet werden. Für die Grammatik des Übungstools wurden die Präzedenzregeln sowohl für die logischen Operatoren ^, und _, als auch für die Operatoren der relationalen Algebra umgesetzt. Die Klammerung der Operanden ist somit optional und kann in den meisten Fällen entfallen. Durch eine explizite Klammersetzung kann eine beliebige Auswertungsreihenfolge erzwungen werden, wie in Beispiel 3.3 anhand der Projektion gezeigt wird. Im Übungstool ist die gewählte Ausführungsreihenfolge nach der Ausführung sofort im Operatorbaum ersichtlich und die eingegebene Abfrage wird zusätzlich vollgeklammert angezeigt. Dadurch wird die Über- 38 Johannes Kessler

KAPITEL 3. ÜBUNGSTOOL prüfung erleichtert, ob die gewählte Ausführungsreihenfolge mit der gewünschten übereinstimmt. 1 π A.Name, P. Name ( 2 ρ A Assistenten 3 P. PersNr=Boss 4 σ Rang >'C3' _ Rangď'C2' 5 ρ P Professoren 6 ) Beispiel 3.3: Abfrage mit minimaler Klammersetzung und Operatorbaumdarstellung. 3.1.6 Plaintext Notation Alternativ zur klassischen Notation, die in Abschnitt 2.2 vorgestellt wurde, wird hier eine alternative Schreibweise eingeführt, die keine Sonderzeichen verwendet und dadurch eine möglichst komfortable und schnelle Eingabe ermöglichen soll. Es ist dadurch möglich, einen Ausdruck in relationaler Algebra als Plaintext zu notieren und ihn in dieser Form auch problemlos abzuspeichern oder in Dokumente einzubetten. Die griechischen Buchstaben werden dabei ausgeschrieben. Für Sonderzeichen wie wird eine alternative Schreibweise eingeführt, die sich an den SQL-Bezeichnern orientiert, um keine neuen Namen einführen zu müssen. Die zwei alternativen Schreibweisen können nach Belieben gemischt verwendet werden. In Tabelle 3.2 sind die alternativen Notationen den semantisch äquivalenten klassischen Notationen gegenübergestellt. Ausdrücke in eckigen Klammern sind optional. Die Klammerung der Relationen R und S dient nur der Veranschaulichung. Johannes Kessler 39

KAPITEL 3. ÜBUNGSTOOL klassische Notation alternative Notation σ aąb (R) sigma a > b ( R ) π a,b (R) pi a, b ( R ) ρ X (R) rho X ( R ) ρ xða,yðb (R) rho x <- a, x <- b ( R ) ρ añx,bñy (R) rho a -> x, a -> x ( R ) R X S R union S R Y S R intersect S R S R - S R z S R \ S R S R / S R S R a=b^a=c S R S R a=b_a=c S R a=b_a=c S R a=b_a=c S R S R S R S R cross join S R x S R [inner] join a=b and a=c S R [natural] join S R left [outer] join a=b or a=c S R right [outer] join a=b or a=c S R full [outer] join a=b or a=c S R left semi join S R right semi join S R anti [semi] join S Tabelle 3.2: Plaintext Notationen der RA-Operatoren. Bei boolschen Ausdrücken für Bedingungen wird dieselbe Notation wie in SQL verwendet: Die logischen Operatoren and, or und!, und Vergleiche mit =, >=, <=,!=, < und >. Als Trennzeichen zwischen den einzelnen Tokens sind Leerzeichen, Tabulatoren und Zeilenumbrüche definiert. Dadurch kann ein großes Statement auch mit Einrückungen formatiert geschrieben werden. Das Statement 1 pi Name, Rang 2 sigma p. PersNr >= 2130 ( 3 rho p Professoren 4 join gelesenvon=persnr 5 Vorlesungen 6 ) ist somit semantisch äquivalent zu π Name,Rang (σ p.p ersnrě2130 (ρ p P rofessoren V orlesungen)) und sollte damit gleich komfortabel zu schreiben sein, wie dieselbe Abfrage als SQL Statement: 40 Johannes Kessler

KAPITEL 3. ÜBUNGSTOOL 1 select distinct Name, Rang 2 from Professoren as p 3 inner join Vorlesungen on gelesenvon=persnr 4 where p. PersNr >= 2130 3.1.7 SQL Der Parser für SQL wurde mit PEG.js (siehe Abschnitt 3.1.1) umgesetzt. Er bietet die Möglichkeit, einfache SQL-SELECT-Statements zu formulieren, die in relationale Algebra übersetzt und ausgeführt werden. Eine Unterstützung für DML-Statements wie INSERT oder UPDATE ist nicht vorgesehen. Die unterstützte Syntax ist in einigen Punkten wie z.b. den Kommentaren an die SQL-Syntax von MySQL 8 und PostgreSQL 9 angelehnt. Die unterstützten Features sollen hier an mehreren kleinen Beispielen erklärt werden: Alle Schlüsselwörter sind nicht case-sensitiv und können daher auch klein geschrieben werden. Für den SELECT-Teil werden einerseits * oder eine Liste mit Spaltennamen in der Form name oder X.name unterstützt. X ist hierbei der Kurzbezeichner einer Tabelle oder Unterabfrage. Das Schlüsselwort distinct wird zwingend verlangt, da die Elimination von Duplikaten in SQL nicht optional ist. In der relationalen Algebra können Relationen jedoch keine Duplikate enthalten. 1 SELECT DISTINCT * 2 FROM Tabellenname Im FROM-Teil können Tabellennamen oder nicht korrelierte Substatements stehen. Jeder Tabelle kann mit as X ein Kurzbezeichner zugewiesen werden, wobei X für einen beliebigen Bezeichner steht. Bei Substatements ist dies obligatorisch. Nicht korreliert bedeutet, dass im Substatement nicht auf Daten der außen liegenden Statements zugegriffen werden kann. 8 http://dev.mysql.com/doc/refman/5.7/en/select.html, zuletzt besucht am 29.04.2014 9 http://www.postgresql.org/docs/9.3/static/sql-select.html, zuletzt besucht am 29.04.2014 Johannes Kessler 41

KAPITEL 3. ÜBUNGSTOOL 1 SELECT DISTINCT * 2 FROM Tabelle1, Tabelle2 as t2, ( 3 SELECT DISTINCT * 4 FROM Tabelle3 5 ) as t3 6 inner join Tabelle4 as t4 on t4.a = t2.a 7 natural join Tabelle5 8 inner join Tabelle6 natural 9 left outer join Tabelle8 as t8 on t8.a = t2.a 10 left outer join Tabelle9 natural 11 right outer join ( 12 select * from Tabelle10 13 ) as t10 Zu joinende Tabellen können entweder, wie in Zeile 2 als Liste hinter FROM aufgelistet werden oder, wie ab Zeile 6 dargestellt ist, explizit aufgeführt werden. Hierbei werden für den inneren Natural-Join zwei alternative Schreibweisen unterstützt, wie in Zeile 6 und 7 zu sehen ist. Der Left-, Right- und Full-Outer-Join wird jeweils mit explizitem Joinkriterium unterstützt, das nach on angeführt wird. Weiters steht jeweils eine Natural-Variante zur Verfügung, bei der das Joinkriterium implizit gegeben ist. Im WHERE-Teil werden Vergleiche in der Form a OPERATOR b mit den Operatoren =,!= oder <>, >, <, >=, <=, is null und is not null unterstützt. Die Operanden a und b stehen hierbei für beliebige Spaltennamen oder Literale. Vergleiche können mit and und or verknüpft werden, die Negation geklammerter Ausdrücke mit! wird unterstützt. Literale haben die Typen String, Number oder Date. Null kann als null oder NULL geschrieben werden. Strings werden in einfachen Hochkommas (z.b. 'text') notiert. Numerische Werte sind entweder ganzzahlig mit optionalem Vorzeichen in der Form (-?[0-9]+) z.b. 42 oder Float Werte wie -42.0, die durch folgenden regulären Ausdruck (-?[0-9]+.[0-9]+) beschrieben werden können. Datumswerte werden in der Form DATE('YYYY-MM-DD') notiert, wobei YYYY für das Jahr, MM für den Monat und DD für den Tag stehen. 1 SELECT DISTINCT * 2 FROM Tabellenname 3 WHERE a>10 and!(b <> '' or c is not null) 4 ORDER BY a, b asc, 3 desc, a, b Das Sortierten der Ausgabe ist mit ORDER BY möglich. Dem Schlüsselwort folgt eine durch Kommas getrennte Liste mit Spaltennamen oder Spalten-Indizes. Jeder Eintrag kann durch asc oder desc ergänzt werden, um die Sortierrichtung anzugeben. Ohne explizite Angabe wird aufsteigend sortiert (asc). Eine Gruppierung ist mit GROUP BY möglich, wobei hier eine Liste der Spalten angegeben wird, nach denen gruppiert werden soll. 42 Johannes Kessler

KAPITEL 3. ÜBUNGSTOOL Für die Aggregation können alle in Abschnitt 2.2.17 beschriebenen Funktionen verwendet werden. Für jede Aggregationsspalte muss mit as ein Name angegeben werden. In der HAVING-Klausel können, analog zur WHERE-Klausel, weitere Einschränkungen formuliert werden. Aggregationsspalten werden dabei über den neuen Bezeichner angesprochen. 1 SELECT DISTINCT a, b, COUNT(*) as anzahl, SUM(d) as summe 2 FROM Tabellenname 3 GROUP BY a, b 4 HAVING summe > 100 5 ORDER BY 4 desc 6 LIMIT 10 OFFSET 0 Wie bei PostgreSQL [Pos, Kapitel 7.6] kann durch LIMIT x OFFSET y oder LIMIT x eine vertikale Partitionierung vorgenommen werden. Es werden dabei die ersten x Zeilen ab der Zeile mit dem Index y ausgegeben. Um die Anzahl der Zeilen nicht zu limitieren, kann statt der Zeilenanzahl x das Schlüsselwort ALL verwendet werden. Ohne Angabe eines Offsets wird ab der ersten Zeile gezählt, was der Angabe LIMIT x OFFSET 0 entspricht. Die Schlüsselwörter UNION und INTERSECT stehen zur Verfügung, um die Vereinigung bzw. die Schnittmenge zweier Abfragen zu bilden. 3.2 Berechnung Die Berechnung der RA erfolgt ausschließlich clientseitig und wurde in JavaScript implementiert. Entgegen der RA-Theorie werden hier keine Mengen von Tupeln, sondern, ähnlich wie in relationalen Datenbanken, Multimengen in Form von zweidimensionalen Arrays von Werten als Basis verwendet. Dies hat den Vorteil, dass die Tupel eine definierte Ordnung besitzen. Duplikate werden vor der Ausgabe unter Beibehaltung der Reihenfolge eliminiert. Ziel dieser Arbeit war nicht, möglichst schnelle Algorithmen zu implementieren, sondern den Fokus auf den Übungscharakter des Programms zu legen. Es wurden daher oft langsamere Algorithmen implementiert, die für den User jedoch noch Vorteile wie das Erhalten einer bestimmten Reihenfolge bieten. Die Ausführungsgeschwindigkeit ist für kleine Tabellen und sinnvolle Abfragen, wie Sie für Übungen und Beispiele verwendet werden, ausreichend. So wird die Abfrage in Beispiel 3.4, die auf den Daten aus [KE11] basiert, in Google Chrome 35 und Mozilla Firefox 28 in ca 2 bis 4 Millisekunden ausgeführt 10. Bei kleinen Ergebnistabellen dauert die Darstellung als Tabelle länger als die eigentliche Berechnung der Daten. 10 Teststyem: Intel(R) Core(TM) i5 CPU M 520 mit 2.40GHz Johannes Kessler 43

KAPITEL 3. ÜBUNGSTOOL 1 tau [1], [2], [3] 2 pi S.Name, S. Semester, P. Name ( 3 ( 4 Vorlesungen 5 natural join ( 6 rho S Studenten 7 natural join 8 rho H hoeren 9 ) 10 ) 11 join gelesenvon=persnr 12 rho P Professoren 13 ) Beispiel 3.4: Abfrage in relationaler Algebra. Alle RA-Operatoren wurden jeweils so umgesetzt, dass die Reihenfolge der Tupel der Argumentrelationen erhalten bleibt. Einer der einfachsten Algorithmen, einen Join auszuführen, ist der Nested-Loop-Join. Dieser wird in Datenbanksystemen, wenn möglich, durch schnellere Algorithmen ersetzt, da er eine Komplexität von O( R S ) besitzt. Der Nested-Loop-Join (Beispiel 3.5) hat jedoch die Eigenschaft, dass das Ergebnis unabhängig von den Werten immer dieselbe leicht nachvollziehbare Struktur aufweist und auch Beispiele oft in dieser Form angegeben werden (z.b. Abbildung 2.14 [GMUW09, Seite 44], Abbildung 2.16 [GMUW09, Seite 46] und Abbildungen [KE11, Seite 88 und 89]). Ein Beispiel für einen Join-Algorithmus, bei dem die Reihenfolge nicht erhalten bleibt, ist der Hash-Join [GMUW09, Seite 734-738]. Dieser besitzt zwar eine durchschnittliche Laufzeit von O( R + S ), die Tupel der Relationen werden jedoch über die Hashwerte der Join-Attribute gejoint. Dadurch ist die Reihenfolge der Tupel in der Ergebnisrelation von den Daten der Join-Attribute und der gewählten Hashfunktion abhängig. 1 for(r in R){ 2 for(s in S){ 3 if(r.a == s.a) 4 // => [r, s] zum Ergebnis hinzufügen 5 } 6 } Beispiel 3.5: Nested-Loop-Join der Operation R r.a=s.a S als Pseudocode. 44 Johannes Kessler

KAPITEL 3. ÜBUNGSTOOL Aus diesem Grund wird für alle Join Operatoren der Nested-Loop-Join verwendet. Die Berechnung des Ergebnisses erfolgt, ausgehend vom Syntaxbaum des Parsers, bei dem verwendete Variablen bereits ersetzt wurden (siehe Abschnitt 3.1.3), in drei Schritten: Übersetzung, Überprüfung und die eigentliche Berechnung. Bei der Übersetzung wird anhand des Syntaxbaums (siehe Abschnitt 3.1.1) rekursiv ein Objekt für jede Operation erzeugt. Die Operanden jeder Operation sind wiederum Objekte der jeweiligen Operation und werden als Argument übergeben. Die verwendeten benannten Relationen werden in diesem Schritt aufgelöst, indem nach entsprechenden Relationen in der aktuell gewählten Gruppe gesucht wird. Nach dem Mapping steht der vollständige Operatorbaum zur Weiterverarbeitung zur Verfügung. Beim Wurzelobjekt dieses Operatorbaums wird im nächsten Schritt die check -Funktion aufgerufen, die das Schema der jeweiligen Operation berechnet und eine semantische Prüfung vornimmt. Diese Funktion wird rekursiv für alle Kindelemente aufgerufen, da die Berechnung des Schemas eines Operators von den Schemata der Argumente abhängt. Die eigentliche Berechnung erfolgt in einem separaten Schritt. Die Basisfälle sind wiederum die Relationen, von denen ausgehend das Ergebnis bottom-up berechnet wird. SQL Die Berechnung von SQL-Statements erfolgt indirekt durch eine Übersetzung in relationale Algebra. Es wird ausgehend vom SQL-Syntaxbaum des Parsers ein RA- Operatorbaum erzeugt. Ab diesem Zeitpunkt findet keine Unterscheidung mehr zwischen den beiden Sprachen statt. Die Übersetzung eines SQL-Statements in relationale Algebra soll exemplarisch an Beispiel 3.6 erklärt werden. Johannes Kessler 45

KAPITEL 3. ÜBUNGSTOOL 1 select distinct Titel as Vorlesungsname, Name 2 from ( 3 select distinct Titel, Name, SWS 4 from Studenten as st 5 natural join hoeren as h 6 inner join Vorlesungen on h. VorlNr=Vorlesungen. VorlNr 7 8 union 9 10 select distinct Titel, Name, SWS 11 from Vorlesungen, Professoren 12 where gelesenvon=persnr 13 ) as t 14 where SWS >= 3 15 order by 1, 2 desc Beispiel 3.6: Abfrage in SQL. Da die relationale Algebra prozedural aufgebaut ist, wird hier von innen nach außen vorgegangen. Im Programm ist dies einfach durch Rekursion abbildbar. Zuerst wird das Statement von Zeile 3 bis 6 übersetzt. Der Ausgangspunkt ist hierbei die Relation Studenten, welcher ein neuer Qualifizierer st zugewiesen wird. ρ st Studenten Dieser Ausdruck wird mit einem Natural-Join mit der Relation hoeren verknüpft, welcher der Kurzbezeichner h zugewiesen wird. (ρ st Studenten) (ρ h hoeren) In Zeile 6 wird mit der Relation Vorlesungen gejoint. Einer Relation, der kein expliziter Kurzbezeichner zugewiesen wird, wird automatisch ein Kurzbezeichner zugewiesen, der dem Relationsnamen entspricht. Dies stellt sicher, dass die Spalten als Tabellenname.Spaltenname ansprechbar sind: ( (ρ st Studenten) (ρ h hoeren) ) h. VorlNr=Vorlesungen. VorlNr ( Vorlesungen ) Der SELECT-Teil des Statements entspricht in der RA einer Projektion. Das Schlüsselwort distinct wird an dieser Stelle zwingend benötigt, da die Duplikateneliminierung in SQL optional ist. Damit kann das Statement von Zeile 3 bis 6 in den folgenden RA-Ausdruck übersetzt werden: π Titel, Name, SWS ( ( (ρ st Studenten) (ρ h hoeren) 46 Johannes Kessler

KAPITEL 3. ÜBUNGSTOOL ) ) h. VorlNr=Vorlesungen. VorlNr ( Vorlesungen ) Im Statement von Zeile 10-12 wird die ältere Join-Syntax verwendet. Hierbei wird zuerst das Kreuzprodukt der Relationen Vorlesungen und Professoren gebildet und darauf die Selektion ausgeführt. Der select-teil wird, wie vorher, durch die Projektion abgebildet. π Titel, Name, SWS ( σ gelesenvon=persnr ( Vorlesungen Professoren) ) Die Union-Operation aus SQL ist äquivalent zur Vereinigung in der relationalen Algebra (siehe Abschnitt 2.2.4). Somit können die Zeilen 3 bis 12 einfach zur folgenden Abfrage zusammengefasst werden: ( π Titel, Name, SWS ( ( (ρ st Studenten) (ρ h hoeren) ) h. VorlNr=Vorlesungen. VorlNr ( Vorlesungen ) ) ) Y ( π Titel, Name, SWS ( σ gelesenvon=persnr ( Vorlesungen Professoren) ) ) Im äußeren Statement wird das vereinigte Statement (Zeile 3 bis 12) als Substatement verwendet, welchem der Bezeichner t zugewiesen wird. Ein nicht korreliertes Substatement 11 wird in der RA einfach als Operand der jeweiligen Operation abgebildet. Eine Übersetzung von korrelierten Unterabfragen wäre wesentlich aufwendiger und wird sowohl in der Literatur, z.b. [KE11], als auch in Vorlesungen selten behandelt. Daher wurde auf die Unterstützung von korrelierten Unterabfragen verzichtet. Der WHERE-Teil entspricht einer einfachen Selektion mit der entsprechenden Bedingung. Im SELECT-Teil in Zeile 1 wird der Spalte Titel ein neuer Name zugewiesen, was in der Verwendung der Umbenennung ρ resultiert. Order-by kann durch die Erweiterung der relationalen Algebra (siehe Abschnitt 2.2.15) mit dem τ-operator abgebildet werden. Das komplette Statement kann somit wie folgt in relationaler Algebra dargestellt werden: 11 Korreliert bedeutet, dass innerhalb des Substatements auf Daten der umschließenden Abfrage referenziert werden kann. Johannes Kessler 47

KAPITEL 3. ÜBUNGSTOOL τ [1], [2] desc (π Titel, Name ( σ SWSě3 (ρ t ( ( π Titel, Name, SWS ( ( (ρ st Studenten) (ρ h hoeren) ) h. VorlNr=Vorlesungen. VorlNr ( Vorlesungen ) ) ) Y ( π Titel, Name, SWS ( σ gelesenvon=persnr ( Vorlesungen Professoren) ) ) )) )) Das SQL-Statement 1 SELECT DISTINCT a, b, COUNT(*) as anzahl 2 FROM R 3 WHERE a >= 1 4 GROUP BY a, b 5 HAVING anzahl > 2 6 ORDER BY 3 desc 7 LIMIT 1 OFFSET 1 kann folgendermaßen in relationale Algebra übersetzt werden: π a, b, anzahl ( σ ROWNUMą1 ^ ROWNUMď2 ( π a, b, anzahl, ROWNUM ( τ [3] desc ( π a, b, anzahl ( σ anzahl >2 ( γ a, b ; COUNT(*)Ñanzahl ( σ aě1 ( R ) ))))))) Die Gruppierung in Zeile 4 wird dabei durch den Gruppierungsoperator γ (siehe Abschnitt 2.2.17) abgebildet. Dabei wird nach allen in GROUP BY angegebenen Spalten gruppiert. Die Aggregationsfunktionen (im Beispiel COUNT(*)) werden in SQL im SELECT-Teil definiert. Die HAVING-Klausel in Zeile 5 entspricht einer Selektion, die nach γ ausgeführt wird. Die vertikale Partitionierung mit LIMIT 1 OFFSET 1 erfolgt in der relationalen Algebra durch eine Selektion mit dem Zeilenindex ROWNUM, der durch die erweiterte Projektion (siehe Abschnitt 2.2.16) zur Verfügung gestellt wird. Die Übersetzung von RA in SQL erfolgt automatisch im Hintergrund, um ein äquivalentes Statement in relationaler Algebra zu erzeugen (siehe Abbildung 3.2). Die Übersetzung soll den Benutzern helfen, einerseits 48 Johannes Kessler

KAPITEL 3. ÜBUNGSTOOL die relationale Algebra schneller zu erlernen, wenn schon gewisse SQL Vorkenntnisse vorhanden sind, und anderseits einen Einblick zu erhalten, wie eine SQL-Abfrage in relationale Algebra übersetzt und ausgeführt werden kann. Abbildung 3.2: Anwendung mit SQL-Statement aus Abschnitt 3.2. 3.3 Server Dieses Kapitel beschreibt die Serverkomponente, welche die Tabellen zur Verfügung stellt, die für die RA- und SQL-Statements verwendet werden. Eine Aufgabe ist eine Zusammenstellung von einer oder mehreren zu- Johannes Kessler 49

KAPITEL 3. ÜBUNGSTOOL sammengehörenden Tabellen zu einer Gruppe. Diese kann mit zusätzlichen Informationen wie eine Referenz zum Übungsblatt und einem optionalen Sichtbarkeitszeitraum versehen werden. Übungsleiter sollen in der Lage sein, neue Aufgaben anzulegen und dabei vorhandene (MySQL) Tabellen wiederzuverwenden, die den Benutzern beispielsweise über Frontends wie phpmyadmin zur Verfügung gestellt werden, um SQL Abfragen ausführen zu können. Zur einfachen Weiterverarbeitung in JavaScript werden die Daten direkt als JSON-codiert ausgegeben. Eine Gruppe hat folgende Struktur: eine eindeutige numerische ID, um die Tabellen nachzuladen, einen Gruppennamen, wie er im Client angezeigt wird, z.b. Tutorial Exercise 1-2014, eine Beschreibung mit weiteren Informationen zur Übung, einen optionalen Zeitraum zur Steuerung der Sichtbarkeit, eine Liste aller Tabellen der Gruppe mit einer numerischen ID, dem Namen der Tabelle, wie er im Client angezeigt wird und den Spaltennamen und -typen der jeweiligen Tabellen. 50 Johannes Kessler

KAPITEL 3. ÜBUNGSTOOL 1 {"2": 2 { 3 "groupid": 2, 4 " groupname": " DatabaseSystems Lecture", 5 " groupdesc": " Tables from and for the lecture <a href =\" http:\/\/ dbis - informatik. uibk.ac.at\/249-0-vo- Datenbanksysteme. html\"> Databases: Foundations, Data Models and System Concepts - University of Innsbruck <\/a> chapter 3", 6 " online_until": null, 7 "tables": [ 8 { 9 "tableid": 0, 10 "tablename": "R", 11 "columnnames": ["a", "b", "c"], 12 "columntypes": ["number", "string", "string"] 13 }, 14 { 15 "tableid": 1, 16 "tablename": "S", 17 "columnnames": ["b", "d"], 18 "columntypes": ["string", "number"] 19 }, 20 { 21 "tableid": 2, 22 "tablename": "T", 23 "columnnames": ["b", "d"], 24 "columntypes": ["string", "number"] 25 } 26 ] 27 } 28 } Beispiel 3.7: Antwort auf eine Abfrage aller Gruppen. Die Serverkomponente wurde in PHP implementiert und stellt die Daten über eine einfache REST-Schnittstelle zur Verfügung. Es gibt zwei einfache Verwaltungstabellen, ra_group und ra_table, in denen die Informationen zu den Gruppen und deren Tabellen gespeichert sind. Die Abfrage GET index.php/groups wird verwendet, um die Spezifikation aller Gruppen und deren Tabellen zu laden. Die Namen und Typen der Spalten der einzelnen Tabellen werden aus der MySQL-Tabelle INFOR- MATION_SCHEMA.COLUMNS 12 geladen, welche die Datentypen der Spalten jeder Tabelle enthält (siehe Beispiel 3.7). Die Abfrage GET index.php/tables/x dient dazu, die Daten der Tabellen der Gruppe mit der group-id X zu laden (siehe Beispiel 3.8). 12 http://dev.mysql.com/doc/refman/5.5/en/columns-table.html - 2014 Johannes Kessler 51

KAPITEL 3. ÜBUNGSTOOL 1 [ 2 [ 3 ["1", "a", "d"], 4 ["3","c","c"], 5 ["4","d","f"], 6 ["5","d","b"], 7 ["6","e","f"] 8 ], 9 [ 10 ["a","100"], 11 ["b","300"], 12 ["c","400"], 13 ["d","200"], 14 ["e","150"] 15 ], 16 [ 17 ["a","100"], 18 ["d","200"], 19 ["f","400"], 20 ["g","120"] 21 ] 22 ] Beispiel 3.8: Antwort auf eine Abfrage index.php/tables/2. 3.4 Geteilte Tabellen In Abschnitt 3.3 wurde eine Möglichkeit vorgestellt, den Usern Gruppen von Tabellen für Abfragen zur Verfügung zu stellen. Der Fokus liegt dabei auf einer einfachen Wiederverwendung von vorhanden Datensätzen und Tabellen in einer Datenbank. Somit können die Daten leicht sowohl über das relationale Algebra Übungstool als auch z.b. per phpmyadmin zur Verfügung gestellt werden. Eine Alternative dazu stellt das Laden der Daten von externen Quellen dar. Das Ziel ist hierbei, eine einfache Möglichkeit zu schaffen, Tabellen für Abfragen zu veröffentlichen und auszutauschen. Dies bietet unter anderem die Möglichkeit, dass Benutzer selbst Tabellen definieren und diese mit anderen teilen können. Eine Gruppe von Tabellen besteht aus dem Namen der Gruppe, einer optionalen Beschreibung und einer oder mehreren Tabellendefinitionen. Für die Definition einer Gruppe wurde ein einfaches Format definiert, das es erlaubt, ein oder mehrere Gruppen als Klartext zu beschreiben. Die verwendete Syntax zur Definition der Tabellen entspricht der in Abschnitt 3.1.1 vorgestellten Syntax für Abfragen in relationaler Algebra. Tabellen werden dazu als Zuweisungen (siehe Abschnitt 3.1.3) abgebildet. 52 Johannes Kessler

KAPITEL 3. ÜBUNGSTOOL Der Gruppenname und die optionale Beschreibung werden am Beginn der Datei notiert. 1 group: Name der Gruppe 2 description[[ Beschreibung der Gruppe 3 über <b>mehrer </b> Zeilen ]] 4 5 TabelleA = { 6 a, b 7 1, a 8 2, b 9 3, c 10 } 11 12 TabelleB = { 13 a, d 14 1, 0.5 15 2, -1 16 4, 42 17 } 18 19 -- Tabellendefinition als komplexer Ausdruck 20 TabelleC = (pi a TabelleB) cross join { 21 e 22 1970-01-01 23 2038-01-19 24 } Jede Headerdeklartation beginnt mit dem Headernamen gefolgt von einem Doppelpunkt bei einzeiligen Text (Zeile 1) oder [[ bei mehrzeiligem Text. Mehrzeilige Header werden durch ]] beendet das innerhalb des Texts als \]] escaped werden kann. Derzeit sind die Header group für den Namen der Gruppe und description für deren Beschreibung definiert. Im Beschreibungstext kann hierbei mit beliebigem HTML ausgezeichnet werden, um beispielsweise Hyperlinks auf weiterführende Literatur setzen zu können. Die Definition der Tabellen erfolgt durch eine Liste von Zuweisungen, wie sie auch in einer Abfrage verwendet werden können. Der Variablenname entspricht hierbei dem Tabellennamen in der Gruppe. Die Tabelle wird durch den zugewiesenen Ausdruck definiert. Der Ausdruck muss dabei ein gültiger RA-Ausdruck sein und ist im einfachsten Fall eine Inline-Relation (siehe Abschnitt 3.1.4). Es ist möglich, innerhalb eines Ausdrucks eine andere Relation der selben Gruppe zu verwenden. Hierbei gelten dieselben Regeln wie für die Verwendung von Zuweisungen (Abschnitt 3.1.3). Die Namen und Typen der Spalten ergeben sich aus dem Schema der Ausdrücke. Der Qualifizierer einer Tabelle wird beim Laden für alle Spalten automatisch auf den Tabellennamen gesetzt. Johannes Kessler 53

KAPITEL 3. ÜBUNGSTOOL Innerhalb einer Datei können mehrere Gruppen untereinander definiert werden, wobei jede mit einem eigenen Header beginnt. Dieses Format wird auch applikationsintern verwendet, um alle Gruppen zu laden, die nicht über die Serverschnittstelle aus der Datenbank geladen werden. Als Quelle wird derzeit Github Gist 13 unterstützt. Github Gist ist eine Plattform, auf der Code-Snippets einfach veröffentlicht und geteilt werden können. Jeder Gist ist dabei ein vollstädiges Git-Repository. Gists können sowohl anonym als auch als registrierter Github User erstellt werden und erhalten jeweils eine eindeutige ID. Über diese ID können die Gruppendefinitionen im Übungstool geladen werden. Dabei wird die Applikation direkt mit dem Querystring?data=gist:ID aufgerufen. Die Url http://example.com/?data=gist:ac267b9cc810ac5f20e2 lädt somit automatisch die Tabellengruppe, die im Gist mit der ID ac267b9cc810ac5f20e2 definiert wurde. 13 https://gist.github.com/, zuletzt besucht am 29.04.2014 54 Johannes Kessler

Kapitel 4 Grafische Benutzeroberfläche Die grafische Benutzeroberfläche des Übungstools ist komplett webbasiert und wurde mit HTML5 umgesetzt. Beim Start der Anwendung wird die Gruppenübersicht vom Server gladen. Die Tabellen werden bei der Auswahl einer Gruppe per AJAX nachgeladen. Sämtliche Berechnungen laufen clientseitig ab. Dies ermöglicht ein komfortables Arbeiten ohne Rücksichtnahme auf die aktuelle Reaktionszeit des Servers. Wie in Abbildung 4.1 auf Seite 56 zu sehen ist, besteht die Oberfläche aus den folgenden Komponenten (von links oben nach rechts unten): 1. einem Dropdownmenü zur Auswahl der Tabellengruppe 2. einer Liste mit Tabellen und deren Spalten 3. dem Editor mit Toolbar (siehe Abschnitt 4.1) 4. einer Operatorbaumdarstellung des Statements (siehe Abschnitt 4.2) 5. der RA-Formel jenes Teils der Formel, welcher berechnet wurde 6. der Anzeige der berechneten Daten als Tabelle Die Oberfläche wurde zu großen Teilen mittels Bootstrap 1 gestaltet. Für die Interaktion mit dem DOM wird jquery 2 verwendet. 1 http://getbootstrap.com/, zuletzt besucht am 29.04.2014 2 http://jquery.com/, zuletzt besucht am 29.04.2014 55

KAPITEL 4. GRAFISCHE BENUTZEROBERFLÄCHE Abbildung 4.1: Editor mit Toolbar im Modus für relationale Algebra. 4.1 Editor Der Editor ist eine der Hauptkomponenten der Applikation und dient neben der Texteingabe auch der Anzeige von Fehlermeldungen. Die Editorkomponente wurde mit CodeMirror 3 umgesetzt 3. CodeMirror ist ein freier webbasierter Editor, der unter der MIT-Lizenz steht und umfangreiche Erweiterungsmöglichkeiten bietet. Die Eingabe einer Abfrage kann im Übungstool sowohl in SQL als auch in relationaler Algebra erfolgen. Für die relationale Algebra steht eine umfangreiche Toolbar zur Verfügung, über die Sonderzeichen der Operatoren komfortabel eingegeben werden können. Wie in Abbildung 4.2 zu sehen ist, wird für jede Operation zusätzlich ein kurzes Beispiel angezeigt, das die Verwendung des 3 http://codemirror.net/, zuletzt besucht am 29.04.2014 56 Johannes Kessler

KAPITEL 4. GRAFISCHE BENUTZEROBERFLÄCHE Operators illustriert. Sprachübergreifend kann die aktuelle Abfrage mit strg. +.. oder der execute -Schaltfläche ausgeführt werden. Über dieselbe Schaltfläche kann, sobald Text innerhalb des Editors markiert ist, dieser Teil der Abfrage ausgeführt werden. Dies ist auch über die Tastatur mit strg. +.. +.. möglich. Abbildung 4.2: Editor mit Toolbar im Modus für relationale Algebra. 4.1.1 Syntax-Highlighting Für die relationale Algebra wurde ein eigener mode 4 definiert, der für das Syntax-Highlighting verwendet wird. Dieser besteht aus einem einfachen Lexer, der die Eingabe in einzelne Tokens aufteilt, und einer einfachen Erkennung für Schlüsselwörter, Strings, einzeilige Kommentare und Blockkommentare. Jedem Token wird in diesem Schritt ein Typ zugeordnet, der das Aussehen als CSS-Klasse definiert (siehe Abbildung 4.2 auf dieser Seite). Für das Syntax-Highlighting wird nicht der Parser aus Abschnitt 3.1.1 verwendet, da dieser nur dann einen Syntaxbaum erzeugt, wenn die gesamte Abfrage syntaktisch korrekt ist. Der Lexer besteht aus einer Funktion token und einem Zustandsobjekt. Die Funktion token wird von Codemirror selbständig aufgerufen, liest bis zum jeweils nächsten Token vom Stream und gibt den entsprechenden Typ zurück. Das Zustandsobjekt wird bei jedem Aufruf der Funktion token übergeben und enthält beispielsweise den Status, ob ein Blockkommentar geöffnet wurde. 4 http://codemirror.net/doc/manual.html#modeapi, zuletzt besucht am 29.04.2014 Johannes Kessler 57

KAPITEL 4. GRAFISCHE BENUTZEROBERFLÄCHE CodeMirror ruft die Funktion token dabei wärend der Eingabe selbständig für Teile des Texts auf. Dabei wird jeweils ein an dieser Position gültiges Zustandsobjekt übergeben. Dadurch wird vermieden, jeweils den gesamten Text neu parsen zu müssen. Ein mode für SQL ist in Codemirror bereits enthalten und musste daher nicht implementiert werden. 4.1.2 Fehlermeldungen Fehlermeldungen werden direkt im Editor angezeigt, wenn Informationen zur Position im Code zur Verfügung stehen (siehe Abbildung 4.3). Allgemeine Fehler, die nicht direkt auf eine bestimmte Textstelle bezogen werden können, werden unter dem Editor angezeigt. Abbildung 4.3: Anzeige von Fehlermeldungen im Editor. Die Überprüfung auf syntaktische und semantische Fehler erfolgt mithilfe des Lint-Addons 5 während der Eingabe automatisch im Hintergrund. Dafür wird der komplette Text kurze Zeit nach der letzten Eingabe geparst, in RA übersetzt und dort die semantische Prüfung vorgenommen. Die Codepositionen werden bei den einzelnen Schritten, wenn möglich, weitergegeben, sodass auch semantische Fehler im Text entsprechend angezeigt werden können. 4.1.3 Autovervollständigung Die Autovervollständigung kann mit strg. + Leertaste. ausgelöst werden und bietet Vorschläge zur Vervollständigung des aktuellen Wortes an. Dazu stehen einerseits die Schlüsselwörter der aktuell ausgewählten Sprache als auch die Namen und Spaltennamen der verwendeten Gruppe von Tabellen zur Verfügung (siehe Abbildung 4.4). Bei jeder erfolgreichen Übersetzung in RA werden zusätzlich alle Spaltennamen der Schemata der Operatoren hinzugefügt. 5 http://codemirror.net/doc/manual.html#addon_lint, zuletzt besucht am 29.04.2014 58 Johannes Kessler

KAPITEL 4. GRAFISCHE BENUTZEROBERFLÄCHE Abbildung 4.4: Autovervollständigung im Code-Editor. Durch diese Erweiterungen und die alternative Plaintext Syntax für die relationale Algebra können Abfragen sehr einfach formuliert und getestet werden, ohne dafür die Maus verwenden zu müssen. 4.2 Operatorbaum Für eine einfache Darstellung des ausgeführten Statements wird dieses im Übungstool als Operatorbaum dargestellt. Die Darstellung lehnt sich dabei an Darstellungen in der Literatur (z.b. [KE11, Seite 98] und [GMUW09, Seite 48]) an und wurde in Abschnitt 2.4 vorgestellt. Durch diese Darstellung kann die Ausführungsreihenfolge selbst bei komplexen Abfragen sehr leicht nachvollzogen werden. Der Baum dient weiters zur Steuerung der Anzeige von Zwischenergebnissen. Beim Ausführen wird jeweils die gesamte Abfrage ausgewertet und das Ergebnis tabellarisch angezeigt. Durch einen Klick auf einen Operator im Baum wird das Ergebnis des jeweiligen Teilbaums berechnet und angezeigt. Der entsprechende Knoten und dessen Kindelemente wird dabei optisch hervorgehoben. Durch dieses Feature ist es den Benutzern leicht möglich, die Berechnung der Abfrage in Einzelschritten nachzuvollziehen. Beim Mouseover über einen bestimmten Knoten werden Informationen zum jeweiligen Zwischenergebnis angezeigt. Hierbei werden einerseits das Schema der Relation als auch die maximale Anzahl der Zeilen 6 angezeigt. Bei Natural-Joins wird zusätzlich angezeigt, über welche Spalten gejoint wird. Jede Verwendung einer durch eine Zuweisung entstandenen Variable (siehe Abschnitt 3.1.3) wird im Operatorbaum durch ein farbiges Label gekennzeichnet. Bei mehrfacher Verwendung derselben Variable erhält das Label jeweils die gleiche Farbe. 6 Zeilenanzahl vor der Duplikatenelimination Johannes Kessler 59

KAPITEL 4. GRAFISCHE BENUTZEROBERFLÄCHE In Abbildung 4.5 auf dieser Seite ist der Operatorbaum der folgenden Abfrage dargestellt: 1 S = rho S sigma Semester > 2 Studenten 2 3 Prof = sigma Rang >'C3' Professoren 4 5 T = 6 hoeren 7 natural join Vorlesungen 8 join gelesenvon=persnr Prof 9 10 pi S. MatrNr, S.Name, Semester ( 11 S join S. MatrNr=hoeren. MatrNr T 12 ) Die Wurzelknoten der Teilbäume der Variablen S, T, und Prof sind jeweils farbig hervorgehoben. Das angezeigte Ergebnis wäre das des ersten Joins, welches jedoch in der Abbildung nicht mehr dargestellt ist. Abbildung 4.6 zeigt einen Ausschnitt desselben Baums beim Mouseover eines Natural-Joins. Abbildung 4.5: Operatorbaumdarstellung mit Variablen. 60 Johannes Kessler