XML-Datenbanken Hauptseminar

XML-Datenbanken
Hauptseminar Informatik
SS 2001
Thema: Query Rewriting
Vortragstermin: 31. 5. 2001
Betreuer: Prof. Dr. Rudolf Bayer
Autor: Arne Seifert
XML-Datenbanken Hauptseminar Informatik im SS01
Seite 2
Inhaltsverzeichnis:
1
Grundbegriffe..................................................................................................... 3
1.1
Was ist SQL?................................................................................................ 3
1.2
Query oder Anfrage ...................................................................................... 3
1.3
Datenstruktur relationales Schema im Vergleich zu XML ............................. 3
1.3.1
Relationales Schema............................................................................. 3
1.3.2
XML DTD bzw. XML Schema............................................................... 4
2
Einführung des Beispiels zur Veranschaulichung ......................................... 5
3
Unterschiedliche Darstellungsformen ............................................................. 6
4
3.1
XML-Rel mit Pfad als Attribut........................................................................ 6
3.2
XML-Triple .................................................................................................... 6
Übersetzung einer XML-Anfrage ...................................................................... 8
4.1
Allgemeine Funktionsweise .......................................................................... 8
4.2
Funktionsweise des Normalisierungsmoduls................................................ 9
4.2.1
Direkt übersetzbare Anfragen................................................................ 9
4.2.2
Nichtübersetzbare Anfragen.................................................................. 9
4.2.3
Anfragen, bei denen eine Normalisierung notwendig ist...................... 10
4.3
Funktionsweise des Übersetzungsmodul (Quilt zu SQL)............................ 12
4.3.1
Übersetzen von Pfadausdrücken ........................................................ 12
4.3.2
Übersetzen von FLWR Ausdrücken .................................................... 13
4.3.3
Übersetzen von heterogenen Typanfragen ......................................... 13
4.3.4
Übersetzen von Funktionen und Funktionsaufrufen ............................ 13
4.3.5
Übersetzen anderer Sprachkonstrukte ................................................ 13
4.4
SQL Query Rewriting.................................................................................. 14
4.4.1
Angewendet auf eine XML-Relation .................................................... 14
4.4.2
Angewendet auf einen Join ................................................................ 15
4.4.3
Umwandlung von XML-Rel mit Join zu XML-Triple ............................. 16
4.5
Zusatzfunktionalität..................................................................................... 16
4.5.1
Myriad Schema mit MHC-Surrogate.................................................... 17
5
Fazit .................................................................................................................. 19
6
Literaturverzeichnis: ....................................................................................... 20
Query Rewriting
28.05.2001
XML-Datenbanken Hauptseminar Informatik im SS01
Seite 3
1 Grundbegriffe
Um dieses Thema verstehen zu können, sind einige Grundbegriffe zu klären, die
das Verständnis erleichtern
1.1 Was ist SQL?
Im Zusammenhang mit Datenbankprogrammierung fällt immer wieder der Begriff
SQL. SQL - Structured Query Language - ist eine standardisierte Abfragesprache
für
die
Datendefinition
und
Datenmanipulation
in
relationalen
Datenbanksystemen, die es ermöglicht, auf Daten in einer Datenbank zuzugreifen
und diese zu manipulieren. SQL ist in Standards festgeschrieben (zur Zeit ist
SQL92 gültig).
Es werden verschieden Möglichkeiten der Nutzung in Programmen oder
Programmiersprachen bereitgestellt:
• Interaktives ("stand-alone") SQL (z. B. Oracle SQL*Plus)
• Eingebettetes ("embedded") SQL (für die gängigen Programmiersprachen)
• Anweisungen zur Integritätssicherung und Zugriffskontrolle
• Anweisungen zur physischen Datenorganisation (Indizes etc.)
• Integration von SQL in "4th Generation Language" (z. B. Oracle PL/SQL)
1.2 Query oder Anfrage
Ein weiterer wichtiger Punkt im Bezug auf Datenbanken sind die Queries oder
Anfragen. Dabei werden die Anfragen als einfache Strings an den Interpreter
übergeben (z. B. ein SQL-fähiges Datenbanksystem), der diese durchparst und
die entsprechende Funktionalität ausführt. Ein großer Vorteil an dieser Struktur
ist, dass die Anfrage sehr einfach erweitert werden kann, da einfach nur neue
Schlüsselworte angehängt werden müssen.
1.3 Datenstruktur relationales Schema im Vergleich zu XML
Die Datenstruktur und Art der Speicherung von Daten geschieht in zwei
vollkommen
unterschiedlichen
Schemata.
Bei
einem
relationalen
Datenbanksystem werden die Daten in Relationen eingeteilt, die im Prinzip
dieselbe Form wie normale Tabellen haben. Bei XML wird ein Schema, ähnlich
einem Inhaltsverzeichnis eines Buches verwendet
1.3.1 Relationales Schema
Heute sind Datenbanken mit relationalen Schemata als Datengrundlage am
meisten verbreitet. Das bedeutet, dass Strukturen und Daten durch Relationen
dargestellt werden, die tabellarisch aufgebaut sind (siehe Abbildung 1).
Das hat natürlich Vor- und Nachteile. Wenn eine komplexe Struktur als Relation
abgebildet werden soll, ist es unter Umständen notwendig, mehrere Tabellen
miteinander über Indizes zu verbinden. Dieser Join wird meist sehr schnell sehr
speicheraufwändig, was zu hohem Datentransfer und damit zu langen
Ausführungszeiten führen kann.
Query Rewriting
28.05.2001
XML-Datenbanken Hauptseminar Informatik im SS01
Seite 4
Außerdem ist das hinzufügen von Attributen zu Relationen immer mit einigem
Aufwand verbunden. Des Weiteren kann durch diese Speicherhart dazu kommen,
dass sehr viele NULL Werte mit abgespeichert werden müssen, wenn zum
Beispiel nicht für alle Attribute konkrete Werte zur Verfügung stehen.
ID Attribut 1 Attribut 2 Attribut 3 Attribut 3 Attribut 4
1
Wert 1
Wert 2
Wert3
…
2
…
…
…
3
…
…
4
…
…
Abbildung 1: Relationales Schema
1.3.2 XML DTD bzw. XML Schema
Die Struktur von XML ist hierarchisch gegliedert, das heißt, sie ist der eines
Buches mit einem Inhaltsverzeichnis sehr ähnlich. Dieses Inhaltsverzeichnis hat
Ober- und Unterpunkte (siehe Abbildung 2). Aus diesem Grund ist es einfacher
Attribute hinzuzufügen, da dies nur für den speziellen Fall geschehen kann.
XPath
Paper
Paper/Title
Paper/Authors[1]
Paper/Authors[1]/FN
Paper/Authors[1]/LN
Paper/Authors[1]/Affiliation
Paper/Authors[2]
Paper/Authors[2]/FN
Paper/Authors[2]/LN
Paper/Authors[2]/Affiliation
Paper/Keywords[1]
Paper/Abstract
Paper/Text
Paper/BibRec[1]
Paper/BibRec[1]/Authors[1]
Paper/BibRec[1]/Authors[2]
Paper/BibRec[1]/Title
Abbildung 2: XML Schema
Außerdem muß nicht immer die komplette Struktur gefüllt werden. Anders, als bei
Relationen, können dann Teile der Struktur einfach ausgelassen werden. Das hat
den Vorteil, dass keine NULL Werte gespeichert werden müssen.
Query Rewriting
28.05.2001
XML-Datenbanken Hauptseminar Informatik im SS01
Seite 5
2 Einführung des Beispiels zur Veranschaulichung
Zur Veranschaulichung der Queries soll folgendes Beispiel beitragen:
Verwaltung einer Bibliothek. Es gibt Bücher mit Titel, Autor(en), Schlüsselworten,
dem eigentlichen Text und Literaturverzeichnis. Die Gliederung erfolgt, wie in
Abbildung 3 beschrieben. Jedes Attribut, dass mit einem * gekennzeichnet ist, wie
zu Beispiel Authors, kann beliebig oft vorkommen und wird zur Adressierung mit
Authors[n] angesprochen, wobei n = 0, 1, 2, ... sein kann
Paper
Title
Authors *
FN
LN
Affiliation
Keywords *
Abstract
Text
BibRec *
Authors*
Title
Abbildung 3: Beispiel „Bibliotheksverwaltung“
Die Datengrundlage für dieses Beispiel ist ein relationales Datenbanksystem und
einige Views über diesem System. Durch Mechanismen werden die Views
genauer beschrieben, so dass eine Abbildung der Daten möglich wird.
Im Folgenden wird außerdem angenommen, dass Views über XML-Rel und XMLTriple vorhanden ist, auf die zugegriffen werden kann. Die genaue Struktur von
XML-Rel und eines XML-Triples wird im folgenden Kapitel 3 näher erläutert.
Interessant ist hierbei, dass beim XML-Triple ein Join der Type-Dim Tabelle mit
der XML-Index Tabelle notwendig ist, damit der Index richtig mit den Werten
verbunden werden kann.
DEFINE VIEW XML-Triple AS
SELECT Did, Attr-Path, Value
FROM Type-Dim T, XML-Ind X
WHERE T.Surrogate = X.Surrogate
Abbildung 4: XML-Triple als View
Query Rewriting
28.05.2001
XML-Datenbanken Hauptseminar Informatik im SS01
Seite 6
3 Unterschiedliche Darstellungsformen
Um Daten im XML-Schema darstellen zu können, gibt es verschiedene
Darstellungsformen. Im Weiteren werden zwei Formen vorkommen, XML-Rel und
XML-Triple
3.1 XML-Rel mit Pfad als Attribut
Die einfachste Form der Darstellung einer XML-Relation ist die Tupelform. Hierbei
werden immer Wertepaare gebildet, die einerseits aus dem Pfad, in der Abbildung
in XPath-Notation, und andererseits aus dem jeweiligen Wert bestehen.
Paper
Paper/Title
Paper/Authors[1]
Paper/Authors[1]/FN
Paper/Authors[1]/LN
Paper/Authors[1]/Affiliation
Paper/Authors[2]
Paper/Authors[2]/FN
Paper/Authors[2]/LN
Paper/Authors[2]/Affiliation
Paper/Keywords[1]
Paper/Abstract
Paper/Text
...
MISTRAL
Rudolf
Bayer
TU
Volker
Markl
FORWISS
UB-Tree
some text
more text
Abbildung 5: XML-Rel mit Pfad als Attribut
Diese Form ist sehr einfach und man kann dadurch schnell an die Daten
gelangen. Allerdings geht die Reihenfolge der einzelnen Elemente und Attribute
verloren. Das liegt daran, dass kein Index erzeugt wird (zum Beispiel mit
fortlaufenden Integerwerten). Wenn also die Reihenfolge eines Dokuments
wichtig ist, dann kann diese Form nicht verwendet werden.
3.2 XML-Triple
Eine weitere Form der Darstellung ist XML-Triple. Die Tripleform kann mit
unterschiedlichen Attributen dargestellt werden:
• Relation XML-Triple mit Pfad (siehe Abbildung 6)
•
Erweitertes XML-Triple mit Surrogaten ohne DokumentID
(siehe Abbildung 7)
Bei XML-Triple wird zusätzlich zu den Attributpfaden und den Werten noch eine
DocumentID als Index mit gespeichert. Diese Did liegt in Form von Surrogaten
vor. Surrogate, siehe Abbildung 7, dienen dazu, eine eindeutige Reihenfolge der
Elemente zu gewähren. Außerdem kann man bei großen Datenbanken eine
Query Rewriting
28.05.2001
Seite 7
XML-Datenbanken Hauptseminar Informatik im SS01
effizientere Art der Speicherung realisieren. So können zum Beispiel die Daten zu
2.1 oder 2.2 auf demselben Laufwerk abgespeichert werden, so dass bei
Anfragen über die Autoren nur eine Festplatte angesprochen werden muß und
somit der Addressraum klein bleibt.
DokumentID Attribut-Pfad
Did
Did
Did
Did
Did
Did
Did
Did
Did
Did
Did
Did
Did
...
Wert
Paper
Paper/Title
Paper/Authors[1]
Paper/Authors[1]/FN
Paper/Authors[1]/LN
Paper/Authors[1]/Affiliation
Paper/Authors[2]
Paper/Authors[2]/FN
Paper/Authors[2]/LN
Paper/Authors[2]/Affiliation
Paper/Keywords[1]
Paper/Abstract
Paper/Text
MISTRAL
Rudolf
Bayer
TU
Volker
Markl
FORWISS
UB-Tree
some text
more text
Abbildung 6: XML-Triple mit Did
Allerdings hat diese Form auch Nachteile. So ist zum Beispiel der
Verwaltungsaufwand, um an die Daten zu gelangen, wesentlich höher, als bei
XML-Rel. Einfach deshalb, weil verschiedene Zwischenschritte notwendig sind,
um die Ausgabedaten entsprechend zu formatieren.
Surrogate
1
2.1
2.1.1
2.1.2
2.1.3
2.2
2.2.1
2.2.2
2.2.3
3.1
4
5
...
Attribut-Pfad
Wert
Paper
Paper/Title
Paper/Authors[1]
Paper/Authors[1]/FN
Paper/Authors[1]/LN
Paper/Authors[1]/Affiliation
Paper/Authors[2]
Paper/Authors[2]/FN
Paper/Authors[2]/LN
Paper/Authors[2]/Affiliation
Paper/Keywords[1]
Paper/Abstract
Paper/Text
MISTRAL
Rudolf
Bayer
TU
Volker
Markl
FORWISS
UB-Tree
some text
more text
Abbildung 7: XML-Triple mit Surrogate
Query Rewriting
28.05.2001
Seite 8
XML-Datenbanken Hauptseminar Informatik im SS01
4 Übersetzung einer XML-Anfrage
4.1 Allgemeine Funktionsweise
Um von einer Anfrage an ein XML-Datenbanksystem zum Ergebniswert zu
gelangen, müssen zahlreiche Zwischenschritte durchlaufen werden. In Abbildung
8 wird dieser Weg beschrieben.
User Interface (XML und XQuery)
Eingabequery
Rewriting
Regeln
Normalisierungsmodul
XML Ergebnis
Normalisierte XQuery
Abfrage
Übersetzungs
regeln
Relationale
View
Definition
Übersetzungsmodul
(Quilt SQL)
Tagger
SQL / virtuelles Schema
Ergebnis Tupel
SQL Query Rewriting
SQL / relationales Schema
SQL Query Optimierung und Ausführung
Abbildung 8: Flussdiagramm
Die Anfrage wird in einem User Interface eingegeben oder abgesetzt, von dort
aus wird eine Normalisierung der Anfrage durchgeführt. Diese Normalisierung ist
notwendig, damit eine Übersetzung in SQL möglich wird. Die eigentliche
Übersetzung in SQL geschieht dann im nächsten Schritt. An dieser Stelle wird
auch die Datensicht gewechselt. Das Übersetzungsmodul arbeitet auf dem
virtuellen Schema des Views. Anschleißend, beim eigentlichen SQL Query
Rewriting, wird die SQL-Anfrage so umgeschrieben, dass auf eine relationale
Datenbasis zugegriffen werden kann. Anschließend wird die so optimierte
Anfrage über dem relationalen Schema ausgeführt und die Ergebnistupel an den
Tagger übergeben. Der Tagger formatiert das Ergebnis entsprechen der XML
Anforderungen. Dabei erhält der Tagger vom Übersetzungsmodul (Quilt SQL)
Informationen über das Format. Im letzten Schritt kann dann das so formatierte
Ergebnis an das User Interface zurückgegeben werden.
Query Rewriting
28.05.2001
XML-Datenbanken Hauptseminar Informatik im SS01
Seite 9
Der Hintergrund, warum dieser hohe Aufwand notwendig ist, um eine Anfrage in
XML zu stellen liegt daran, dass man Anfragen oder Queries nur auf relationalen
Datenstrukturen vernünftig ausführen kann. Da die Daten bei XML aber nicht
einheitlich beziehungsweise nur teilweise in relationalen Schemata vorliegen,
muß diese Datenstruktur erst geschaffen werden.
Um Anfragen über diese Daten ausführen zu können, muß zweimal ein Query
Rewriting erfolgen, einmal, um eine SQL-Anfrage nach der Normalisierung
formulieren zu können und dann noch, um beim Ausführen dieser Anfrage die
Daten zurückgeben zu können.
4.2 Funktionsweise des Normalisierungsmoduls
Meist werden Anfragen von einem XML User Interface in Form von Quilt gestellt,
da diese Sprache umfangreiche Möglichkeiten zur Verfügung stellt, um Daten
zum Beispiel zu selektieren oder zu gruppieren. Für eine Beschreibung von Quilt
siehe dazu Ausarbeitung zu Vortrag 3 „XML-Anfragesprachen“.
FOR $a IN E1
LET y = E2($a)
FOR $b IN E3($a,y)
WHERE C($a, y, $b)
RETURN R($a, y, $b)
Abbildung 9: Beispiel einer Quilt-Anfrage
Um einen Quilt Ausdruck in SQL übersetzen zu können, ist meist eine
Normalisierung notwendig. Dabei lassen sich Quilt Anfragen in drei Gruppen
einteilen:
4.2.1 Direkt übersetzbare Anfragen
Bei dieser Art ist keine Normalisierung notwendig. Das sind einfache Anfragen,
bei denen die Pfadangaben direkt ab dem Dokument angegeben werden, oder
logische oder arithmetische Operationen über demselben Datentyp ausgeführt
werden. Dieser Typ kann direkt in eine SQL-Anfrage übersetzt werden.
4.2.2 Nichtübersetzbare Anfragen
Hierbei handelt es sich um Quilt Anfragen, bei denen die innere Logik oder die
Semantik zu verschieden ist, um übersetzt werden zu können. Als Beispiel, in
Quilt gibt es Scalarkonstanten. In SQL gibt es keine Möglichkeit, diese
Konstanten
ausdrücken
zu
können.
Query Rewriting
28.05.2001
Seite 10
XML-Datenbanken Hauptseminar Informatik im SS01
4.2.3 Anfragen, bei denen eine Normalisierung notwendig ist
Das sind alle übrigen Anfragen. Normalisierung heißt in dem Zusammenhang,
dass ein Algorithmus die Quilt Anfrage durchparst und entsprechend
umformatiert, so dass eine Transformation in SQL ermöglicht wird. Dies geschieht
in mehreren Schritten:
• Eliminierung von temporären Variablen und nichtrekursiven
Funktionen
Bei diesem ersten Schritt wird versucht, alle temporären Variablen zu
entfernen. Im Beispiel heißt das, dass die LET Bedingung ersetzt wird.
Außerdem werden alle temporären Variablen, in diesem Fall das y ersetzt.
(Siehe Abbildung 10)
FOR $a IN E1
LET y = E2($a)
FOR $b IN E3($a,y)
WHERE C($a, y, $b)
RETURN R($a, y, $b)
FOR $a IN E1,
$b IN E3($a, E2($a))
WHERE C($a, E2($a), $b)
RETURN R($a, E2($a), $b)
Abbildung 10: Eliminierung temporärer Variablen
•
Auflösen verschachtelter Ausdrücke auf Basis von FLWR
Ausdrücken
Mit der abfragesprache Quilt ist es möglich Anfragen zu erstellen, die
wiederum aus einer Anfrage bestehen. Diese verschachtelten Anfragen
müssen bei der Normalisierung umgewandelt werden. (FLWR meint For,
Let, Where, Return)
E1( FOR $a IN E2,
WHERE C($a)
RETURN E3($a))
FOR $a IN E2,
WHERE C($a)
RETURN E1(E3($a))
FOR $a IN E2,
WHERE C($a)
RETURN E1(E3($a))/nameTest
FOR $a IN E2,
WHERE C($a)
RETURN E3($a) /nameTest
Abbildung 11: Auflösen verschachtelter Ausdrücke
•
Elementarkonstruktoren herstellen (in Pfad oder FLWR)
Wenn Pfadausdrücke in der Anfrage vorkommen, dann müssen diese
Ausdrücke so umgeschrieben werden, dass Elementkonstruktoren die
selbe Funktionalität übernehmen.
Query Rewriting
28.05.2001
Seite 11
XML-Datenbanken Hauptseminar Informatik im SS01
(<tag>
E($a)
</tag>)//nameTest
(<tag>
E($a)
</tag>)//nameTest
IF tag = nameTest
THEN (<tag> E($a) </tag>
ELSE E($a)//nameTest
FOR $a IN E($a)
WHERE name($b) = nameTest
RETURN $b
Abbildung 12: Elementarkonstruktoren herstellen
•
Umwandlung von FLWR Ausdrücken im FOR- oder RETURN
Ausdruck
Wenn im FOR oder RETURN-Ausdruck Verschachtelungen durch FLWR
Ausdrücke vorhanden sind, dann müssen diese aufgelöst werden. (Siehe
Abbildung 12)
FOR $a IN E1
WHERE (IF C1 ($a)
THEN E2($a)
ELSE E3($a))
RETURN E4($a)
FOR $a IN E1
WHERE (C1($a) AND
E2($a)) OR
( C1($a) AND
E3($a))
RETURN E4($a)
Abbildung 13: Umwandlung von FLWR Ausdrücken im FOR- oder RETURN
Ausdruck
•
Eliminierung von einschränkenden Ausdrücken
Abbildung 14 zeigt, wie einschränkende Ausdrücke im WHERE, RETURN
oder FOR Teil aufgelöst werden müssen. Dabei ist darauf zu achten, dass
die Reihenfolge der Ausgabe entsprechend angepasst wird, damit das
Ergebnis richtig weiterverarbeitet werden kann.
FOR $a IN E1
WHERE (IF C1 ($a)
THEN E2($a)
ELSE E3($a))
RETURN E4($a)
FOR $a IN E1
WHERE (C1($a) AND
E2($a)) OR
( C1($a) AND
E3($a))
RETURN E4($a)
¬
Abbildung 14: Eliminierung von einschränkenden Ausdrücken
Query Rewriting
28.05.2001
Seite 12
XML-Datenbanken Hauptseminar Informatik im SS01
•
Übersetzung von Prädikatausdrücken in FLWR
In diesem Schritt wird eine einfache semantische Umformung
durchgeführt. Wenn E2 eine Prädikateinschränkung von E1 darstellt, dann
kann dies durch eine Einschränkung mit WHERE ersetzt werden. Bei
einem Pfadprädikat in der FOR-Klausel kann dies durch eine Umformung
in der WHERE-Klausel erreicht werden.
E1[E2]
FOR $a IN
E1[E2]/PathExpr.
WHERE C($a)
RETURN R($a)
FOR $a IN E1
WHERE E2($a)
RETURN $a
FOR $b IN E1, $a IN
$b[E2]/PathExpr
WHERE C($a) AND
E2($b)
RETURN R($a)
Abbildung 15: Übersetzung von Prädikatausdrücken in FLWR
4.3 Funktionsweise des Übersetzungsmodul (Quilt zu SQL)
Die nun vorliegende Quilt-Anfrage ist nun entweder normalisiert oder bereits von
Haus aus in entsprechender Form gewesen, so dass das Übersetzungsmodul
aus der Quilt-Anfrage eine SQL-Anfrage generieren kann. Wie schon in den
vorherigen Bearbeitungsschritten, muß diese Übersetzung in mehreren Schritten
erfolgen.
4.3.1 Übersetzen von Pfadausdrücken
Die erste Regel kann Pfadausdrücke zum Basisdokument übersetzen. Dabei muß
man zwei unterschiedliche Fälle betrachten, denn einerseits kann der Pfad ein
String sein oder das Ergebnis einer weiteren Anfrage. Aber in jedem Fall kann
daraus eine einzige Anfrage erstellt werden.
T(document(docName))=
SELECT d.docID
FROM Document d, URI u, Value v
WHERE d.docURIID = u.uriID AND
uriValID = v.valID AND
v.value = docName
SELECT d.docID
FROM Document d, URI u, Value v
WHERE d.docURIID = u.uriID AND
uriValID = v.valID AND
v.value = (T(E))
T(document(E))=
Abbildung 16: Übersetzen von Pfadausdrücken
Query Rewriting
28.05.2001
Seite 13
XML-Datenbanken Hauptseminar Informatik im SS01
Anhand dieses Beispiels lässt sich gut erkennen, dass im Prinzip diese Anfragen
identisch sind. Es unterscheiden sich nur die letzten Zeilen, je nachdem, ob es
sich um einen String oder das Ergebnis einer Anfrage handelt.
4.3.2 Übersetzen von FLWR Ausdrücken
Um eine Quilt-Anfrage korrekt übersetzen zu können, muß einem klar sein, was
die einzelnen Teile des FLWR-Ausdruckes bewirken. Der FOR-Teil definiert die
Ergebnistupel, der WHERE-Teil bestimmt einschränkende Kriterien näher und der
RETUN-Teil liefert die passenden Tupel zurück.
Im folgenden Beispiel wird allgemein die Umwandlung gezeigt.
T (FOR x1 IN E1,
X2 IN E2,...
Xn IN En
WHERE C(x1), C(c2),…C(xn)
RETURN x1, x2,…xn)=
SELECT S(E1), S(E2),…S(E3)
FROM F(E1), F(E2),…F(En)
WHERE W(E1) AND
W(E2) AND … W(En) AND
(T(C(x1, x2,…xn)))
Abbildung 17: Übersetzen von FLWR Ausdrücken
4.3.3 Übersetzen von heterogenen Typanfragen
Die Übersetzung der Anfragen kann leider nicht systematisch von Anfang bis zum
Ende erfolgen, da bei Anfragen unterschiedliche Datentypen beteiligt sein
können. So können zum Beispiel String- und Integerwerte abgefragt werden. In
solchen Fällen sind entweder Casts notwendig, die die Datentypen auf einen
reduzieren oder man muß für jeden Datentyp eine eigene Spalte vorsehen. Bei
der zweiten Methode muß dann der Tagger die entsprechenden Werte wieder
zusammensuchen.
4.3.4 Übersetzen von Funktionen und Funktionsaufrufen
Funktionen in XML-Anfragen lassen sich in drei Kategorien einteilen:
Standardfunktionen (zum Beispiel count, distinct), benutzerdefinierte Funktionen
und externe Funktionen.
Standartfunktionen können direkt übersetzt werden, da SQL diese Funktionalität
standardmäßig bereitstellt. Benutzerdefinierte Funktionen können einerseits
rekursive – andererseits nichtrekursive Ausdrücke sein. Bei rekursiven
Ausdrücken können diese direkt in SQL übersetzt werden. Nichtrekursive müssen
zuvor umgeformt werden. Zu beachten dabei ist, dass SQL nur bestimmte Arten
von Rekursionen unterstützt.
4.3.5 Übersetzen anderer Sprachkonstrukte
Zu dieser Gruppe zählen alle anderen Funktionen, die einfach zu übersetzen
sind, zum Beispiel logische Operationen, Quantifizierer oder Textoperationen
Außerdem gibt es noch eine weiter Gruppe, die eine Sonderbehandlung
benötigen. Das sind Sortierungen, Identitätsoperationen oder XML spezifische
Query Rewriting
28.05.2001
XML-Datenbanken Hauptseminar Informatik im SS01
Seite 14
Funktionen. Dann gibt es noch eine Gruppe mit problematischen Funktionen, wie
zum Beispiel Konstanten, Metadatenanfragen oder Laufzeitzugriff auf Typen.
4.4 SQL Query Rewriting
Wenn nun alle zuvor bescheidenen Schritte der Normalisierung und Übersetzung
der Quilt Anfrage zu einer SQL Anfrage durchgeführt wurden, dann kann man
diese SQL Anfrage ausführen, um Ergebnistupel zu erhalten.
Um eine SQL Anfrage über dem relationalen Schema einer XML Datenbank
ausführen zu können, muß zuerst ein Query Rewriting durchgeführt werden.
Dabei wird über die relationale View-Definition eine Anfrage gestartet. Da es aber
verschiedene Möglichkeiten der Darstellung einer XML-Relation gibt, kann dies
auf verschiedene Arten geschehen. Im Allgemeinen werden aber 3 Schritte
durchlaufen:
• Abfragen des XML-Schemas
Hierbei wird die Indexstruktur durchlaufen, um alle notwendigen
Indexeinträge zu finden, die für die Ausführung der SQL-Anfrage
notwendig sind.
•
Generierung der Anfrage auf dem Index aus Schritt 1
Im nun folgenden Schritt wird eine Anfrage generiert, die auf dem Index
aus Schritt 1 aufbaut.
•
Ausführen der Anfrage aus Schritt 2
4.4.1 Angewendet auf eine XML-Relation
Mit der folgenden SQL-Abfrage sollen die Titel aller Paper ausgegeben werden,
an denen als erster Autor Herr Bayer geschrieben hat.
SELECT Paper/Title
FROM XML-REL
WHERE Paper/Author[1]/LN = ‘Bayer’
Abbildung 18: SQL Beispiel
Diese Anfrage wird in zwei Teile zerlegt. Einerseits wird im Index gesucht, dass
alle notwendigen Attribute zusammengestellt werden können (Schritt 1). Im
Beispiel bedeutet das, dass aus den XML-Triple alle Einträge mit dem Pfad
’Paper/Author[1]/LN’ , die den Wert ’Bayer’ haben gesucht werden.
SELECT Did INTO Did-Set
FROM XML-Triple
WHERE Paper/Authors[1]/LN = ‘Bayer’
Abbildung 19: Erste Anfrage über XML-Triple
Query Rewriting
28.05.2001
XML-Datenbanken Hauptseminar Informatik im SS01
Seite 15
Die zweite Abfrage erstellt, aufbauend auf der ersten Abfrage, eine Verknüpfung
zwischen dem Index und den eigentlichen Werten. Dabei werden alle Did-Set
Einträge der ersten Abfrage durchsucht und der ’Paper/Title’ Wert als Ergebnis
zurückgegeben (Schritt 2).
SELECT Value
FROM XML-Rel
WHERE Attr-Path = ’Paper/Title’ AND
Did IN Did-Set
Abbildung 20: Zweite Anfrage über XML-Triple
Anschließend werden diese beiden Anfrage ausgeführt, um die Ergebnistupel zu
erhalten (Schritt 3).
4.4.2 Angewendet auf einen Join
SELECT Paper/Title
FROM XML-REL
WHERE Paper/Author[1]/LN = ‘Bayer’
Abbildung 21: SQL Beispiel
Das vorherige Beispiel lässt sich auch mit einem Join zusammenfassen. Dadurch
kann man sich eine Abfrage sparen und erhält folgenden Ausdruck
SELECT t2.Value
FROM XML-Triple t1, XML-Triple t2
WHERE (t1.Attr-Path = Paper/Authors[1]/LN AND
t1.Value = ’Bayer’ AND
t1.Did = t2.Did AND
t2.Attr-Path = ‘Paper/Title’
Abbildung 22: Rewriting Ergebnis mit Join
Man benötigt dazu einen Join der XML-Triple mit sich selber. Das Ergebnis wird
dadurch nicht beeinflusst.
An diesem Beispiel sieht man sehr schön, wie ein Self-Join einer Tabelle
aussieht.
T1.Did = t2.Did
Dieser Join kann so verstanden werden, dass innerhalb der Datensätze immer zu
einem passenden Wertepaar gesprungen wird, so dass das geforderte Kriterium
erfüllt wird.
Query Rewriting
28.05.2001
Seite 16
XML-Datenbanken Hauptseminar Informatik im SS01
4.4.3 Umwandlung von XML-Rel mit Join zu XML-Triple
Für eine Umwandlung von XML-Rel zu XML-Triple gibt es einfache
Gesetzmäßigkeiten. So wird zum Beispiel ein XPath Ausdruck ersetzt durch
Value und dem entsprechenden Wert mit Attr-Path = „“ in der WHERE Klausel.
Ebenso kann man eine Zuweisung XPath Attribut = const durch Value = const
ersetzen.Außerdem müssen alle Instanzen eines XML-Tripel Ausdruckes mit
einem Join über die DocumentId miteinander verbunden werden.
SELECT Api, APj
FROM XML-REL WHERE APk= c1 AND APl = c2
Abbildung 23: SQL Anfrage
Im Beispiel sind vier Attribute beteiligt, APi, APj, APk und APl. Das führt zu vier
Tupelvariablen T1, T2, T3 und T4, sowie einem 3-teiligen Join über die vier
Instanzen von XML-Triple mit der DocumentId Did.
SELECT T3.Value, T4.Value
FROM XML-Triple T1, XML-Triple T2, XML-Triple T3, XML-Triple T1
WHERE T1.Attr-Path = ‘APk‘ AND T1.Value = c1 AND
T2.Attr-Path = ‘APl‘ AND T2.Value = c2 AND
T3.Attr-Path = ‘APi‘ AND
T4.Attr-Path = ‘APj‘ AND
T1.Did = T2.Did AND
T2.Did = T3.Did AND
T3.Did = T4.Did
Abbildung 24: Rewriting Ergebnis mit Join
4.5 Zusatzfunktionalität
XML bietet aber nicht nur diese Standardanfragen, die auch in SQL implementiert
sind, sondern auch noch einige Zusätze, die sehr komfortable Möglichkeiten zur
Verfügung stellen.
So kann man zum Beispiel Platzhalter in der Surrogate einfügen, so dass innerhalb
eines kompletten Dokuments nach einem bestimmten Wert gesucht werden kann
oder eine Volltextsuche über ein XML-Dokument mit Hilfe des Myriad Schemas
realisieren.
Bei diesem Schema wird, zusätzlich zu den Ergebnistupeln, immer noch die
genaue Position innerhalb des Dokuments mit erstellt. Somit kann man bestimmen,
wie oft ein Wert vor oder nach einem anderen vorkommt.
Query Rewriting
28.05.2001
XML-Datenbanken Hauptseminar Informatik im SS01
Seite 17
4.5.1 Myriad Schema mit MHC-Surrogate
Als Beispiel dient eine Anfrage nach den Titeln der Artikel, an denen Herr Bayer als
Autor beteiligt ist. Dabei interessiert nicht nur, ob der Name bei den Autoren
auftaucht, sondern auch, ob im Literaturverzeichnis eines Artikels ein Verweis auf
den Namen vorhanden ist.
SELECT Paper/Title
FROM XML-Rel
WHERE //Author/LN = ‘Bayer‘
Abbildung 25: SQL Anfrage mit Platzhalter
Wenn man nun herausbekommen will, an welcher Stelle diese Artikel stehen, dann
kann man dies mit folgendem Rewriting realisieren
SELECT Did
FROM XML-Ind
WHERE Value=‘Bayer‘ AND Surrogate IN
(SELECT X1.MHC FROM Xmy X1, Xmy X2
WHERE X1.ElAtt = ‘Authors‘ AND
X2.ElAtt = ‚LN‘ AND
X1.Pos < X2.Pos AND
X1.MHC = X2.MHC)
Abbildung 26: Rewriting Ergebnis aus Myriad-Schema
Um diese Funktionalität nutzen zu können, benötiget man MHC Codes. Das sind
Systemkomponenten, die eine Ebene tiefer im System zu finden sind, als die
XPatterns. Diese Codes ermöglichen den direkten Vergleich einzelner Ausdrücke.
Außerdem muß die Anfrage verschachtelt werden, damit alle Pfade mit dem
Namen „Author/LN“ durchsucht werden können.
Für eine Suche im Myriad Schema sind drei Attribute notwendig:
• das SearchPattern SP
• das SearchValue SV
• das ResultPattern RP
Begonnen wird, anhand des SearchPatterns, den Index zu erstellen. Als nächstes
wird, zusammen mit SearchIndex und SearchValue, die DocumentId erstellt.
Auch für das ResultPattern wird ein MHC-Index erstellt. Dieser wird zusammen
mit der DocumentId zum ResultValue zusammengefasst. Zusätzlich zu diesem
diesem wird mit dem MHC-Index des ResultPatterns noch der ResultPath erstellt.
Im letzten Schritt wird dann noch aus ResultRalue und ResultPath das
Anfrageergebnis generiert. (Siehe Abbildung 27)
Query Rewriting
28.05.2001
Seite 18
XML-Datenbanken Hauptseminar Informatik im SS01
SP
RP
MHC(SP)
SV
MHC(RP)
SDid
RPath
RV
Anfrage Ergebnis
Abbildung 27: Ablaufschema der Myriad-Anfrage
Query Rewriting
28.05.2001
XML-Datenbanken Hauptseminar Informatik im SS01
Seite 19
5 Fazit
Jede XML-Datenbank nutzt eine Art von Query Rewriting, da die Datenstruktur
von XML nicht einheitlich ist. Dabei wendet jeder Datenbankhersteller seine
eigene Methode an, um Indexstrukturen und Daten abzubilden und zu speichern.
Somit ist auch kein einheitlicher Synthesealgorithmus anzugeben, der diese
Funktionalität im Allgemeinen erfüllt. Diese Ausarbeitung soll nur einen Einblick in
die generelle Funktionsweise liefern und ist deshalb auch nicht speziell auf eine
Datenbanklösung zugeschnitten.
Es stellt sich auch die Frage, warum man diesen Aufwand in Kauf nimmt, um eine
Anfrage an ein Datenbanksystem zu stellen. Darauf könnte man antworten, dass
jedes System seine Vor- und Nachteile hat. So auch XML basierende Systeme.
Aber mit diesem hier vorgestellten Verfahren lassen sich die Vorteile von XML
Systemen mit Quilt Anfragen mit den Vorteilen relationaler Systeme verbinden.
So ist es möglich eine Anwendung zu erstellen, die ihre Daten mit
unterschiedlichen anderen Komponenten austauschen kann, aber trotzdem
komfortabel zu bedienen bleibt.
XML ist noch eine recht junge Sprache und es bleibt abzuwarten, wie weit
Schnittstellen zu anderen Systemen und Sprachen geschaffen werden, so dass
der Datenaustausch kein Problem mehr darstellt.
Query Rewriting
28.05.2001
XML-Datenbanken Hauptseminar Informatik im SS01
Seite 20
6 Literaturverzeichnis:
•
Folienskript: Kap. 8.3 „XML-Models and Indexing“, Vorlesung Prof. R.
Bayer, TUM, 29.12.2000, version 8
•
Vortragsfolien: „Query Languages for XML“, Don Chamberlin, IBM
Almaden Research Center, 26.10.2000
•
“Pushing XML Queries inside Relational Databases”, Ioana Manolescu,
Daniela Florescu, Donald Kossmann, Januar 2001
•
“Query Rewriting for Semistructured Data”, Yannis Papakonstantinou,
Vasilis Vassalos
Query Rewriting
28.05.2001