VL 9: Kombination von XQuery und SQL

XML-Dokumente in
objektrelationalen
Datenbanksystemen
Meike Klettke
Universität Rostock
[email protected]
www.xml-und-datenbanken.de
1
Ein Titel ... und ein Untertitel
XML-Dokumente in objektrelationalen
Datenbanksystemen –
Möglichkeiten in DB2 und Oracle,
Kombination von XQuery und SQL,
hybride Speicherung
Motivation
 XML als Format zur Dokumentdarstellung existiert
seit 10 Jahren




als Schlagwort sehr populär (gewesen)
mittlerweile gibt es viele Anwendungen, die XML-Dokumente
erzeugen oder verwenden
häufig ist eine dauerhafte Speicherung notwendig
Datenbanksysteme wurde erweitert, um XML-Dokumente
verarbeiten zu können
... in der Vorlesung heute ...
Erweiterungen von Datenbankmanagementsystemen, um XMLDokumente zu speichern, anzufragen und zu verändern, dazu
1.
Realisierung in objekt-relationalen Datenbanksystemen
1.
2.
3.
2.
Speicherung
Anfragen in DB2 und Oracle
Updates und Schemaevolution
Einsatz und Verwendung dieser Speicherungsvarianten
Hybride Ansätze
nachricht:
<nachricht id="ID0001" bedeutung="4">
<autor autor_id="A0001">
<nachname>Fürst</nachname>
<vorname>Christian</vorname>
<agentur>dpa</agentur>
<e-mail>[email protected]</e-mail>
</autor>
<einordnung>
<rubrik>Mozartjahr 2006</rubrik>
…
<inhalt>
<ueberschrift>Ein Vermarktungsfest
</ueberschrift>
<text>Als Wolfgang Amadeus Mozart im
Alter von 35 Jahren starb, ..
</text>
</inhalt>
</nachricht>
id
bedeutung
autor
inhalt
ID0001
4
A0001
P0001
autor:
ID
autor_id
nachname
Vorname
x00001
A0001
Fürst
Christian
<inhalt>
<ueberschrift>Ein Vermarktungsfest
</ueberschrift>
<text>Als Wolfgang Amadeus Mozart im
Alter von 35 Jahren starb, ..
</text>
</inhalt>
 für daten- als auch dokumentzentrierte Anteile
 Auswahl unterschiedlicher Speicherungsmethoden für verschiedene
Dokumentanteile
...
3) Realisierung in
objektrelationalen Datenbanken
 verschiedene Speicherungsmöglichkeiten werden
unterstützt:
 Speicherungsmöglichkeiten bei Oracle:
 DB2:
Abbildung nach Ulrike Schwinn,
Oracle
Realisierung in objektrelationalen
Datenbanken
Abbildung: DB2,
aus einem Artikel
von Holger Seubert
3.1) Verwenden des XML-Typs
 XML als nativer Datentyp, kann einzelnen Attributen
zugeordnet sein
 Beispiel:
create table nachricht
( id integer not null primary key,
titel varchar(30) not null,
autor varchar(30) not null,
datum date,
agentur varchar(10),
text xml,
kontext xml );
 also hybride Speicherung
Werte einfügen
insert into nachricht values(1, 'Ein Vermarktungsfest',
'Christian Fürst', '2006-12-12', 'dpa', '<text>Als Wolfgang
Amadeus Mozart im Alter von 35 Jahren starb, war er
bettelarm. Jetzt, zu seinem 250. Geburtstag, zeigen
insbesondere österreichische PR-Experten, wie man mit dem
Namen des Salzburger Genies Millionen machen kann...
</text>',
'<einordnung>
<ort>
<land>Österreich</land>
<stadt>Salzburg</stadt>
<stadt>Wien</stadt>
</ort>
<zeit> ... </zeit>
<rubrik>Festakte</rubrik>
<kategorie>Mozart</kategorie>
<kategorie>Musik</kategorie>
<kategorie>Kultur</kategorie>
</einordnung>');
es erfolgt: Test auf Wohlgeformtheit
Gültigkeitstest beim Einfügen von
Werten
Test auf Gültigkeit ist möglich:
 dazu Schemazuordnung
REGISTER XMLSCHEMA
http://www.informatik.uni-rostock/~meike/testschema_text.xsd
FROM /users/db01/meike/public_html/testschema_text.xsd
AS text_schema COMPLETE;
insert into nachricht values(1, 'Ein Vermarktungsfest',
'Christian Fürst', '2006-12-12', 'dpa', XMLVALIDATE (
XMLPARSE(document '<text>Als Wolfgang Amadeus Mozart im
Alter von 35 Jahren starb, war er bettelarm. Jetzt, zu
seinem 250. Geburtstag, zeigen insbesondere österreichische
PR-Experten, wie man mit dem Namen des Salzburger Genies
Millionen machen kann... </text>' )
ACCORDING TO XMLSCHEMA ID text_schema)), ...
);
3.2) Anfragen
 Anfragesprache für relationale: SQL
 Anfragesprache für XML-Dokumente: XQuery
 Anfragemöglichkeiten (Kombination dieser Anfragen):




