Impressum Kontakt

Hacking Perl / XML

(balle)

XML das Datenaustauschformat der Zukunft hat seinen eigenen Hype überlebt und etabliert sich langsam, aber unaufhaltsam. Schon jetzt gibt es so viele verschiedene XML Anwendungen und Perl Module, dass man gar nicht mehr weiss wo man anfangen soll. XML, XSLT, XSL-FO, XPath, RSS, SVG, SOAP und XML::Parser, XML::LibXML, XML::Twig, XML::Simple und DOM, SAX wer blickt denn da noch durch? Dieser Text will versuchen einen Einstieg in die Perl / XML Welt zu geben, wird aber keinen Einstieg in XML an und für sich geben, weil es hierfür schon genug Tutorials z.B. unter

Als Programmierer solltest Du Dir XML Dateien als Datenbank vorstellen und daran denken, dass XML eine Sprache zum strukturieren von Daten ist, auf die neue (hoffentlich) standartisierte Datenformate aufbauen.

Zuerst werde ich grundlegende Techniken im Umgang mit XML Parsern erläutern, wie man XML Daten liest und schreibt, in andere Datenformate transformiert, um abschliessend noch ein paar interessante auf XML aufbauende Datenformate vor zu stellen.

Also schnell noch ne Jolt oder nen Bier geschnappt und in die Hände gespuckt! Es gibt viel zu entdecken in den Tiefen und Weiten des Perl / XML Universums!

Wer nach diesem Tutorial noch mehr wissen will, der sollte sich die Perl XML FAQ anschauen.

////[ Parsen ]////

Bevor man mit XML Daten in seinem Perl Programm spielen kann, muss man sie natürlich irgendwie aus einer XML Datei oder einer anderen Datenquelle in sein Programm laden. Dafür gibt es sogenannte XML Parser und es gibt eine schier unübersichtliche Anzahl von fertigen XML-Parser Modulen auf CPAN. Deshalb habe ich mal in einer kurzen Übersicht versucht die meiner Meinung nach wichtigsten zusammen zu fassen.

Zu aller erst wird man sich zwischen validierenden und nicht validierenden Parsern entscheiden müssen. Ein validierender Parser überprüft die Gültigkeit eines XML Dokuments anhand einer DTD oder eines Schematas. In einer DTD (Document Type Definition) wird festgelegt wie ein XML Dokument strukturiert ist und in einem Schemata kann man zusätzlich noch Datenformate für den Inhalt der einzelnen XML Tags bestimmen. Mehr Informationen zu XML Schema bekommt man hier.

Außerdem gibt es verschiedene Möglichkeiten XML Daten zu parsen, die beiden wichtigsten Methoden sind Tree- und Stream-basiertes parsen. Tree-basierte Parser lesen das komplette XML Dokument ein und bauen einen XML-Baum im Hauptspeicher auf. Diese Methode ist je nach Menge der XML Daten sehr Ressourcen fressend, erlaubt dem Perl XML Hacker allerdings auf eine angenehme Art und Weise auf die Daten zu zu greifen, weil man sich quasi wie ein Eichhörnchen flink durch die XML Daten hangeln kann.

Das W3C hat mit DOM (Document Object Modell) eine standartisierte Schnittstelle für Tree-basierte Parser definiert, d.h. Methoden um sich durch einen XML Baum zu hangeln, Elemente zu identifizieren, zu löschen, zu modifizieren, anzuhängen usw.

Man unterscheidet momentan zwischen DOM und DOM 2. Der Unterschied zwischen DOM und DOM 2 ist der, dass DOM 2 Namensräume unterstützt. Über Namensräume kann man in einem XML Dokument einen Tagnamen mehrmals einsetzen und definiert vorher welchem Namensraum er angehört. Das kann man mit den Namensräumen in Perl Modulen vergleichen.

Das W3C arbeitet derzeit schon an der Version 3 von DOM, auf die ich hier allerdings nicht weiter eingehen werde, weil es dafür noch keine Perl Module auf CPAN gibt.

