Projekt xml2sql

Dynamische Generierung von Datenbank-Designs aus XML-Quellen

Andreas Popper


Inhaltsverzeichnis

1 Zugangsdaten und Layoutkonventionen
Zugangsdaten
Config-Files
Layoutkonventionen
2 Projektplanung
Oberziel
Projektziel
Angestrebte Ergebnisse
Indikatoren
XML-Produktionsumgebung
PostgreSQL-7.0.3
PHP4
Dynamisches Anlegen der Datenbank
Umwandlung von xml zu sql
XML-Abfragen
Dokumentation
Maßnahmen
XML-Produktionsumgebung
Relationale Datenbank
Dynamisches SQL-Design
Dateneingabe aus XML-Dateien
Kommunikation und Dokumentation
3 Ergebnisse:
Direkte Umsetzung von XML-Quellen nach SQL
Zusammenfassung
Die Ergebnisse im Einzelnen:
Umsetzung von XML:Schema nach SQL
Zusammenfassung
Installation von XMLAuthority
Die Ergebnisse im Einzelnen
4 Zeittafel des Projektes xml2sql
Juni 2000
Juli 2000
August 2000
September 2000
Oktober 2000
November 2000
Dezember 2000
Januar 2001
Februar 2001
März 2001
April 2001
5 Quellenverzeichnis

Kapitel 1. Zugangsdaten und Layoutkonventionen

Zugangsdaten

SuperUser: root
Root-Passwort:(passwd)

User geronimo: Passwort: geronimo
User für alle Arbeiten am Projekt xml2sql inkl. Protokoll, Bericht und Installationsanleitungen.

User postgres: Passwort: postgres
home-Verzeichnis: /usr/local/pgsql
Heimatverzeichnis der Datenbank PostgreSQL inkl. aller Konfigurationen und Datenbanken. postmaster bzw. postgres, der Startprozess, muss vom User: postgres gestartet werden!

Sonstige Passwörter: Passwort entspricht immer dem Usernamen.

Verzeichnisse xml: /home/geronimo/apache/xml:
In diesem Verzeichnis liegen alle selbstgebauten Files.
projekt_anp/protokoll/(monat)/(datum).xml: Die Tagesprotokolle
projekt_anp/Projektbericht/bericht1: Zwischenbericht xml2sql
projekt_anp/Projektbericht/bericht2: Abschlussbericht xml2sql
projekt_anp/xml2sql: Alle Testfiles und Stylesheets des eigentlichen Projektes
LDAP/: Installationsanleitung und Testfiles für das LDAP-Modul von Cocoon
cocoon_sql/: Testfiles und Übungen zum SQL-Modul von Cocoon und zu sql allgemein

Config-Files

Apache
/usr/local/apache2/conf/httpd.conf

Tomcat
/usr/local/jakarta/dist/tomcat/conf/jakarta.conf
server.xml
web.xml
workers.xml

Cocoon
/usr/local/jakarta/dist/tomcat/webapps/cocoon/WEB-INF/web.xml
cocoon.properties

Layoutkonventionen

Relevante Systemverzeichnisse werden fett ausgegeben.
Beispiel:
/usr/local/lib

Befehle erscheinen inline in Originalschrift.
Beispiel:
./configure

Listings erscheinen in Originalschrift als eigener Absatz.
Beispiel:

#! /bin/sh
./configure \
--prefix=/usr/local/apache \
--enable-rule=SHARED_CORE \
--enable-module=so

Kapitel 2. Projektplanung

Oberziel

Im Rahmen einer Fortbildung zum Multimedia/Internet-Programmierer eignet sich der Projektführende die Auszeichnungssprache XML an sowie den Umgang mit SQL und das Erstellen relationaler Datenbankdesigns.

Projektziel

Methode und Nutzen der Erzeugung relationaler Datenbankdesigns aus einem XML-File und die Abbildung von XML-Daten darauf zum Zwecke der Erhebung, Speicherung und jederzeitigen Verfügbarkeit der Daten sind geklärt.
Der Umgang mit XML und die Umwandlung von .xsl-Dateien mittels XSL/XSLT-Stylesheets in verschiedene Ausgabeformate ist zur Routine geworden.

Angestrebte Ergebnisse

  1. Eine funktionsfähige xml-Produktionsumgebung ist aufgebaut und in Betrieb genommen.
  2. Die relationale Datenbank PostgreSQL-7.0.3 ist installiert, eingerichtet und in Betrieb genommen.
  3. Ein xsl-Stylesheet ist erzeugt, das die Struktur eines xml-Files in sql-Befehlssequenzen umwandelt, die das analoge relationale Datenbankdesign beschreiben und installieren.
  4. Die Umwandlungsroutine der xml-Datenquelle in Befehlssequenzen für die sql-Eingabe ist als xsl-Stylesheet realisiert.
  5. xml-Abfragen der Datenbank inklusive der zugehörigen Stylesheets sind erstellt.
  6. Die Protokolle der einzelnen Projekttage liegen im .xml-Format vor. Sie sind als Website organisiert.
  7. Für jede im Rahmen des Projektes installierte Software existiert eine ausführliche und mehrfach erprobte Installationsanleitung.
  8. Für das Projekt ist eine Dokumentation erstellt.

Indikatoren

XML-Produktionsumgebung

  • Alle notwendigen Bestandteile für eine funktionsfähige xml-Produktionsumgebung sind installiert und konfiguriert
  • Die Funktionsfähigkeit der xml-Produktionsumgebung einschließlich aller Module ist sichergestellt.
  • Die xml-Produktionsumgebung läuft auf dem Rechner des Projektführenden.
  • Die xml-Produktionsumgebung mit allen Funktionalitäten ist nach drei Arbeitstagen verfügbar.
  • Die xml-Produktionsumgebung wurde innerhalb der Multimedia-Abteilung der Firma Ision in Kiel eingerichtet.