SQL
SQL mit eingebettetem XQuery
XQuery
XQuery mit eingebettetem SQL
 Verwendung von build-in-functions zum Zugriff auf
die XML-Anteile bzw. SQL-Anteile
 Zugriff auf die XML-Anteile über build-in-functions
innerhalb von SQL-Anweisungen
 Dazu verfügbare build-in-functions (für die Einbettung
von XQuery in SQL):




xmlquery
xmlexists
xmltable
...
 Ergebnis der build-in-functions:




Relation (xmltable) oder
Wert (contains, xmlexists, xmlquery)
XML-Element (XMLELEMENT)
XML-Attribut (XMLATTRIBUTE)
Relationale Anfragen /1
select * from nachricht;
select titel, text from nachricht;
Liefert als Ergebnis:
TITEL
TEXT
-----------------------------------------------------------Ein Vermarktungsfest <text>Als Wolfgang Amadeus Mozart im
Alter von 35 Jahren starb, ... </text>
Mozartjahr eröffnet
<text>Mit einem Fest für Mozart haben
Salzburg und Wien am ... </text>
Relationale Anfragen /2
 In den Anfragen werden XML-Attribute nur als “Ganzes”
behandelt, das heißt vollständig ausgegeben oder vollständig in
Bedingungen verglichen
 Will man Bedingungen an die XML-Attribute formulieren, lässt
sich die Funktion contains einsetzen, Beispiel:
select titel
from nachricht
where contains(text, 'Mozart')=1;
 DB2 Net Search Extender muss dafür verfügbar sein,
 unterstützt werden:
 Schlüsselwortsuche,
 Stammwortsuche,
 fuzzy search in 37 Sprachen, ..
