Als Ausgangssituation dient ein einfaches Datenmodell für Wertpapierdepots (Abbildung 1).

Es enthält drei Tabellen: Ein Kunde kann null bis viele Wertpapierdepots besitzen und in jedem Depot können null bis viele Wertpapierpositionen enthalten sein. Das XML-Format ist in Abbildung 2 dargestellt. Die XML-Schnittstelle muss dieses Format demnach sowohl erzeugen als auch verarbeiten können.

XML erzeugen: Von einfachen Strukturen ...

Im ersten Schritt wird das Generieren der XML-Dokumente betrachtet. Dazu kommen die Funktionen des SQL/XML-Standards [1] zum Einsatz. Sie dienen zum Erzeugen von XML mit SQL und sind Bestandteil des ANSI-SQL-Standards (SQL:2003).

• XMLElement(): erzeugt ein XML-Tag
• XMLAttributes(): erzeugt ein oder mehrere XML-Attribute
• XMLComment(): erzeugt einen XML-Kommentar
• XMLRoot(): generiert den XML-Prolog
• XMLAgg(): dient zum Erzeugen von Hierarchien

Die SQL/XML-Funktionen werden wie gewöhnliche SQL-Funktionen eingesetzt und können natürlich auch mit solchen kombiniert werden. Sie verwenden intern keine DOM-Objekte und arbeiten auch mit großen Datenmengen extrem performant.

1. select XMLElement("Gruss", 'Hallo Welt') TEXT
2. from dual
4. TEXT
5. -------------------------
6. <Gruss>Hallo Welt</Gruss>

Listing 1 zeigt den konkreten Einsatz der SQL/XML-Funktionen.

1. Listing 1: Einfache XML-Sicht auf die Wertpapier-Tabelle
2. ==============================================================
3. create view WERTPAPIER_XML_VIEW as
4. select
5. XMLRoot(
6. XMLElement("wertpapier",
7. XMLAttributes(
8. wp.ISIN as "isin",
9. dp.KONTONR as "depotnummer"
10. ),
11. XMLElement("bezeichnung", wp.BEZEICHNUNG),
12. XMLElement("stueck_nominale", wp.STUECK_NOM)
13. )
14. ) as XML
15. from WERTPAPIER_TAB wp join DEPOT_TAB dp

Es erzeugt aus der Tabelle WERTPAPIER_TAB für jede Zeile ein (einfaches) XML-Dokument. Als Datentyp liefert die so erzeugte View einen XMLTYPE zurück. Es ist für den Nutzer der View nicht erkennbar, ob die XML-Dokumente tatsächlich als XMLTYPE in der Datenbank gespeichert sind oder ob sie aus relationalen Daten generiert wurden.

1. SQL> select XML from WERTPAPIER_XML_VIEW
3. XML
4. --------------------------------------------------------
5. <wertpapier isin="US00010281" depotnummer="500917211">
6. <bezeichnung>Oracle Corp</bezeichnung>
7. <stueck_nominale>1000</stueck_nominale>
8. </wertpapier>
9. <wertpapier isin="DE01020911" depotnummer="500917211">
10. <bezeichnung>Bundesanleihe 10/2010</bezeichnung>
11. :

... hin zu komplexen Strukturen

In der Praxis sind meist komplexere, hierarchische XML-Strukturen gefordert. Auch diese lassen sich mit den SQL/XML-Funktionen erzeugen. XMLAgg() fügt eine neue Hierarchieebene ein. Das Beispiel in Listing 2 erzeugt zwei Hierarchieebenen, wobei jedes XMLAgg() in eine Unterabfrage (Sub-Select) eingebettet ist.

Es ist einleuchtend, dass die SQL-Abfrage mit zunehmender Komplexität der zu erzeugenden XML-Dokumente immer länger und unübersichtlicher wird. In der Praxis empfiehlt es sich daher, nach dem "Bausteinprinzip" vorzugehen – also zunächst Views für kleine XML-Dokumente aus einzelnen Tabellen zu erzeugen und diese dann in anderen Views zusammenzufassen.

Da virtuelle XML-Dokumente aus einer XML-View tatsächlich gespeicherten gleichgestellt sind, können Operationen wie Stylesheet-Transformationen (XML-TRANSFORM) oder Datenextraktion (EXTRACTVALUE) auch mit XML-Views durchgeführt werden. Daraus kann dennoch eine relationale Übersicht über alle Depots eines Kunden angefordert werden.