PostgreSQL-7.0.3

  • Innerhalb von drei Arbeitstagen ist die relationale Datenbank PostgreSQL-7.0.3 auf Linux RedHat 6.2 installiert, der Superuser konfiguriert und die einzelnen User mit ihren jeweiligen Rechten und Datenbanken angelegt.
  • Die Datenbank wird beim Booten des Systems vom User postgres gestartet und beim shutdown regulär beendet.
  • Das Datenbank-Frontend PgAccess ist installiert und von jedem User zu erreichen.
  • Für die relevanten Funktionen der Datenbank sind Beispielskripte erstellt.

PHP4

  • Die Scriptsprache PHP4 ist installiert und in den verwendeten Apache-Server integriert.

Dynamisches Anlegen der Datenbank

  • Die Umsetzung der in Professional XML festgelegten Algorithmen für die Erzeugung relationaler Datenbankdesigns inklusive referentielle Integrität und Normalisierung aus einem xml-File mittels .xsl-Stylesheet ist getestet.
  • Die Umsetzung der in Professional XML festgelegten Algorithmen für die Erzeugung relationaler Datenbankdesigns inklusive referentielle Integrität und Normalisierung aus einem xml:Schema (W3C-Norm) mittels .xsl-Stylesheet ist getestet.
  • Die xml-Produktionsumgebung ist in der Lage, xml-Files in sql-Befehlssequenzen umzuwandeln und auszuführen.

Umwandlung von xml zu sql

  • Das xsl-Stylesheet wandelt eine xml-Datenquelle mit vorgegebner Struktur in sql-Befehlssequenzen um.
  • Alle sql-Befehlssequenzen werden auf die Datenbankstruktur fehlerfrei abgebildet.

XML-Abfragen

  • Die Abfrage der Datenbankeinträge wird über xml-Dateien mit entsprechenden Stylesheets realisiert, die das sql-Modul von Cocoon nutzen.

Dokumentation

  • Für das Projekt ist eine detaillierte Projektplanung gemacht worden.
  • An jedem Projekttag wird Protokoll über alle Aktivitäten geführt.
  • Die Protokolle sind als XML-Website organisiert und vom Browser ansprechbar
  • Für alle Software-Bestandteile sind detaillierte Installationsanleitungen erstellt
  • Alle verwendeten Dateien, Stylesheets usw. werden dokumentiert

Maßnahmen

XML-Produktionsumgebung

Betriebssystem
Auf einem PC PentiumI 200MMX mit 32 MB Arbeitsspeicher und einer Windows-NT-Partition wird von einem Mitarbeiter der Fa. ision Linux RedHat 6.2 eingerichtet inklusive Apache Webserver und PostgreSQL Datenbank.
Dauer: Ein Tag
Apache, Tomcat
Mit aus dem Netz besorgtem SourceCode wird Apache-1.3.14 kompiliert und installiert und darauf in gleicher Weise die Servlet-Engine Tomcat-3.2.1 aufgesetzt (s. Kap. Installation des Autorenwerkzeugs Cocoon).
Dauer: Vier Tage
Cocoon
Das XML-Autorenwerkzeug Cocoon wird als SourdeCode aus dem Netz besorgt und installiert (s. Kap. Installation des Autorenwerkzeugs Cocoon).
Dauer: Ein Tag
Anschließend werden die Cocoon-Module LDAP (s. Kap. Installation des LDAP-Moduls von Cocoon), SQL (s. Kap. Installation des SQL-Moduls von Cocoon) und XSP installiert und mit Beispiel-xml-Dateien und -xsl-Stylesheets in Betrieb genommen.
Dauer: Ein Tag
Website
Für das Projekt wird in xml eine Website erstellt.
Dauer: 2 Tage
Bemerkung: Die Installationen folgen vorhandenen Installationsanleitungen (s. Installationen ), was den dafür notwendigen Zeitaufwand erheblich reduziert.

Relationale Datenbank

Installation
RedHat-6.2 installiert PostgreSQL-6.5.3. Aber erst ab Version 7.x steht referentielle Integrität zur Verfügung, ein Feature, das für das Projekt benötigt wird. Deshalb wird die vorinstallierte Datenbank deinstalliert. Aus dem Netz wird der SourceCode von PostgreSQL-7.0.3 besorgt und installiert (s. Kap. Die relationale Datenbank PostgreSQL).
Anschließend erfolgt die Konfiguration für Zugriff mittels TCP/IP und zum automatischen Booten und Beenden der Datenbank.
Dauer: 3 Tage
Installationsanleitung: PosgreSQL-7.x
JDBC für PostgreSQL
Damit Cocoon auf PostgreSQL zugreifen kann, wird JDBC (Java DataBase Connectivity) benötigt. Der SourceCode der für PostgreSQL-7.0.3 benötigten Version wird aus dem Netz besorgt und installiert. Anschließend wird PostgreSQL für die Ansprache über JDBC konfiguriert (s. Kap. Die relationale Datenbank PostgreSQL).
Dauer: In der Installation von PostgreSQL enthalten. Installationsanleitung: JDBC für PosgreSQL-7.x
PgAccess
Das GUI-Frontend PgAccess wird besorgt und installiert.
Dauer: In der Installation von PostgreSQL enthalten.

Dynamisches SQL-Design

Algorithmen
I n dem Buch: Professional XML werden Regeln festgelegt, die ein Programm beachten muss, das die Struktur von xml-Dateien in ein relationales Datenbank-Design umsetzt. Diese Regeln werden einzeln anhand der im Buch gegebenen Beispiele als xslt-Stylesheets implementiert.
Dauer: 12 Tage
Dynamische Erzeugung
Für die im Buch Professional XML gegebenen Beispiele werden Stylesheets geschrieben und mit den von ihnen generierten sql-Eingabesequenzen Datenbankdesigns realisiert, soweit das der Funktionsumfang von XSLT zulässt.
Dauer: 5 Tage