SQL mit eingebetteten XQueryAnfragen /1
select titel,
xmlquery(
'for $e in $i/einordnung/ort/stadt/text()
return $e' passing kontext as "i ")
as Ortsbezug
from nachricht;
 Ergebnis:
 TITEL
-------------------Ein Vermarktungsfest
ORTSBEZUG
------------------------------Salzburg Wien Augsburg
Mozartjahr eröffnet
Salzburg Wien Augsburg
SQL mit eingebetteten XQueryAnfragen /2
 Verwendet wird also eine Funktion xmlquery,


die als Eingabeparameter eine XQuery-Anfrage hat, weiterer
Parameter beschreibt die Belegung einer XQuery-Variablen
mit einem Datenbankattribut
Ergebnis der Funktion ist ein Wert (String), der als Attribut
ausgegeben wird
XQuery-Anfragen /1
xquery
for $e in db2-fn:xmlcolumn('NACHRICHT.KONTEXT')
where $e/einordnung/ort/stadt/text()="Wien"
return $e;
 Anmerkung:
Großschreibung der Bezeichnungen NACHRICHT und KONTEXT
notwendig, sonst werden Relation und Attribut nicht gefunden
XQuery-Anfragen /2
Ergebnis:
1
----------------------------------------------------------<einordnung><ort><land>Österreich</land><land>Deutschland</
land><stadt>Salzburg</stadt><stadt>Wien</stadt><stadt>Augsb
urg</stadt></ort><zeit><datum>2006-0127</datum></zeit><rubrik>Festakte</rubrik><kategorie>Mozart
</kategorie><kategorie>Musik</kategorie><kategorie>Kultur</
kategorie></einordnung>
<einordnung><ort><land>Österreich</land><land>Deutschland</
land><stadt>Salzburg</stadt><stadt>Wien</stadt><stadt>Augsb
urg</stadt></ort><zeit><datum>2006-0127</datum></zeit><rubrik>Festakte</rubrik><kategorie>Mozart
</kategorie><kategorie>Musik</kategorie><kategorie>Kultur</
kategorie></einordnung>
XQuery-Anfragen /3
xquery
for $e in db2-fn:xmlcolumn('NACHRICHT.KONTEXT')
where $e/einordnung/ort/stadt/text()="Wien"
return $e;
 Innerhalb dieser Anfrage ist eine Funktion zu sehen:
db2-fn:xmlcolumn,


Hat als Parameter die Angaben zu (Owner.)Relation.Attribut
Liefert den Inhalt des Attributes als Ergebnis, es muss ein
Attribut vom Typ XML sein
XQuery-Anfragen /4
Verwendung eines etwas komplexeren Beispiels mit Pfadausdrücken
xquery
for $e in
db2-fn:xmlcolumn('NACHRICHT.TEXT')[person/text()=
"Wolfgang Amadeus Mozart"]
return $e;
Ergebnis:
1
--------------------------------------------------<text>Jedes Jahr ist Mozartjahr. ... Aber nicht um
isoliertes, unreflektiertes Feiern des 250.
Geburtsjahres <person>Wolfgang Amadeus Mozart</person>
sollte und durfte es beim WIENER MOZARTJAHR 2006 gehen,
sondern um einen neuerlichen Versuch, sich dem „Wunder
Mozart“ (Goethe) von verschiedenen Seiten zu nähern und
gleichzeitig, mit seiner Hilfe, ... </text>
XQuery mit eingebetteten SQLAnfragen
 man kann auch Anfragen stellen,

die XQuery-Anfragen sind und
über build-in-functions auf relationale Anteile zugreifen

dazu jetzt ein Beispiel

XQuery mit eingebetteten SQLAnfragen
xquery for $n in db2-fn:sqlquery("select einordnung
from nachricht where agentur='dpa‘ ")
where $n[//land/stadt/text()="Wien"] return $n;
Ergebnis:
1
----------------------------------------------------<einordnung><ort><land>Österreich</land><land>Deutschland</
land><stadt>Salzburg</stadt><stadt>Wien</stadt><stadt>Augsb
urg</stadt></ort><zeit><datum>Freitag, 27. Januar
2006</datum><uhrzeit>String</uhrzeit><zeitzone>String</zeit
zone></zeit><rubrik>Festakte</rubrik><kategorie>Mozart</kat
egorie><kategorie>Musik</kategorie><kategorie>Kultur</kateg
orie></einordnung>
Auch möglich: Verwendung von XQuery
zur Anfrage relationaler Daten
xquery
for $x in db2-fn:sqlquery ("select XMLELEMENT(NAME
""headline"", XMLATTRIBUTES(id AS ""id""), titel)
from nachricht")
for $y in db2-fn:sqlquery ("select XMLELEMENT(NAME
""nachrichtenagentur"", XMLATTRIBUTES(id AS
""id""), agentur) from nachricht")
where (contains($x/text(), 'Mozart')) and
(contains($y/text(), 'spiegel')) and
($x/@id=$y/@id)
return <klassiknachricht>{$x} </klassiknachricht>;
Verwendung von XQuery zur
Anfrage relationaler Daten /2
Ergebnis:
1
---------------------------------------------<klassiknachricht><headline id="2">Mozartjahr
eröffnet</headline></klassiknachricht>
Verwendung von SQL
Verwendung:
 Zur Anfrage relationaler Attribute
 Soll XML-Attribut als Ganzes ausgegeben werden
und ist zur Suche auf den XML-Attributen
Volltextsuche ausreichend
 dann eignet sich diese Variante
Nicht realisierbar:
 Anfragen auf den XML-Attributen (XPath, XQuery)
Verwendung von SQL mit
eingebettetem XQuery
 Verwendung:



überwiegend relationale Daten und wenig XMLFunktionalität, die ergänzt werden muss
geeignet, wenn Anfragen gleichzeitig auf relationale Daten
und XML-Daten zugreifen
wenn Volltextsuchanfragen notwendig sind
 wenn Entwickler SQL bevorzugen
Verwendung von XQuery
Verwendung:
 reine XML-Anwendungen
 verfügbare XQuerys können mit nur geringen
Änderungen (db2-fn:xmlcolumn() statt collection() )
verwendet werden
 wenn das Ergebnis XML sein soll
 kann joins zwischen XML-Dokumenten ausdrücken
 bisher keinen Volltextunterstützung
 keine Verwendung von user-defined functions
Verwendung von XQuery mit
eingebettetem SQL
 effizient bei Verwendung auf XML-Daten,
 ineffizient, wenn relationale Daten und XML-Daten
zusammen ausgewertet werden
 Volltextsuche möglich (über contains)
 keine Joins zwischen relationalen Attributen und
XML-Attributen
Oracle: XML-Unterstützung /1
 XMLType statt XML
 Anfragen ebenfalls über Funktionen realisiert, andere
Bezeichnungen:



ExtractValue
extract
existsNode
 im Create Table kann einem XML-Attribut ein
Schema zugeordnet sein
Oracle: XML-Unterstützung /2
 Update von XML-Dokumenten ist hier möglich,
Funktionen dazu:





UpdateXML
insertChildXML
insertXMLbefore
appendChildXML
deleteXML
im Fall einer Schemazuordnung:
partielle Validierung
Umsetzung der Schemaevolution
bei Oracle
Oracle: Schemaevolution seit Version 10g:
 Speicherung der XML-Dokumente als CLOB:
Schemaevolution hat keine Auswirkungen, neue und
alte Dokumente werden in der gleichen Relation/ im
gleichen Attribut gespeichert
 Objektrelationale Speicherung: 2 Fälle:


Alte Struktur soll neben der neuen weiterexistieren =
Versionierung
 Anschließend existieren beide Speicherungsformen in
der DB (zum Beispiel in 2 Relationen)
Neue Struktur soll alte ersetzen
 Dokumente entladen, transformieren, neu laden
 in Oracle 10 automatisiert, Eingabeparameter: neues
Schema und XSL-Stylesheets
Schemaevolution in DB2
 neue Version des Schemas als neues Schema registrieren
 Bestimmen, welche Attribute mit dem alten Schema validiert wurden:
select xmlxsrobjectid(kontext) from nachricht where id=4;
1
-------------------11821949021857536
select objectname, schemaLocation from syscat.xsrobjects where
objectid=11821949021857536;
----------------------------------------------------------------------------------------------EINORDNUNG_SCHEMA3 http://www.informatik.uni-rostock/
/~meike/testschema_einordnung3.xsd
 Update dieser Dokumente und Revalidieren mit dem neuen Schema
Zusammenfassung
 Vorstellung der gegenwärtig vorhandenen Methoden
zur Speicherung und Anfrage von XML-Dokumenten
in DB2 und Oracle
 Schwerpunkt: verschiedene Varianten zur
Anfragerealisierung
 weiterhin gezeigt: XML-Dokumentvalidierung bei
Insert und Update
 offene Punkte im Bereich XML-Update und XMLSchema-Evolution
Systeme, hybrid
 Hybride Speicherungsverfahren werden durch
Datenbanksysteme unterstützt, die mehrere
Speicherungsmöglichkeiten für XML-Dokumente
anbieten.
 Oracle


Speicherung eines XMLType in relationalen Datenbanken
Anfragen realisierbar
 DB2



Speicherung von XML-Dokumenten als Attribut vom Typ
XML in relationalen Datenbanken
Anfragen realisierbar
Updates bisher nur Austausch der gesamten XMLDokumente
5) Verwendung dieser Methoden
 Verwendung von XML-Typen in Datenbanken
 Verwendung der Anfragevarianten
 Verwendung der Validierung
 Verwendung der Updatefunktionen
 XML-Schemaevolution
Literatur
 www.ibm.com
 Matthias Nicola, Fatma Ozcan: pureXML in DB2 9: Which way to
query your XML data?
http://www.ibm.com/developerworks/db2/library/techarticle/dm0606nicola/, Juni 2006
 Holger Seubert: XML-Indizierung, Update und SchemaVerwaltung mit DB2 9,
http://entwickler.de/zonen/portale/psecom,id,101,online,1037,p,0.h
tml
 www.oracle.com
 Ulrike Schwinn (Oracle): XML in der Oracle Datenbank „relational
and beyond“, BTW 2003