1. select
2. extractvalue(kd.XML, '/kunde/name') name,
3. extractvalue(value(dp), '/depot/@kontonummer') dpnr
4. from KUNDE_XML_VIEW kd,
5. table(xmlsequence(extract(kd.XML, '/kunde/depot'))) dp
7. NAME DPNR
8. -----------------------------------------
9. Mustermann 500917211
10. Meier 500189212
11. : :

Der Vorteil liegt auf der Hand. Da die Datenbank die View-Definition kennt, kann der Optimizer ein Query Rewrite durchführen. Die Datenbank führt also tatsächlich eine (wesentlich performantere) relationale Abfrage aus. Obwohl die relationalen Tabellen dem Nutzer verborgen bleiben, profitiert er dennoch davon.

XML abrufen? Ganz einfach mit HTTP!

Mit dem Erstellen der Views ist der erste Teil der XML-Schnittstelle abgeschlossen. Die relationalen Tabellendaten können nun als XML-Dokumente aus der Datenbank abgerufen werden. Dies ist in der Oracle-Datenbank übrigens nicht nur per SQL, sondern auch per HTTP-Protokoll möglich. Eine standardmäßig installierte Oracle-Datenbank "lauscht" auf Port 8080 auf HTTP-Anfragen. Mit einem speziell formulierten URL kann die XML-View aus Listing 2 direkt angesprochen werden (Abbildung 3): http://[host]:8080/oradb/[DB-USER]/[VIEW-NAME].

1. Listing 2: Erstellung komplexer XML-Dokumente mit den SQL/XML-Funktionen
2. ==============================================================
3. create view KUNDE_XML_VIEW as
4. select
5. XMLElement("kunde",
6. XMLAttributes(kd.KUNDE_ID as "kundennummer"),
7. XMLElement("name", kd.NAME),
8. XMLElement("vorname", kd.VORNAME),
9. XMLElement("ort", kd.ORT),
10. (
11. select
12. XMLAgg(
13. XMLElement("depot",
14. XMLAttributes(dp.KONTONR as "kontonummer"),
15. (
16. select
17. XMLAgg(
18. XMLElement("wertpapier",
19. XMLAttributes(wp.ISIN as "isin"),
20. XMLElement("bezeichnung", wp.BEZEICHNUNG),
21. XMLElement("stueck_nominale", wp.STEUCK_NOM)
22. ))
23. from WERTPAPIER_TAB wp where depot_id = dp.depot_id
24. )))
25. from DEPOT_TAB dp where dp.kunde_id = kd.kunde_id
26. )) as XML
27. from KUNDE_TAB kd

XML entgegennehmen

Die vollständige XML-Schnittstelle muss XML auch entgegennehmen können. Wird ein XML-Dokument gespeichert, so soll die Datenbank dessen Inhalt auf die relationalen Tabellen verteilen.

Versucht man, ein XML-Dokument per SQL INSERT in die View einzufügen, so erhält man eine Fehlermeldung. Der Grund dafür ist die fehlende Update-Fähigkeit der View (siehe Kasten "DML auf Views").

1. SQL> insert into KUNDE_XML_VIEW values ('<kunde>...');
3. insert into KUNDE_XML_VIEW values ('<kunde>...')
4. *
5. ERROR at line 1:
6. ORA-01733: virtual column not allowed here

Speziell zu diesem Zweck wurden in der Oracle-Datenbank die INSTEAD-OF-Trigger [3] eingeführt. Sie sind seit der Version 8 verfügbar, werden auf Views angelegt und anstelle eines INSERT, UPDATE oder DELETE ausgeführt. So lässt sich jede View updatefähig machen – der Entwickler entscheidet selbst, was bei einer DML-Operation geschehen soll.

Der Aufbau eines INSTEAD-OF-Triggers ist in Listing 3 dargestellt.

1. Listing 3: Deklaration und "Gerüst" eines INSTEAD-OF-Triggers
2. ==============================================================
3. create or replace trigger tr_kunde_xml_view
4. instead of insert or update or delete
5. on kunde_xml_view for each row
6. declare
7. begin
8. if inserting then
9. ...
10. end if;
11. if updating then
12. ...
13. end if;
14. if deleting then
15. ...
16. end if;
17. end;

Im Gegensatz zu einem normalen Datenbanktrigger enthält er in Zeile 2 die Schlüsselworte INSTEAD OF. Im Trigger-Body können nun unterschiedliche Aktionen für die verschiedenen DML-Ereignisse implementiert werden. Das neu eingefügte oder geänderte XML-Dokument wird durch das Präfix :new referenziert, das "alte" durch :old.   Die folgenden Beispiele gehen auf die Aktionen des INSTEAD-OF-Triggers für ein INSERT ein – UPDATE und DELETE können dann analog implementiert werden.