Dateneingabe aus XML-Dateien

Umwandlungsroutine
Für die im Buch Professional XML gegebenen Beispiele werden Stylesheets geschrieben, die den Inhalt der XML-Datenquellen in sql-Befehlssequenzen umwandeln.
Dauer: 3 Tage
Einlesen
Für die entstandenen sql-Befehlssequenzen werden Eingaberoutinen für das Cocoon-SQL-Modul erstellt.
Dauer: 3 Tage

Kommunikation und Dokumentation

Kommunikation
Das Projekt wird in Umrissen zusammen mit dem Supervisor, einem Angestellten der Fa. ision geplant. Anschließend wird in lockeren Abständen über den Fortgang des Projektes berichtet, die Ergebnisse vorgeführt und das weitere Vorgehen besprochen.
Protokoll
Von jedem Projekttag wird fortlaufend ein Protokoll angefertigt, Dateiformat: xml. Es wird ein Stylesheet erstellt, das diese Protokolle nach html wandelt. Die Protokolle werden als vom Browser ansprechbare xml-Website organisiert.
Dauer: vier Tage
Installationsanleitungen
Aus den Protokollen werden für alle Softwarebestandteile Installationsanleitungen erstellt.
Dauer: 2 Tage
Listings
Alle verwendeten Konfigurationsdateien, sql-Dateien, xml-Dateien, xsl- Stylesheets und die Programmcodes für selbst erstellte Java- und Perl-Programme werden als Listings dokumentiert.
Dauer: 1 Tag
Bericht
Über das gesamte Projekt wird ein Bericht in XML erstellt und daraus sowohl eine Website als auch eine gedruckte Ausgabe erzeugt.
Dauer: 7 Tage

Kapitel 3. Ergebnisse:

Das Projekt xml2sql wurde durchgeführt im Rahmen einer Fortbildung zum Internet/Multimedia-Designer und endet entsprechend mit dieser Maßnahme. Zu seiner Durchführung waren die Einarbeitung in nicht triviale Installationen diverser benötigter Software, in XML und XSLT sowie in SQL notwendig.

Direkte Umsetzung von XML-Quellen nach SQL

Zusammenfassung

Die Umsetzung erfolgte mit dem W3C-Standard XSLT. Mit einer xml-Datei als Datenquelle ergeben sich folgende Schlussfolgerungen:

  • Gleichnamige Elemente können in .xml-Dateien mehrfach vorkommen. Da aber nur eine Tabelle dafür erzeugt werden soll und nur ein Eintrag dafür in die Muttertabelle, muss dafür Sorge getragen werden, dass nur ein Element für die Anlage der Tabelle herangezogen wird. Eine Schleifenbildung mit Testabfrage ist aber in XSLT nur sehr umständlich zu realisieren.
  • Tests lassen sich nicht beliebig schachteln: Für das mehrfache Vorkommen von Elementen funktionieren sie und für das Vorkommen von Textelementen, aber nicht für beides zusammen. Das kann auch ein Problem der Software sein.
  • Für die Einspeisung in eine Datenbank wäre nützlich, für jedes Element den Datentyp identifizieren zu können. Dafür bietet aber xslt keine Handhabe, ebensowenig wie php. Hier sind andere Programmiersprachen gefragt; damit ist dann aber der Rahmen des Projektes gesprengt, das die Umwandlung von xml nach sql mittels xslt untersucht.

Die Ergebnisse im Einzelnen:

Inhaltsverzeichnis

Regel 1
Regel 2
Regel 3
Regel 4

Die Durchführung des Projektes orientiert sich an einem Fallbeispiel, das in:
XML Professionell, Richard Anderson et al, mitp Verlag, Bonn 2000 Die dort ab Seite 461 gestellten Forderungen für die Umsetzung von XML in SQL lassen sich bis zur Regel 3 erfüllen:

Regel 1

Sobald eine neue Tabelle erstellt wird, soll auch ein Schlüssel mit demselben Namen erstellt werden, der Das Präfix pk_ trägt. Diese Spalte soll vom Datentyp automatically-incremented sein. Für Postgresql heißt das: SERIAL PRIMARY KEY

Regel 2

Für jeden Elementtyp-Knoten erzeugen wir eine eigene Tabelle mit dem Namen des Elements. Anschließend bleibt noch folgendes zu tun:

  • Ist der Element-Knoten ein Kind-Knoten, dann erzeugen wir eine Spalte mit dem gleichen Namen und dem Präfix fk_ in der Tabelle des Eltern-Elementes.
  • Wir erzeugen eine Beziehung über einen Fremdschlüssel zwischen dieser aktuell erzeugten Spalte und der Spalte in der Tabelle für das Eltern-Element, die den Namen des Eltern-Elementes trägt und da Präfix pk_ hat.

Die xml-Quelle:
projekt_anp/xml2sql/dbdesign4/book04.xml

<?xml version="1.0"?>
<?xml-stylesheet version="1.0" href="books05.xsl" type="text/xsl"?>
<?cocoon-process type="xslt"?>
<books name="books">
	<book category="reference">
		<author>Nigel Rees</author>
		<title>Sayings of the Century</title>
		<price>8.95</price>
	</book>
	<book category="fiction">
		<author>Evelyn Waugh</author>
		<title>Sword of Honour</title>
		<price>12.99</price>
	</book>
	<book category="fiction">
		<author>Herman Melville</author>
		<title>Moby Dick</title>
		<price>8.99</price>
	</book>
</books>

Die Regeln 1 und 2 werden umgesetzt mit folgendem Stylesheet:
projekt_anp/xml2sql/dbdesign4/book02.xsl

<?xml version="1.0"?>

