XML-Einsatzmöglichkeiten für Datenbankanwendungen im Internet

Transcrição

Seminar 1905 Thema 9 [FernUniversität Hagen]
XML-Einsatzmöglichkeiten für
Datenbankanwendungen im Internet
Matthias Knop - Thorsten Rood - Ute Stegmann
Wintersemester 2000/2001
16. März 2001
Seminar 1905 Thema 9 [FernUniversität Hagen] WS 2000/2001
Dieser Seminarbeitrag soll mögliche Vorgehensweisen und verschiedene Modelle beschreiben mit
denen die XML-Technologie für Datenbankanwendungen im Internet genutzt werden kann. Es wird
eine Übersicht gegeben, welche Hersteller von Standarddatenbanken XML unterstützen und einige
konkrete Beispiele gegeben.
Inhaltsverzeichnis
Inhaltsverzeichnis .......................................................................................................................2
1 Einführung ...............................................................................................................................3
1.1 Themenbeschreibung/Motivation.........................................................................................3
1.2 Vorteile von XML ................................................................................................................3
1.3 XML-Einsatzmöglichkeiten (Architekturmodelle) ..............................................................4
1.4 Auf der Suche nach Standards
für XML und Datenbanken ..........................................9
2 Grundlagen ............................................................................................................................11
2.1 Abbildung XML <-> Datenbank-Strukturen......................................................................11
2.2 Datenbankexport nach XML ..............................................................................................20
2.3 XML-Import in Datenbanken .............................................................................................24
2.4 Java und XML-Parser.........................................................................................................27
2.5 XML-Darstellung ...............................................................................................................29
2.6 Datenbank-Benutzeranfragen .............................................................................................30
2.7 XML-Dokumente mit gemischtem Inhalt (BLOB,CLOB) ................................................31
2.8 XML Query ........................................................................................................................32
3 XML-Einsatz in Datenbanken-Applikationen.......................................................................34
3.1 Übersicht Datenbank-Hersteller und -Produkte .................................................................34
3.1.1 IBM DB2 XML Extender................................................................................................35
3.1.2 Oracle 8i/9i, XML SQL Util, XSQL ...............................................................................37
3.1.3 Microsoft SQL Server, Access ........................................................................................38
3.1.4 Tamino XML Database ...................................................................................................38
3.1.5 Verschiedene Datenbank-Hersteller ................................................................................39
3.2 Microsoft SQL 2000 ...........................................................................................................40
3.2.1 Begriffe ............................................................................................................................40
3.2.2 Lesezugriffe DB->XML ..................................................................................................43
3.2.3 Schreibzugriffe XML->DB .............................................................................................46
3.2.4 Stylesheets .......................................................................................................................51
3.2.5 Security............................................................................................................................54
3.2.6 Performance.....................................................................................................................55
3.2.7 Entwicklung/AddOns ......................................................................................................56
3.2.8 Einsatz in Linux-/Unix-Umgebungen .............................................................................56
3.3 Oracle 8i/9i XML-SQL Utility (XSU) ...............................................................................57
3.3.1 XSU Funktionsprinzip.....................................................................................................58
3.3.2 XSU Command Line Front End ......................................................................................63
3.3.3 XSU Java API..................................................................................................................65
3.3.4 XSU PL/SQL...................................................................................................................71
3.4 Bewertung...........................................................................................................................73
4 Demo .....................................................................................................................................75
4.1 Microsoft SQL 2000 ...........................................................................................................75
4.2 Oracle XSQL Servlets ........................................................................................................75
Literaturverzeichnis ..................................................................................................................76
Seite 2 von 2
Stand: 20.03.2001
1 Einführung
In diesem Kapitel wird eine kurze Einführung in das Thema im Hinblick auf die Vorteile und die
Einsatzmöglichkeiten von XML in Datenbankanwendungen im Internet gegeben
1.1 Themenbeschreibung/Motivation
1.2 Vorteile von XML
1.3 XML-Einsatzmöglichkeiten (Architekturmodelle)
1.4 Auf der Suche nach Standards für XML und Datenbanken
1.1 Themenbeschreibung/Motivation
XML (eXtensible Markup Language) ist ein von dem WorldWideWeb-Consortium (W3C)
entwickelter Standard, eine Metasprache, mit der man Auszeichnungen (Markups) zu Dokumenten
hinzuzufügen kann, um deren Struktur zu beschreiben. Das Ziel dieser Bemühungen ist nicht die
Präsentation, sondern die Abbildung semantischer Hierarchien. XML ermöglicht es, als ein für den
Informationsaustausch nutzbares Format, interne Unternehmensdaten, über Systemgrenzen und
Plattformen hinweg, im Internet nutzbar zu machen. Im Prinzip soll es also der Standard der Zukunft
sein um reine Informationen in einfacher strukturierter Form für das Internet verfügbar zu machen. Es
liegt also nahe XML im Zusammenhang mit der Darstellung von Datenbankinformationen in Internetbasierten Anwendungen zu verwenden. Dies haben auch diverse Hersteller von Standard-Datenbanken
erkannt und unterstützen mehr oder weniger direkt XML (u.a. Microsoft, IBM und Oracle).
Dieser Seminarbeitrag soll mögliche Vorgehensweisen und verschiedene Modelle beschreiben mit
denen die XML-Technologie für Datenbankanwendungen im Internet genutzt werden kann.
© 2001Ute Stegmann
1.2 Vorteile von XML
Grundsätzlich sprechen folgende Gründe für den Einsatz von XML:
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
XML ist ein offener Standard mit hoher Akzeptanz.
XML ermöglicht eine klare Trennung zwischen Daten und Präsentation.
XML ist textorientiert.
XML ist erweiterbar.
XML ist selbstbeschreibend.
XML ist internationalisierbar.
XML ist plattform- und programmiersprachenunabhängig.
XML ist maschinell verarbeitbar.
XML ist geeignet für langfristige Datenablage.
XML ist leicht transformierbar.
In [FM1] ist über den Vorteil durch den XML-Einsatz in Verbindung mit Datenbankanwendungen im
Internet folgendes zu lesen:
"Gegenüber allen bisher angesprochenen Verfahren und Möglichkeiten weist die XML-Technologie
einige bemerkenswerte Vorteile bei der Veröffentlichung von Datenbankinhalten in Netzwerken auf:
Seite 3 von 3
Stand: 20.03.2001
1. Der gravierendste Vorteil ist die Geschwindigkeit. XML ist deutlich schneller, da viele
Aufgaben vom Client-Rechner bearbeitet werden und den Datenbankserver spürbar entlasten.
Der Server empfängt die Abfrage und sendet seine Antwort nahezu in Rohdaten zurück. Es ist
keinerlei CPU-Zeit des Servers für die aufwendige Umrechnung der Daten in das vom Client
zur Anzeige benötigte HTML-Format notwendig. Die Formatierung eines einzigen HTMLDokuments ist zwar keine besonders aufwendige Sache. Wenn aber mehrere Tausend
Dokumente formatiert werden müssen, geht jedem Server früher oder später die Leistung aus.
Wenn diese Aufgabe dagegen von jedem einzelnen Client-Rechner parallel übernommen wird,
ist die Arbeit gleichmäßig und in geringerem Umfang auf die jeweiligen Prozessoren verteilt.
Selbst leistungsstarke Server profitieren von dieser gleichmäßigen Lastverteilung.
2. XML ist als offener Industriestandard eine hervorragend dokumentierte, häufig genutzte und
weit verbreitete Technologie, für die es eine Vielzahl Third-Party Produkte und Unterstützung
gibt: Software, Bücher, technische Unterlagen und vieles mehr. Das Erlernen wie auch die
Nutzung von XML geschieht mit diesen Hilfsmitteln so einfach, problemlos und schnell wie
bei keiner anderen der hier vorgestellten Technologien. Darüber hinaus wird der
Datenaustausch zwischen Individuen, Unternehmen, Händlern, Kunden, Partnern und deren
Datenbanken zu einer leichten Übung – die Verwendung der gleichen Technologie macht es
möglich. XML ist übergreifende Plattform, Datenbank und Programmsprache in einem. XML
kann daher .. .. eingesetzt werden, ohne dass Probleme beim Datenaustausch zwischen den
Systemen auftreten.
3. Ein zusätzlicher Vorteil von XML in heterogenen Welten wie dem Internet ist, dass XMLDokumente zum größten Teil selbstbeschreibend sind. Wenn zum Beispiel eine Seite die
Zeichenfolge <person> <last> Naeve </last> <first> Andrea </first> </person> enthält,
erkennen wir sofort den Vornamen „Andrea“ und den Nachnamen „Naeve“ einer Person, die
in einer Datenbank gespeichert ist. Mit einem Schema wie DTD oder entsprechenden
Kommentaren wird die Identifizierung solcher Zeichenketten bzw. Daten noch eindeutiger.
Weniger flexible Formate wie HTML oder Tabulator-orientierter Text weisen solche
Möglichkeiten nicht auf."
© 2001Ute Stegmann
1.3 XML-Einsatzmöglichkeiten (Architekturmodelle)
Nachfolgend sehen Sie einen Überblick möglicher XML-Architekturen, wie sie in [Quin] dargestellt
sind.
Zusammen mit den bereits in Kapitel 1.2. dargestellten Vorteilen von XML werden damit die
vielfältigen Einsatzmöglichkeiten von XML im Zusammenhang mit Datenbankanwendungen im
Internet deutlich.
XML zur Datensicherung und für den Datentransport
Seite 4 von 4
Stand: 20.03.2001
XML als Hub Format
XML zum Datenaustausch mit anderen Organisationen
Seite 5 von 5
Stand: 20.03.2001
XML für Publikationen
XML zum Datenaustausch zwischen Anwendungen
Seite 6 von 6
Stand: 20.03.2001
XML als ein Format zur Darstellung von Informationen in Web-Seiten
Seite 7 von 7
Stand: 20.03.2001
Anwendungsbeispiel: XML-Daten werden durch mehrere Instanzen bearbeitet
Quelle: Software AG
Anwendungsbeispiel: XML-Data-Warehouse
Quelle: Internet
© 2001Ute Stegmann
Seite 8 von 8
Stand: 20.03.2001
1.4 Auf der Suche nach Standards
für XML und Datenbanken
Ein Vorteil von XML ist, wie bereits erwähnt, dass es sich um einen Standard handelt.
Bei der Informationsbeschaffung für diesen Seminarbeitrag haben wir festgestellt, dass XML von fast
allen wichtigen Datenbankherstellern in irgendeiner Form unterstützt wird. Wobei in nächster Zeit
noch einige Veränderungen bezüglich Integrationstiefe zu erwarten sind oder gerade umgesetzt
werden.
Was wir nicht gefunden haben, ist ein einheitlicher Standard, der bei allen Datenbanken in gleicher
Weise funktioniert. Dies ist sicherlich einerseits darauf zurückzuführen, dass XML noch nicht alt ist.
Andererseits scheint hier das Bestreben der kommerziellen Datenbankhersteller eher in die Richtung
zu gehen sich von der Konkurrenz abzusetzen und ihre XML-Unterstützung als die bessere Variante
zu verkaufen.
Für profesionelle Softwareentwickler, die verschiedene Datenbankplattformen unterstützen müssen, ist
also der Einsatz universeller XML-Parser, die verschiedene Datenbanken bedienen können, zur Zeit
wohl noch der bessere Weg.
Abschließend möchte ich zu diesem Thema bezüglich der Definitionen von Standards durch das
WWW-Konsortiums zu XML-Query (oder heißt es nun XQL?), der als Standard gedachten
Abfragesprache für XML-Dokumente (kleines Beispiel siehe 2.1.), noch einen von mir
anonymisierten Auszug aus einer öffentlichen Newsgroup wiedergeben, den ich eher zufällig
gefunden habe.
(Hinweis: die Einträge sind von unten nach oben zu lesen)
Meine Fragen und alle in diesem Zusammenhang getroffenen
Aussagen
bezogen sich ausschliesslich auf die proprietäre XMLAnfragesprache
der Software AG (X-Query). Für die unbewusste Verwendung des
falschen Begriffes und die dadurch möglicherweise
entstandene Verwirrung bitte ich um Entschuldigung!
-----Ursprüngliche Nachricht----Von: Deutschsprachige XML Liste [mailto:[email protected]]
.....
Gesendet: Mittwoch, 15. November 2000 18:22
An: [email protected]
Betreff: Re: XML-Query in Tamino
> > Gibt es eine Möglichkeit, mit XML-Query 'komplexe'
Unterabfragen zu stellen
> > wie:
> > Gib mir dasjenige Land, in welchem der Gesamtumsatz höher
ist als in allen
> > anderen Ländern.
Ich möchte klar stellen, daß mit "XML Query" [tm?] stets die
Seite 9 von 9
Stand: 20.03.2001
in Enticklung
befindliche XML Anfragesprache des W3C gemeint ist. Andere
Sprachen wie
X-Query (Software AG) oder XQL (z.B. Software AG, eXcelon,
GMD-IPSI) sind
proprietäre Anfragesprachen.
Das W3C kann, wie im Standard-Disclaimer klar ausgesagt, keine
Rücksicht auf
frühe Implementationen und Produkte nehmen. Es kann sein oder
es kann nicht
sein, das "XML Query" Ähnlichkeit mit X-Query, XQL o.ä. hat.
Aussagen
darüber dürfen nicht öffentlich gemacht werden (W3C nondisclosure
agreement). Das betrifft alle Aspekte von Syntax, Semantik und
Funktionsumfang.
> dito
>
> > Ist es überhaupt möglich, diese Fragen mit XML-Query zu
formulieren?
> Ja und bald kriegt man auch die Antwort, die man verdient
Die offiziellen Antworten finden sich auf:
http://www.w3.org/XML/Query (non-member)
http://www.w3.org/XML/Group/Query (W3C-member)
Alles andere ist spekulativ bzw. produktspezifisch.
.....
Anmerkungen:
Eine kurze Vorstellung der Tamino XML Database finden Sie übrigens in Kapitel 3.1].
© 2001Ute Stegmann
Seite 10 von 10
Stand: 20.03.2001
2 Grundlagen
In diesem Kapitel versuchen wir einen Überblick über die im Zusammenhang mit dem XML-Einsatz
in Datenbank-Anwendungen relevanten Techniken bzw. Technologien zu geben.
2.1 Abbildung XML <-> Datenbank-Strukturen
2.2 Datenbankexport nach XML
2.3 XML-Import in Datenbanken
2.4 Java und XML-Parser
2.5 XML-Darstellung
2.6 Datenbank-Benutzeranfragen
2.7 XML-Dokumente mit gemischtem Inhalt (BLOB,CLOB)
2.8 XML Query
Anmerkung: Für weitere Grundlagen über Datenbanken und Internet verweisen wir an dieser Stelle
auf die anderen Seminarbeiträge (S1905 WS 2000/2001 FernUni Hagen).
2.1 Abbildung XML <-> Datenbank-Strukturen
Bevor ich zu der Frage komme, wie sich XML-Strukturen in Datenbank-Strukturen abbilden lassen oder anders gesagt Informationen aus XML-Dokumenten in Datenbankinhalte überführt werden
können - und umgekehrt, sollen zunächst zwei grundsätzliche Punkte geklärt werden.
•
•
Welche strukturellen Gemeinsamkeiten bestehen zwischen XML-Dokumenten und
Datenbanken?
Lassen sich XML-Dokumente auf Grund typischer Merkmale in verschiedene Klassen
einteilen und welchen Einfluß hat das auf die Art der Abbildung der Daten in Datenbanken?
Der erste Frage läßt sich recht einfach beantworten in dem man sich ein paar Stichpunkte klar macht.
Sowohl in Datenbanken als auch in XML-Dokumente werden Informationen in strukturierter Form
gespeichert. [ROBOU1] zählt weitere Punkte auf. Es gibt beschreibende Schemata zu den
Informationen. Für XML sind das z.B. die Document Type Definitions (DTD) und als Beispiel in
relationalen Datenbanken sind die Strukturen unter anderem in Tabellen festgelegt. Es gibt
Abfragesprachen wie SQL für relationale Datenbanken und XML Query Language für XML. Und
auch Programmierschnittstellen wie SAX oder DOM für XML verdeutlichen die Gemeinsamkeiten
mit Datenbanken. [ROBOU1] stellt sogar die Frage "Is XML a Database" und beantwortet sie so:
"In strictest sense -- .. -- it is no. .. In more liberal sense – that is, when "XML" means an
XML Document and all surrounding XML tools and technologies – then the answer is yes,
but .. .. but because it lacks many of things found in real databases: efficient storage,
indexes, security, transaction and data integrity, multi-user access triggers ...
So while it may be possible to use XML as a database in envirenments with not too much
data, few users, and modest performance requirements, it will be fail in most production
environments, which have many users, strict data integrity requirements, and the need for
good performance. Furthermore, given the low price and ease of use of databases like dBase
and Access, there seems little reason to use XML as a database even in the first case.
Seite 11 von 11
Stand: 20.03.2001
Die Diskussion, ob man XML-Dokumente als Datenbank nutzen kann, habe ich auch einmal in einer
Newgroups gefunden. Auch dort war man der Meinung "..ja, aber wozu?".
Als kleines frei erfundenes Beispiel am Rande möchte ich zur Motivation des Themas das
nachfolgende Beipiel geben.
Gegeben sei folgendes "Mini-Lexikon mit Büchertips" einer kleinen Buchhandlung, die sich auf
bestimmte Bücher spezialisiert hat und alle 3 Monate ein XML-Dokument an Interessenten versendet:
<BOERSENLEXIKON>
<EINTRAG>
<BEGRIFF>Aktie</>
<ERKLAERUNG>Anteil an einer Aktiengesellschaft .. </ERKLÄRUNG>
</EINTRAG>
<EINTRAG>
<BEGRIFF>Börse</>
<ERKLAERUNG>Handelsplatz für den Ankauf und Verkauf von..
</ERKLÄRUNG>
</EINTRAG>
..
<BOERSENLEKIKON>
<BUECHERLISTE>
<BUCH>
<ISBN>XX-XXX-XXX</ISBN>
<TITEL>Aktien und Optionsscheine.. </ERKLÄRUNG>
<BESCHREIBUNG>Eine kompakte Zusammenfassung zum Handel mit
Aktien und.. </BESCHREIBUNG>
<AUTHOR>Börsenguru</AUTHOR>
<PREIS>999,99 DM</PREIS>
</BUCH>
..
<BOERSENLEKIKON>
Man kann sich nun in diesem Fall vorstellen, das ein solches Lexikon mit einem XML-Editor zu
pflegen und dann die Datei komplett weiterzugeben, da der Inhalt sich nur selten ändert. Für die
Interessenten bzw. Nutzer stellt sich allerdings die Frage nach einer Anwendung mit der sie bestimmte
Leseanfragen durchführen können. Sie würden vielleicht gerne die Ergebnisse in Form einer Liste
angezeigt bekommen, daraus Ergebnisse auswählen und diese dann lesen und ausdrucken.
Man könnte sich z.B. folgende Anfragen vorstellen:
Anzeige aller Bücher zum Thema Aktie sortiert nach Preis:
SELECT * FROM BUECHERLISTE
WHERE BESCHREIBUNG CONTAINS "Aktie"
Anzeige Erklärungen zum Begriff Aktie:
SELECT * BORSENLEXIKON
WHERE BEGRIFF ="Aktie"
(oder mit einer XML-Query etwa so:
BOERSENLEXIKON/BEGRIFF = ‘Aktie‘ )
Seite 12 von 12
Stand: 20.03.2001
Hätte die Buchhandlung also z.B. ein JAVA-Aplet mitgeliefert, daß solche Anfragen auf das XMLDokument umsetzt, so würde sich das ganze System für den Benutzer als Datenbank darstellen ohne
daß er im Besitz einer Datenbanksoftware sein müßte. Er könnte die Anwendung ganz einfach offline
in einem Browser laufen lassen.
Die Verbindungen zwischen XML- und Datenbank-Strukturen dürften damit verständlich geworden
sein.
Nun zur Frage der typischen Merkmale von XML-Dokumenten und dem Einfluß auf die Art der
Abbildung der Daten in Datenbanken.
[Quin] zählt zur Abgrenzung der XML-Daten gegenüber Daten in Datenbanken die folgende Punkte
auf:
"The main ways that an XML document differs from the sort of data you find in
"typical" relational databases include:
•
•
•
•
•
Fields and data are normaly intermixed (mixed content).
Any document can have ist own schema, or DTD.
Fields do not have length restriction.
Fields can nest arbitrarily.
Fields have a sequence"
Am Ende dieses Abschnitt werden wir noch kurz auf die zu beachtenden Datentypen in XMLDokumenten näher eingehen.
Zunächst komme ich nun aber zur Struktur von XML-Dokumenten.
[ROBOU1] erläutert hierzu, der wichtigste Faktor bei der Auswahl einer Datenbank ist die Frage, ob
man die Datenbank benutzt um Daten oder Dokumente zu speichern. Er unterscheidet dabei zwischen
datenorientierten Dokumenten ("Data-Centric"), deren Schwerpunkt auf den Inhalten der einzelnen
Strukturen liegt und dokumentorientierten Dokumenten ("Document-Centric"), bei denen das
Dokument als ganzes betrachtet wird. Bei Dokument-orientierten XML-Dateien ist die Granularität
das Dokument, bei Daten-orientierten XML-Dateien sind es Elemente, Attribute und Zeichenketten.
Daten-orientiertes XML sind ferner durch eine relativ regelmäßige Struktur gekennzeichnet und ihre
Strukturen sind normalerweise für die maschinelle Verarbeitung entworfen worden. Im Gegensatz
dazu sind Dokument-orientierte XML-Dateien eher für den menschlichen Benutzer gemacht.
Wir wollen die Aussageen an zwei Beispielen nachvollziehen.
Beispiel 1: (Data-Centric Document aus [ROBOU1])
<Orders>
<SalesOrder SONumber="12345">
<Customer CustNumber="543">
<CustName>ABC Industries</CustName>
<Street>123 Main St.</Street>
<City>Chicago</City>
<State>IL</State>
<PostCode>60609</PostCode>
</Customer>
<OrderDate>981215</OrderDate>
Seite 13 von 13
Stand: 20.03.2001
<Line LineNumber="1">
<Part PartNumber="123">
<Description>
<p><b>Turkey wrench:</b><br />
Stainless steel, one-piece construction,
lifetime guarantee.</p>
</Description>
<Price>9.95</Price>
</Part>
<Quantity>10</Quantity>
</Line>
<Line LineNumber="2">
<Part PartNumber="456">
<Description>
<p><b>Stuffing separator:<b><br />
Aluminum, one-year guarantee.</p>
</Description>
<Price>13.27</Price>
</Part>
<Quantity>5</Quantity>
</Line>
</SalesOrder>
</Orders>
Note that in the XML world, many prose-rich documents are, in fact,
data-centric. For example, consider a page on Amazon.com that displays
information about a book. Although the page is largely text, the
structure of that text is highly regular, much of it is common to all
pages describing books, and each piece of page-specific text is limited
in size. Thus, the page could be built from a simple, data-centric XML
document -- containing page-specific text retrieved from the database -and an XSL stylesheet that adds the boilerplate text. In general, any
Web site that dynamically constructs HTML documents today by filling
a template with database data can probably be replaced by data-centric
XML documents and one or more XSL stylesheets.
For example, the following lease document:
<Lease>
<Lessee>ABC Industries</Lessee> agrees to lease the property at
<Address>123 Main St., Chicago, IL</Address> from <Lessor>XYZ
Properties</Lessor> for a term of not less than <LeaseTerm
TimeUnit="Months">18</LeaseTerm> at a cost of <Price
Currency="USD" TimeUnit="Months">1000</Price>.
</Lease>
could be built from the following XML document and a simple stylesheet:
<Lease>
<Lessee>ABC Industries</Lessee>
<Address>123 Main St., Chicago, IL</Address>
<Lessor>XYZ Properties</Lessor>
<LeaseTerm TimeUnit="Months">18</LeaseTerm>
<Price Currency="USD" TimeUnit="Months">1000</Price>
</Lease>
Seite 14 von 14
Stand: 20.03.2001
Beispiel 2: (Document-Centric Document aus [ROBOU1])
<Product>
<Name>Turkey Wrench</Name>
<Developer>Full Fabrication Labs, Inc.</Developer>
<Summary>Like a monkey wrench, but not as big.</Summary>
<Description>
<Para>The turkey wrench, which comes in both right- and
left-handed versions (skyhook optional), is made of the finest
stainless steel. The Readi-grip rubberized handle quickly adapts
to your hands, even in the greasiest situations. Adjustment is
possible through a variety of custom dials.</Para>
<Para>You can:</Para>
<List>
<Item><Link URL="Order.html">Order your own turkey wrench</Link></Item>
<Item><Link URL="Wrenches.htm">Read more about wrenches</Link></Item>
<Item><Link URL="catalog.zip">Download the catalog</Link></Item>
</List>
<Para>The turkey wrench costs just $19.99 and, if you
order now, comes with a hand-crafted shrimp hammer as a
bonus gift.</Para>
</Description>
Im ersten Beispiel kann man sich z.B. eine dazu passende Tabelle einer realtionalen Datenbank
vorstellen.
Bei der dokumentorientierten XML-Struktur wäre dies nicht so ohne weiteres eingängig und auch
nicht unbedingt sinnvoll. Hier könnte man sich eher vorstellen das XML-Dokument als ganzes in einer
Datenbank zu speichern. [ROBOU1] vertritt hierzu die These, daß der Einsatz von Content
Management Systemen (CMS) im zweiten Fall allerdings wesentlich sinnvoller wäre.
Nun zur eigentlichen Frage dieses Kapitels, der Abbildung der XML-Strukturen auf
Datenbankstrukturen. Grundsätzlich kann man dabei zwischen der Template-gesteuerten und Modellgesteuerte Abbildung unterscheiden:
Template-gesteuerte Abbildung
Hierbei gibt es keine vordefinierte Zuordnung zwischen der Struktur des XML-Dokuments und der
Datenbank-Struktur. Stattdessen werden entsprechende Kommandos in ein Template eingebettet, die
dann von der für den Datentransport verantwortlichen Middleware verarbeitet werden.
Seite 15 von 15
Stand: 20.03.2001
Beispiel 3: (aus [ROBOU1])
For example, consider the following template (not used by any real
product),
in which SELECT statements are embedded in <SelectStmt> elements:
<?xml version="1.0"?>
<FlightInfo>
<Intro>The following flights have available seats:</Intro>
<SelectStmt>SELECT Airline, FltNumber, Depart, Arrive FROM
Flights</SelectStmt>
<Conclude>We hope one of these meets your needs</Conclude>
</FlightInfo>
When processed by the data-transfer middleware, each SELECT statement might
be
replaced by its results, formatted as XML:
<?xml version="1.0"?>
<FlightInfo>
<Intro>The following flights have available seats:</Intro>
<Flights>
<Row>
<Airline>ACME</Airline>
<FltNumber>123</FltNumber>
<Depart>Dec 12, 1998 13:43</Depart>
<Arrive>Dec 13, 1998 01:21</Arrive>
</Row>
...
</Flights>
<Conclude>We hope one of these meets your needs</Conclude>
</FlightInfo>
Diese Art der Abbildung kann sehr flexibel eingesetzt werden.
[ROBOU1] schreibt hierzu:
"For example, some products allow you to place result set values wherever you want in the result set -including using them as parameters in a subsequent SELECT statement -- rather than simply
formatting the results themselves, as is shown above. Others support programming constructs such as
for loops and if statements. And still others support parameterization of SELECT statements, such as
through HTTP parameters."
Template-gesteurte Abbildungen werden derzeit nur für die Überführung von Daten aus relationale
Datenbanken in XML-Dokumente genutzt. Weitere Informationen hierzu finden Sie unter 2.2. und
2.6.
Modell-gesteuerte Abbildung
Bei einer Modell-gesteuerten Abbildung gibt es ein konkretes Modell nach dem die XML-Struktur
implizit oder explizit auf die Datenbank-Struktur abgebildet wird.
Zwei bekannte Modelle sind das Table Modell, bei dem ein XML-Dokument auf einzelne oder
mehrere Tabellen einer realtionalen Datenbank abgebildet wird, und das datenspezifische ObjektModell, bei dem der XML-Baum direkt auf eine objektorientierte oder hierarchische Datenbank
abgebildet wird.
Seite 16 von 16
Stand: 20.03.2001
Beispiel 4: Table Modell (aus [ROBOU1])
<database>
<table>
<row>
<column1>...</column1>
<column2>...</column2>
...
</row>
...
</table>
...
</database>
The term "table" is loosely interpreted to mean a single result set
(when transferring data from the database to XML) or a single table
or updateable view (when transferring data from XML to the database).
If data from more than one result set is desired (when transferring data
from the database) or the XML document contains more deeply nested elements
than those necessary to represent a set of tables (when transferring data
to the database), then the transfer is simply not possible
Beispiel 5: Objekt-Modell (aus [ROBOU1]) (tree bezieht sich auf Beispiel 1)
Vorbemerkung: Der Dokumentenbaum (tree) eines XML-Dokuments stellt die Einsatzreihenfolge der in der
zugehörigen DTD definierten Elemente der XML-Struktur übersichtlich dar.
For example, the sales order document shown above could be viewed as
a tree(*) of objects from five classes -- Orders, SalesOrder, Customer,
Line, and Part -- as shown in the following diagram:
Orders
|
SalesOrder
/
|
\
Customer
Line
Line
|
|
Part
Part
[ROBOU1] schreibt weiter über das Objekt-Modell:
"..is a tree of data-specific objects, in which element types generally correspond to objects
and content models, attributes, and PCDATA correspond to properties. This model maps
directly to object-oriented and hierarchical databases and can be mapped to relational
databases using traditional object-relational mapping techniques or SQL 3 object views.
Note that this model is not the Document Object Model (DOM); the DOM models the
document itself, not the data in the document, and is used to build content managment
systems over relational databases..
..When modelling an XML document as a tree of data-specific objects, there is no
requirement that elements necessarily correspond to objects. For example, if an element
contains only PCDATA, such as the CustName element in the sales order document, it can
be reasonably viewed as a property because, like a property, it contains a single, scalar
value. Similarly, it is sometimes useful to model elements with mixed or element content
as properties. An example of this is the Description element in the sales order document:
although it has mixed content in the form of XHTML, it is more useful to view the
Seite 17 von 17
Stand: 20.03.2001
description as a single property because its component pieces are meaningless by
themselves."
Weil einfache Bilder oft Zusammenhänge viel besser erklären als komplizierte Erläuterungen, möchte
wir an dieser Stellen noch eine Illustration aus [Quin] zeigen, die die Abbildung einer XML-Struktur
in eine relationale Datenbanktabelle veranschaulicht:
Seite 18 von 18
Stand: 20.03.2001
Abschließend wollen wir noch kurz auf die verschiedenen Datentypen und Informationen einer XMLStruktur und die Art und Weise wie sie in Datenbanken abgebildet werden können eingehen.
Datentypen und Datenhaltung in XML-Strukturen
Die nachfolgenden Beschreibungen sind wieder [ROBOU1] entnommen.Bei der realen Umsetzung hat
man allerdings oft wenig Einfluß daruf, wie die für die XML-Unterstützung gewählte Datenbank oder
die Software manche Dinge konkret umsetzt.
Datentypen
"XML does not support data types in any meaningful sense of the word. Except for unparsed entities,
all data in an XML document is text, even if it represents another data type, such as a date or an
integer. Generally, the data transfer middleware will convert data from text (in the XML document) to
other types (in the database) and vice versa. However, the number of text formats recognized for a
particular data type are likely to be limited, such as to those supported by a given JDBC driver. Dates
are most likely to cause problems, as the range of possible formats is enormous. Numbers, with their
various international formats, might cause problems as well."
Binärdaten
"There are two common ways to store binary data in XML documents: unparsed entities and Base64
encoding (a MIME encoding that maps binary data to a subset of US-ASCII). For relational databases,
both can prove problematic, as the rules governing how binary data is sent to or retrieved from the
database can be quite strict and can cause problems for the middleware. In addition, there is no
standard notation for indicating that an element contains Base64-encoded data, so the middleware
might not recognize this encoding at all. Finally, the notation associated with an unparsed entity or
Base64 encoded element is one of those things that might be discarded by the middleware when
storing data in the database. Therefore, if binary data is important to you, be sure to check that your
middleware supports it."
"Null"-Daten
"In the database world, null data means data that simply isn't there. This is very different from a value
of 0 (for numbers) or zero length (for a string). For example, suppose you have data collected from a
weather station. If the thermometer isn't working, a null value is stored in the database rather than a 0,
which would mean something different altogether.
XML also supports the concept of null data through optional element types and attributes. If the value
of an optional element type or attribute is null, it simply isn't included in the document. As with
databases, empty elements or attributes containing zero length strings are not null: their value is a
zero-length string.
When mapping the structure of an XML document to the database and vice versa, you should be
careful that optional element types and attributes are mapped to nullable columns and vice versa. The
result of not doing so is likely to be an insertion error (when transferring data to the database) or
invalid document (when transferring data from the database).
Because the XML community is likely to have a more flexible notion of what is meant by null than the
database community -- in particular, many XML users are likely to consider empty elements or
attributes containing zero-length strings to be "null" -- you should check how your chosen middleware
handles this situation. Some middleware may offer the user the choice of defining what constitutes
"null" in an XML document."
Zeichenketten
"By definition, an XML document can contain any Unicode character except some of the control
characters. Unfortunately, many databases offer limited or no support for Unicode and require special
configuration to handle non-ASCII encodings of character data. If your data contains non-ASCII
characters, be sure to check how and if both your database and middleware handle these characters."
Seite 19 von 19
Stand: 20.03.2001
Verarbeitungsanweisungen
"Processing instructions are not part of the "data" of an XML document and it is likely that most
middleware cannot handle them. The problem is that, especially with a strict mapping of the XML
document structure to database structure, processing instructions simply do not fit because they can
occur virtually anywhere in the document. Thus, it is hard for middleware to know where to store
them and when to retrieve them. If processing instructions and "round-tripping" of documents are
important to you, be sure to check how your middleware handles this."
Speicherung von Markups
"As was mentioned in section ..., it is sometimes useful to store elements with element or mixed
content in the database without further parsing. The most common way to do this is simply to store the
markup itself in the database. Unfortunately, this leads to a problem when retrieving the data: it is
impossible to determine whether such markup in the database is, in fact, true markup or was originally
an entity that represented a markup character, such as can be done with the lt and gt entities.
For example, if the following description:
<description>
<b>Confusing example:</b> <foo/>
</description>
is stored in the database as:
<b>Confusing example:</b> <foo/>
the database cannot tell whether and are markup or text. There are several possible solutions to this,
such as flagging markup in some way or using entities for non-markup markup characters, but you
must be careful that these are acceptable to your other applications that use the data. For example, if
you want to search for a less-than sign ("<") and an lt entity ("<") is stored in the database, you need to
be aware of this."
© 2001Ute Stegmann
2.2 Datenbankexport nach XML
Das grundsätzliche Vorgehen beim Exportieren von Datenbank-Informationen in XML-Strukturen
bzw. -Dokumente ist im Prinzip einfach. Es sind nur folgende Schritte notwendig:
•
•
•
Festlegung des Mappings (siehe Kapitel 2.1)
Selektieren der gewünschten Datensätze aus der Datenbank
Erzeugen XML-Struktur gemäß Mapping und Speichern als XML-Dokument
Auch wenn das Prinzip so einfach scheint, die Frage ist dennoch, wie geht das nun konkret. Genauer
also die Fragen:
•
•
•
Wo und wie wird das Mapping festgelegt?
Werden und wenn ja wie DTDs unterstützt?
Gibt es ein allgemeingültiges Konzept für die konkrete Syntax (Standard)?
Wir hatten es bereits angedeutet, aus unserer Sicht gibt es keine herstellerunabhängigen Antworten auf
diese Fragen. Deshalb gehen wir auf die konkrete Umsetzung auch erst in Kapitel 3 genauer ein. Auf
den nachfolgenden Seiten dieses Abschnitts folgen allgemeine Beispiele für die Gruppe der
realionalen Datenbanken.
© 2001Ute Stegmann
Seite 20 von 20
Stand: 20.03.2001
2.2 Datenbankexport nach XML [Darstellungsansätze]
Es existieren eine Vielzahl an Möglichkeiten, den Inhalt einer Datenbank in XML "zu verpacken". Um
ein Gefühl dafür zu bekommen, wie diese XML-Darstellung aussehen kann, folgende
Grundüberlegung:
Man nehme eine bel. Tabelle einer Datenbank und vereinfache das Anschauungsmodell auf
"natürlichsprachige" Inhalte, d.h. Binärobjekte und andere spezielle Datentypen fallen "unter den
Tisch" (Hinweis: für solche Fälle gibt es in XML ja auch die Auszeichnung mit CDATA...). Dann
liegt es nahe, den Tabellennamen als Element aufzufassen und jede Tabellenzeile (also den Inhalt)
diesem Element unterzuordnen:
Unterstellt man folgende Datenbanktabelle
Tabelle: "franchisers"
bezeichnung
plz
ort
Friedhelm Meier
42477 Radevormwald
Franziskus GmbH 99999 In den Bergen
dann kann findet man in der Literatur oft folgende Umsetzung:
<franchisers>
<row>
<bezeichnung>Friedhelm Meier</bezeichnung>
<plz>42477</plz>
<ort>Radevormwald</ort>
</row>
<row>
<bezeichnung>Franziskus GmbH</bezeichnung>
<plz>99999</plz>
<ort>In den Bergen</ort>
</row>
</franchisers>
Das ist die "schöne" und ausführliche Umsetzung. Da XML - in ungepackter Form - ein sehr
ausuferndes Dateiformat ist, sollte man Vereinfachungen vornehmen und abstrahiert beispielsweise
folgendes:
Auszeichnung der Tabellenfelder als Elemente
<franchisers>
<bezeichnung>Friedhelm Meier</bezeichnung> <plz>42477</plz> <ort>Radevormwald</ort>
</franchisers>
<franchisers>
<bezeichnung>Franziskus GmbH</bezeichnung> <plz>99999</plz> <ort>In den Bergen</ort>
</franchisers>
Seite 21 von 21
Stand: 20.03.2001
Eine Alternative kann aber auch so aussehen:
Auszeichnung der Tabellenfelder als Attribute
<franchisers bezeichnung="Friedhelm Meier" plz="42477" ort="Radevormwald" />
<franchisers bezeichnung="Franziskus GmbH" plz="99999" ort="In den Bergen" />
Da es (noch) keinen Standard gibt, wie dies am besten umgesetzt werden sollte, entwickelt hier derzeit
jeder Hersteller sein eigenes Süppchen. Aus meinen bisherigen Erfahrungen gibt es für beide Ansätze
gute Gründe, die ich hier nachfolgend einmal zur Diskussion stellen möchte:
Aufstellung einiger potentieller Vorteile der Verkapselung von Tabellenfeldern
als Elemente
als Attribute
einfacher lesbar
platzsparendes Format
"multivalue"-Felder sind intuitiv umsetzbar
eindeutige Feldstruktur
Feldtypen in den Attributen der Elemente möglich Feldtypbeschreibungen in getrennter DTD
Die Vorteile des einen Formatierungsansatzes sind gleichzeitig in negierter Form die Nachteile des
anderen, bzw. umgekehrt.
Bei der Programmentwicklung dürfte es belanglos sein, welche Auszeichnung benutzt wird, da die
XPath-Funktionalität sowohl mit Elementen, als auch mit Attributen umgehen kann. Beim Transfer
zwischen verschiedenen Anwendungen sollte man derartige Konventionen aber frühzeitig zueinander
abstimmen.
© 2001Thorsten Rood
2.2 Datenbankexport nach XML [1:n-Beziehungen]
Während man sich in relationalen Datenbanken bei der Abbildung der Beziehungen zwischen
einzelnen Datensätzen selber Gedanken über die notwendigen Zeiger machen muss (und nur bei der
Erhaltung der Integrität anschließend durch das RDBMS unterstützt wird), gestaltet sich die
"klassische" 1:n-Beziehung in einem XML-Datensatz völlig intuitiv.
franchisers
RDBMS-Tabellen:
locations
Id ort
plz
1
Radevormwald 42477
2
In den Bergen
bezeichnung
ort_id
Friedhelm Meier
1
Friedrich Müller
1
Franziskus GmbH 2
99999
Seite 22 von 22
Stand: 20.03.2001
XML-Datensatz (hier am Beispiel der Auszeichnung durch Attribute):
<locations name="Radevormwald" plz="42477">
<franchisers bezeichnung="Friedhelm Meier" />
<franchisers bezeichnung="Friedrich Müller" />
</locations>
</locations name="In den Bergen" plz="99999">
<franchisers bezeichnung="Franziskus GmbH" />
</locations>
2.2 Datenbankexport nach XML [Informationsmix]
Schlussendlich verwischt XML auch die physikalische Trennung von Datenpools, die man in
Datenbanken zwangsläufig (schon aus technischen Gründen) vornehmen muss. So ist es kein Problem,
Informationen unterschiedlichster Herkunft in ein einzelnes XML-Dokument zu speichern.
<customer>
<personal_data bezeichnung="Friedhelm Meier" plz="42477" ort="Radevormwald" />
<billing_information type="credit_card" ref="Eurocard" number="47110815" />
<orders item="XML-Kochbuch" price="DEM 98,90" ref="11426992" />
<orders item="XPath Quick-Tour" price="DEM 48,99" ref="6625341" />
</customer>
<result last_action="ok" detail="Artikel wurde Ihrem Warenkorb hinzugefügt" />
<cross_selling>
<book title="XML in 21 Tagen" ref="888451228" />
<book title="XML für Dummies" ref="3342192" />
<cdrom title="XML-Examples" ref="776352533" dvd="yes" />
</cross_selling>
Ausblick:
1. Durch die Anwendung verschiedener Stylesheets (z.B. interaktiv in Abhängigkeit vom
Benutzer) kann man Daten, Erfolgs- und Fehlermeldungen sowie Statusinformationen in
einem einzigen XML-Datensatz abwickeln und je nach Bedarf entsprechend die
Informationen anzeigen oder verbergen.
2. Durch XPath erhält man eine leistungsfähige Navigations- und Selektionstechnik, nur die
notwendigen Informationen aus einem "bunt gemischten" XML-Datensatz zu extrahieren.
Seite 23 von 23
Stand: 20.03.2001
2.2 Datenbankexport nach XML [eigene Programme]
Auch wenn wir uns in diesem Seminarbeitrag hauptsächlich mit Datenbanken mit XML-Unterstützung
beschäftigen, kann es sehr wohl sinnvoll den Export von Datenbank-Informationen mit eigenen
Prozeduren / Programmen oder zumindest mit DB-neutralen Tools durchzuführen.
Gründe dafür könnten sein:
•
•
•
Die geplante Applikation soll möglichst unabhängig von der eingesetzten Datenbank sein
(z.B. weil diese noch nicht feststeht oder ein Wechsel der DB-Produkte später möglich
sein soll)
Die geplante Internet-Applikation hat verschiedene Datenquellen (siehe hierzu auch
Kapitel 1.3 XML als Hub Format)
Die Datenquelle ist eine Datenbank, die XML nicht unterstützt und geeignette
Middleware soll nicht angeschaft werden
In diesen Fällen kann es also sinnvoll sein die am Anfang dieses Kapitels beschriebenen Abläufe
selbst zu Programmieren. Hierfür können im Prinzip verschiedene teilweise bereits in den
Seminarbeiträgen 1 - 8 beschriebene Techniken genutzt werden (z.B. CGI). Wir gehen in unserem
Seminarbeitrag auf die Möglichkeiten von Java im Zusammenhang mit XML näher ein (siehe hierzu
Kapitel 2.4).
© 2001Matthias Knop
2.3 XML-Import in Datenbanken
Das Importieren bzw. genauer die Übernahme neuer, geänderter oder gelöschter Informationen aus
XML-Strukturen in Datenbanken ist komplizierter als das Exportieren. Hierbei müssen zunächst
einmal die DB-Strukturen (z.B. Tabelleinformationen, Feldinformationen bei relationalen Datenbanen)
ermittelt werden. Dabei ist das zugrunde liegende Mapping (Abbildung) zu berücksichtigen wie es in
2.1 und 2.2 bereits beschrieben wurde. Anschließend müssen diese Informationen mit den
Informationen aus den XML-Strukturen zu den entsprechenden Datenbankanweisungen (z.B. als SQLKommandos) zusammengefügt werden. Dabei sind natürlich gewisse Plausibilitäten notwendig auf die
ich hier nicht genauer eingehen werden. Jeder kann sich aber vielleicht vorstellen, das mindestens die
Art des Feldinhaltes geprüft werden sollte und auf die Eindeutigkeit bestimmter Indizes zu achten ist.
Es wäre dabei auch möglich, nicht alle Feldinhalte in dem XML-Dokument anzugeben. Z.B. könnten
eindeutige IDs bei der Übernahme automatisch vergeben werden oder einige Felder nicht gefüllt
werden (NULL-Wertel), weil sie später mit anderen Anwendungen gepflegt werden sollen.
Das konkrete Vorgehen und die Syntax solcher Funktionen ist abhängig vom eingesetzten
Datenbanksystem (siehe Kapitel 3).
Über die Techniken der DB-Ansteuerung lesen ebenfalls in den Nachfolgenden Abschnitten bzw.
Kapitel mehr.
Ein mögliches Vorgehen bei einer relationalen könnnte vereinfacht beispielsweise etwa so aussehen:
Seite 24 von 24
Stand: 20.03.2001
•
Einfügen von Daten (Insert)
1. Die Rohform eines Insert-Statement für die gewünschte Datenbank-Tabelle wird generiert.
2. Je einzufügendem Datensatz wird aus dem XML-Dokument die Belegung der Feldinhalte
extrahiert und der Insert durchgeführt.
Beispiel 1:
Die Tablle einer relationalen Datenbank wurde mit folgendem Statement angelegt:Create
Table Auftragstabelle (Auftragsnummer NUMBER, Auftragsdatum DATE, ArtikelNummer
NUMBER, BestellMenge NUMBER)
Der Insert aus folgender XML-Struktur
<Auftragstabelle>
<Row>
<Auftragsnummer>1</Auftragsnummer>
<AuftragsDatum>21.02.2001</OrderNumber>
<ArtikelNummer>120565</ArtikelNummer>
<BestellMenge>10</BestellMenge>
</Row>
<Row>
<AuftragsDatum>02/02/2001 0:0:0</OrderNumber>
<ArtikelNummer>120568</ArtikelNummer>
</Row>
</Auftragstabelle>
kann durch folgende zwei SQL-Statements ausgeführt werden:
INSERT INTO Auftragstabelle (Auftragsnummer, Auftragsdatum, ArtikelNummer ,
BestellMenge) VALUES ('1', '02/21/2001 0:0:0', '120565','10')
INSERT INTO Auftragstabelle (Auftragsnummer, Auftragsdatum, ArtikelNummer ,
BestellMenge) VALUES ('2', '02/01/2001 0:0:0', '120568','4')
•
Ändern von Daten (Update)
Ein Update kann im Prinzip genauso umgesetzt werden wie ein Insert. Wichtig ist allerdings.
das aus dem XML-Dokument die eindeutige Identifikation eines zugeordnetten Datensatzes in
der Datenbank hervorgeht (Außnahme: Komplexer Update über mehrere Datensätze). Wenn
nur einzelne Feldinhalte geändert werden sollen, ist natürlich für den Update auch eine XMLStruktur denkbar, die nicht alle Feldnamen enthält.
Beispiel 2:
Betrachten wir noch einmal obiges Insert-Beispiel. Eine nachträgliche Änderung der
Bestellmenge von 4 auf 5 des Auftrages Nummer 2 könnte als Update mit folgender XMLStruktur als Eingabe ausgeführt werden:
<Auftragstabelle>
<Row>
</Row>
</Auftragstabelle>
UPDATE Auftragstabelle SET BestellMenge = '10' WHERE Auftragsnummer = '1'
Seite 25 von 25
Stand: 20.03.2001
•
Löschen von Daten (Delete)
Für das Löschen von Datensätzen gilt wie beim Ändern, dass er über die XML-Struktur
eindeutig identifizierbar sein muss. Dies kann wiederum durch Angabe des eindeutigen Keys
in der XML-Struktur geschehen.
Beispiel 3:
In Anlehnung an die Beispiele 1 und 2 würde das spätere Löschen des 2. Auftrages über den
Delete aus folgender XML-Struktur ausgeführt:
<Auftragstabelle>
<Row>
</Row>
</Auftragstabelle>
resultierendes SQL-Statement
Delete Auftragstabelle WHERE Auftragsnummer = '2'
Bleibt abschließend zu bemerken, dass Datenbankänderungen natürlich auch sehr viel komplexer sein
können. Änderungen können sich z.B. auch auf mehrere Datenbanktabellen beziehen. Grundsätzlich
ist dies dann eine Frage des Designs der Anwendung bzw. der Festlegung sauberer Schnittstellen.
Wichtig ist dabei vor allem, dass das Mapping zwischen XML und der jeweiligen Datenbank vorher
genau festgelegt wird.
Alle Fragen, die im Zusammenhang mit der Datenkonsistenz, Multiuserbetrieb,Transaktionen, etc.
sind natürlich auch bei Änderungsfunktionen mittels XML zu bedenken.
© 2001Ute Stegmann
2.3 XML-Import in Datenbanken [eigene Programme]
Wir haben in dem vorherigen Kapitel 2.2 bereits darauf hingewiesen, warum es unter gewissen
Umständen sinnvoll sein kann die XML-Unterstützung möglichst unabhängig von der verwendeten
Datenbank bzw. dessen Hersteller zu halten. Dies gilt natürlich nicht nur für den Datenexport sondern
sogar verstärkt für den Import.
Insbesondere sind die Möglichkeiten eigener Entwicklungen bzw. plattformneutraler Produkte oft
weitreichender und können besser speziellen Anforderungen angepaßt werden.
Für die Übernahme (Einfügen,Ändern und Löschen) von XML-Informationen in Datenbanken müssen
im ersten Schritt wie wir gesehen haben zunächst einmal die XML-Strukturen analysiert werden um
daraus später Datenbank-Zugriffe zu erzeugen. Hierfür benötigt man sogenante XML-Parser.
Wir beschäftigen uns im nächsten Kapitel "Java und XML-Parser" mit den in Java bestehenden
Möglichkeiten und geben Hinweise auf bereits bestehende Lösungen.
Seite 26 von 26
Stand: 20.03.2001
2.4 Java und XML-Parser
Quelle:[OBJMID1] (OBJEKT SPEKTRUM 5/99)
Die Aufgabe: Ein XML-Dokument soll Verarbeitet werden. Welche Programmiersprache und welche
Werkzeuge stehen zur Verfügung? Java ist hier das Mittel der Wahl, zumal es hier leistungsfähige und
frei verfügbare java-basierte Werkzeuge gibt. Zu den Herstellern von Java-Software für XML zählen
unter anderem so bekannte Namen wie JavaSoft, Microsoft, Oracle und IBM.
XML wurde unter anderem für den Einsatz im Web als Antwort auf die Beschränkungen von HTML
entwickelt. Auch Java zählt zu den wichtigen Web-Technologien.
Ein weiteres gemeinsames Merkmal ist der Unicode. So wie XML auf die Kodierung von UnicodeZeichen ausgelegt ist, so bietet auch Java Unterstützung an. Im Quelltext sind Unicode-Zeichen
erlaubt und der Datentyp char sowie zahlreiche Klassen in der Standardbibliothek erlauben die
Verarbeitung von Unicode.
Es gibt noch weitere strukturelle Analogien:
•
•
•
•
Eine Java-Klasse legt die Struktur und alle Merkmale der daraus erzeugten Objekte fest.
Bei XML definiert die DTD (Dokument Type Definition) die Struktur der damit
ausgezeichneten Dokumente und die Charakteristika der erlaubten Elemente.
Wie bei Java zwischen einer Klasse und den von ihr erzeugten Exemplaren unterschieden
wird, spricht man auch bei XML von der DTD und den Exemplaren einer DTD.
Aus der Baumhierarchie der Bestandteile eines XML-Dokuments kann ein Baum von
Java-Objekten generiert werden.
Die Attribute eines Elementknotens können auf Attribute einer Java-Klasse abgebildet
werden, die dieses Element repräsentiert(sogenannte XML-Beans).
XML-Dokumente durchlaufen üblicherweise folgenden Zyklus:
1. Erstellung einer DTD: Dadurch wird die Stuktur der Dokumente festgelegt.
2. Erstellung eines Dokumentes: Dieses Dokument entspricht der festgelegten Struktur.
Diese Dokumente werden in Analogie zur OOP Exemplare ihrer DTD genannt.
Seite 27 von 27
Stand: 20.03.2001
3. Analysieren des Dokuments mit einem Parser: Hierbei baut der Parser einen ParseBaum auf, dessen Knoten die Bestandteile des Dokuments repräsentieren. Bei XML wird
zwischen validierenden und nicht-validierenden Parsern unterschieden. Validierende
Parser bekommen neben dem Dokument auch die DTD als Eingabe und prüfen das
Dokument auf Konformität mit der DTD. Nicht-validierende Parser beschränken sich
dagegen auf die Generierung des Parse-Baumes. Sie kommen dann zum Einsatz, wenn
davon ausgegangen werden kann, dass die zu verarbeitenden Dokumente korrekt sind, und
wenn es darauf ankommt, den Parse-Baum möglichst schnell aufzubauen. Entsprechend
den verschiedenen Teilen, aus denen ein XML-Dokument besteht, gibt es verschiedene
Knotentypen ( für die DTD, Elemente, Attribute, Entitäten usw.). Ein einzelner Knoten
kann das Vorkommen eines in der DTD definierten Strukturelements (Kapitel, Absatz,
Aufzählung usw.) repräsentieren oder auch einen Unicode-String enthalten (etwa den Titel
eines Kapitels)
4. Verarbeitung des Parse-Baums: Dies geschieht in der sogenannten Applikation, die die
eigentliche Verarbeitungslogik enthält. eine Applikation könnte ein Konverter nach
HTML oder ind das Portable Document Format (PDF) sein oder auch eine Datenbank, die
XML-Dokumente speichert.
Für die letzen beiden Stufen sind java-basierende Werkzeuge verfügbar.
Bei der Entwicklung von XML-Applikationen hat man es vorwiegend mit zwei
Programmierschnittstellen zu tun: DOM und SAX.
DOM
Beim DocumentObject Model (DOM) handelt es sich um einen vom WorLd Wide Web
Consortium (W3C) standardisierten Satz von Schnittstellen für die einzelnen Knotentypen des
Parse-Baums. So gibt es ein Interface Element, das einen Elementknoten repräsentiert.
Element hat unter anderem eine Methode getTagName(), mit der der Name des Elements
abgerufen werden kann.
Für DOM existieren verschiedene Java-Implementierungen. Einige Parser, wie z. B.
"XML4J" von IBM, "XP" von James Clark oder "Project X" von JavaSoft verfügen über eine
DOM-Implementierung.
Insgesamt sind die Funktionen von DOM recht einfach gehalten; bei komplexeren
Applikationen benötigt man oft zusätzliche Funktionen, die die verschiedenen Parser bieten.
DOM ist daher nur als kleinster gemeinsame Nenner zu betrachten. Bei der Parser-Auswahl
ist auch darauf zu achten, welche Möglichkeiten die einzelnen Pakete über die reine
Implementierung von DOM hinaus bieten.
Ortmals sind solche Funktionen essentiell für eine Anwendung und somit ausschlaggebend
für die Auswahl des Werkzeugs. Wenn der Zugriff auf den Parse-Baum nur über die DOMInterfaces erfolgt, hat man zwar den Vorteil, daß die Applikation vollständig unabhängig von
den Parsern und ihrer DOM-Implementierung ist. Nachteil ist allerdings, daß die
Möglichkeiten der Applikation hinsichtlich des Zugriffs auf den Parse-Baum und seine
Inhalte eingeschränkt und mitunter recht umständlich sind. Die zusätzlichen Funktionen der
Parser bieten hier mehr Komfort.
Seite 28 von 28
Stand: 20.03.2001
SAX
Die Simple API for XML (SAX) wurde von David Megginson entwickelt und definiert einen
einheitlichen Zugriff auf den Parser. Ähnlich wie DOM besteht SAX zum größten Teil aus
Interfaces, die parser-spezifisch durch sogenannte SAX-Treiber implementiert werden. Bei
den Parsern von IBM, JavaSoft und James Clark wird ein SAX-Treiber mitgeliefert. Für
andere Parser, wie z. B. "msxml" von Microsoft, sind Treiber von Drittanbietern verfügbar.
SAX definiert beispielsweise eine Methode parse(), mit der der Parser veranlaßt wird, ein
Dokument zu analysieren. Darüber hinaus spezifiziert SAXInterfaces und Klassen, mit denen
eine XML-Applikation beim Eintritt bestimmter Ereignisse während der Baumtraversierung
Callbacks erhalten kann, z. B. beim Erreichen des Anfangs oder des Endes eines Elements im
Dokument.
2.5 XML-Darstellung
Die Darstellung der XML-Syntax entspricht nicht unbedingt einer idealen, übersichtlichen Darstellung
für den Anwender. Dafür sollten vielmehr ansprechende Internet-Seiten angezeigt werden. Das XMLFormat enthält aber keine Informationen darüber, wie die Daten dargestellt werden sollen. Dafür sind
die Style Sheets oder Skripte zuständig – sie bestimmen das Aussehen der fertigen Web-Seite und die
dort erfolgende Anzeige der einzelnen Elemente. Es gibt mehrere Möglichkeiten, XML-Daten zu
formatieren. Cascading Style Sheets (CSS) sind die derzeit am häufigsten genutzte und gleichzeitig
einfachste Form hierfür. Mit einer Einschränkung: Die erzielbaren Formatierungen sind im Vergleich
zu anderen Verfahren eher geringer. Die Extensible Style Language (XSL) ist zwar etwas komplexer,
dafür aber auch um einiges leistungsfähiger. Aber auch in diesem Fall gibt es eine Einschränkung:
Noch nicht alle Browser unterstützen XSL-Formatierungen. Allerdings wird die Unterstützung durch
Third-Party Produkte von Tag zu Tag besser. Eine weitere Technik ist das Document Object Model
(DOM), das in Verbindung mit einer Skriptsprache wie JavaScript oder VBScript eingesetzt wird.
Zwar mit deutlich höherer Komplexität, aber dafür andererseits mit einer Vielfalt an Methoden zum
Formatieren und Editieren von XML-Daten oder deren Umwandlung in HTML und umgekehrt.
Die Verknüpfung eines Style Sheets oder Skriptes mit den aktuell von einer Datenbank
zurückgelieferten Daten ist denkbar einfach, selbst wenn das betreffende Style Sheet von einem
anderen Web-Server angefordert werden muss. Alle bisher beschriebenen Formatierungsvarianten
haben nämlich einen gemeinsamen Vorteil: Die Formatierungsinformationen sind in einer separaten,
von den Daten getrennten Datei abgelegt. Datenbankdesigner und Entwickler brauchen daher nicht auf
vertrauten Tools zu verzichten, um Style Sheets zu entwerfen oder Skripte zu schreiben. Mit einer
guten Vorausplanung vor Beginn des Datenbankdesigns ist es möglich, viele unterschiedliche
Datenbankabfragen mit einigen wenigen Style Sheets oder Skripten zu ermöglichen.
Lesen Sie bitte die Grundlagen über XML, XSL etc. im Beitrag Thema 8 "XML-Grundlagen".
© 2001Ute Stegmann, Thorsten Rood
Seite 29 von 29
Stand: 20.03.2001
2.5 XML-Darstellung [Fortsetzung]
Oft steckt der Teufel im Detail. Sobald man mit XSL-Techniken beginnt, sollte man sich zuerst von
dem Irrglauben befreien, dass HTML eine Teilmenge von XML sei. Der Umstand, dass HTML
beispielsweise nicht wohlgeformt sein muss, hat auch in der Entwicklung von Webbrowsern dazu
geführt, dass an bestimmten Stellen Probleme auftauchen, sobald kritische HTML-Anweisungen dann
doch einmal in wohlgeformter Syntax auftauchen. Das fällt zwar in der Mehrheit der Fälle in die
Kategorie "Programmfehler", dennoch kann man die bereits installierte Basis nicht einfach
ignorieren...
Besonderheiten:
•
•
•
HTML-Anweisungen in einem XSL-Stylesheet müssen immer wohlgeformt sein, auch
wenn es nach W3C eigentlich nicht notwendig vorgegeben ist. Sonst meldet nämlich der
XSLT-Prozessor einen Syntaxfehler (die XML-Daten sind dann ja fehlerhaft) und
traversiert die Dokumente nicht oder nicht zu Ende.
HTML-Code kann nicht einfach von bestehenden Produkten zum Site-Design "kopiert"
werden, da ein Nachpflegen der Wohlgeformtheitsklauseln i.d.R. länger dauert als direkt
gültigen HTML-Code zu entwickeln.
"kurze" HTML-Elemente werden nicht von jedem Browser verstanden. So sind
<textarea></textarea>
und
<textarea />
XML-syntaktisch gleichwertig, bei letzterem steigen jedoch ältere Browser aus...
Zur Darstellung des Template-Matching bei XSLT verweise ich auf die Demo des MSSQL2K im
Rahmen dieses Referatthemas.
Ein absolut unverzichtbarer Aspekt zur Aufbereitung eines XML-Dokuments in das HTML-Format ist
ein Grundlagenverständnis in XPath - einer Terminologie zur Navigation in einem beliebig komplexen
XML-Dokument und zur Selektion definierter Elemente und Attribute zur weiteren Verarbeitung. Ein
guter Einstieg findet sich in [STMU1] sowie [MIBA1] und wird aus Komplexitätsgründen hier nicht
weiter verfolgt. Nur soviel (stark vereinfacht) vorweg: Wer einen relativen Pfadnamen im Dateisystem
bilden kann, ist auch in der Lage, eine Kurznotation von Elementen bzw. Attributen in einem
hierarchischen XML-Dokument zu formulieren. Allerdings trägt dies dem Leistungsumfang von
XPath nicht Rechnung, dieser geht weit darüber hinaus...
2.6 Datenbank-Benutzeranfragen
Natürlich braucht man eine definierte Schnittstelle, um Datenbankoperationen (i.d.R. SQLAnweisungen) über das Internet verfügbar zu machen. In der Vergangenheit sind eine Vielzahl von
Produkten entstanden, die versuchen, eine Brücke vom Web in die Datenbank zu bieten
(Schablonentechniken, Servlets, usw.)
Streng genommen entsteht in Zusammenhang mit der XML-Technik hier auch "nur" ein weiteres
Produkt in diesem Umfeld, schließlich ist XML erst einmal nur eine Transporthülle um beliebige
Daten. Nun sind diese Daten eben SQL-Anfragen.
Eine Norm zur Realisierung ist aber (noch) nicht in Sicht, so dass hier die von den einzelnen
Seite 30 von 30
Stand: 20.03.2001
Herstellern eingeschlagenen Wege stark voneinander abweichen. Ich glaube, dass hier noch einiges
passieren wird, denn immerhin bei der Auswertung von XML-Datensätzen (also dem Ergebnis der
Datenbankabfragen) scheint man sich auf gemeinsame Nenner einigen zu können (XPath, XPointer).
Der Weg "raus" aus dem Datenbanksystem in Abhängigkeit von benutzerdefinierten Parametern, d.h.
der Export von Informatioen in XML-konforme Datenpakete dürfte von jedem Hersteller, der zum
heutigen Zeitpunkt mit XML-Features wirbt, gewährleistet sein. Unterschiedlich leistungsfähig fallen
dagegen Schnittstellen und Mechanismen zum Import der XML-Daten aus. Die Wunschliste ist lang im Idealfall schickt man einfach einen formatierten XML-Datensatz an das RDBMS und alle
notwendigen Tabellen werden automatisch auf den neuesten Stand gebracht...
In den nachfolgenden Kapiteln wird vielleicht deutlich, dass das zwar funktioniert, aber längst nicht so
einfach realisiert ist, wie es klingt.
2.7 XML-Dokumente mit gemischtem Inhalt (BLOB,CLOB)
Bisher haben wir uns hauptsächlich mit der Abbildung von Datenorientierten XML-Dokumenten
(siehe 2.1) in relationale, objekt-relationale oder objektorientierte Datenbanken beschäftigt, bei denen
die XML-Strukturen relativ eindeutig (z.B. XML-Tags sind einem Tabellennamen oder einem Feld
einer DB-Tabelle zugeordnet) zugeordnet werden. Bisher ging es also um klar struktierte Daten, die
sinnvoll in klassischen Datenbanken abgelegt werden können. Wir kommen nun noch zu einer anderen
Art Datentypen. Die Integration der Typen Binary Large Object (BLOB) und Character Large Object
(CLOB) ermöglicht die Verwaltung großer Objekte in einer Datenbank. Insbesondere Anwendungen
wie "Digitale Bibliotheken" nutzen diese Datentypen. Durch die Verwaltung großer Objekte in der
Datenbank kommt der Retrieval-Funktionalität hier eine wachsende Bedeutung zu. Neben den
unstrukturierten Textobjekten existiert eine Dokumentenkategorie, die eine implizite Struktur
aufweist, die aber aufgrund der Heterogenität nicht durch ein Datenbankschema beschrieben werden
kann. Was hat das mit XML zu tun? Nun, wir erinnern uns an die Dokumentoriententen XMLDokumente, also XML-Daten mit vermischtem Inhalt, bei denen die direkte Abbildung in die
klassischer Feldtypen eines Datenbank-Schemas nicht sinnvoll erscheint.
Ein Beispiel:
<PHOTOARCHIV>
<ORT>MADEIRA</ORT>
<AUTOR>ANNA STEGMANN</AUTOR>
<REISEBERICHT>Eine schöne Insel ...
..sehr empfehlenswert sind ...
..und dann haben wir noch den höchsten Berg
und da lag doch tatsächlich Schnee .. man sagte die Kinder
hatten so etwas noch nie gesehen ..
...auch mit dem Linienbus kann man ..
..
<REISEBERICHT>
<BILD1>
[hier digitale Bilddaten]
</BILD1>
<BILD2>
</BILD2>
...
<BILD214>
</BILD214>
<PHOTOARCHIV>
Seite 31 von 31
Stand: 20.03.2001
Diese XML-Struktur wird man sicher nicht in klassische Datenbankstrukturen bzw. -Typen
abbilden, sondern hier kommen die oben genannten Typen BLOB bzw. CLOB zum tragen.
[Quin] beschreibt zwei Strategien zur Speicherung solcher Strukturen in einer Datenbank.
Entweder man speichert die komplette XML-Struktur als ganzes in einen BLOB oder man
zerteilt die Hauptstruktur in sinnvolle Unterstrukturen, die dann wiederum als BLOB oder
CLOB gespeichert werden. In unserem Beispiel könnte man also REISEBERICHT als CLOB
und BILD1 bis BILD214 als BLOB speichern. Die Zielrichtung solchen Vorgehens dürfte
auch klar sein. Es geht darum, diese Daten strukturiert abzulegen, um später gezielt nach
bestimmten Inhalten suchen bzw. sie darstellen zu können. Derzeit gibt es zwar noch keine
ausgereiften Möglichkeiten in Bildquellen nach bestimmen Inhalten zu suchen, aber wer
wünscht sich nicht für die Zukunft auch in Bilddateien gezielt z.B. nach Landschaften suchen
zu können. Wie Datenbank-Hersteller solche Anforderungen konkret umsetzten, werden wir
in Teil 3 sehen. Meiner Meinung nach sind reine XML-Datenbanken wie z.B. Tamino (siehe
3.1.4) dazu am Besten geeignet.
© 2001Ute Stegmann
2.8 XML Query
Effizientes und skalierbares Datenmanagement für XML benötigt die Unterstützung durch
Datenbanken. Heutige Losungen basieren auf relationaler oder objektorientierter Technologie, die der
semi-strukturierten Struktur von XML nur unzureichend gerecht werden. Daher wird unter Obhut des
World-Wide-Web-Consortium W3C (siehe [W3CI1]) derzeit an der auf XML zugeschnittenen,
deklarativen Anfragesprache "XML Query" gearbeitet.
Die Ziele dieser Bemühungen werden vom [W3CI1] so beschrieben:
"The mission of the XML Query working group is to provide flexible query facilities to extract data
from real and virtual documents on the Web, therefore finally providing the needed interaction
between the web world and the database world. Ultimately, collections of XML files will be accessed
like databases.
Specifications:
o
o
o
o
o
XML Query Requirements, last release 16 February 2001
XML Query Use Cases , first release 16 February 2001
XML Query Data Model, last release 16 February 2001
The XML Query Algebra, last release 16 February 2001
XQuery: A Query Language for XML, first release 16 February 2001"
Das Datum der letzen Änderung läßt schon ahnen, dass es noch keine Datenbank gibt, die eine XMLQuery-Sprache nach der neuesten Beschreibung des W3C unterstützt. Das ist auch der Grund, warum
wir hier nicht genauer auf die Inhalte dieser Beschreibungen eingehen.
Allerdings gab es in jüngster Vergangenheit, sehrwohl solche Art Sprachen die zum Zeitpunkt ihres
entstehens den damals aktuellen Stand der Bemühungen des W3C unterstützten. Zunächst wurde dafür
z.B. der Begriff XQL (z.B. von Software AG, eXcelon, GMD-IPSI) verwendet, heute gibt es z.B. XQuery von der Software AG für eben die erwähnte Tamino-XML-Datenbank. Wir haben in Kapitel
1.4. bereits darauf hingewiesen. Die Sprache der Software AG basiert laut Hersteller-Angaben auf
XPATH.
Seite 32 von 32
Stand: 20.03.2001
Beispiel:
Hier noch einmal das kleine Beispiel aus 2.1 zur Verdeutlichung
des Prinzips:
BOERSENLEXIKON/BEGRIFF = 'Aktie'
Dies könnte etwa angewandt auf eine relationale Datenbank
folgender SQL-Anfrage entsprechen:
SELECT * BORSENLEXIKON
WHERE BEGRIFF ="Aktie"
Sprachen gemäß XML Query dürfen allerdings auch auf reine XML-Dokumente angewandt werden
(siehe obige Beschreibung der Ziele der "XML Query working group").
© 2001Ute Stegmann
Seite 33 von 33
Stand: 20.03.2001
3 XML-Einsatz in Datenbanken-Applikationen
In diesem Kapitel wird nun die Unterstützung von XML durch Standarddatenbanken näher untersucht.
Unter DB-Produkte wird dabei zunächst eine Übersicht (Kurzvorstellungen) von Datenbankprodukten
gegeben. Wir beschränken uns dabei im wesentlichen auf einige uns wichtig erscheinende relationale
Standard-Datenbanken wie IBM DB2, Oracle 8i/9i und Microsoft SQL Server. Als Beispiel aus der
Katagorie der reinen XML Datenbanken wird die Tamino XML Database der Software AG kurz
beschreiben. MS SQL Server 2000 und Oracle 8i werden in 3.2 bzw. 3.3 dann konkret vertieft.
Abschließende wird versucht eine Bewertung der vorgestellten Technologien und Produkte
durchzuführen.
3.1 Übersicht Datenbank-Hersteller und -Produkte
3.2 Microsoft SQL 2000
3.3 Oracle 8i/9i XML-SQL Utility(XSU)
3.4 Bewertung
3.1 Übersicht Datenbank-Hersteller und -Produkte
In [ROBOU2] findet man unter der Überschrift "XML und Databases" einen Recht gut strukturierten
Überblick von Produkten zum Thema XML und Datenbanken.
[ROBOU2] schreibt
"I have divided products into the following seven categories. Please note that the
boundaries between some of these categories, especially XML-Enabled Databases, Native
XML Databases, XML Servers, and XML Application Servers, is somewhat arbitrary.
Middleware: Software you call from your application to transfer data between XML
documents and databases. For data-centric applications.
XML-Enabled Databases: Databases with extensions for transferring data between XML
documents and themselves. Primarily for data-centric applications.
Native XML Databases: Databases that store XML in "native" form. The term is not well
defined, but these are designed to maintain the structure of XML documents. For dataand document-centric applications.
XML Servers: Platforms that serve data -- in the form of XML documents -- to and from
distributed applications, such as e-commerce and business-to-business applications.
Primarily for data-centric applications.
XML Application Servers: Web application servers that serve XML -- usually built from
dynamic Web pages -- to browsers. For data- and document-centric applications.
Content Management Systems: Systems for managing fragments of human-readable
documents and include support for editing, version control, and building new documents
from existing fragments. Primarily for document-centric applications.
Persistent DOM Implementations: DOM implementations that use a database for speed
and to avoid memory limits. For data- or document-centric applications.
In general, you have to write code to integrate Middleware, XML-Enabled Databases,
Native XML Databases, XML Servers, and Persistent DOM implementations with your
applications. XML Application Servers require you to do some scripting, and Content
Management Systems need to be configured, which may be a non-trivial task in itself."
Seite 34 von 34
Stand: 20.03.2001
Die Nachfolgenden Kurzvorstellungen beziehen sich hauptsächlich auf "XML-Enabled Databases"
wobei wir uns auf einige uns wesentlich erscheinende Standard-Datenbanken beschränken wie IBM
DB2, Oracle 8i, Microsoft SQL Server, Filemaker und zusätzlich als Beispiel aus der Katagorie der
"Native XML Databases" die Tamino XML Database kurz beschreiben. Um die Brücke zu den JAVA
XML-Parsern (siehe Kapitel 2 Grundlagen XML-Parser) zu schlagen, werden wir außerdem die
beiden Oracle-Produkte "XML SQL Utility for Java" und "XSQL Servlet" auszugsweise vorstellen.
(MS SQL Server 2000 und Oracle 8i werden in Kapitel 3.2 und 3.2 vertieft)
Übersicht der Datenbankhersteller/-produkte:
3.1.1 IBM DB2 XML Extender
3.1.2 Oracle 8i/9i, XML SQL Util, XSQL
3.1.3 Microsoft SQL Server, Access
3.1.4 Tamino XML Database
3.1.5 Verschiedene Datenbank-Hersteller
Anmerkung:
Unter Verschiedene Datenbank-Hersteller finden Sie noch ein paar DB-Produkte, die im Rahmen der
Seminararbeit nicht näher untersucht wurden, aufgelistet.
© 2001Ute Stegmann
3.1.1 IBM DB2 XML Extender
Der DB2 XML Extender von IBM ist eine DB2 UDB Erweiterung, die die Möglichkeit zum Speichern
und Aufrufen von XML-Dokumenten und zum Generieren von XML-Dokumenten aus vorhandenen
relationalen Daten sowie zum Unterteilen (Zerlegen, Speichern nicht markierter Elemente oder
Attributinhalte) von XML-Dokumenten in relationale Daten bietet. XML Extender bietet dafür neue
Datentypen, Funktionen und gespeicherte Prozeduren (stored procedures) zum Verwalten von XMLDaten in DB2. Der XML Extender ist für die Betriebssysteme Windows NT, AIX, Sun Solaris und
LINUX verfügbar. Im einzelnen werden in [DB2EXT] die Möglichkeiten wie folgt beschrieben:
" Speicher- und Zugriffsmethoden
XML Extender bietet zwei Speicher- und Zugriffsmethoden für die Integration von
XML-Dokumenten in DB2: XML-Spalte und XML-Objektgruppe. Diese Methoden
werden sehr unterschiedlich verwendet; sie können jedoch in derselben Anwendung
eingesetzt werden.
XML-Spalte
Diese Methode ermöglicht das Speichern intakter XML-Dokumente in DB2. XMLSpalte eignet sich gut zum Aktivieren von Dokumenten. Die Dokumente werden in
Spalten eingefügt, die für XML aktiviert sind und aktualisiert, abgerufen und
durchsucht werden können. Element- und attributive Daten können DB2-Tabellen
(Seitentabellen) zugeordnet werden; diese wiederum können für eine schnelle
strukturelle
XML-Objektgruppe
Diese Methode ermöglicht das Zuordnen von XML-Dokument-strukturen zu DB2Tabellen, so daß Sie entweder XML-Dokumente aus vorhandenen DB2-Daten
Seite 35 von 35
Stand: 20.03.2001
zusammensetzen oder XML-Dokumente in DB2-Daten zerlegen (nicht markierte
Element- oder Attributinhalte speichern) können. Diese Methode eignet sich gut für
Anwendungen zum Datenaustausch, besonders wenn der Inhalt der XML-Dokumente
häufig aktualisiert wird.
DTD-Repository
Der XML Extender bietet ein XML DTD-Repository (Document Type Definition),
eine Gruppe von Deklarationen für XML-Elemente und -Attribute. Beim Aktivieren
einer Datenbank für XML wird eine DTD-Referenztabelle (DTD_REF) erstellt. Jede
Zeile dieser Tabelle stellt eine DTD mit zusätzlichen Metadaten-Informationen dar.
Die Benutzer können auf diese Tabelle zugreifen, um ihre eigenen DTDs einzufügen.
Die DTDs in der Tabelle DTD_REF werden zum Überprüfen von XML-Dokumenten
verwendet.
Dokumentzugriffsdefinitionen (Document Access Definitions, DADs)
Sie geben in einer Dokumentzugriffsdefinition (Document Access Definition, DAD)
an, wie strukturierte XML-Dokumente verarbeitet werden sollen. Die DAD ist selbst
ein formatiertes XML-Dokument. Sie ordnet bei Verwendung von XML-Spalten oder
XML-Objektgruppen eine XML-Dokumentstruktur einer DB2-Datenbank zu. Die
Struktur der DAD ist bei der Definition einer XML-Spalte anders als bei einer XMLObjektgruppe. DAD-Dateien werden über die Tabelle XML_USAGE verwaltet; diese
Tabelle wurde beim Aktivieren einer Datenbank für XML erstellt.
Verwaltungs-Tools
Die Verwaltungs-Tools zum XML Extender erleichtern das Aktivieren der Datenbank
und der Tabellenspalten für XML und das Zuordnen der XML-Daten zu den
relationalen DB2-Strukturen. Der XML Extender bietet verschiedene VerwaltungsTools, je nachdem, ob Sie eine Anwendung entwickeln oder einfach mit einem
Assistentenprogramm (Wizard) arbeiten wollen. Sie können die Verwaltungs-Tasks
für den XML Extender mit den folgenden Tools ausführen: · Die XML Extender
Verwaltungsassistenten bieten eine grafische Benutzerschnittstelle für die
Verwaltungs-Tasks. · Der Befehl dxxadm bietet eine Befehlszeilenoption für
Verwaltungs-Tasks. · Die gespeicherten Prozeduren des XML Extender für die
Verwaltung enthalten Optionen für die Anwendungsentwicklung zu VerwaltungsTasks."
Ein kurzes einführendes Beispiel findet man auf den IBM-Internetseiten unter XML Extender
Administration and Programming/Getting startet .
Ferner bietet IBM auch eine Trialversion und Dokumentationen zum Download an.
© 2001Ute Stegmann
Seite 36 von 36
Stand: 20.03.2001
3.1.2 Oracle 8i/9i, XML SQL Util, XSQL
Oracle bietet eine sehr ausgereifte Unterstützung von XML. In Kapitel 3.3 gehen wir noch konkret
daruf ein. Ein kompakte Zusammenfassung der Möglichkeiten zitieren wir aus [ROBOU2] :
" Oracle 8i can store XML documents in three different ways: in the Internet File
System (iFS), using the XML SQL Utility for Java, and as a BLOB that can be
searched using the Oracle Intermedia XML Search. Oracle 8i also includes a number
of other XML-related tools, the most interesting of which is the XML Class
Generator, which can generate Java classes from a DTD.
With iFS, one or more type definition (mapping) files defines how to map an XML
document as a tree of data-specific objects. iFS uses these mapping files both to
construct tables in which the XML document can be stored, and to transfer data
between XML documents and the database. Of interest, iFS can return data from the
database directly as objects instead of XML documents, which is useful to many
applications. iFS also supports content management features such as check-in/checkout and versioning.
The XML SQL Utility for Java was described .."(siehe unten)" When it is used with
Oracle 8i, it models XML documents as a tree of data-specific objects, since Oracle 8i
supports SQL 3 object views.
Oracle Intermedia XML Search is a utility that can, "Automatically index and search
XML Documents and Document Fragments of any size up to 4 Gigabytes each. [It
has] powerful XML document searching including hierarchical element containership,
doctype discrimination, and searching on XML attributes."
Oracle 9i (announced 2 Oct, 2000) includes "Native XML Database Support (XDB)",
which introduces a new object data type (XMLType) and "features ... 'navigational'
access and search for XML documents."
XML SQL Utility for Java is a set of Java classes for transferring data between a
relational database and an XML document. These classes may be used through one of
the provided front ends or in a user-written application. The product is model-driven.
If the database supports SQL 3 object views, it models the document as a tree of dataspecific objects; otherwise it models the document as a single table. When transferring
data from the database to XML, the user provides either a SELECT statement or a
JDBC result set; the results are returned as an XML document or DOM Document.
When transferring data from XML to the database, the user provides an XML
document or DOM Document. Options include specifying some of the tags used in the
output document.
XSQL Servlet is a Java servlet that uses the XML SQL Utility for Java to transfer data
from a relational database to an XML document. The servlet is template-driven, with
SELECT statements embedded in the template as elements; when processed, these are
replaced by the result of the query, formatted as XML. Support for passing query
parameters through HTTP and for processing the output document with XSL are
provided. "
© 2001Matthias Knop, Ute Stegmann
Seite 37 von 37
Stand: 20.03.2001
3.1.3 Microsoft SQL Server, Access
SQL Server 2000
Der Microsoft SQL Server 2000 unterstützt XML direkt. Dabei gibt es verschiedene Varianten, die in
Kapitel 3.2 ausführlich beschrieben werden. In Kapitel 4 wird außerdem eine kleine Applikation
"Party-Service" vorgestellt, die mit MS Sql server 2000 umgesetzt wurde. Der MS SQL Server 2000
ist für das Betriebssystem Microsoft Windows 2000 (Server) verfügbar, kann aber auch noch unter NT
4.0 betrieben werden.
Access
Microsoft Access bietet keinen direkten XML-Support. Es ist aber möglich z.B. über Microsoft Active
Server Pages (ASP) XML zu nutzen. In dem Buch "Web-Datenbanken Schritt für Schritt" aus der
Microsoft-Press-Reihe [MS1] wird dies in Kapitel E "Datenaustausch mit XML" beschrieben. Da
Access eine weit verbreitete Datenbank ist (insbesondere haben auch viele Privatanwender diese
Datenbank) und zumindest für Anwendungen mit kleinerem Datenvolumen durchaus interessant ist,
wollten wir dies hier nicht unerwähnt lassen.
© 2001Ute Stegmann
3.1.4 Tamino XML Database
Die Software AG bietet mit Tamino neben einer reinen XML-Datenbank, die laut [ROBOU2]
hierarchisch ist, eine ganze Reihe von Werkzeugen und Entwicklungsumgebungen für XMLArchithekturen an.
Der Hersteller Software AG ([SAG1]) sagt über Tamino:
•
•
•
•
•
•
•
•
"Tamino
... ist der Information-Server für Electronic Business
... basiert auf der nativen XML-Technologie der Software AG (X-Machine)
... greift auf beliebige Datenquellen zu (X-Node)
... ermöglicht Datenaustausch zwischen Unternehmen auf der Basis von XMLDokumenten
... wurde von Grund auf für Internet-Anwendungen entwickelt
... unterstützt XQL aber auch SQL für strukturierte Daten
... basiert auf anerkannten Standards (XML, HTTP, TCP/IP)
... unterstützt NT, Unix und Mainframe-Systeme"
Wer Tamino ausprobieren möchte kann derzeit ein sogenanntes Tamino Starterkit als 90-Tage-Version
per Internet bei der Software AG ([SAG2]) bestellen, wenn man sich dort regristrieren läßt (aber
Achtung: Man benötigt ausreichend Speicher - 256 MB - und ein Apache-Web-Server muß installiert
werden). Das Starterkit umfaßt - soweit wir das in der Kürze beurteilen konnten - neben der XML
Datenbank sämtliche Tamino XML-Werkzeuge.
Ein ausführlich vorgestelltes Beipiel für eine Anwendung, die die Tamino XML-Datenbank nutzt,
haben wir Ausgabe 3.2001 März der Zeitschrift "Java Magazin" ([JAVA1]) in dem Artikel "Tamino:
Die Pur-XML-Datenbank für ein Medizin-Forum" gefunden.
© 2001Ute Stegmann
Seite 38 von 38
Stand: 20.03.2001
3.1.5 Verschiedene Datenbank-Hersteller
Informix
"Informix supports XML through its Object Translator and through the Web DataBlade.
The Object Translator generates object code, including the ability for objects to transfer their data to
and from the database. It also supports functionality such as transactions and optimistic and
pessimistic locking. XML support is provided through generated methods that transfer data between
objects and XML documents. Users map XML documents to a tree of data-specific objects (and the
database) with a GUI tool. Version 2.0 of the Object Translator (beta expected in Sept. 2000) is
expected to support SOAP as well as be able to generate XML DTDs from object schema and
relational schema.
The Web DataBlade is an application that creates XML documents from templates containing
embedded SQL statements and other scripting language commands. It is run from a Web server and
supports most major Web server APIs." (aus [ROBOU2] )
Filemaker
FileMaker Pro stellt XML über den FileMaker Web Companion zur Verfügung.
Hier ein Auszug aus der der Hersteller-Beschreibung "XML Overview":
"Mit FileMaker Pro lassen sich Daten in drei unterschiedliche XML-Formate konvertieren.
Es handelt sich dabei um:
• FMPDSORESULT (Datenbankabhängig)
• FMPXMLRESULT (Datenbankabhängig)
• FMPXMLLAYOUT
FMPDSORESULT und FMPXMLRESULT sind alternative XML-Vokabularien zur
Beschreibung von Datensätzen und Feldern einer FileMaker Pro Datenbank. Die Auswahl
hängt davon ab, ob Sie ein einheitliches XML-Format für alle Datenbanken nutzen
möchten oder ob verschiedene Datenbanken mit spezielleren – und somit unterschiedlichen
– XML-Vokabularien arbeiten sollen.
Das FMPDSORESULT-Format verwendet Elemente, deren Namen denjenigen der
Datenbankfelder entsprechen. Das bedeutet, dass Sie gleichen Datenbankfeldern
unterschiedliche stilistische Regeln mit mehreren CSS zuordnen können. Dabei muss
allerdings für jede Datenbank, mit der Sie arbeiten möchten, ein separates Style Sheet
entworfen werden.
Die FMPXMLRESULT-Grammatik verwendet ein Vokabular mit Elementen, die
Datensätze, Felder, Ergebnisse etc. repräsentieren. Mit diesen Elemen-ten lässt sich jede
Datenbank hinreichend beschreiben, sie sind jedoch etwas gewöhnungsbedürftig. So wird
ein Buchtitel mit dem gleichen Daten-Tag (DATA) beschrieben, das auch für den Namen
des Autors, ISBN-Nummern, Preisangaben und andere Felder verwendet wird. Hierdurch
wird die Zuord-nung von unterschiedlichen Stilen zu verschiedenen Feldern durch CSS
schwierig. XSL Style Sheets sind dagegen flexibler und verstehen sich deut-lich besser mit
einer von Datenbanktabellen unabhängigen Grammatik anstatt der Verwendung von
namenlosen Hinweisen wie es beispielsweise Elementbeschreibungen sind.
Kommen wir nun zur FMPXMLLAYOUT-Grammatik. Diese dient zur Beschreibung der
semantischen Vereinbarungen und nicht der Daten einer Tabelle – sagt also etwas über die
Gültigkeit von Werten im Rahmen einer Werteliste aus. "
Weitere Produkte finden Sie bei [ROBOU2] .
© 2001Ute Stegmann
Seite 39 von 39
Stand: 20.03.2001
Nach vielen Überlegungen zu Möglichkeiten und Anforderungen zur XML-Integration in
Datenbanksystemen soll hier ein Einblick gegeben werden, in welchem Umfang die aktuelle Version
des SQL Server 2000 von Microsoft derartige Features bereit stellt. Die Ausführungen beziehen sich
auf die SQL 2000 Server Enterprise Edition (wobei sich lt. Produktdatenblatt die sog. StandardEdition in Bezug auf XML-Support identisch verhalten soll), nachfolgend nur noch mit MSSQL2K
bezeichnet.
Auch wenn der Produktname es nicht unbedingt vermuten lässt, kann man den MSSQL2K auch noch
unter Windows NT 4.0 betreiben, im Zusammenhang mit Internettechnologien empfielt Microsoft
allerdings den Einsatz unter Windows 2000 (höhere Performance des IIS).
Ein Betrieb direkt unter Unix-OS ist nicht möglich; ein Betrieb in heterogener Umgebung aber
realisierbar.
Mit Hinblick auf das grundlegende Seminarthema "Datenbanken in Internetumgebungen" wurde eine
Beispielanwendung erstellt, welche eine fiktive Datenbank anstatt über traditionelle ScriptingTechnologien nun weitestgehend über XML/XSL-Architektur des MSSQL2K "ins Web bringt".
Zuerst aber eine Vertiefung der XML-Features und der Philosophie, die der MS-Lösung zugrunde
liegt.
Themenüberblick:
3.2.1 Begriffe
3.2.2 Lesezugriffe DB->XML
3.2.3 Schreibzugriffe XML->DB
3.2.4 Stylesheets
3.2.5 Security
3.2.6 Performance
3.2.7 Entwicklung/AddOns
3.2.8 Einsatz in Linux-/Unix-Umgebungen
3.2.1 Begriffe
Bei der Beschreibung der XML-Architektur des SQL-Server besteht leicht die Möglichkeit, im Laufe
des Textes in FLAs (four-letter-acronyms) und TLAs (three-letter-acronyms) zu verfallen und damit
den Leser unmittelbar zu vergraulen. Da sich einige spezifische Abkürzungen nicht wirklich
vermeiden lassen, folgt nun erst eine kleine Erklärung der Dienste, die einen Server auf WindowsBasis ans Internet ankoppeln (Firewall bleibt zur Vereinfachung unberücksichtigt).
I. Internet Information Server
Der Webserver der Microsoft Plattform ist der Internet Information Server [kurz: IIS], der aus
getrennten Diensten für die Protokolle http(s) und ftp besteht.
Seite 40 von 40
Stand: 20.03.2001
II. Plugin-Technologie
Um nachträglich Funktionen in den Webserver bereitstellen zu können, ist das Internet Services
Application Programming Interface [kurz: ISAPI] zu benutzen. Dies erlaubt es, http(s)-Anfragen in
Abhängigkeit von Protokoll, URL bzw. URL-Pfad und/oder Dateinamenserweiterung durch
entsprechende (genormte) Zusatzprogramme verarbeiten zu lassen. Dabei werden die notwendigen
Module beim ersten Aufruf permanent in den Speicher geladen, so dass kein Performanceeinbruch
entsteht.
Der prominenteste Vertreter der Plugins ist das Modul für Active Server Pages [kurz: ASP], also die
serverseitige Skriptsprache von Microsoft. In frühen Produktversionen (v3) war ASP tatsächlich noch
gesondert zu installieren, seit IIS4 ist es serienmäßig "an Bord".
Inzwischen existieren u.a. ISAPI-Module für PHP4, Perl, Phyton und die MS-Outlook WebOberfläche des Exchange Server 2000.
III. Multi-Tier
...ist kein MS-spezifischer Ausdruck, aber dennoch wichtig zu wissen: Nur, weil man - rein technisch
betrachtet - einige hundert Funktionalitäten auf einen einzigen Server packen kann, heißt das noch
lange nicht, dass man das auch so realisieren sollte. Unter hoher Lastanforderung bzw. differenzierter
Sicherheitsbedürfnisse muss man Dienste und Rechenlast auf mehrere Server verteilen und zwar u.a.
eine Verteilung unter funktionalen Gesichtspunkten (z.B. Trennung von Web- und Datenbankserver).
Man gelangt so zu einer n-tier-Architektur. Eine gängige Unterteilung für Internet-Anwendungen ist
die 3-Tier-Architektur, d.h.
•
•
•
1st-Tier: Client (Javascript oder "passiv")
2nd-Tier: Webserver (Server-Side Scripting)
3rd-Tier: Datenbankserver (SQL stored procedures)
IV. Virtual Directories
...sind keine Erfindung von MS, sondern gängige Praxis in der Verwaltung eines Webservers. Über ein
Alias, welches sich in der URL für den Benutzer wie ein Verzeichnis auf dem Webserver darstellt,
können Daten aus dem nachgelagerten (und von außen damit eigentlich nicht erreichbaren) Netzwerk
im Internet publiziert werden.
Mit diesen Informationen sollte das nachfolgende Schaubild zur Implementation verständlich sein.
Der XML-Support des MSSQL2K wird durch ein ISAPI-Plugin realisiert, welches sich in den IIS
einklinkt und für jede entsprechend freigegebene SQL-Datenbank ein virtuelles Verzeichnis - relativ
zum Root-Folder der selektierten Web-Site - konfiguriert. Über dieses Alias können die
Datenbankzugriffe abgewickelt werden.
Seite 41 von 41
Stand: 20.03.2001
Abb301: Verteilung der Funktionen für den XML-Support im MSSSQL2K
Durch die neue Technologie ergeben sich Veränderungen und Besonderheiten für die einzelnen
Ebenen:
1st-Tier: Client
Wünschenswert ist es nach meiner Meinung, dass der Endanwender von der neuen Technologie nicht
negativ beeinflusst wird, d.h. nicht zum "Zwangs-Nachrüsten" genötigt wird. Damit bleibt die
Möglichkeit des Exports von XML-Rohdaten über die http(s)-Schnittstelle nur speziell angepassten
Anwendungen vorbehalten; für Browser muss eine Möglichkeit gefunden werden, den "üblichen"
HTML-Output zu erzeugen. Während in einem Corporate Network kaum Bedenken gegen den Einsatz
von Javascript vorherrschen dürften, muss für den Einsatz im Internet (z.B. in Shopping-Portalen,
Ordersystemen im B2B, Informationssystemen, usw.) eine Möglichkeit existieren, dass der Benutzer
auch mit deaktiviertem Javascript die Site ohne Einschränkungen benutzten kann.
Auf die benötigte Technik der XSL-Stylesheets und des Skripting wird in nachfolgenden Kapiteln
noch eingegangen.
2nd-Tier: IIS und SQLXML.DLL
Der Middleware kommt die Aufgabe zu, die Datenbankstruktur nach außen hin abzuschirmen (vgl.
nachfolgende Kapitel: Template-Technik) und ggf. eine Transformation des XML-Datenstroms in
HTML-Code durchzuführen (vgl. nachfolgende Kapitel: XSL-Stylesheets).
Außerdem besteht die Möglichkeit, die Datenstruktur der XML-Information an sich "on-the-fly" durch
zusätzliche Schemabeschreibungen und -definitionen zu verändern [DTD, annotated schema]. Auf
diese Technik wird aus Komplexitätsgründen nicht vertieft eingegangen. Nähere Informationen finden
sich in [MSSQ1].
3rd-Tier: SQL-Server
Der SQL-Server wurde für die XML-Unterstützung mit neuen Funktionen ausgestattet. Neben der
Fähigkeit des Streaming (weniger Zeitverzögerung bei Anfragen über http) sind zwei neue
Schlüsselwörter in den SQL-Sprachdialekt [Transact-SQL] eingefügt worden:
Seite 42 von 42
Stand: 20.03.2001
•
•
"select for xml" ist eine Erweiterung des Query-Befehls für Leseoperationen aus der
Datenbank und sorgt (in Abhängigkeit weiterer Parameter) für eine Strukturierung der
Datensätze als XML-Information anstatt als "klassisches Row-Set" (vgl. nachfolgendes
Kapitel: Lesezugriffe DB->XML).
"OpenXML" ist ein dynamischer Tabellenplatzhalter, der es gestattet, auf XML-Daten
wie eine SQL-Tabelle zugreifen zu können (vgl. nachfolgendes Kapitel: Schreibzugriffe
XML->DB).
3.2.2 Lesezugriffe DB->XML
Der MSSQL2K unterstützt für Leseoperationen die bereits in den Grundlagen vorgestellten
Technologien URL-SQL, URL-Template und URL-Template mit XPath. Natürlich sind auch
Schreibzugriffe über diese Schnittstellen möglich, da die Mehrheit aller Befehle des Transact-SQL zur
Verfügung steht - diese wären dann aber nur auf "eindimensionale" Eingabeparameter beschränkt und
nicht auf die Verarbeitung eines komplexen Datenelements anwendbar.
Die XPath-Funktionalität im Rahmen des virtuellen Verzeichnisses geht (in dieser Version des
MSSQL2K) allerdings nicht so weit wie XPath-Anweisungen im Rahmen von XSL-Templates. Bei
der Erstellung der Demoanwendung ist mir dies nicht als Einschränkung aufgefallen, da hauptsächlich
XSL-Stylesheets gebraucht wurden. Bei neu entwickelten Anwendungen, welche direkt mit XMLDaten arbeiten können, mag das Fazit anders ausfallen. Ich glaube allerdings, dass die Mehrheit der
XPath-Anweisungen auch über Selektionskriterien in den zugrunde liegenden Datenbankoperationen
abzubilden ist. Das hätte dann zusätzlich den Vorteil, dass von vorneherein weniger Daten zur
Verarbeitung übrig blieben - bei gleichem Ergebnis.
Die drei erwähnten Schnittstellen können einzeln aktiviert bzw. deaktiviert werden. Beim Zugriff über
alle Schnittstellen ist gemeinsam, dass im Ergebnis ein XML-Datensatz erwartet werden soll, so dass
zwingend ein Statement der Art "select ... for xml ..." auftauchen wird. Diese Befehlserweiterung
kennt drei verschiedene Parameter:
•
select ... for xml raw
Der XML-Datensatz wird "ohne Gimmicks" transferiert, d.h. jeder Datensatz wird durch
ein mit "row" benanntes Element ausgegeben. Dies ist nur bei eindimensionalen
Datenbankabfragen sinnvoll.
•
select ... for xml auto
Der XML-Datensatz wird "hübsch" formatiert, d.h. jedes Element wird so benannt wie die
zugehörige Tabelle und Elemente aus einer 1:n-Relation bei geschickter Wahl der
Tabellenfelder und deren Reihenfolge in der Abfrage auch "passend" hierarchisch
geschachtelt.
•
select ... for xml explicit
Hier stehen (fast) alle Möglichkeiten offen, d.h. der Programmierer/Designer muss die
XML-Struktur selber definieren [DTD]. Eine detaillierte Beschreibung würde den
Umfang des Seminars sprengen und findet sich in [MSSQ1].
Seite 43 von 43
Stand: 20.03.2001
Unterstellt man folgende Datenbanktabelle
Tabelle: "franchisers"
bezeichnung
plz
ort
Friedhelm Meier
42477 Radevormwald
dann sehen die XML-Datensätze so aus:
select * from franchisers for xml raw
<base>
<row bezeichnung="Friedhelm Meier" plz="42477" ort="Radevormwald" />
<row bezeichnung="Franziskus GmbH" plz="99999" ort="In den Bergen" />
</base>
select * from franchisers for xml auto
<base>
</base>
Anmerkung: Die XML-ISAPI des MSSQL2K kann bei Leseoperationen auf der obersten Ebene des
XML-Datensatzes nur ein eindimensionales Element verwalten [hier: <base>] - eine Erklärung liefert
MS dafür nicht (wahrscheinlich vereinfacht es die Behandlung von "leeren" Abragen?).
3.2.2 Lesezugriffe DB->XML [URL-SQL]
Eine Möglichkeit, per http(s) auf SQL-Daten zuzugreifen, ist der SQL-Query [URL-SQL], d.h. das
SQL-Statement wird direkt in die URL verpackt.
Mit einer solchen Methode wird natürlich die Struktur der Datenbank nach außen unmissverständlich
offengelegt. Eine Kontrolle, welche Transact-SQL-Anweisungen möglich sind, wird nur noch über das
verwendete Benutzerkonto, also die Sicherheitsstruktur im SQL-Server selbst, möglich (vgl.
nachfolgendes Kapitel "Security"). Außerdem werden Hyperlinks sehr lang und unübersichtlich, so
dass mir eine Verwendung nur im frühen Entwicklungsstadium einer Web-Applikation oder im Zuge
einer ausgefeilten Sicherheitsstruktur und einer eigens erstellten Anwendung, welche die Befehle nicht
mehr dem Benutzer preisgibt, sinnvoll erscheint.
Sofern die URL-SQL-Schnittstelle freigeschaltet ist, akzeptiert das virtuelle IIS-Verzeichnis der
Datenbank verschiedene Parameter:
•
•
•
sql=Transact-SQL-Anweisung in internet-konformer Notation
root=Name des Parent-Elements
xsl=Name des XSL-Stylesheets, d.h. Datenstrom wird auf das Stylesheet umgelenkt und
entsprechend modifiziert (vgl. nachfolgendes Kapitel "Template-Matching")
Seite 44 von 44
Stand: 20.03.2001
Beispiele:
http://demo.server.intranet/my_database?sql=select+*+from+franchisers+for+xml+auto&root=base
http://demo.server.intranet/my_database?sql=exec+my_storedprocedure&root=base
(my_storedprocedure: select * from franchisers for xml auto)
3.2.2 Lesezugriffe DB->XML [URL-Template]
Eine typische Internet-Site mit Datenbankanbindung ist mit Sicherheit dadurch gekennzeichnet, dass
sich die Datenbankabfragen ähneln und deshalb "nach Schema F" immer einheitlich ablaufen,
abgesehen von situationsspezifischen Parametern (Produktnummern, Kundennummer, Ordernummer,
usw.).
In solchen Fällen bietet es sich an, diese Anweisungen in ein sog. Template zu speichern. Als
Hyperlink bleibt ein Dateiname - ggf. mit Parametern - übrig. Da die Übergabe von Parametern nicht
durch herstellerspezifische Erweiterungen erfolgt, sondern vom W3C genormt vorgegeben ist, kann
man ein solches Template auch als "action"-URL eines Formular angeben.
Beispiel:
my_template.xml
<base xmlns:sql="urn:schemas-microsoft-com:xml-sql">
<sql:header>
<sql:param name="suche"></sql:param>
</sql:header>
<sql:query>
select * from franchisers where ort=@suche for xml auto
</sql:query>
</base>
http://demo.server.intranet/my_database/my_template.xml?suche=Radevormwald
<base>
</base>
Die XML-ISAPI des MSSQL2K erkennt und verwaltet einen eigenen Namensraum sql, in den die
Anweisungen und Parameterdefinitionen verkapselt werden müssen. Da es als XML-Datei den
üblichen Syntaxanforderungen entsprechend muss, sind Vergleichsoperatoren in einer SelectAnweisung ggf. in Sonderzeichen zu deklarieren, d.h.
select * from franchisers where min <= @numof and max >= @numof for xml auto
Seite 45 von 45
Stand: 20.03.2001
wird zu
select * from franchisers where min <= @numof and max >= @numof for xml auto
da sonst der XML-Parser einen Fehler wegen Verletzung der Wohlgeformheitsanforderung melden
wird.
Der Vorteil der Lösung auf Template-Basis dürfte offensichtlich sein: Der Anwender sieht nichts mehr
von der Datenbankstruktur, denn das XML-Template wird (ähnlich ASP-Skripts) nicht mehr an den
Browser geliefert, sondern über das IIS-Plugin nur noch intern gelesen und verarbeitet. Der Client
(z.B. Webbrowser) erhält nur noch das Abfrageergebnis.
Auf diese Weise wird die Datenbanksicherheit und der Dateninhalt nicht durch Manipulationen von
außen gefährdet. (Jedenfalls nicht mehr, als es die Templates in sich bereits zulassen.)
Anmerkung: Das <root>-Element [hier: <base>] wird aus dem XML-Template übernommen.
Natürlich können auch mehrere SQL-Anweisungen in mehreren <sql:query>-Abschnitten benutzt
werden.
3.2.3 Schreibzugriffe XML->DB
Einzelne Datensätze könnten prinzipiell auch über die im vorhergehenden Kapitel beschriebene
Verkapselung durch XML-Templates angelegt und/oder aktualisiert werden, akzeptieren diese doch
beliebige benutzerdefinierte Parameter und können Befehle wie INSERT und UPDATE ausführen.
Dennoch gibt es Anwendungsszenarien für den XML-Import: Stellt man eine Schnittstelle zur
Verfügung, welche eine "Massenverarbeitung" zulässt, so ist das Speichern eines einzelnen
Datensatzes nur ein Spezialfall daraus. Die Erstellung und der Transport von Datensätzen kann
"offline" erfolgen und ein späteres Zusammenführen über dieselbe Schnittstelle erfolgen wie im
"online"-Betrieb.
In Summe muss man also nur noch eine Schnittstelle pflegen und kann damit eine Vielzahl von
Anwendungsszenarien abdecken...
Um die Hürde von einer strukturierten (evtl. hierarchischen) XML-Datenstruktur zu einer für RDBMS
typischen "flachen" Tabellenstruktur zu nehmen, stellt der MSSQL2K das Schlüsselwort OPENXML
(mit entsprechenden Parametern) zur Verfügung. OPENXML ist ein sog. "Rowset-Provider", d.h. an
jeder Stelle, an der die Transact-SQL-Sprachsyntax die lesende Benutzung einer Datenbanktabelle
erlaubt, kann OPENXML eingesetzt werden.
Seite 46 von 46
Stand: 20.03.2001
Abb302: Interpretation von XML-Daten als Tabellenform mit OpenXML
Was passiert hier? Nun, zuerst noch eine Anmerkung: Die Verarbeitung eines XML-Dokuments kann
sehr komplex werden, so dass der Zugriff über OPENXML mehrfach notwendig wird. Würde nun bei
jedem Aufruf der XML-Datensatz neu analysiert und bereitgestellt werden, so wäre die Performance
rasch "im Keller". Deshalb kann man OPENXML nicht ohne "Vorbereitungen" einsetzen - mit zwei
internen stored procedures sp_xml_preparedocument und sp_xml_removedocument muss die
Benutzung von OPENXML explizit verkapselt werden. Dadurch wird die XML-Struktur nur einmal
geprüft und im Speicher aufgebaut.
Mit dem OPENXML-Platzhalter wird aus einem hierarchischen XML-Dokument eine "flache"
Datenbanktabelle. Mit Rückgriff auf bekannte Beispiele nun ein etwas komplizierterer XMLDatensatz:
<base>
<locations name="Radevormwald" plz="42477">
<franchisers bezeichnung="Friedhelm Meier" unique_key="76" />
<franchisers bezeichnung="Friedrich Müller" unique_key="10056" />
</locations>
</locations name="In den Bergen" plz="99999">
<franchisers bezeichnung="Franziskus GmbH" unique_key="429" />
</locations>
</base>
Seite 47 von 47
Stand: 20.03.2001
Um die hier vorliegenden Informationen verarbeitbar zu gestalten, muss das XML-Dokument als
Datenbankzeilen interpretiert werden; ein "Cursor" muss für die <franchisers> auf der X-Path-Ebene
"/base/locations/franchisers", für <locations> auf der X-Path-Ebene "/base/locations" durch die
Dokumentstruktur laufen. Außerdem muss dem OPENXML-Platzhalter die gewünschte Struktur der
Datensätze und die Zuordnung von Tabellenfeldern zu XML-Attributen und -elementen beigefügt
werden ("with"-Klausel).
Eine mögliche OPENXML-Syntax wäre also:
exec sp_xml_preparedocument @xml_dom, OUTPUT, @xml_input
...
...
...
select * from OPENXML (@xml_dom, '/base/locations/franchisers', 2)
with (bezeichnung varchar(30) '@bezeichnung',
plz varchar(5) '../@plz',
ort varchar(30) '../@name',
id int '@unique_key')
...
...
...
select * from OPENXML (@xml_dom, '/base/locations', 2)
with (plz varchar(5) '@plz',
ort varchar(30) '@name')
...
...
...
exec sp_xml_removedocument @xml_dom
OPENXML /base/locations/franchisers
bezeichnung
plz
ort
Friedhelm Meier
42477 Radevormwald 76
Friedrich Müller
42477 Radevormwald 10056
id
429
OPENXML /base/locations
plz
ort
42477
Radevormwald
99999
In den Bergen
Ein berechtigter Einwand wäre jetzt "Hey, da wird ja gar nichts in die Datenbank gespeichert!".
Stimmt - in diesem Beispiel (noch) nicht. Nun dürfte aber nachvollziehbar sein, was über OPENXML
eigentlich zurückgeliefert wird.
Seite 48 von 48
Stand: 20.03.2001
3.2.3 Schreibzugriffe XML->DB [Fortsetzung]
Nun komme ich zum eigentlichen Update. Nicht ohne Grund enthält die fiktive Datenbanktabelle
<franchisers> einen Primärschlüssel "id", schließlich muss ein Mechanismus existieren, die
Datensätze eindeutig zu identifizieren.
So kommt man zur Aktualisierung von Datensätzen:
...
...
...
update franchisers
set
franchisers.bezeichnung = my_input.bezeichung,
franchisers.plz = my_input.plz,
franchisers.ort = my_input.ort
from OPENXML (@xml_dom, '/base/locations/franchisers', 2)
id int '@unique_key') as my_input
where franchisers.id = my_input.id
...
...
...
Wahrscheinlich ist die hier verwendete Syntax nicht so bekannt, deshalb folgende Erläuterung: Die
Aktualisierung eines einzelnen Datensatzes kennt man in der SQL-Notation
update <table> set (<field1>,<field2>,...,<field_n>)
values (<value1>,<value2>,...,<value_n>)
where <table>.<any_field> = <expression>
um einen einzelnen Datensatz zu aktualisieren. Zulässig in Transact-SQL ist aber auch die
Verwendung einer weiteren Datenbanktabelle, um eine "Massenverarbeitung" zuzulassen:
update <table1>
set
<table1>.<field1> = <table2>.<field1>,
<table1>.<field2> = <table2>.<field2>,
...
<table1>.<field_n> = <table2>.<field_n>
from <table2>
where <table1>.<any_field> = <table2>.<any_field>
Fügt man in der letzteren Syntax statt <table2> die OPENXML-Technologie ein, erhält man das oben
angegebene Beispiel. Natürlich wird die ganze Angelegenheit noch etwas komplizierter, wenn man
auch auf der Seite der SQL-Datenbank eine relationale Anordnung der Daten unterstellt. Dies würde
Seite 49 von 49
Stand: 20.03.2001
aber den hier vorgestellten Rahmen deutlich sprengen und fällt auch eher in das Themengebiet "SQLSprachsyntax und -dialekte"...
Die einfachsten Dinge benötigen oft mehr Erklärung als im Kern eigentlich passiert. So auch hier.
Bisher war nur von Transact-SQL-Anweisungen die Rede. Bleibt noch zu (er)klären, wie die Brücke
vom Internet hin zu OPENXML zu nehmen ist.
Die Lösung wurde schon im Rahmen der Lesezugriffe dargestellt: URL-Templates.
So sieht dann das fertige "Kochrezept" für OPENXML aus:
1. Aufbau eines XML-Datensatzes durch Javascript im Webbrowser, durch Übergabe der
entsprechenden Felder an eine ASP-Seite, welche diesen Datensatz serverbasiert erzeugt
oder durch eine spezifische Anwendung, die mit http-Aufrufen umgehen kann.
2. Aufruf eines URL-Templates, welches den XML-Datensatz als Parameter akzeptiert und
als SQL-Anweisung eine benutzerdefinierte stored procedure ansteuert.
3. Definition einer benutzerdefinierten stored procedure, welche die OPENXMLTechnologie benutzt.
Vollständige Lösung:
my_template.xml
<base xmlns:sql="urn:schemas-microsoft-com:xml-sql">
<sql:header>
<sql:param name="datensatz"></sql:param>
</sql:header>
<sql:query>
exec my_xmlupdate @datensatz
</sql:query>
</base>
stored procedure my_xmlupdate
create procedure [dbo].[my_xmlupdate] @xml_input ntext
as
update franchisers
set
franchisers.bezeichnung = my_input.bezeichung,
franchisers.plz = my_input.plz,
franchisers.ort = my_input.ort
from OPENXML (@xml_dom, '/base/locations/franchisers', 2)
id int '@unique_key') as my_input
where franchisers.id = my_input.id
go
Seite 50 von 50
Stand: 20.03.2001
http(s)-Aufruf
http://demo.server.intranet/my_database/my_xmlupdate.xml?datensatz=<base><locations>...</locations></base>
Auf diese Weise wird die Rechenlast auf dem Web-Server deutlich reduziert, da sämtliche
Datenbankoperationen unmittelbar auf dem SQL-Server ausgeführt werden. Zudem sind stored
procedures vorcompiliert, so dass die Verarbeitung insgesamt schneller erfolgt als bei einer Lösung,
welche die Daten im Rahmen eines serverbasierten Skripts in der Datenbank aktualisiert.
3.2.4 Stylesheets
Für speziell angepasste Anwendungen ist die XML-Schnittstelle zur Kommunikation ausreichend. Ein
(i.d.R. anonymer) Anwender im Internet stellt "höhere" Anforderungen; hier muss die Darstellung der
HTML-Syntax genügen.
Zu diesem Zweck gibt es die Möglichkeit, das "XML-Ergebnis" einer URL-SQL-Abfrage bzw. eines
URL-Templates einem XSLT-Prozessor zu übergeben. Dieser traversiert unter Zuhilfenahme eines
XSL-Stylesheets die XML-Quelledaten in ein neues Dokument. Bei geschickter Wahl der
Ersetzungsregeln entsteht ein HTML-Dokument.
Diese Umformungen geschehen auf dem Webserver selbst und funktionieren demnach auch mit
"uralten" Browsern.
Anwendung von XSLT:
URL-SQL
Aufruf
http://demo.server.intranet/my_database?sql=select+*+from+franchisers+for+xml+auto&root=base
&xsl=my_stylesheet.xsl
URL-Template
Aufruf
http://demo.server.intranet/my_database/template.xml
template.xml
<base xmlns:sql="urn:schemas-microsoft-com:xml-sql" sql:xsl="my_stylesheet.xsl">
<sql:query>
select * from franchisers for xml auto
</sql:query>
</base>
Seite 51 von 51
Stand: 20.03.2001
Bei der Erstellung des XSL-Stylesheets und der zugehörigen X-Path-Navigation ist zu
berücksichtigen, dass in der Microsoft-Implementation für den XML-Datensatz aus den
Tabellenbezeichnungen die Elementnamen und aus den Feldbezeichnungen die Attributnamen
gebildet werden, sofern nicht durch ein benutzerdefiniertes Schema (im Rahmen dieses Referats nicht
weiter besprochen) die Struktur gänzlich anders aufgebaut wird.
Ein einfaches Beispiel: Die auf der vorhergehenden Seite beschriebenen Datenbankabfragen erzeugen
(intern) folgenden Datensatz:
<base>
</base>
Bei Benutzung des folgenden Stylessheets my_stylesheet.xsl
<?xml version='1.0' encoding='utf-8'?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<xsl:output media-type="text/html"/>
<xsl:template match="/">
<html>
<head><meta http-equiv="Content-type" content="text/html; charset=utf-8"/></head>
<body>
<table>
<tr>
<td><b>bezeichnung</b></td>
<td><b>plz</b></td>
<td><b>ort</b></td>
</tr>
<xsl:apply-templates select="base/franchisers"/>
</table>
</body>
</html>
</xsl:template>
<xsl:template match="franchisers">
<tr>
<td><xsl:value-of select="@bezeichnung"/></td>
<td><xsl:value-of select="@plz"/></td>
<td><xsl:value-of select="@ort"/></td>
</tr>
</xsl:template>
</xsl:stylesheet>
entsteht dieses HTML-Ergebnis:
bezeichnung
plz
ort
Friedhelm Meier
42477 Radevormwald
Seite 52 von 52
Stand: 20.03.2001
Vorsicht, Falle: Selbst wenn der Web-Browser in der Lage ist, XML-Daten darzustellen (z.B. MS
Internet Explorer ab v5), reicht es nicht aus, die notwendigen HTML-Informationen zu ergänzen, es
muss außerdem der MIME Content Type (um)definiert werden, da der Browser sonst trotzdem einen
Anzeigemodus wählt, der die Informationen strukturiert darstellt.
Zu diesem Zweck wird ein Element output im xsl-Namensraum zur Verfügung gestellt:
<?xml version='1.0' encoding='utf-8'?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<xsl:output media-type="text/html"/>
<xsl:template match="/">
...
</xsl:template>
</xsl:stylesheet>
Seite 53 von 53
Stand: 20.03.2001
3.2.5 Security
Mit der Freigabe einer Datenbank im Internet geht i.d.R. auch die Frage nach Sicherheitsmechanismen
einher. Selbst wenn der Datenbankinhalt einen öffentlichen Charakter besitzt, so muss dennoch die
Integrität und Struktur der Daten vor unbefugter Benutzung geschützt werden.
Im Zusammenhang mit XML-Technologie ist diese Frage besonders bedeutsam, handelt es sich doch
um ein offenes und meist selbsterklärendes Datenformat.
Zu klären ist (min.) die Fragestellung "wer kann wie und von wo in welchem Umfang auf welche
Daten der Datenbank zugreifen"?
1. wer?
Die Freigabe der Datenbank geschieht unabhängig bzw. ergänzend zur der Rechtestruktur
des Web-Servers, auf dem das virtuelle Verzeichnis für den XML-Support eingerichtet
wird.
Beim anonymen Zugriff wird das virtuelle Verzeichnis so konfiguriert, dass alle
Datenbankzugriffe über ein einheitliches Benutzerkonto abgewickelt werden (welches
dann inkl. Passwort auf dem IIS konfiguriert wird). Andernfalls wird beim ersten Zugriff
(genauer: bei Initialisierung der ersten IIS-Session pro Client) eine Kombination von
Benutzername und Passwort angefordert.
Wichtig: An dieser Stelle wird nur die Kombination von Benutzer und Passwort geklärt,
mehr nicht!
2. von wo?
Da der XML-Support als IIS-ISAPI realisiert ist, müssen alle Anfragen an die Datenbank
über den IIS geleitet werden. Deshalb erbt die XML-Freigabe die Rechtestrukturen des IIS
bezogen auf den angesprochenen Web-Server.
Dazu gehört z.B. die Definition der zulässigen IP-Adressbereiche (also beispielsweise
eine Einschränkung auf die Rechner des Corporate Network eines Unternehmens).
Ebenfalls über den IIS wird geregelt, ob als Zugriffsprotokoll http oder https
gewählt/notwendig ist.
3. in welchem Umfang auf welche Daten?
Die eigentliche Verwaltung und Einhaltung der Rechtestruktur obliegt ausschließlich dem
SQL-Server, d.h. der Benutzer erhält genau den Zugriffsumfang, welcher dem
Benutzerkonto aus 1) auf dem SQL-Server eingeräumt wurde. Gängige Unterscheidungen
sind Lese-, Schreib- und DBO-Rechte (DBO=Database owner).; eine sehr viel granularere
Unterscheidung ist natürlich (bis auf Feldebene) möglich...
4. mit welchen Techniken?
Eine generelle Voreinstellung der XML-Freigabe unterscheidet zusätzlich zwischen
Zugriffen durch URL-SQL, URL-Template, URL-XPath und http-post. Diese können
getrennt voneinander (global pro virtuellem XML-Verzeichnis) eingestellt werden.
Eine mehrfache Bereitstellung der Datenbank (bzw. der XML-Features) unter verschiedenen
Rechtestrukturen ist möglich, entsprechend viele virtuelle Verzeichnisse sind zu konfigurieren und zu
verwalten.
Vorsicht, Falle: Wird eine Freischaltung für URL-SQL nach Abschluss der Testphase nicht
deaktiviert, so kann - wenn die Datenbank mit einem Benutzerkonto auf dem Level des DBO oder gar
des SA erreichbar ist - ein unbefugter Benutzer ohne Rückfrage ein SQL-Statement ähnlich "drop
<table>" oder "drop <database>" ausführen!
Seite 54 von 54
Stand: 20.03.2001
3.2.6 Performance
Die Rechenlast zur Traversierung des Quelldokuments in HTML wird auf dem Web-Server generiert.
Allerdings ist die Vorgehensweise über XML/XSL schneller als über den "klassischen" Weg des
Skripting, bei dem Datenbankabfragen und Erzeugung der Ausgabe zeilenweise durch den IIS
realisiert werden und entlastet den Server also trotzdem.
Für den fiktiven Anwendungsfall eines Shopping-Portals gibt Microsoft in [MSMS2]
Vergleichsergebnisse zwischen ASP und XML/XSL für eine definierte Hardwareplattform bekannt:
Abb303: Performance des MSSSQL2K bei XSLT-Benutzung im Vergleich zu ASP
Diese Performance-Werte beziehen sich auf ungepufferte Abfrageszenarien. Unter Berücksichtigung
von Geschwindigkeitsverbesserungen durch Caching soll sich die "positive Lücke" um den Faktor 10
vergrößern.
Seite 55 von 55
Stand: 20.03.2001
3.2.7 Entwicklung/AddOns
Wenngleich eine Verarbeitung von XML-Datenpaketen beim Speichern mit dem OPENXMLPlatzhalter zum Erfolg führt, muss man (wie beschrieben) noch sehr viel Handarbeit bei der
Erstelltung der zuständigen Stored Procedure(s) aufwenden. Dies ist fehleranfällig, in punkto
Geschwindigkeit noch nicht sehr performant und nach meiner Meinung auch sehr lästig.
Als jüngste Entwicklung sollte man sich das Zusatzpaket XML for SQL Web Release 1 ansehen,
welches die ISAPI-Erweiterung um neue Funktionen ergänzt. Zum einen das Bulk-Load (Nutzung von
Streaming-Features beim Entgegennehmen von XML-Daten) und in diesem Zusammenhang
besonders interessant die sogenannten Updategrams: Durch geschickte Strukturierung der XMLDaten als "vorher/nachher"-Information werden die notwendigen INSERT-, UPDATE- und DELETEOperationen dann automatisch ausgeführt.
Da dieses Zusatzprodukt erst seit kurzem den Beta-Status verlassen und nun als kostenfreies FeatureRelease bereitsteht, entfällt hier eine detaillierte Beschreibung, zumal hier auch die DTD-Technik
(wieder) relevant wird und damit der Umfang des Seminars gesprengt wird.
Bedenkt man, dass der XML-Support in der aktuellen Version des MSSQL2K gerade erst Version 1.0
erreicht hat, sind hier bestimmt noch spannende Veränderungen zu erwarten. Dieser Eindruck hat sich
bei mir während der Themenbearbeitung ohnehin vertieft, denn herstellerübergreifend ist der Thema
XML sehr stark "in Bewegung"...
3.2.8 Einsatz in Linux-/Unix-Umgebungen
In einem homogenen Umfeld aus Microsoft-Produkten, in dem vom Desktop über den BackboneBereich bis hin zum Hosting die wesentlichen Technologien auf Microsoft basieren, gestaltet sich der
Einsatz der XML-Features relativ unproblematisch.
Zu einem wesentlichen Teil trifft man (z.B. aus Gründen der Lizenzproblematik und dem positiven
Standing von Unix und -derivaten im e-Business) aber auf Konstellationen, in denen eine Vielzahl von
Betriebssystemen und -plattformen miteinander integriert werden muss.
Nachfolgend einige Überlegungen zu einer Koexistenz von MSSQL2K-XML und Unix/Linux, der
wohl häufigsten Kombination in einem heterogenen Umfeld.
Grundsätzlich glaube ich, dass sich diese gemischte Umgebung nur ergibt, wenn ein Unternehmen im
Backbone bereits vorher eine Microsoft-Infrastruktur (als Ergänzung oder gleichberechtigt) unterhält,
denn niemand wird nach meiner Überzeugung nur wegen der XML-Features den MSSQL2K
implementieren, wenn damit auch die (Neu)einführung der Microsoft-Plattform notwendig wird. Für
solche Fälle gibt es genügend Alternativanbieter, deren Lösung unmittelbar auf Unix/Linux aufgesetzt
werden kann. Mögliche Implementationsszenarien:
1. Einbinden des MSSQL2K als virtuelles Verzeichnis auf dem Unix-System
Vorteil: schnellste Implementationsvariante
Nachteil: langsame Performance
2. Verkapselung des MSSQL2K in Skripting-Technologien auf dem Unix-System
Vorteil: "sanfte" Migration von bestehenden Lösungen
Nachteil: kein unmittelbarer Zugriff auf XML-Upload/-download von externen Clients,
sofern nicht entsprechende weitere Schnittstellen auf dem Unix-Host konfiguriert werden
3. Unterscheidung der Serverumgebungen durch die Port-Adresse durch Aufteilung der
http(s)-Anfragen über die vorgelagerte Firewall bzw. die vorgelagerten Load-Balancer
Vorteil: Koexistenz aller Features aus beiden Systemen
Nachteil: intuitive Eingabe der URLs nicht mehr möglich, d.h. Pflege und Administration
der Internet-Site wird aufwendiger
Seite 56 von 56
Stand: 20.03.2001
3.3 Oracle 8i/9i XML-SQL Utility(XSU)
In Kapitel 3.1.4 haben wir bereits eine kurze Zusammenfassung der Features von Oracle bezüglich
XML gegeben.
Hier noch einmal die Übersicht laut [ORACLE1]:
"Erweiterte XML Unterstützung
XML SQL Utility
Oracles XML SQL Utility ermöglicht das Schreiben und Lesen von XML Dokumenten in ihrem nativen
Format in die Datenbank bzw. aus der Datenbank.
Enhanced XML Development Kits (XDK)
XML Development Kits für Java, Java Beans, C, C++ und PL/SQL wurden in die Oracle Internet Developer
Suite integriert. Dieses XDK beinhaltet:
•
•
•
•
•
XML Parser für den programmatischen Zugang zu XML Dokumenten.
XSL Prozessoren transformieren jedes XML Dokument in jedes beliebige textbasierte
Format (z.B. HTML)
XML Klassen Generatoren generieren Class-Files für die Erzeugung von XML
Documenten, die in Anwendungen, Applets und JavaServer Pages verwendet
werden.
XML Java Beans bieten sichtbare und nichtsichtbare XML Funktionalitäten (z.B.
Viewing, Parsing und die Transformation von XML Dokumenten)
XSQL Servlets produzieren dynamische XML oder HTML Dokumente als Resultat
von SQL Abfragen über das Internet"
Wir wollen hier über das mit der Oracle Datenbank 8i bzw. der neuesten Version 9i nutzbare XML
SQL Utility berichten.
Vorweg aber noch ein Hinweis auf zum XSQL Servlet:
XSQL ist ein Java-Servlet von Oracle, das XML-Dokumente aus SQL-Anfragen liefert und diese über
ein XSLT-Stylesheet weiterverarbeiten kann. XSQL kann frei verwendet werden. Hierüber können
die mit dem XML SQL Utility gelieferten Funktionalitäten in einem Java Servlet genutzt werden. Im
Kapitel Demo XSQL Servlets stellen wir einen Link zu einer Demo-Seite des Oracle Technology
Network (OTN) im Internet bereit. Auf dieser Seite stellt Oracle kleine Beispiele teilweise inklusive
des Source-Codes zum ausprobieren bereit.
Nun aber zu dem XML SQL Utility (XSU):
3.3.1 Oracle XML-SQL Utility [Funktionsprinzip]
3.3.2 Oracle XML-SQL Utility [Command Line Front End]
3.3.3 Oracle XML-SQL Utility [Java API]
3.3.4 Oracle XML-SQL Utility [PL/SQL]
Seite 57 von 57
Stand: 20.03.2001
3.3.1 Oracle XML-SQL Utility [Funktionsprinzip]
Vorbemerkung: Als Informationsquelle des nachfoldenen Beitrags wurde [XSU1], der XSUDokumentation von Oracle verwendet.
Das Oracle XML SQL-Utility (XSU) ist in Java geschrieben, es kann deshalb laut Oracle im Prinzip in
allen Archithektur-Komponenten genutzt werden, die Java unterstützen.
Nachfolgend erhaltenÜberblick über die Einsatzmöglichkeiten und das Funktionsprinzip:
Einsatz von XML-SQL Utility in der Datenbank (Genereller Überblick)
Die Datenbank Oracle 8i bzw. spätere Versionen unterstützt Java ("java enabled Oracle 8i"). Die JavaKLassen des XSU können deshalb in die Datenbank geladen werden . Zusätzlich können sie auch über
Oracles stored Procedures ("PL/SQL") genutzt werden.
Einschub für alle die mit PL/SQL nichts anfangen können:
PL/SQL ist die prozedurale Sprache von Oracle. Sie umfaßt die Standardsprache von SQL und einen
weiten Bereich von Befehlen, mit denen man die Ausführung von SQL-Anweisungen entsprechend
unterschiedlicher Bedingungen steuern kann. PL/SQL kann auch Laufzeitfehler behandeln.
Möglichkeiten wie Schleifen und IF...THEN-Anweisungen verleihen PL/SQL die Leistungsfähigkeit
von Programmiersprachen der dritten Generation. Es lassen sich interaktive, benutzerfreundliche
Programme schreiben, die Werte an Variablen übergeben können. Zum Lieferumfang gehören
verschiedene vordefinierte Pakete, zum Beispiel für die Anzeige von Meldungen für den Benutzer.
Nun zum Einsatz von XSU in Datenbanken:
Seite 58 von 58
Stand: 20.03.2001
Einsatz von XML-SQL Utility in "Middle Tier"
Wie schon gesagt, XSU kann in "Middle Tier"-Komponenten genutzt werden, die Java unterstützen.
Einsatz von XML-SQL Utility in Web-Servern
Auf Web-Servern kann XSU verwendet werden, sofern diese Java servlets unterstützen
Einsatz von XML-SQL Utility auf dem Client
Auf dem Client können im Prinzip genauso Java-Programme unter verwendung des XSU geschrieben
werden. Oder man verwendet das Command Line Front End
Funktionsprinzip und Mapping (Abbildung XML-DB)des XSU
Es werden die Funktionen Select, Insert, Update und Delete unterstützt. Update und Delete werden
allerdings nur von dem Java API und den PL/SQL und nicht von dem Command Line Front End
unterstützt. Laut Oracle soll dies aber später folgend. Das grundsätzliche Prinzip folgt in etwa dem
Vorgehen, wie wir es bereits in 2.3. bzw. 2.3. erläutert haben.
Das Prinzip des Mappings von XML in relationale Datenbanken haben wir ebenfalls in den
Seite 59 von 59
Stand: 20.03.2001
Grundlagen erläutert. Zu erwähnen wäre noch, dass Oracle inzwischen eine Object-relationale
datenbank ist, d.h. es werden auch Object-Typen.
Im folgenden ein paar Mapping-Beispiele aus [XSU1]:
Beispiel 1:
CREATE TABLE emp
(
EMPNO NUMBER,
ENAME VARCHAR2(20),
JOB VARCHAR2(20),
MGR NUMBER,
HIREDATE DATE,
SAL NUMBER,
DEPTNO NUMBER
);
Specified the query "select * from emp", the XSU would generate the
following XML document:
<?xml version='1.0'?>
<ROWSET>
<ROW num="1">
<EMPNO>7369</EMPNO>
<ENAME>Smith</ENAME>
<JOB>CLERK</JOB>
<MGR>7902</MGR>
<HIREDATE>12/17/1980 0:0:0</HIREDATE>
<SAL>800</SAL>
<DEPTNO>20</DEPTNO>
</ROW>