Neben dem Tree-basierten parsen sollte man wie gesagt auch noch das Stream- oder auch Event-basierte parsen beherrschen.

Beim Stream-basierten parsen definiert man eine Anzahl von Handlern (Funktionen), die aufgerufen werden, wenn der Parser auf ein Event (Ereignis) stößt wie z.B. ein Start-Tag oder einen Kommentar. Stream-basierte Parser sind wesentlich Ressourcen schonender, weil sie nicht das komplette XML Dokument in den Speicher laden. Für Stream-basierte Parser gibt es vom W3C auch eine standatisierte Schnittstelle SAX (Simple API for XML). Hier gibt es ebenfalls die Version 1 und 2 und wieder besteht der Unterschied zwischen den Versionen darin, dass die Version 2 Namensräume unterstützt.

Nach so viel Theorie gibt's erstmal ein wenig Source Code. Hier ein Beispiel für einen validierenden Tree-basierten DOM 2 Parser unter der Verwendung von XML::LibXML. Alles klar? ;D

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

`

  • !/usr/bin/perl

  • Module laden

  • use XML::LibXML;
  • use strict;
  • Erzeuge ein Parser Objekt

  • my $parser = XML::LibXML->new(validation => 1);
  • Parse die XML Datei, die der Anwender als Parameter uebergibt

  • my $doc = $parser->parse_file($ARGV[0]);
  • Gib alle Elementnamen angefangen beim Root-Element aus

  • dump_nodes($doc->getDocumentElement);
  • Diese Funktion gibt den Element (Node) Namen des aktuellen

  • Elements aus und wird rekursiv für alle Kindelemente

  • (Childnodes) des aktuellen Elements aufgerufen.

  • sub dump_nodes
  • {
  • print $_[0]->nodeName . "\n";
  • map { dumpnodes($) } $_[0]->getChildnodes;
  • } `

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

Das obige Beispiel sollte mit den Kommentaren ohne weitere Erklärungen verständlich sein. Und hier direkt noch ein Beispiel für einen nicht validierenden Stream- basierten SAX 1 Parser mit Hilfe des Modules XML::Parser::PerlSAX.

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

`

  • !/usr/bin/perl

  • Module laden

  • use XML::Parser::PerlSAX;
  • use strict;
  • Erstelle ein Parser Objekt,

  • In der Klasse XMLHandler spezifizieren wir Methoden wie sie von SAX

  • vorgegeben und über den Parser aufgerufen werden.

  • my $parser = XML::Parser::PerlSAX->new(Handler => XMLHandler->new());
  • Parse die Datei, die der Anwender als ersten Parameter angibt.

  • $parser->parse(Source => {SystemId => $ARGV[0]});
  • exit 0;
  • Ab hier folgt die Klasse XMLHandler

  • In dieser Klasse werden SAX konforme Handlermethoden definiert

  • package XMLHandler;
  • Konstruktor

  • sub new { return bless {}, $_[0]; }
  • Diese Methode wird aufgerufen, wenn ein Start-Tag gefunden wird

  • sub startelement { print "Found Start-Tag " . $[1]->{'Name'} . "\n"; }
  • Diese Methode wird aufgerufen, wenn ein End-Tag gefunden wird

  • sub endelement { print "Found End-Tag " . $[1]->{'Name'} . "\n"; }
  • Diese Methode wird aufgerufen, wenn Text gefunden wird

  • sub characters { print "Found text " . $_[1]->{'Data'} . "\n"; }
  • 1; `

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

Nachdem Du jetzt zwei Beispiele für die verschiedenen Parsing Methoden kennst, fragst Du Dich vielleicht wann Du was einsetzen solltest. Behalte im Hinterkopf, dass Tree-basierte Parser sehr viel Ressourcen hungriger sind als Stream-basierte Parser, dass aber im Gegenzug Tree-basierte Parser einen direkteren Zugriff auf die Daten ermöglichen. Hierzu möchte ich noch kurz ein Beispiel geben, wie man mit XML::LibXML einen XML-Baum im Speicher aufbaut und dann über XPath Ausdrücke schnell und bequem auf Daten zu greifen kann.