<xsl:stylesheet version="1.0" 
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:strip-space elements="*"/>

	<xsl:template match="/">
   		<xsl:processing-instruction name="cocoon-format">
   			type="text/plain"
		</xsl:processing-instruction>
   		<php>			<!-- Root-Element; ohne dem geht es nicht!-->
   			<xsl:apply-templates/>
			
   		</php>
		
  	</xsl:template>
	
	<xsl:template match="child::*">
	
	<xsl:variable name="name1" select="string(name(*[1]))"/>
	<xsl:variable name="name2" select="string(name(*[2]))"/>
	<xsl:variable name="name3" select="string(name(*[3]))"/>
	
	CREATE TABLE <xsl:value-of select="name()"/>(		
	<xsl:if test= "$name1 != $name3 and $name2">
	<xsl:value-of select="name(*[1])"/> CHAR(10),
	</xsl:if>
	<xsl:if test= "$name2 != $name3 and $name1">
	<xsl:value-of select="name(*[2])"/> CHAR(10),
	</xsl:if>
	<xsl:if test= "$name3 != $name1 and $name2">
	<xsl:value-of select="name(*[3])"/> CHAR(10),
	</xsl:if>		
	pk_<xsl:value-of select="name()"/> SERIAL PRIMARY KEY
	);
	
	<xsl:if test= "$name1 != $name3 and $name2">
	CREATE TABLE <xsl:value-of select="name(*[1])"/> (
	fk_<xsl:value-of select="name()"/> 
	INTEGER REFERENCES <xsl:value-of select="name()"/>,
	pk_<xsl:value-of select="name(*[1])"/> SERIAL PRIMARY KEY
	);
	</xsl:if>
	<xsl:if test= "$name2 != $name3 and $name1">
	CREATE TABLE <xsl:value-of select="name(*[2])"/> (
	fk_<xsl:value-of select="name()"/> 
	INTEGER REFERENCES <xsl:value-of select="name()"/>,
	pk_<xsl:value-of select="name(*[2])"/> SERIAL PRIMARY KEY
	);
	</xsl:if>
	<xsl:if test= "$name3 != $name1 and $name2">
	CREATE TABLE <xsl:value-of select="name(*[3])"/> (
	fk_<xsl:value-of select="name()"/> 
	INTEGER REFERENCES <xsl:value-of select="name()"/>,
	pk_<xsl:value-of select="name(*[3])"/> SERIAL PRIMARY KEY
	);
	</xsl:if>	
	
	</xsl:template>
	
</xsl:stylesheet>
Daraus ergibt sich die sql-Eingabesequenz:
projekt_anp/xml2sql/dbdesign4/book02.sql
        CREATE TABLE books(             
        reference CHAR(10),
        fiction CHAR(10),                       
        pk_books SERIAL PRIMARY KEY
        );
               
        CREATE TABLE reference (
        fk_books INTEGER REFERENCES books,
        pk_reference SERIAL PRIMARY KEY
        );
        
        CREATE TABLE fiction (
        fk_books INTEGER REFERENCES books,
        pk_fiction SERIAL PRIMARY KEY
        );

Regel 3

Auch Regel Nr. 3 aus Professional XML lässt sich noch umsetzen:
Für jeden Attribut-Knoten:

  • Erzeuge eine Spalte mit dem Namen des Attribut-Knotens
  • Ist das Attribut zwingend vorgeschrieben, dann darf die Spalte keine NULL-Werte enthalten.

Die xml-Quelle:
projekt_anp/xml2sql/dbdesign5/books02.xml

<?xml version="1.0"?>
<?xml-stylesheet version="1.0" href="books03.xsl" type="text/xsl"?>
<?cocoon-process type="xslt"?>
<books>
	<book bookid="1" pubdate="01/03/1999">
		<title>Professional ADSI CDO Programming with ASP</title>
		<authors>
			<author>Mikael Freidlitz</author>
			<author>Todd Mondor</author>
		</authors>
		<subject>ASP</subject>
	</book>
	<book bookid="2" pubdate="11/10/2000">
		<title>Professional Site Server 3.0</title>
		<title>UnProfessional Site Server 3.0</title>
		<authors>
			<author>Nick Apostolopoulos</author>
			<author>Joey Bernal</author>
			<author>Steve Edens</author>
			<author>Robert Howard</author>
			<author>Stephen Howard</author>
			<author>Mike Kendzierski</author>
			<author>Steven Livingstone</author>
			<author>Craig McQueen</author>
			<author>Marco Tabini</author>
			<author>Alex Toussaint</author>
			<author>Peter Watt</author>
		</authors>
		<subject>Commerce</subject>
	</book>
	<book bookid="3" pubdate="11/12/1999">
		<title>Professional MTS & MSMQ Programming with VB and ASP</title>	
		<authors>
			<author>Alex Homer</author>
			<author>David Sussman</author>
		</authors>
		<subject>IIS</subject>
	</book>
	<book bookid="4" pubdate="02/07/1998">
		<title>Professional MFC with Visual C++ 6</title>	
		<authors>
			<author>Mike Blaszczak</author>
		</authors>
		<subject>C++</subject>
	</book>
	<book bookid="5" pubdate="11/12/1999">
		<title>Site Server 3.0 Personalization and Membership</title>	
		<authors>
			<author>Robert Howard</author>
		</authors>
		<subject>Site Server</subject>
	</book>	
</books>

Das xsl-Stylesheet, mit dem Regel 3 umgesetzt wird:
projekt_anp/xml2sql/dbdesign5/books03.xsl