</ROWSET>
Beispiel 2:
Next we describe this mapping but against an object-relational schema like
the following:
The AddressType is an object type whose attributes are all scalar types...
CREATE TYPE AddressType AS OBJECT (
STREET VARCHAR2(20),
CITY
VARCHAR2(20),
STATE CHAR(2),
ZIP
VARCHAR2(10)
);
/
An EmplyeeType is also an object type but whose EMPADDR attribute is of an
object type itself, specifically AddressType...
CREATE TYPE EmployeeType AS OBJECT
(
EMPNO NUMBER,
ENAME VARCHAR2(20),
SALARY NUMBER,
EMPADDR AddressType );
Seite 60 von 60
Stand: 20.03.2001
EmployeeListType is a collection type whose elements are of EmployeeType
object type...
CREATE TYPE EmployeeListType AS TABLE OF EmployeeType;
/
Finally, dept is a table with, among other things, an object type column
and a collection type column -- AddressType and EmployeeListType
respectively.
CREATE TABLE dept
(
DEPTNO NUMBER,
DEPTNAME VARCHAR2(20),
DEPTADDR AddressType,
EMPLIST EmployeeListType
);
Assuming that valid values are stored in the dept table, given the query
"select * from dept", the XSU will generate the following XML document:
<ROWSET>
<ROW num="1">
<DEPTNO>100</DEPTNO>
<DEPTNAME>Sports</DEPTNAME>
<DEPTADDR>
<STREET>100 Redwood Shores Pkwy</STREET>
<CITY>Redwood Shores</CITY>
<STATE>CA</STATE>
<ZIP>94065</ZIP>
</DEPTADDR>
<EMPLIST>
<EMPLIST_ITEM num="1">
<EMPNO>7369</EMPNO>
<ENAME>John</ENAME>
<SALARY>10000</SALARY>
<EMPADDR>
<STREET>300 Embarcadero</STREET>
<CITY>Palo Alto</CITY>
<STATE>CA</STATE>
<ZIP>94056</ZIP>
</EMPADDR>
</EMPLIST_ITEM>