XPath ist eine Sprache mit der man auf Knotenpunkte (Nodes) eines XML-Baums zu greifen und somit auch einen Teilbaum aus einem XML-Baum extrahieren kann. XPath Ausdrücke erinnern ein wenig an eine Mischung aus Unix Dateipfaden und Perl basierten regulären Ausdrücken. Zu allererst eine Beispiel XML Datei, aus der wir gleich bestimmte Daten pflücken werden.

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

`

  • <? xml version="1.0" ?>
  • <!DOCTYPE beispiel SYSTEM "beispiel.dtd">
  • <config>
  • <server>
  • <name>Testserver</name>
  • <ip>192.168.1.1</ip>
  • </server>
  • <service available="true">
  • <name>HTTP</name>
  • <port>80</port>
  • </service>
  • </config> `

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

Hier noch schnell eine DTD für unser Beispiel

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

`

  • <!ELEMENT config (server+, service*)>
  • <!ELEMENT server (name, ip)>
  • <!ELEMENT name (#CDATA)>
  • <!ELEMENT ip (#CDATA)>
  • <!ELEMENT service (name, port)>
  • <!ATTLIST service available (true|false) "false" >
  • <!ELEMENT port (#CDATA)> `

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

Diese XML Datei beschreibt einen Server und einen Dienst und speichert ob der Dienst erreichbar ist. Solch eine XML Datei könnte man z.B. für ein Servertest System gebrauchen, allerdings ist es nur ein sehr einfaches Beispiel. Jetzt werden wir mit XPath Ausdrücken gezielt den Servernamen und den Port aus der XML Datei extrahieren.

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

`

  • !/usr/bin/perl

  • Laden der Module

  • use XML::LibXML;
  • use strict;
  • Erzeuge ein validierendes Parser Objekt

  • my $parser = XML::LibXML->new(validation => 1);
  • Parse die XML Datei, died er Anwender als ersten Parameter angibt

  • my $doc = $parser->parse_file($ARGV[0]);
  • Greife über einen XPath Ausdruck gezielt auf alle Knotenpunkte

  • des XML-Baums zu, die dem angegeben XPath Ausdruck entsprechen

  • my $nodelist = $doc->findnodes('/config/server/name');
  • my $nodelist2 = $doc->findnodes('/config/service/port');
  • Laufe durch die Liste und geben den enthaltenen Text aus

  • map { print $_->textContent . "\n" } $nodelist->get_nodelist;
  • map { print $_->textContent . "\n" } $nodelist2->get_nodelist; `

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

Wann verwendet man denn nun Tree- und wann Event-basierte Parser?? Nun wenn man einfach nur bestimmte Daten aus dem XML Dokument auslesen möchte, dann sollte man entweder die oben beschriebene XPath Variante verwenden oder auf Event-basierte Parser setzen, die dann in den Eventhandler für Start-Tags überprüfen, ob gerade das für Dich interessante Tag gelesen wird, ein Flag setzen und anschliessend die zwischen diesem Start- und dem nächsten End-Tag enthaltenen Text speichern.

Falls Du irgendwelche Statistiken über vorhandene XML Strukturen errechnen möchtest, solltest Du ebenfalls auf das Stream-baserte parsen setzen. Wenn man allerdings ein XML-Dokument komplett analysieren bzw. umschreiben möchte, dann sollte man auf jeden Fall Tree-basierte Parser verwenden, weil man sich sonst schnell dabei erwischt, dass man in den Eventhandlern eine eigene Datenstruktur aufbaut, die dann doch das komplette XML-Dokument in den Speicher lädt. Letztendlich ist es aber auch eine Frage des Geschmacks bzw. des eigenen Programmierstiles und auf jeden Fall auch eine Frage der Geschwindigkeit. Falls Du Dich nicht entscheiden kannst, möchte ich Dir hier noch kurz das Modul XML::Twig vorstellen, der zwar auf den Tree-Parse Modus von XML::Parser zurück greift, aber dennoch ein Event-basiertes Interface, sowie die Möglichkeit bietet nur Teilbäume zu parsen und somit 90% Ressourcen zu sparen. Das Beispiel verwendet ebenfalls die vorherige XML Datei und extrahiert nur den Servernamen.

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