<?xml version="1.0"?>
<xsl:stylesheet version="1.0" 
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:strip-space elements="*"/>

	<xsl:template match="/">
   		<xsl:processing-instruction name="cocoon-format">
   			type="text/plain"
		</xsl:processing-instruction>
   		<php>			<!-- Root-Element; ohne dem geht es nicht!-->
   			<xsl:apply-templates/>			
   		</php>
		
  	</xsl:template>
	
	<xsl:template match="child::*">	
	CREATE TABLE <xsl:value-of select="name()"/>(
	<xsl:for-each select="@*">
	<xsl:value-of select="name()"/> CHAR(15),	
	 </xsl:for-each>		
	<xsl:for-each select="*">	
	<xsl:value-of select="name()"/><xsl:value-of select="@*[1]"/> CHAR(10),
	</xsl:for-each>pk_<xsl:value-of select="name()"/> SERIAL PRIMARY KEY
	);
	<xsl:for-each select="*">	
	<xsl:variable name="name1" select="string(name(*[1]))"/>
	<xsl:variable name="name2" select="string(name(*[2]))"/>
	<xsl:variable name="name3" select="string(name(*[3]))"/>	
	<xsl:variable name="name4" select="string(name(*[4]))"/>
	<xsl:variable name="name5" select="string(name(*[5]))"/>		
	CREATE TABLE <xsl:value-of select="name()"/>
	<xsl:value-of select="@*[1]"/> (<xsl:for-each select="@*">
	attr_<xsl:value-of select="name()"/> CHAR(15) NOT NULL,</xsl:for-each>
	fk_<xsl:value-of select="name(..)"/> INTEGER REFERENCES
	 <xsl:value-of select="name()"/>,
	<xsl:if test="name(*[1]) != name(*[2])">	
	<xsl:for-each select="*[text()]">
	elem_<xsl:value-of select="name()"/> CHAR(18),
	</xsl:for-each></xsl:if>pk_<xsl:value-of select="name()"/> SERIAL PRIMARY KEY
	);
	</xsl:for-each>
	</xsl:template>
	
</xsl:stylesheet>

Damit wird folgende .sql-Eingabesequenz generiert:
projekt_anp/xml2sql/dbdesign5/books03.sql

     
        CREATE TABLE books(
        book1 CHAR(10),
        book2 CHAR(10),
        book3 CHAR(10),
        book4 CHAR(10),
        book5 CHAR(10),
        pk_books SERIAL PRIMARY KEY
        );
                        
        CREATE TABLE book1 (
        attr_bookid CHAR(15) NOT NULL,
        attr_pubdate CHAR(15) NOT NULL,
        fk_books INTEGER REFERENCES book,
        elem_title CHAR(18),
        elem_subject CHAR(18),
        pk_book SERIAL PRIMARY KEY
        );
                        
        CREATE TABLE book2 (
        attr_bookid CHAR(15) NOT NULL,
        attr_pubdate CHAR(15) NOT NULL,
        fk_books INTEGER REFERENCES book,
        pk_book SERIAL PRIMARY KEY
        );
                        
        CREATE TABLE book3 (
        attr_bookid CHAR(15) NOT NULL,
        attr_pubdate CHAR(15) NOT NULL,
        fk_books INTEGER REFERENCES book,
        elem_title CHAR(18),
        elem_subject CHAR(18),
        pk_book SERIAL PRIMARY KEY
        );
                        
        CREATE TABLE book4 (
        attr_bookid CHAR(15) NOT NULL,
        attr_pubdate CHAR(15) NOT NULL,
        fk_books INTEGER REFERENCES book,
        elem_title CHAR(18),
        elem_subject CHAR(18),
        pk_book SERIAL PRIMARY KEY
        );
                        
        CREATE TABLE book5 (
        attr_bookid CHAR(15) NOT NULL,
        attr_pubdate CHAR(15) NOT NULL,
        fk_books INTEGER REFERENCES book,
        elem_title CHAR(18),
        elem_subject CHAR(18),
        pk_book SERIAL PRIMARY KEY
        );
        
<!-- This page was served in 35 milliseconds by Cocoon 1.8.2 -->

Regel 4

Enthält ein Element nur Text, und tritt das Element nur ein Mal auf, dann erstellen wir eine Spalte in der Tabelle des Eltern-Elementes und geben der Spalte den Namen des Elementes und das Präfix elem_

Diese Regel ließ sich direkt aus der xml-Datenquelle heraus nicht umsetzen. Dazu sind die Möglichkeiten von xslt als Programmiersprache zu begrenzt.

Umsetzung von XML:Schema nach SQL

Zusammenfassung