</EMPLIST>
</ROW>
</ROWSET>
As in the last example, the mapping is canonical -- <ROWSET> contains
<ROW>'s which contain elements corresponding to columns. And as before, the
elements
corresponding to scalar type columns simply contain the data from the colu
Seite 61 von 61
Stand: 20.03.2001
Nun noch Beispiele für Insert, Update und Delete:
Beispiel Insert:
For example, assume that the target table is dept and the XML document is
the one generated from dept (see: Default SQL to XML Mapping). XSU would
generate the following insert statement.
INSERT INTO Dept (DEPTNO, DEPTNAME, DEPTADDR, EMPLIST) VALUES (?,?,?,?)
Next, the XSU would parse the XML document, and for each record, it would
bind the appropriate values to the appropriate columns/attributes and
execute the
statement:
DEPTNO <- 100
DEPTNAME <- SPORTS
DEPTADDR <- AddressType('100 Redwood Shores Pkwy','Redwood Shores',
'CA','94065')
EMPLIST <- EmployeeListType(EmployeeType(7369,'John',100000,
AddressType('300 Embarcadero','Palo Alto','CA','94056'),...)
Beispiel Update:
For example, to update the DEPTNAME to SportsDept instead of Sports, you
can have an XML document such as,
<ROWSET>
<ROW num="1">
<DEPTNAME>SportsDept</DEPTNAME>
</ROW>
</ROWSET>
and supply the DEPTNO as the key column. This would fire off the following
update statement:
UPDATE DEPT SET DEPTNAME = ? WHERE DEPTNO = ?
and bind the values,
DEPTNO <- 100
DEPTNAME <- SportsDept
Seite 62 von 62
Stand: 20.03.2001
Beispiel Delete:
Given a document such as:
<ROWSET>
<ROW num="1">
<DEPTNAME>Sports</DEPTNAME>
<DEPTADDR>
<STREET>100 Redwood Shores Pkwy</STREET>
<CITY>Redwood Shores</CITY>
<STATE>CA</STATE>
<ZIP>94065</ZIP>
</DEPTADDR>
</ROW>
</ROWSET>
to delete, the utility will fire off a delete statement (one per ROW
element) which would look like the following:
DELETE FROM Dept WHERE DEPTNO = ? AND DEPTNAME = ? AND DEPTADDR = ?
binding,
DEPTNO <- 100
DEPTNAME <- Sports
DEPTADDR <- AddressType('100 Redwood Shores Pkwy','Redwood
City','CA','94065')
3.3.2 Oracle XML-SQL Utility [Command Line Front End]
Das Command Line Front End wird als Kommandozeilenbefehl direkt aufgerufen.
Beispiel-Aufruf:
java OracleXML getXML -user "scott/tiger" "select * from emp"
This performs the following tasks:
Connects to the current default database
Executes the query "select * from emp"
Converts the result to XML
Displays the result
Es werden die die Funktionen getXML und putXML mit der nachfolgenden Syntax angeboten:
Seite 63 von 63
Stand: 20.03.2001
-getXML Option
Description
-user "<username>/<password>"
Used to specify the user name and password to connect to the database.
If this is not specified, the user defaults to "scott/tiger". Note that he
connect string is also being specified, the user name and password can
be specified as part of the connect string.
-conn "<JDBC_connect_string>"
Used to specify the JDBC database connect string. By default the
connect string is: "jdbc:oracle:oci8:@"):
-withDTD
Instructs the XSU to generate the DTD along with the XML document.
-rowsetTag "<tag_name>"
Used to specify rowset tag (i.e. the tag that encloses all the XML
elements corresponding to the records returned by the query) The default
rowset tag is ROWSET. Specifying an empty string for the rowset tells
the xsu to completely omit the rowset element.
-rowTag "<tag_name>"
Used to specify the row tag (the tag used to enclose the data
coresponding to a database row). The default row tag is ROW.
Specifying an empty string for the row tag tells the xsu to completely
omit the row tag.
-rowIdAttr "<row_id-attribute-name>"
Used to name the attribute of the ROW element keeping track of the
cardinality of the rows. By default this attribute is called "num".
Specifying an empty string (i.e. "") as the row id attribute will tell the
XSU to omit the attribute.
-rowIdColumn "<row Id column
name>"
Used to specify that the value of one of the scalar columns from the
query should be used as the value of the row id attribute.
-collectionIdAttr "<collection id attribute Used to name the attribute of a XML list element keeping track of the
cardinality of the elements of the list (note: the generated XML lists
name>"
correspond to either a cursor query, or collection). Specifying an empty
string (i.e. "") as the row id attribute will tell the XSU to omit the
attribute..
-useNullAttrId
Used to tell the XSU to use the attribute "NULL (TRUE/FALSE)" to
indicate the nullness of an element.
-styleSheet "<stylesheet URI>"
Used to specify the stylesheet in the XML PI (Processing Instruction).
-stylesheetType "<stylesheet type>"
Used to specify the stylesheet type in the XML PI (Processing
Instruction).
-errorTag "<error tag name>"
Used to specify the error tag -- the tag to enclose error messages which
are formated into XML.
-raiseNoRowsException
Used to tell the XSU to raise an exception if no rows are returned.
-maxRows "<maximum number of
rows>"
Used to specify the maximum number of rows to be retreived and
converted to XML.
-skipRows "<number of rows to skip>"
Used to specify the number of rows to be skipped.
-encoding "<encoding name>"
Used to specify the characterset encoding of the generated XML.
-dateFormat "<date format>"
Used to specify the date format for the date values in the XML
document.
-fileName "<SQL query fileName>" |
<sql query>
Used to specify the file name which contains the query or specify
the query itself.
Seite 64 von 64
Stand: 20.03.2001
-putXML Options
Description
-user "<username>/<password>"
Used to specify the user name and password to connect to the database.
If this is not specified, the user defaults to "scott/tiger". Note that he
connect string is also being specified, the user name and password can
be specified as part of the connect string.
-conn "<JDBC_connect_string>"
Used to specify the JDBC database connect string. By default the
connect string is: "jdbc:oracle:oci8:@"):
-batchSize "<batching size>"
Used to specify the batch size, which control the number of rows which
are batched together and inserted in a single trip to the database.
Batching improves performance.
-commitBatch "<commit size>"
Used to specify the number of inserted records after which a commit is
to be executed. Note that if the autocommit is true (default), then setting
the commitBatch has no consequence.
-rowTag "<tag_name>"
Used to specify the row tag (the tag used to enclose the data
coresponding to a database row). The default row tag is ROW.
Specifying an empty string for the row tag tells the XSU that no row
enclosing tag is used in the XML document.
-dateFormat "<date format>"
Used to specify the date format for the date values in the XML
document.
-ignoreCase
Used to make the matching of the column names with tag names case
insensitive (e.g. "EmpNo" will match with "EMPNO" if ignoreCase is
on).
-fileName "<file name>" | -URL "<url>" Used to specify the XML document to insert. The fileName option
specifies a local file, the URL specifies a URL to fetch the document
| -xmlDoc "<xml document>"
from and the xmlDoc option inlines the XML document as a string on
the command line.
<tableName>
The name of the table to put the values into.
3.3.3 Oracle XML-SQL Utility [Java API]
Das Java API des XSU beinhaltet folgende Möglichkeiten:
Generieren von XML mit XML SQL Utility für Java: Grundsätzliche Schritte
Seite 65 von 65
Stand: 20.03.2001
Generieren von XML mit XML-SQL Utility: Ablaufprozess
Speichern XML in Datenbanken mit XML-SQL Utility: Aublaufprozess
Seite 66 von 66
Stand: 20.03.2001
Nun folgen Beispiele für Insert, Update und Delete:
Beispiel Insert:
This example inserts XML values into all columns:
import java.sql.*;
import oracle.xml.sql.dml.OracleXMLSave;
public class testInsert
{
public static void main(String argv[])
throws SQLException
{
Connection conn = getConnection("scott","tiger");
OracleXMLSave sav = new OracleXMLSave(conn, "scott.emp");
// Assume that the user passes in this document. Save it in to the
table.!
sav.insertXML(argv[0]);
sav.close();
}
// Get the connection given the user name and password..!
private static Connection getConnection(String user, String passwd)
throws SQLException
{
DriverManager.registerDriver(new oracle.jdbc.driver.OracleDriver());
Connection conn =
DriverManager.getConnection("jdbc:oracle:oci8:@",user,passwd);
return conn;
}
}
An insert statement of the form:
insert into scott.emp (EMPNO, ENAME, JOB, MGR, SAL, DEPTNO)
VALUES(?,?,?,?,?,?);
will be generated and the element tags in the input XML document matching
the column names will be matched and their values bound. If you sned the
code snippet
shown above, to the following XML document:
<ROWSET>
<ROW num="1">
<EMPNO>7369</EMPNO>
<ENAME>Smith</ENAME>
<JOB>CLERK</JOB>
<MGR>7902</MGR>
<HIREDATE>12/17/1980 0:0:0</HIREDATE>
<SAL>800</SAL>
<DEPTNO>20</DEPTNO>
</ROW>
</ROWSET>
Seite 67 von 67
Stand: 20.03.2001
Beispiel Update:
<ROWSET>
<ROW num="1">
<EMPNO>7369</EMPNO>
<SAL>1800</SAL>
<DEPTNO>30</DEPTNO>
</ROW>
<ROW>
<EMPNO>2290</EMPNO>
<SAL>2000</SAL>
<HIREDATE>12/31/1992</HIREDATE>
</ROWSET>
In the emp table shown above, the employee number (EMPNO) column forms
the key and you use that for updates.
This example updates the emp table using keyColumns:
import java.sql.*;
public class testUpdate
{
throws SQLException
{
String [] keyColNames = new String[1];
keyColNames[0] = "EMPNO";
sav.setKeyColumnList(keyColNames);
// Assume that the user passes in this document as the first argument!
sav.updateXML(argv[0]);
sav.close();
}
throws SQLException
{
Connection conn =
return conn;
}
}
In this example, two update statements would be generated. For the first
ROW element,
you would generate an update statement to update the SAL and JOB fields as
shown below:
update scott.emp SET SAL = 1800 and DEPTNO = 30 WHERE EMPNO = 7369;
and for the second ROW element,
update scott.emp SET SAL=2000 and HIREDATE = 12/31/1992 WHERE EMPNO = 2290;
Seite 68 von 68
Stand: 20.03.2001
Beispiel Delete:
Consider the delete example shown below,
import java.sql.*;
public class testDelete
{
throws SQLException
{
// Assume that the user passes in this document as the first argument!
sav.deleteXML(argv[0]);
sav.close();
}
throws SQLException
{
Connection conn =
return conn;
}
}
If you use the same XML document shown for the update example, you would
end up with two delete statements,
DELETE FROM scott.emp WHERE empno=7369 and sal=1800 and deptno=30;
DELETE FROM scott.emp WHERE empno=2200 and sal=2000 and hiredate=12/31/1992
;
Beispiel - Generating XML from JDBC ResultSets (Java):
We will show how to use the JDBC ResultSet and generate XML from that. Note
that using the ResultSet might be necessary in cases which are not handled
directly by the utility (for example, setting the batch size, binding
values,...) We will extend the previously defined pageTest class so that we
handle any page.
public class pageTest()
{
Connection conn;
OracleXMLQuery qry;
ResultSet rset;
int lastRow = 0;
public pageTest(String sqlQuery)
{
conn = getConnection("scott","tiger");
Statement stmt= conn.createStatement(sqlQuery);//create a scrollable Rset
ResultSet rset = stmt.executeQuery(); //get the result set..
qry = new OracleXMLQuery(conn,rset);
//create a OracleXMLQuery instance
qry.keepObjectOpen(true); // Don't lose state after the first fetch
}
Seite 69 von 69
Stand: 20.03.2001
// Returns the next XML page..!
public String getResult(int startRow, int endRow)
{
rset.scroll(lastRow-startRow); // scroll inside the result set
qry.setMaxRows(endRow-startRow); // set the max # of rows to retrieve..!
return qry.getXMLString();
}
// Function to still perform the next page.
public String nextPage()
{
String result = getResult(lastRow,lastRow+10);
lastRow+= 10;
return result;
}
public void close()
{
stmt.close();
// close the statement..
conn.close();
// close the connection
qry.close();
// close the query..
}
public void main(String[] argv)
{
pageTest test = new pageTest("select * from emp");
int i = 0;
// Get the data one page at a time..!!!!!
while ((str = test.getResult(i,i+10))!= null)
{
System.out.println(str);
i+= 10;
}
test.close();
}
}
Seite 70 von 70
Stand: 20.03.2001
3.3.4 Oracle XML-SQL Utility [PL/SQL]
PL/SQL ist die prozedurale Sprache von Oracle. Sie umfaßt die Standardsprache von SQL und einen
weiten Bereich von Befehlen, mit denen man die Ausführung von SQL-Anweisungen entsprechend
unterschiedlicher Bedingungen steuern kann. PL/SQL kann auch Laufzeitfehler behandeln.
Möglichkeiten wie Schleifen und IF...THEN-Anweisungen verleihen PL/SQL die Leistungsfähigkeit
von Programmiersprachen der dritten Generation. Es lassen sich interaktive, benutzerfreundliche
Programme schreiben, die Werte an Variablen übergeben können. Zum Lieferumfang gehören
verschiedene vordefinierte Pakete, zum Beispiel für die Anzeige von Meldungen für den Benutzer.
Das "XSU PL/SQL API" bietet nun die Möglichkeit über solche Prozeduren das XSU Java API zu
nutzen. In der Dokumentation des XSU werden die Möglichkeiten wie folgt beschrieben:
"The XML-SQL Utility PL/SQL API reflects the Java API in the generation and storage.
The DBMS_XMLQuery and DBMS_XMLSave are the two packages that reflect the
functions in the java classes - OracleXMLQuery and OracleXMLSave.
Both these packages have a context handle associated with them. Create a context by
calling one of the constructor-like functions to get the handle and then use the handle in
all subsequent calls.
Generating XML with DBMS_XMLQuery()
Generating XML results in a CLOB that contains the XML document. To use
DBMS_XMLQuery's and the generation engine follow these steps:
1. Create a context handle by calling the DBMS_XMLQuery.getCtx function and
supplying it the query (either as a CLOB or a VARCHAR2)
2. Bind possible values to the query using the DBMS_XMLQuery.bind function.
The binds work by binding a name to the position. For example, the query can be
something like, select * from emp where empno = :EMPNO_VAR. Here the user
binds the value for the EMPNO_VAR using the setBindValue function.
3. Set optional arguments like the ROW tag name, the ROWSET tag name or the
number of rows to fetch etc.
4. Fetch the XML as a CLOB using the getXML() functions. The getXML can be
called to generate the XML with or without a DTD.
5. Close the context.
Here are some examples that use the DBMS_XMLQuery PL/SQL package.
XSU Example 13: Generating XML From Simple Queries (PL/SQL)
In this example, you will try to select rows from the emp table and get a XML document
as a CLOB. You first get the context handle by passing in a query and then call the
getXMLClob routine to get the CLOB value. The document will be in the same encoding
Seite 71 von 71
Stand: 20.03.2001
as that of the database character set.
declare
queryCtx DBMS_XMLquery.ctxType;
result CLOB;
begin
-- set up the query context...!
queryCtx := DBMS_XMLQuery.newContext('select * from emp');
-- get the result..!
result := DBMS_XMLQuery.getXML(queryCtx);
-- Now you can use the result to put it in tables/send as
messages..
printClobOut(result);
DBMS_XMLQuery.closeContext(queryCtx); -- you must close the
query handle..
end;
/
.."
Weitere Informationen finden Sie in bei [ORAXML1].
Seite 72 von 72
Stand: 20.03.2001
3.4 Bewertung [Skripting vs. XSLT]
Die (potentiellen) Vorteile des Einsatzes von XML als Transporthülle im Internet, als
Datenaustauschformat, usw. wurden schon diskutiert. Interessant ist aber auch, in wie weit XML im
unmittelbaren Umfeld von Browsertechnologie einsetzbar ist.
Zu betrachten ist (bei konsequenter Umsetzung) der Datenfluss
Benutzer/Browser <-> HTML <-> XML <-> Datenbank
und Vorteile, wie auch Konsequenzen, die sich aus diesem Ansatz ergeben. Eine solche
Gegenüberstellung zwischen XML und Skripting ist allerdings schwierig, da sie zum einen
herstellerspezifisch und versionsabhängig unterschiedlich ausfallen wird/muss und zum anderen auch
im konkreten Einsatzszenario andere Folgen nach sich zieht. Die nachfolgende Übersicht ist
dementsprechend subjektiv zu verstehen...
Anmerkung: die Verpackung von XML-Informationen in eine HTML-Hülle resultiert natürlich auch
daraus, dass ältere Browser ansonsten überfordert wären. Natürlich könnte man anführen, dass diese
"Krücke" in modernen Produktversionen entfallen kann, dennoch darf man die weltweit installierte
Basis nicht einfach vergessen!
Web-Publishing mit Datenbanken
Skripting
XSLT
Site-Designer muss über
Programmierkenntnisse für den
Datenbankzugriff verfügen
Änderungen in der physischen
Datenbankstruktur sind autark möglich
Vermengung von HTML-Design und
Skriptingblöcken erschwert die Lesbarkeit des
Quelltextes
Trennung von Daten und Layout; Verringerung
des Anteiles an fehleranfälligem Quelltext
Site-Designer ist i.d.R. auch
Datenbankadministrator
funktionale und administrative Trennung von
Site- und Datenbank-Personal möglich
schneller Entwicklungszyklus (gerade bei
Implementation neuer Funktionen) möglich
permanente Abstimmung zwischen SiteDesigner und Datenbankadministrator bzgl. der
Schnittstellen notwendig
Skalierung für hohe Performance ist
schwieriger
hohe Ausführungsgeschwindigkeit durch
Nutzung "genormter" Schnittstellen in
Maschinencode
etablierte Entwicklungswerkzeuge vorhanden
schwierige Fehlersuche und Debugging durch
Komponententechnologie
erfahrene Entwickler "vorhanden"
wenig einführende Literatur vorhanden;
Ausbildungs- und Implementationskosten für
neue Technologie
Austausch der Datenbankplattform i.d.R.
einfach möglich (sofern ODBC/JDBC und
ANSI-SQL benutzt wurde)
Umsetzung der XML-Technologie noch stark
im Wandel
Seite 73 von 73
Stand: 20.03.2001
3.4 Bewertung [Skripting vs. XSLT - Fortsetzung]
Ein interessanter Aspekt im Vergleich zwischen den verschiedenen Modellen ist Fehlerbearbeitung
und Plausibilitätskontrolle. Während bei der Ausgabe von Daten über XML/XSL "nur" eine
Datenkonvertierung vorzunehmen ist, muss beim Entgegennehmen von XML-Datenpaketen inhaltlich
sichergestellt werden, dass die Informationen korrekt und sinnvoll sind.
Eine Kontrolle über entsprechend restriktive Definition von Tabellenfeldern in der SQL-Datenbank ist
in diesem Zusammenhang wichtig, da über ein "Upload" von außen eine Schnittstelle zur Verfügung
steht, die ohne Benutzerinteraktion auskommen muss.
Im Umfeld von Internet-Browsern kann dagegen gezielter auf Datensätze reagiert werden. Damit stellt
sich allerdings die Frage, in wie weit auf Skripting dann tatsächlich noch verzichtet werden kann, da
sonst keine detaillierte Fehlermeldung mehr generiert werden kann. Gleichzeitig bietet sich aber auch
die Möglichkeit, mit einem einzigen XSL-Stylesheet sowohl gültige Datenelemente, als auch
Fehlermeldungen und Hinweistexte zu verbinden (der für den XSLT-Prozessor zugrunde liegende
XML-Datensatz enthält dann manchmal Daten, manchmal Fehlermeldungen, oder auch beides...) und
somit eines durchgängiges Design durchhalten zu können.
Seite 74 von 74
Stand: 20.03.2001
4 Demo
In diesem Kapitel wird an einem fiktiven Beispiel eines "Party-Service" die XML-Nutzung gezeigt.
Ferner haben wir Hinweise und die URL einer Oracle Demo-Seite bereitgestellt.
4.2 Oracle XSQL Servlets
Eine Erklärung der XML-Features ist am "lebenden Objekt" viel einfacher als in einer theoretischen
Abhandlung, die manchmal aus dem Zusammenhang gerissen werden muss. Deshalb habe ich
versucht, in einem in sich geschlossenen Anwendungsfall die XML-Technologie und ihre Nutzung im
MSSQL2K zu demonstrieren:
Partyservice "Demo-Modus" [online]
Partyservice "Demo-Modus" [offline]
ZIP archive, Dateigröße: 97 kb
Partyservice "Live-Modus" [offline]
ZIP archive, Dateigröße: xx kb
4.2 Oracle XSQL Servlets
XSQL ist ein Java-Servlet von Oracle, das XML-Dokumente aus SQL-Anfragen liefert und diese über
ein XSLT-Stylesheet weiterverarbeiten kann. XSQL kann frei verwendet werden. Hierüber können
die mit dem XML SQL Utility gelieferten Funktionalitäten in einem Java Servlet genutzt werden.
Um das ganze anschaulich zu machen, haben wir zwar kein eigenes Demo für Oracle XSQL erstellt,
aber die folgende Seite im Oracle Technology Network (OTN) im Internet aufgestöbert. Sie bietet
kleine Beispiele zum Ausprobieren, die größtenteils mit dem Sourcecode bereitgestellt sind. Ferner
findet man auf diesen Seiten auch Dokumentationen und Hinweise zum Download.
Hinweis: Für einige Beispiele wird IE 5 benötigt
ORACLE XSQL Pages & XSQL Servlets
© 2001Ute Stegmann
Seite 75 von 75
Stand: 20.03.2001
Literaturverzeichnis
[ROEK1]
Robert Eckstein, XML kurz & gut
O'Reilly Taschenbibliothek, 2. Auflage 2000, ISBN 3-89721-219-6
[MIBA1]
Mike Bach, XSL und XPath - verständlich und praxisnah
Addison-Wesley Verlag, 01/2000, ISBN 3-8273-1661-8
[Quin]
Liam Quin, Open Source XML Database Toolkit
John Wiley & Sons, Inc., Copyright 2000, ISBN 0-471-37522-5
[MSSQ1]
Microsoft Corporation, SQL Server 2000 Online-Books
Product version 8.00.194 RTM, Enterprise Edition, 17.07.2000
[MS1]
Jim Buyens Web-Datenbanken Schritt für Schritt
Microsoft Press, Copyright 2000, ISBN: 3-86063-766-5
[MSMS1]
Microsoft Corporation, MSDN Library Online-Books
April 2000
[MSMS2]
Microsoft Corporation, MSDN Library / "Duwamish Online Bookstore"
Server: msdn.microsoft.com
[MSXML1]
Microsoft Corporation, MSDN Library / "XML Developper Center"
Server: msdn.microsoft.com
[ORACLE1] Oracle, Oracle
Server: www.oracle.com
[ORAXML1] Oracle Technologie Network, OTN Technologie XML
Server: www.technet.oracle.com
[MSNG1]
Newsgroup, microsoft.public.sqlserver.xml
Server: msnews.microsoft.com
[MSNG2]
Newsgroup, microsoft.public.de.german.xml
Server: msnews.microsoft.com
[W3CI1]
World Wide Web Consortium, Internationalization / Localization
Server: www.w3c.org
[DB2EXT]
IBM DB2 XML Extender, XML Extender Administration and Programmingt
Server: www-4.ibm.com
[FM1]
Filemaker XML Technologie Overview, FILEMAKER/BACKGROUNDER/xml/
Server: www.filemaker.de
[ROBOU1]
Ronald Bourret, XML and Databases Ronald Bourret/Wrinting/XML and
Databases
Server: www.rpbourret.com, Copyright 1999, 2000 by Ronald Bourret
[ROBOU2]
Ronald Bourret, XML Database Products Ronald Bourret/Wrinting/XML
Database Products
Server: www.rpbourret.com, Copyright 2000 by Ronald Bourret
[STMU1]
Steve Muench, Building Oracle XML Applications Sample Chapter
O'Reilly, ISBN 1-56592-691-9, Server: www.oreilly.com
[OBJMID1]
Stefan Middendorf, XML und Java
Copyright OBJEKTSpectrum Ausgabe 5/99
[JavaSoft]
Sun Microsystems Inc., THE SOURCE FOR JAVA TECHNOLOGY
Server: www.javasoft.comg
Seite 76 von 76
Stand: 20.03.2001

XML-Einsatzmöglichkeiten für Datenbankanwendungen im Internet

Transcrição

Documentos relacionados

Carte client • Kundenkarte

anlage ref/plan zeitplan für juli und august 2015 preise

Mise en page 1

Übungsblatt 11

anlage ref/plan zeitplan für november 2015 preise

baden-baden airport + shuttle

XSL, XSLT, FO - Einstieg für XML

geht`s zur Karte..

internet adresse szeged

Folien zum Vortrag