`

  • !/usr/bin/perl

  • Laden der Module

  • use XML::Twig;
  • use strict;
  • Erzeuge ein Parser Objekt und setze Eventhandler für XPath Ausdrücke

  • my $parser = new XML::Twig( TwigHandlers => {
  • "/config/server/name" => \&print_server });
  • Parse die Datei

  • $parser->parsefile($ARGV[0]);
  • Diese Funktion wird für alle zutreffenden XPath Ausdrücke aufgerufen,

  • gibt den Text des Elements aus und löscht den XML-Baum bis zu diesem

  • Element aus dem Speicher.

  • sub print_server
  • {
  • my ($tree, $element) = @_;
  • print "Found server " . $element->text . "\n";
  • $tree->flush_up_to($element);
  • } `

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

Wenn Du jetzt sagst, das ist ja alles schön und gut, aber geht's vielleicht auch ein wenig einfacher? Noch einfacher als über XPath Ausdrücke? Vielleicht solltest Du Dir mal das Modul XML::Simple anschauen, weil wie man es von Perl gewohnt ist "Es gibt mehr als einen Weg ans Ziel zu kommen".

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

`

  • !/usr/bin/perl

  • Laden der Module

  • use XML::Simple;
  • use strict;
  • XML Datei parsen

  • my $doc = XMLin($ARGV[0]);
  • Servernamen ausgeben

  • print "Server name " . $doc->{'server'}->{'name'} . "\n"; `

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

Jetzt solltest Du auf jeden Fall genügend Möglichkeiten kennen XML Daten in Dein Programm zu laden und darauf zu zu greifen.

////[ XML Output ]////

Falls Du keine komplexe Datenstruktur im Speicher zusammen gebastelt hast, die Du jetzt irgendwie gerne als XML Datenstruktur verpacken möchtest, kannst Du natürlich einfach die print() Funktion verwenden und so die XML Datenstruktur selbst aufbauen. Dadurch hast Du die größtmögliche Kontrolle allerdings auch am meisten Arbeit und Du musst selbst für die Wohlgeformtheit Deiner XML Daten sorgen.

Irgendwann wirst Du eine automatisierte Methode zur Konvertierung und Ausgabe verwenden wollen. Dafür gibt es fast schon selbstverständlich mehrere Möglichkeiten und Module in Perl.

Einmal kannst Du einen Parser verwenden, der auch in der Lage ist die Datenstruktur, die er aus Deinen XML Daten gebastelt hat, wieder in XML zurück zu verwandeln. Das ist vielleicht die eleganteste Methode, weil Du nur ein Modul zum lesen und schreiben verwendest und somit nicht noch die Verwendung eines neuen Moduls erlernen musst. Beispiele für solche Parser sind die bereits verwendeten Module XML::LibXML und XML::Simple.

Hier kurz ein Beispiel wie Du mit XML::Simple die XML-Datei einliest, den Servernamen änderst und wieder als XML Daten in eine Datei schreibst. Natürlich kann man die XML Daten auch in einen String schreiben, übers Netzwerk verschicken, in eine Datenbank packen oder sonst was damit anstellen...

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

`

  • !/usr/bin/perl

  • Laden der Module

  • use XML::Simple;
  • use strict;
  • XML Datei parsen

  • my $doc = XMLin($ARGV[0]);
  • Servernamen anpassen

  • $doc->{'server'}->{'name'} = "whatever";
  • XML Struktur in einen String und anschliessend in eine Datei schreiben

  • my $xml = XMLout($doc);
  • open(OUT,">$ARGV[1]") || die $!;
  • print OUT $xml;
  • close(OUT); `

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