XML:Schema beschreibt die Struktur eines .xml-Dokumentes im XML-Format, anders als eine DTD. XML:Schema ist noch Candidate Recommendation des W3C (s. http://www.w3.org/TR) und entsprechend neu. Als Software wurde XMLAuthority (http://www.extensibility.com/tibco/solutions/xml_authority/index.htm) verwendet, um XML:Schemata zu erzeugen.

Die Umsetzung von XML:Schema nach SQL erbrachte folgende Ergebnisse:

  • Ein-oder Mehrfachvorkommen von Elementen und z.T. Datentypen werden durch XML:Schema erfasst.
  • Die Formatierung in XML erlaubt problemlose Umwandlung
  • Die Zuordnung von Tabellen zu den korrespondierenden Tabelleneinträgen gestaltet sich schwierig.

Installation von XMLAuthority

Runterladen der Sourcen von:
http://www.extensibility.com/tibco/solutions/xml_authority/index.htm
nach: /home/software/xml/authority
Verzeichnis erzeugen: /usr/local/authority und den heruntergeladenen File XA_21-linux.tar.gz dorthin kopieren.
Auspacken mit tar -xzf
Es entsteht das Verzeichnis: TIBCOExtensibiltity, das nach /usr/local kopiert wird. /usr/local/authority wird wieder gelöscht.
Es gibt eine ausführbare Datei: setup.sh. . Es wird einiges abgefragt, u.a. der Registration Code: 1FFC-0212-CC84-CCCB.
Anschließend wird von: /home/geronimo/TIBCOExtensibility/XMLAuthority/XA/xa ein symbolisches Link gesetzt nach /usr/local/bin, damit XMLAuthority allgemein zur Verfügung steht. Starten tut es zunächst seinem Heimatverzeichnis, das lässt sich ab er einstellen.

Die Ergebnisse im Einzelnen

XML-Ursprungsfile

/home/geronimo/xml/projekt_anp/xml2sql/schema2/schema01.xml

<?xml version="1.0"?>
<?xml-stylesheet version="1.0" href="books03.xsl" type="text/xsl"?>
<?cocoon-process type="xslt"?>
<books>
	<book bookid="1" pubdate="01/03/1999">
		<title>Professional ADSI CDO Programming with ASP</title>
		<authors>
			<author>Mikael Freidlitz</author>
			<author>Todd Mondor</author>
		</authors>
		<subject>ASP</subject>
	</book>
	<book bookid="2" pubdate="11/10/2000">
		<title>Professional Site Server 3.0</title>
		<title>UnProfessional Site Server 3.0</title>
		<authors>
			<author>Nick Apostolopoulos</author>
			<author>Joey Bernal</author>
			<author>Steve Edens</author>
			<author>Robert Howard</author>
			<author>Stephen Howard</author>
			<author>Mike Kendzierski</author>
			<author>Steven Livingstone</author>
			<author>Craig McQueen</author>
			<author>Marco Tabini</author>
			<author>Alex Toussaint</author>
			<author>Peter Watt</author>
		</authors>
		<subject>Commerce</subject>
	</book>
	<book bookid="3" pubdate="11/12/1999">
		<title>Professional MTS & MSMQ Programming with VB and ASP</title>	
		<authors>
			<author>Alex Homer</author>
			<author>David Sussman</author>
		</authors>
		<subject>IIS</subject>
	</book>
	<book bookid="4" pubdate="02/07/1998">
		<title>Professional MFC with Visual C++ 6</title>	
		<authors>
			<author>Mike Blaszczak</author>
		</authors>
		<subject>C++</subject>
	</book>
	<book bookid="5" pubdate="11/12/1999">
		<title>Site Server 3.0 Personalization and Membership</title>	
		<authors>
			<author>Robert Howard</author>
		</authors>
		<subject>Site Server</subject>
	</book>	
</books>
Daraus macht XMLAuthority das xml:Schema, mit dem im folgenden gearbeitet wird.

Regel 1

Aus xml Professional, S. 461:
Regel 1: Sobald eine neue Tabelle erstellt wird, soll auch ein Schlüssel mit demselben Namen erstellt werden, der das präfix "`_pk"' trägt. Diese Spalte sollte ein Datentyp automatically-incremented Integer sein.

Zunächst braucht es zur Verwendung von xml:Schema den richtigen Header. Dazu muss in jeder <xsd:element>-angabe das xsd: eliminiert werden. Das Ergebnis sieht so aus:
/home/geronimo/xml/projekt_anp/xml2sql/schema2/schema01.xml

<?xml version="1.0"?>
<?xml-stylesheet href="schema01.xsl" type="text/xsl"?>
<?cocoon-process type="xslt"?>

<!--Generated by XML Authority. 
Conforms to w3c http://www.w3.org/2000/10/XMLSchema-->
<schema xmlns:xsd = "http://www.w3.org/2000/10/XMLSchema">
	<element name = "books">
		<complexType>
			<sequence>
				<element ref = "book" maxOccurs = "unbounded"/>
			</sequence>
		</complexType>
	</element>
	<element name = "book">
		<complexType>
			<sequence>
				<element ref = "title" maxOccurs = "unbounded"/>
				<element ref = "authors"/>
				<element ref = "subject"/>
			</sequence>
			<attribute name = "pubdate" use = "required" type = "string"/>
			<attribute name = "bookid" use = "required" type = "string"/>
		</complexType>
	</element>
	<element name = "title">
		<complexType mixed = "true">
			<choice/>
		</complexType>
	</element>
	<element name = "authors">
		<complexType>
			<sequence>
				<element ref = "author" maxOccurs = "unbounded"/>
			</sequence>
		</complexType>
	</element>
	<element name = "author">
		<complexType mixed = "true">
			<choice/>
		</complexType>
	</element>
	<element name = "subject">
		<complexType mixed = "true">
			<choice minOccurs = "0" maxOccurs = "unbounded"/>
		</complexType>
	</element>
</schema>

Die Umsetzung der Regel 1 erfolgt mit diesem Stylesheet:
/home/geronimo/xml/projekt_anp/xml2sql/schema2/schema01.xsl

<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:strip-space elements="*"/>

<xsl:template match="schema">
   		<xsl:processing-instruction name="cocoon-format">
   			type="text/plain"
		</xsl:processing-instruction>
   		<sql>			<!-- Root-Element; ohne dem geht es nicht!-->
   			<xsl:apply-templates/>
   		</sql>
</xsl:template>
	
	<xsl:template match="element">
		CREATE TABLE <xsl:value-of select="@name"/>(
		pk_<xsl:value-of select="@name"/>.id SERIAL PRIMARY KEY
		);
		
	</xsl:template>
	
</xsl:stylesheet>

Das ergibt folgende sql-Eingabesequenz:
/home/geronimo/xml/projekt_anp/xml2sql/schema2/schema01.sql

                CREATE TABLE books(
                pk_books.id SERIAL PRIMARY KEY
                );
                       
                CREATE TABLE book(
                pk_book.id SERIAL PRIMARY KEY
                );
                
                CREATE TABLE title(
                pk_title.id SERIAL PRIMARY KEY
                );
                        
                CREATE TABLE authors(
                pk_authors.id SERIAL PRIMARY KEY
                );                
        
                CREATE TABLE author(
                pk_author.id SERIAL PRIMARY KEY
                );
                       
                CREATE TABLE subject(
                pk_subject.id SERIAL PRIMARY KEY
                );
                        
<!-- This page was served in 36 milliseconds by Cocoon 1.8.2 -->
Damit ist die erste Regel erfüllt.

Regel 2

Aus Professional XML, S. 461:
Regel 2: Für jeden Element-Knoten erzeigen wir eine eigene Tabelle mit dem Namen des Elementes. Danach bleibt noch folgendes zu tun:

  • Ist der Element-Knoten ein Kind-Knoten, dann erzeugen wir eine Spalte mit dem gleichen Namen und dem Präfix fk_ in der Tabelle des Eltern-Elementes.
  • Wir erzeugen eine Beziehung über einen Fremdschlüssel zwischen dieser aktuell erzeugten Spalte und der Spalte in der Tabelle für das Eltern-Element, die den Namen des Eltern-Elementes trägt.

Die Lösung für die xml-Datei von oben (schema01.xml) sieht so aus:
/home/geronimo/xml/projekt_anp/xml2sql/schema2/schema02.xsl

<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:strip-space elements="*"/>

<xsl:template match="/">
   		<xsl:processing-instruction name="cocoon-format">
   			type="text/plain"
		</xsl:processing-instruction>
   		<sql>			<!-- Root-Element; ohne dem geht es nicht!-->
   			<xsl:apply-templates/>
   		</sql>
</xsl:template>
	
	<xsl:template match="element">
		CREATE TABLE <xsl:value-of select="@name"/>(
		<xsl:for-each select="complexType/sequence/element">
		fk_<xsl:value-of select="@ref"/> INTEGER REFERENCES,
		</xsl:for-each>pk_<xsl:value-of select="@name"/>.id SERIAL PRIMARY KEY	
		);		
	</xsl:template>
		
</xsl:stylesheet>

Das ergibt die sql-Eingabesequenz:
/home/geronimo/xml/projekt_anp/xml2sql/schema2/schema02.sql


     CREATE TABLE books(
                fk_book INTEGER REFERENCES,
                pk_books.id SERIAL PRIMARY KEY  
                );              
        
                CREATE TABLE book(
                fk_title INTEGER REFERENCES,
                fk_authors INTEGER REFERENCES,
                fk_subject INTEGER REFERENCES,
                pk_book.id SERIAL PRIMARY KEY   
                );              
        
                CREATE TABLE title(
                pk_title.id SERIAL PRIMARY KEY  
                );              
        
                CREATE TABLE authors(
                fk_author INTEGER REFERENCES,
                pk_authors.id SERIAL PRIMARY KEY        
                );              
        
                CREATE TABLE author(
                pk_author.id SERIAL PRIMARY KEY 
                );              
        
                CREATE TABLE subject(
                pk_subject.id SERIAL PRIMARY KEY        
                );              
        
<!-- This page was served from cache in 1 milliseconds by Cocoon 1.8.2 -->

Regel 3

Aus Professional XML, s. 462:

Regel 3: Für jeden Attribut-Knoten:

  • Erzeuge eine Spalte mit dem Namen des Attributes und dem Präfix attr_
  • ist das Attribut zwingend vorgeschrieben, dann darf die Spalte keine NULL-Werte enthalten

Die verlangten Funktionen sind in xml:Schema schon angelegt:
<attribute name = "pubdate" use = "required" type = "string"/>
Damit lassen sich die Erfordernisse der Regel 3 recht einfach erfüllen. Ausgangsdatei ist immer noch schema01.xml
Die Lösung für die xml-Datei von oben (schema01.xml) sieht so aus:
/home/geronimo/xml/projekt_anp/xml2sql/schema2/schema03.xsl

<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:strip-space elements="*"/>

<xsl:template match="/">
   		<xsl:processing-instruction name="cocoon-format">
   			type="text/plain"
		</xsl:processing-instruction>
   		<sql>			<!-- Root-Element; ohne dem geht es nicht!-->
   			<xsl:apply-templates/>
   		</sql>
</xsl:template>
	
	<xsl:template match="element">
		CREATE TABLE <xsl:value-of select="@name"/>(
		<xsl:for-each select="complexType/sequence/element">
		fk_<xsl:value-of select="@ref"/>  INTEGER REFERENCES,
		</xsl:for-each>
		<xsl:for-each select="complexType/attribute">
		attr_<xsl:value-of select="@name"/>
		 VARCHAR <xsl:if test="@use ='required'">NOT NULL</xsl:if>,
		</xsl:for-each>pk_<xsl:value-of select="@name"/>.id SERIAL PRIMARY KEY		
		);
	</xsl:template>
		
</xsl:stylesheet>

Daraus ergibt sich die SQL-Eingabesequenz:
/home/geronimo/xml/projekt_anp/xml2sql/schema2/schema03.sql

    CREATE TABLE books(
                fk_book  INTEGER REFERENCES,
                pk_books.id SERIAL PRIMARY KEY          
                );
        
                CREATE TABLE book(
                fk_title  INTEGER REFERENCES,
                fk_authors  INTEGER REFERENCES,
                fk_subject  INTEGER REFERENCES,
                attr_pubdate VARCHAR NOT NULL,
                attr_bookid VARCHAR NOT NULL,
                pk_book.id SERIAL PRIMARY KEY           
                );
        
                CREATE TABLE title(
                pk_title.id SERIAL PRIMARY KEY          
                );
        
                CREATE TABLE authors(
                fk_author  INTEGER REFERENCES,
                pk_authors.id SERIAL PRIMARY KEY                
                );
        
                CREATE TABLE author(
                pk_author.id SERIAL PRIMARY KEY         
                );
        
                CREATE TABLE subject(
                pk_subject.id SERIAL PRIMARY KEY                
                );
        
<!-- This page was served in 27 milliseconds by Cocoon 1.8.2 -->

Regel 4

Aus XML Professional, S. 464:
Regel 4: Ist ein Element ein Text-Element und tritt nur ein Mal auf, dann erzeugen wir eine Spalte in der Tabelle des Eltern-Elementes und geben der Spalte den Namen des Elementes und das Präfix: elem_

Es konnte keine Möglichkeit gefunden werden, dafür einen Testalgorithmus in XSLT/XPATH zu schreiben. Nötig wäre es, die Gleichheit von
element/complexType/sequence/element[@ref] mit:
element[@name] zu testen und gleichzeitig das Vorkommen von:
complexType[@mixed ='true'].
Das ist trotz mehrerer Anläufe mit XSLT nicht gelungen.

Kapitel 4. Zeittafel des Projektes xml2sql

Juni 2000

12.06.2000
Einrichtung des Arbeitsplatzes, Installation von Linux Redhat-6.2
19.06.2000
Installation von ApacheJServ-1.1.1
26.06.2000
Installation von ApacheJServ-1.1.1
27.06.2000
Installation von ApacheJServ-1.1.1
30.06.2000
Installation von ApacheJServ-1.1.1

Juli 2000

03.07.2000
Installation von ApacheJServ-1.1.1
14.07.2000
Abschluss der Installation von ApacheJServ-1.1.1
21.07.2000
Installation von Cocoon-1.7.4
26.07.2000
Abschluss der Installation von Cocoon-1.7.4[1]

August 2000

04.08.2000
Inbetriebnahme des LDAP-Moduls von Cocoon; Entwicklung erster Header und Stylesheets
11.08.2000
Inbetriebnahme des LDAP-Moduls von Cocoon
18.08.2000
Inbetriebnahme des LDAP-Moduls von Cocoon
24.08.2000
Abschluss der Inbetriebnahme des LDAP-Moduls von Cocoon; Entwicklung zugeöriger Stylesheets und Perl-Programme
25.08.2000
Inbetriebnahme des XSP-Moduls von Cocoon incl. erster Stylesheets
31.08.2000
Inbetriebnahme von PostgreSQL-6.5.3 einschließlich des grafischen Frontends PgAccess

September 2000

08.09.2000
Entwicklung von Frames und einem Stylesheet für die Website: projekt_anp.xml
11.09.2000
Entwicklung der Navigation für die Website: projekt_anp.xml
15.09.2000
Installation und Inbetriebnahme des sql-Moduls von Cocoon mit der Datenbank PostgreSQL-6.5.3; Installation von JDBC für PostgreSQL und Funktionstest.
22.09.2000
Inbetriebnahme des Cocoon-SQL-Moduls: Servlet für PostgreSQL via JDBC
29.09.2000
Inbetriebnahme des Cocoon-SQL-Moduls: Servlet für PostgreSQL via JDBC

Oktober 2000

06.10.2000
Inbetriebnahme des Cocoon-SQL-Moduls: Datenbankabfrage, Stylesheets für Html-Ausgabe
13.10.2000
Übungen in sql mit dem Cocoon-SQL-Modul
31.10.2000
Hineinschreiben in PostgreSQL mit JDBC, Servlet, Cocoon-XSP

November 2000

03.11.2000
Hineinschreiben in PostgreSQL: Generierung der sql-Befehlssequenz aus einer xml-Datei mittels xsl-Stylesheet
09.11.2000
Referentielle Integrität bei PostgreSQL; Installation von PostgreSQL-7.0.3
17.11.2000
Installation von PostgreSQL-7.0.3
24.11.2000
Formulierung und Test der benötigten SQL-Sequenzen

Dezember 2000

01.12.2000
Zwischenbericht xml2sql
05.12.2000
Installation von JDBC für PostgreSQL-7.0.3, entsprechendes Konfigurieren der Datenbank, Aktivieren über ein Servlet und das Cocoon-SQL-Modul. Erstellen der Installationsanleitung von Cocoon-SQL. Fortsetzung Projektbericht
07.12.2000
Fortsetzung Zwischenbericht
08.12.2000
Fortsetzung Zwischenbericht
11.12.2000
Entwicklung von xsl-Stylesheets zur Generierung von Datenbanken
12.12.2000
Transformierung von xml-Attributen
14.12.2000
Umsetzung der DB-Rules in XSLT
15.12.2000
Formulieren der Regeln
18.12.2000
Installation eines xml:Schema Generators
20.12.2000
Aktuelles xml:Schema und Rules
21.12.2000
Stylesheets für Rule 2-?

Januar 2001

04.01.2001
Installation einer aktuellen xml-Produktionsumgebung
05.01.2001
Installation einer aktuellen xml-Produktionsumgebung
10.01.2001
Installation einer aktuellen xml-Produktionsumgebung
11.01.2001
Installation einer aktuellen xml-Produktionsumgebung
12.01.2001
Installation von Apache2
16.01.2001
Stylesheets und Verlinkung
17.01.2001
Stylesheet für xml2sq
18.01.2001
Stylesheet für xml2sql
19.01.2001
Bearbeitung von Stylesheets mit php
24.01.2001
Cocoon und SQL: Artikel für die iX
25.01.2001
Cocoon und SQL: Artikel für die iX

Februar 2001

06.02.2001
Cocoon und SQL: Artikel für die iX
08.02.2001
Cocoon und SQL: Artikel für die iX
14.02.2001
xml2sql; Stylesheets
21.02.2001
xml2sql; Stylesheets
22.02.2001
xml2sql; Stylesheets
28.02.2001
xml2sql; Stylesheets mit xml-Schema

März 2001

07.03.2001
XML-Website für xml2sql
08.03.2001
Stylesheets für LaTeX
08.03.2001
Abschlussbericht xml2sq
19.03.2001
Abschlussbericht xml2sq
20.03.2001
Abschlussbericht xml2sq
23.03.2001
Abschlussbericht xml2sq: XML-Version
24.03.2001
Abschlussbericht xml2sq: XML-Version

April 2001

02.04.2001
Abschlussbericht xml2sq: XML-Version
03.04.2001
Abschlussbericht xml2sq: XML-Version


Mit der aus den Protokollen erstellten Installationsanleitung hat die Installation von Cocoon-1.7.4 ein halbes Jahr später und mit einer anderen Distribution (SuSE-6.4) einen Tag gedauert.

Kapitel 5. Quellenverzeichnis

Home