Zunächst wird die "Root"-Ebene des XML-Dokuments in die relationale Tabelle KUNDE_TAB übernommen (Listing 4).

1. Listing 4: INSTEAD-OF-Trigger – Bearbeitung der Root-Ebene
2. ==============================================================
3. :
4. if inserting then
5. insert into kunde_TAB (
6. kunde_id, name, vorname, ort)
7. values (
8. extractvalue(:new.XML, '/kunde/@kundennummer'),
9. extractvalue(:new.XML, '/kunde/name'),
10. extractvalue(:new.XML, '/kunde/vorname'),
11. extractvalue(:new.XML, '/kunde/ort')
12. ) returning kunde_id into v_kundeid;
13. :
14. end if;
15. :

Informationen zum Kunden kommen im XML-Dokument nur einmal vor. Die Übernahme erfolgt durch ein einfaches SQL INSERT-Kommando, wobei die Werte mit der EXTRACTVALUE-Funktion aus dem neu eingefügten XML-Dokument (:new) extrahiert werden. Welcher XML-Knoten von EXTRACTVALUE angesprochen wird, richtet sich nach dem übergebenen XPath-Ausdruck. Da die Kundennummer für die weitere Verarbeitung der Depot- und Wertpapierinformationen noch gebraucht wird, wird sie in eine Variable (v_kundeid) übernommen.

Die Informationen zu Depot und Wertpapieren können im XML-Dokument mehrfach vorkommen – daher müssen sie anders behandelt werden. Die Funktion TABLE(XMLSEQUENCE(EXTRACT(...))) extrahiert das XML-Fragment mit den Depot-Informationen und erzeugt daraus eine Sequenz über die einzelnen Depots (Listing 5). Die Schleife (loop) läuft über diese Sequenz. Die Schleifen können geschachtelt werden.

1. Listing 5: INSTEAD-OF-Trigger – Übernahme der mehrfach vorkommenden Elemente
2. ==============================================================
3. :
4. for dp_lst in (
5. select
6. extractvalue(value(dp), '/depot/@kontonummer') as ktonr
7. from table(xmlsequence(extract(:new.XML, '/kunde/depot'))) dp
8. ) loop
9. insert into DEPOT_TAB (kunde_id, KONTONR)
10. values (dp_list.ktonr, v_kundeid);
12. -- Hier eine geschachtelte Schleife für die Verarbeitung
13. -- der Wertpapier-Informationen
15. end loop;
16. :

Nach Erstellung des Triggers ist die XML-Schnittstelle vollständig. Ein SQL INSERT in die View ist nun erfolgreich. Die Inhalte finden sich anschließend in den relationalen Tabellen wieder.

1. SQL> insert into kunde_xml_view values ('<kunde>...');
3. 1 row created.

Beim Implementieren der Schnittstelle sollte man auch mögliche Konfliktfälle von vorneherein berücksichtigen. Ein neu einzufügender Kunde könnte bereits existieren. Die Frage ist, woran man dies erkennen kann und was passieren soll: Sollen die alten Informationen überschrieben, beibehalten oder soll eine Fehlermeldung ausgelöst werden? Solche Fragen können jedoch nicht pauschal, sondern nur im Einzelfall entschieden werden.

Fazit

Mit der vorgestellten Technik kann man eine XML-Schnittstelle direkt in der Datenbank hinterlegen. Im Vergleich zu vielfach verfügbaren, fertigen Frameworks ist diese Variante auf den ersten Blick aufwendiger. Bei genauerer Betrachtung bieten sich jedoch einige Vorteile:

• Information hiding: Das XML-Dokument kann direkt aus der Datenbank abgerufen werden. Der Nutzer greift auf eine View zu – die Herkunft der Daten bleibt verborgen.
• Offenheit: Die so erzeugte XML-Schnittstelle ist für viele Programmierumgebungen (Java, .NET, PHP, Perl, C/C++ ...) nutzbar. Die einzige Voraussetzung ist die Fähigkeit zur Kommunikation mit der Datenbank.
• Performance: Besonders das Erzeugen von XML ist hier sehr performant gelöst. Denn die Datenbank stellt das XML-Dokument zusammen und liefert es "auf einmal" aus. Dies ist wesentlich effizienter als das Ausliefern zahlreicher Einzelsätze.

Links & Literatur

1. SQL-/XML-Standard
2. XML-Views in der Oracle-Datenbank
3. INSTEAD-OF-Trigger in der Oracle-Datenbank