XML::Simple ist wie der Name schon sagt und die Beispiele auch zeigen nur für einfache Anwendungen geeignet, aber dafür auch sehr einfach zu verwenden. Ein weiteres Modul zum schreiben von XML Datenstrukturen ist XML::Writer. Die Verwendung erinnert an die Möglichkeiten des CGI Moduls HTML Tags zu produzieren und wird in der POD Dokumentation auch sehr gut beschrieben, weshalb ich jetzt hier kein Beispiel geben möchte.

O.K. Mittlerweile kannst Du XML Datenstrukturen lesen und schreiben, aber was stellst Du jetzt mit diesem Wissen an?

////[ Transformation ]////

XML wird gerne dazu verwendet, um einmal erfasste und strukturiete Daten in verschiedene Ausgabeformate zu konvertieren (transformieren). Hierfür dient die Stylesheetsprache XSLT.

Mit XSLT kann man XML z.B in HTML und auf XML basierende Datenformate wie RSS konvertieren, man kann die XML Daten eigentlich ausgeben wie man möchte und hierfür auch Schleifen oder If-Anweisungen verwenden. Somit ist XSLT eher eine Programmiersprache als eine Stylesheetsprache. Ich möchte ein kleines Beispiel bieten, wie wir mit Hilfe eines XSLT Stylesheets unsere XML Beispieldatei in eine HTML Datei transformieren. Dazu schreiben wir einmal ein XSLT Stylesheet und realisieren in wenigen Perl Codezeilen einen XSLT Processor. Hier die XSLT Stylesheetdatei:

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

`

  • <?xml version="1.0" ?>
  • <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"; version="1.0">
  • <xsl:output method="html" />
  • <xsl:template match="/">
  • <html>
  • <body>
  • <p align="center">Beispiel für XSLT Transformationen</p>
  • <br /><br />
  • Hier steht gleich der Servername:
  • <xsl:value-of select="/config/server/name">
  • </body>
  • </html> `

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

Nun zuerst mal ein paar warme Worte zu diesem bewusst gaaanz einfach gehaltenen XSLT Stylesheet.

&lt;xsl:stylesheet xmlns:xsl=&quot;http://www.w3.org/1999/XSL/Transform&quot; version=&quot;1.0&quot;&gt;

leitet ein XSL Stylesheet ein.

&lt;xsl:output method=&quot;html&quot; /&gt; teilt dem XSLT Prozessor das Ausgabeformat mit. &lt;xsl:template match=&quot;/&quot;&gt; teilt dem Processor mit, dass dieses Template für das komplette XML Dokument (also ab dem Root-Element /) gilt. Danach folgt gewöhnlicher HTML Code und über die Anweisung &lt;xsl:value-of select=&quot;/config/server/name&quot;&gt; fügen wir den Servernamen an eine bestimmte Stelle in den HTML Code ein.

XSLT kann soviel, dass es ganze Bücher über diese Sprache gibt. Falls Hier nun erstmal der Source Code für einen einfachen XSLT Processor, der eine XML und eine XSLT Stylesheet Datei einliest, die XML Daten anhand des Stylesheets transformiert und in eine dritte Datei schreibt.

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

`

  • !/usr/bin/perl

  • Laden der Module

  • use XML::LibXML;
  • use XML::LibXSLT;
  • use Getopt::Std;
  • use strict;
  • Einlesen der Parameter

  • i == XML Datei

  • s == XSLT Stylesheet Datei

  • o == Ausgabe Datei

  • my %opts;
  • getopt('i:s:o:', \%opts);
  • XML Parser Objekt erzeugen

  • my $xml_parser = XML::LibXML->new();
  • XSLT Parser Objekt erzeugen

  • my $xslt_parser = XML::LibXSLT->new();
  • XSLT Stylesheet parsen

  • my $xslt = $xslt_parser->parse_stylesheet_file($opts{'s'});
  • XML Datei parsen

  • my $xml = $xml_parser->parse_file($opts{'i'});
  • XML Daten transformieren

  • my $result = $xslt->transform($xml);
  • Transformierte Daten in eine Datei schreiben

  • $xslt->output_file($result,$opts{'o'}); `

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

Aktuelle Browser können eine XML Datei, die auf ein XSLT Stylesheet verweist, einlesen und diese Transformation mit einem eingebauten XSLT Processor selbst durch führen.

Allerdings gibt es da draussen momentan noch viel zu viele alte Browser Versionen, die von XML noch nicht einmal ansatzweise etwas gehört haben, weswegen es zur Zeit wohl noch besser ist die Transformation serverseitig durch zu führen und dem Browser wohl bekanntes HTML zu liefern.

Wenn Du die durch XML strukturierten Daten in ein Druckformat wie z.B. PDF transformieren möchtest, musst Du zusätzlich noch XSL-FO verwenden. Ich werde auf XSL-FO nicht weiter eingehen, weil es bisher noch keinen XSL-FO Processor für Perl gibt und man somit noch ein externes Tool wie FOP aus Apaches XML Project verwenden muss, um XML in PDF zu verwandeln. O.K. Es gibt das Modul XML::Handler::AxPoint mit dem man in einem AxPoint Format strukturierte Daten parsen und in PDF transformieren kann, aber das hat nichts mit XSL-FO zu tun.

Genauso wie man XML in ein anderes Format konvertieren kann, kann man auch andere Formate in XML transformieren. Hier ein Beispiel wie Du eine SQL Tabelle ausliest und das Ergebnis als XML Datei auf die Platte schreibst.

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

`

  • !/usr/bin/perl

  • Laden der Module

  • use XML::Generator::DBI;
  • use XML::Handler::YAWriter;
  • use DBI;
  • SAX Handler

  • my $ya = XML::Handler::YAWriter->new(AsFile => "-");
  • DBI Handle

  • my $dbh = DBI->connect("dbi:mysql:dbname=test", "test", "test");
  • XML Generator erzeugen

  • my $generator = XML::Generator::DBI->new(
  • Handler => $ya,
  • dbh => $dbh
  • );
  • SQL Anweisung ausfuehren und Ergebnis als XML auf STDOUT ausgeben

  • $generator->execute("select * from user"); `

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

Dieses Beispiel habe ich einfach aus der POD Dokumentation des Modules XML::Generator::DBI geklaut und ein wenig kommentiert. Bei Fragen gilt RFTM! ;D Weitere Möglichkeiten andere Formate nach XML zu transformieren sind SAX Treiber Module wie z.B. XML::SAXDriver::Excel und XML::SAXDriver::CSV, die man sich wie die Datenbank Treiber Module DBD::* vorstellen kann, sofern man schon mit DBI gearbeitet hat...

////[ XML Anwendungen ]////

Hier noch ein paar interessante XML Anwendungen:

  • RSS - Rich Site Summary ist eine XML Anwendung zur Bereitstellung von Tickermeldungen (Logo, Title, Link, Beschreibung) für RSS Newsreader.
  • RDF - Resource Description Framework ist eine Sprache mit der man Metadaten über einen Webdienst / URI (Resource) bereitstellen kann.
  • SOAP - Simpe Object Access Protocol zum übertragen von ganzen Objekten über das HTTP Protokoll. Man kann Objekte auch über eine Netzwerkverbindung erzeugen, Methoden aufrufen und mit ihnen arbeiten als wären sie lokal.
  • SVG - Scaleable Vector Graphics ist eine Sprache zum beschreiben von zwei dimensionalen Grafiken.
  • Docbook - Docbook ist eine DTD zum schreiben von technischen Dokumentationen bzw. Büchern und konvertieren in die verschiedensten Formate.