<\/p>\n
Mit den eingebauten Funktionen für den Export von Daten aus Tabellen und Abfragen in das XML-Format können Sie bereits recht gute Ergebnisse erzielen. Natürlich können Sie aber nicht komplett steuern, wie das Zieldokument später aussehen wird. Je nach den Anforderungen der Anwendung, die das XML-Dokument weiterverarbeiten soll, sind noch änderungen notwendig. Hier tritt die Transformation von XML-Dokumenten auf den Plan: Mit einer sogenannten .xslt-Datei legen Sie fest, wie ein Dokument in ein anderes umgeformt werden soll. Den vollständigen Vorgang steuern Sie dann per VBA-Prozedur. Dieser Beitrag liefert die Grundlagen der Transformation und die notwendigen VBA-Techniken.<\/b><\/p>\nVoraussetzungen<\/h2>\n
Wenn Sie mit den eingebauten Export-Funktionen einfach nur XML-Dokumente auf Basis von Tabellen oder Abfragen erstellen wollen, benötigen Sie dazu keine weiteren Bibliotheken. Auch eine Transformation eines exportierten XML-Dokuments über die entsprechende Funktion der Benutzeroberfläche (zum Beispiel über den Ribbon-Eintrag Externe Daten|Exportieren|XML-Datei<\/b>) können Sie ohne weitere Hilfsmittel durchführen – Sie können einfach im Assistenten angeben, welche .xslt<\/b>-Datei die Vorgaben für die Transformation enthält. Das erzeugte XML-Dokument wird dann nach dem Export automatisch auf Basis dieser Datei transformiert. Sollten Sie jedoch einen Export mit der Methode ExportXML <\/b>des Application<\/b>-Objekts durchführen wollen, können Sie die .xslt<\/b>-Datei dort nicht etwa per Parameter angeben. Sie exportieren die Daten dort erst in ein XML-Dokument und führen dann die Transformation durch. Für diese Transformation benötigen Sie Objekte und Methoden der Bibliothek Microsoft XML, vx.0<\/b>, wobei Sie die jeweils aktuellste Version dieser Bibliothek wählen sollten (s. Bild 1).<\/p>\n
![\"Verweis](\"..\/fileadmin\/_temp_\/2016_04\/pic_1047_001.png\")
<\/p>\n
Bild 1: Verweis auf die Bibliothek Microsoft XML, v6.0<\/span><\/b><\/p>\n XML-Dokumente bestehen aus Daten und aus Elementen zur Strukturierung dieser Daten. Damit lassen sich beispielsweise die Daten aus verknüpften Tabellen einer Datenbank hierarchisch darstellen – zum Beispiel haben Sie eine Kategorien-Tabelle und eine Artikel-Tabelle, wo jedem Artikel eine Kategorie zugewiesen ist. In einem XML-Dokument könnten Sie nun die Kategorien und Artikel hierarchisch strukturiert speichern:<\/p>\n Die Elemente aus solch einem XML-Dokument können Sie mit einer entsprechenden .xslt<\/b>-Datei in beliebiger Form umstrukturieren, also transformieren.<\/p>\n Dazu sind nur wenige Schritte nötig:<\/p>\n Für diese Anweisungen haben wir eine einfache Prozedur geschrieben, der Sie die Pfade für die drei beteiligten XML-Dokumente per Parameter übergeben können. Diese Prozedur heißt Transformieren<\/b> und sieht wie in Listing 1 aus. Mit dem ersten Parameter übergeben Sie den Pfad zu der zu transformierenden XML-Datei, mit dem zweiten den Pfad zur .xslt<\/b>-Datei und mit dem dritten den Pfad, unter dem die transformierte Datei gespeichert werden soll.<\/p>\n Listing 1: Prozedur für die einfache Transformation eines XML-Dokuments<\/span><\/b><\/p>\n Der vierte Parameter ist ein optionaler Rückgabeparameter, der von der Funktion mit einer Fehlermeldung gefüllt wird, wenn ein Fehler auftritt. Die Funktion deklariert dann die drei benötigten Objekte vom Typ DOMDocument60<\/b>.<\/p>\n Dann erstellt sie das erste Objekt objQuelle <\/b>mit der New<\/b>-Anweisung und füllt es mit der Load<\/b>-Methode. Die Load<\/b>-Methode erwartet den Pfad zu einer XML-Datei, den wir mit dem Parameter strQuelle <\/b>übergeben. Hierbei kann es geschehen, dass ein Fehler auftritt – beispielsweise, dass unter dem mit strQuelle <\/b>angegebenen Pfad gar keine Datei gefunden werden kann. Tritt ein solcher Fehler auf, liefert die Eigenschaft parseError <\/b>von objQuelle <\/b>einen Wert ungleich 0<\/b>. Dies prüfen wir in einer If…Then<\/b>-Bedingung, deren Else<\/b>-Teil gegebenenfalls die Fehlermeldung in den Rückgabeparameter strFehler <\/b>schreibt – samt Angabe der fehlerhaften Datei. Außerdem weist die Funktion dem Rückgabewert der Funktion die Fehlernummer zu.<\/p>\n Tritt kein Fehler auf, erstellt die Funktion das zweite Objekt objXSLT <\/b>und füllt es mit dem Inhalt der mit strXSLT <\/b>angegebenen .xslt<\/b>-Datei – wieder unter Verwendung der Load<\/b>-Methode. Auch hier eventuell auftretende Fehler werden entsprechend behandelt.<\/p>\n Ist bis hierher kein Fehler aufgetreten, erstellt die Prozedur das DOMDocument60<\/b>-Objekt für das transformierte XML-Dokument. Die Transformation selbst erfolgt dann durch die Methode transformNodeToObject <\/b>des Objekts objQuelle<\/b>. Dieser übergeben wir Verweise auf die DOMDocument60<\/b>-Objekte mit der .xslt<\/b>-Datei und der Zieldatei als Parameter.<\/p>\n Nach erfolgter Transformation speichern wir den Inhalt des neu erzeugten und gefüllten XML-Dokuments aus objZiel <\/b>mit der Save<\/b>-Methode in der mit dem Parameter strZiel <\/b>angegebenen XML-Datei.<\/p>\n Der Aufruf dieser Funktion kann, wenn Sie das zu transformierende XML-Dokument und das .xslt<\/b>-Dokument bereits auf der Festplatte abgelegt haben, ganz einfach wie folgt geschehen:<\/p>\n So erhalten Sie zwar keinen Zugriff auf eine eventuelle Fehlermeldung, aber es ist der schnellste Weg, um die Transformation durchzuführen, wenn die Dateien im Dateisystem liegen.<\/p>\n Wenn Sie sich die Funktionsweise inklusive Fehlermeldung ansehen möchten, können Sie die Methode aus Listing 2 nutzen – gemeinsam mit den Tabellen der Beispieldatenbank zu diesem Beitrag. Die Methode deklariert zunächst die benötigten Variablen. Dann exportiert sie ein XML-Dokument auf Basis der Tabellen tblKategorien <\/b>und tblArtikel<\/b>, wobei die Artikeldaten den Kategorie-Elementen untergeordnet werden sollen (wie dies im Detail funktioniert, lesen Sie im Beitrag XML-Export mit VBA<\/b>, www.access-im-unternehmen.de\/1046<\/b>).<\/p>\n Listing 2: Aufruf der Funktion Transformieren mit Beispieldaten<\/span><\/b><\/p>\n Der Export landet in der Datei KategorienUndArtikel_Untransformiert.xml<\/b>. Die .xslt<\/b>-Datei zu diesem Beispiel finden Sie in den Download-Dateien. Sie heißt KategorienUndArtikel.xslt <\/b>und sollte sich im gleichen Verzeichnis wie die Datenbank befinden. Schließlich legt die Prozedur noch den Namen der Zieldatei fest, die unter KategorienUndArtikel_Transformiert.xml <\/b>gespeichert werden soll. Die drei Variablen strQuelle<\/b>, strXSLT <\/b>und strZiel <\/b>werden samt der Variablen strFehler <\/b>für den optionalen Parameter an die Funktion Transformieren <\/b>übergeben. Sollte hier einer der oben erläuterten Fehler auftreten, liefert diese einen Wert ungleich 0 <\/b>zurück, was zur Ausgabe der mit strFehler <\/b>zurückgegebenen Fehlermeldung per MsgBox<\/b>-Anweisung führt. Anderenfalls finden Sie nun in der Datei KategorienUndArtikel_Transformiert.xml <\/b>das transformierte XML-Dokument vor. Sie können sich das Beispiel vorab anhand der Beispieldaten anschauen, in den folgenden Abschnitten erläutern wir die einzelnen Elemente einer .xslt<\/b>-Datei.<\/p>\n XSLT <\/b>ist die Sprache, mit der Transformationen von XML-Dateien in andere XML-Dateien oder auch HTML-Dateien durchgeführt werden. Dabei greifen Sie über eine spezielle weitere Sprache namens XPath <\/b>auf das oder die gewünschten Elemente des zu transformierenden XML-Dokuments zu und überführen die kompletten Elemente oder auch nur deren Inhalt in das zu erstellende Dokument. Die Sprache XPath und ihre Anwendung mittels VBA beschreiben wir in einem weiteren Beitrag namens VBA und XPath <\/b>(www.access-im-unternehmen.de\/1050<\/b>).<\/p>\n Wenn Sie schon einmal eine Webseite programmiert haben, die nicht nur aus reinem HTML besteht, sondern auch aus Skript-Elementen etwa auf Basis von PHP oder ASP\/ASP.NET, haben Sie unbewusst bereits eine Vorstellung davon, wie XSLT ein neues Dokument auf Basis eines bestehenden Dokuments zusammensetzt. Ein XSLT-Dokument ist dabei ähnlich aufgebaut wie eine aus Skript- und HTML-Teilen bestehende Webseite.<\/p>\n Sie finden dort nämlich feste Zeichenketten, aber auch dynamische Elemente, mit denen etwa die Inhalte des zu transformierenden Dokuments ermittelt und ausgegeben werden.<\/p>\n Damit die .xslt<\/b>-Datei korrekt interpretiert werden kann, teilen wir der jeweiligen Verarbeitungsinstanz (in unserem Beispiel etwa die Methode transformNodeToObject<\/b>) mit einer entsprechenden Deklaration in der ersten Zeile mit, um was für einen Dokumenttyp es sich handelt. In diesem Fall soll die Datei mit der folgenden Zeile starten:<\/p>\n Damit wird der offizielle Namespace des W3C-Konsortiums vorgegeben. Alle folgenden Zeilen, die XSLT-Befehle enthalten, starten mit <xsl:<\/b> und werden mit einem XSLT-Schlüsselwort fortgesetzt. Dadurch können Sie die auszuführenden Elemente des .xslt<\/b>-Dokuments von den statischen Elementen unterscheiden – ähnlich wie etwa beim einem PHP-Dokument, wo die PHP-Anweisungen in Dieser Zeile stellen wir noch die folgende Zeile voran:<\/p>\n Das Basis-Element einer .xslt<\/b>-Datei ist das template<\/b>-Element. Es enthält auch ein Attribut namens match<\/b>. Mit match<\/b> referenzieren Sie das Element eines XML-Dokuments, auf das sich die innerhalb des template<\/b>-Elements befindlichen Elemente beziehen. Der Wert von match <\/b>ist ein XPath<\/b>-Ausdruck. XPath ist, wie oben bereits erwähnt wurde, die Sprache für den Zugriff auf die Elemente in einem XML-Dokument. Jede Menge Beispiele dazu finden Sie im Beitrag VBA und XPath <\/b>(www.access-im-unternehmen.de\/1050<\/b>). Wenn Sie beispielsweise auf das Root-Element des Dokuments (also das oberste Element) zugreifen wollen, geben Sie für das Attribut match <\/b>einen Schrägstrich an (\/<\/b>).<\/p>\n Es werden nur Informationen ausgegeben, die sich innerhalb eines template<\/b>-Elements befinden. Sie können also Folgendes in die .xslt<\/b>-Datei schreiben und es wird nichts ausgegeben:<\/p>\n Innerhalb des template<\/b>-Elements befinden sich keine Daten, und das davor angegebene blabla<\/b>-Element wird nicht ausgegeben, weil es sich nicht innerhalb eines template<\/b>-Elements befindet. Das Ergebnisdokument ist folglich leer. Wenn Sie das blabla<\/b>-Element innerhalb des template<\/b>-Elements platzieren, wird es allerdings ausgegeben:<\/p>\n Das heißt, dass Sie selbst eigene Elemente zur Ausgabe hinzufügen können, auch ohne dynamische xsl:…<\/b>-Elemente innerhalb des template<\/b>-Elements hinzuzufügen. Sie könnten also etwa die Grundstruktur des Dokuments anlegen:<\/p>\n <\/p>\n Dies liefert die folgende Ausgabe:<\/p>\n XML-Dokumente haben den Vorteil, dass sie sowohl maschinell erfasst werden können also auch durch das menschliche Auge in den meisten Fällen gut verarbeitet werden können. Dies fällt jedoch umso leichter, wenn der Inhalt des Dokuments einigermaßen strukturiert ausgegeben wird – also mit Zeilenumbrüchen und Einrückungen. Das vorherige Beispiel enthält keine Zeilenumbrüche, was bei dem Hauptelement Damit erhalten wir nun im Zieldokument:<\/p>\n Das ist viel besser – darauf können wir aufbauen! Das Element Wenn Sie während der Erstellung eines .xslt<\/b>-Dokuments Bereiche auskommentieren wollen, finden Sie dazu ein eigenes Element. Dieses heißt comment <\/b>und wird beispielsweise wie folgt eingesetzt:<\/p>\n Nun wollen wir endlich auf die Daten in unserem Ausgangsdokument zugreifen, das wir transformieren wollen. Bereits jetzt wird offensichtlich, dass es eher eine Neuerstellung eines Dokuments ist als eine Transformation, denn wir müssen wohl für jedes einzelne gewünschte Element festlegen, ob und wo wir es platzieren wollen.<\/p>\n Wenn Sie nur den Inhalt eines bestimmten Elements des Ausgangsdokuments ausgeben wollen, verwenden Sie dazu das value-of<\/b>-Element. Dieses erwartet mit dem select<\/b>-Attribut die Angabe des betroffenen Elements, das Sie wiederum mit einem XPath-Ausdruck definieren.<\/p>\n Wir möchten einfach den Namen der ersten Kategorie in unserem Ausgangsdokument ermitteln. Damit wir wissen, von welchem Aufbau wir beim Auslesen des Dokuments reden, haben wir dieses auszugsweise in Listing 3 abgebildet. Dieses Dokument wird mit der Prozedur TestTransformieren <\/b>aus den beiden Tabellen tblKategorien <\/b>und tblArtikel <\/b>der Beispieldatenbank erzeugt, die wir weiter oben vorgestellt haben.<\/p>\n Listing 3: Ausgangsdokument für unsere Experimente<\/span><\/b><\/p>\n Wir möchten also nun auf den Inhalt des Elements Kategoriename <\/b>unterhalb von dataroot <\/b>und tblKategorien <\/b>zugreifen. Dazu fügen wir unserem Dokument nun einfach eine Zeile mit dem value-of<\/b>-Element und der Angabe des gesuchten Elements, also dataroot\/tblKategorien\/Kategoriename<\/b> hinzu:<\/p>\n Dies liefert nun ein XML-Dokument mit folgendem Inhalt:<\/p>\n Oh – das ist zwar ein gültiges XML-Dokument, aber wir wollen die Kategorie natürlich in ein eigenes Element stecken.<\/p>\n Dazu fügen wir einfach ein paar statische Elemente zum .xslt<\/b>-Dokument hinzu, sodass wir sowohl ein Kategorie<\/b>– als auch ein Kategoriename<\/b>-Element erhalten:<\/p>\n Innerhalb der .xslt<\/b>-Datei haben wir überall dort, wo Zeilenumbrüche eingefügt werden sollen, das Element Das Ergebnis sieht schon eher nach XML aus:<\/p>\n Wenn das Ausgangsdokument Elemente mit Attributen enthält, auf die Sie per XSLT zugreifen wollen, gelingt dies ebenfalls mit dem value-of<\/b>-Element. Sie müssen hier nur den entsprechenden select<\/b>-Ausdruck für ein Attribut verwenden. Auf die ArtikelID <\/b>in Allerdings haben wir nun erst eine einzige Kategorie in das Zieldokument übertragen. Wie gelangen wir an die übrigen<\/p>\n Sie ahnen es bereits: Genau, wie es ein Element gibt, mit dem man auf das Ausgangselement zeigen kann ( Der folgende Ausschnitt zeigt, wie wir alle tblKategorie<\/b>-Elemente unterhalb von dataroot <\/b>durchlaufen. Dazu fügen wir ein for-each<\/b>-Element mit dem Bezug dataroot\/tblKategorien <\/b>als XPath-Ausdruck an. Zwischen diesem und dem schließenden for-each<\/b>-Element fügen wir dann die Struktur ein, die wir für jede Kategorie im Zieldokument ausgeben wollen – nämlich das Kategorie<\/b>-Element und darin das Kategoriename<\/b>-Element mit dem Namen der Kategorie (die Zeilenumbruch-Ausdrücke haben wir der übersichtlichkeit halber weggelassen):<\/p>\n Das Ergebnis sieht nun schon wesentlich besser aus:<\/p>\n Es erscheinen nun alle Kategorien inklusive Kategoriename in der Ausgabe.<\/p>\n Wir haben zwar ein Ausgangsdokument, das in der ersten Ebene Kategorien und darunter Artikel abbildet. Daraus haben wir nun die Kategorien extrahiert. Aber wer sagt eigentlich, dass wir nicht auch einfach die Artikel exportieren können, ohne auf die tblKategorie<\/b>-Elemente Rücksicht zu nehmen Dazu formulieren wir einfach das Attribut select <\/b>des for-each<\/b>-Elements um, sodass es nach den tblArtikel<\/b>-Elementen sucht – nämlich in dataroot\/tblKategorien\/tblArtikel<\/b>. Außerdem ändern wir natürlich die Bezeichnungen der zu erzeugenden Elemente und greifen mit dem value-of<\/b>-Element nicht mehr auf Kategoriename<\/b>, sondern auf Artikelname <\/b>zu:<\/p>\n Das Ergebnis ist eine aus einer hierarchisch strukturierten XML-Datei mit zwei Ebenen exportierte XML-Datei, die nur noch die Elemente der zweiten Ebene enthält:<\/p>\n Das Ergebnis sieht schon gut aus, aber was ist, wenn wir die Daten nach dem Artikelnamen sortiert ausgeben wollen<\/p>\n Auch die Sortierung innerhalb einer for-each<\/b>-Schleife ist kein Problem. Dafür hinterlegen Sie einfach hinter dem öffnenden for-each<\/b>-Element ein sort<\/b>-Element. Dieses verwendet ebenfalls das Attribut select<\/b>, diesmal allerdings mit dem Elementnamen des Originaldokuments, nach dessen Inhalt das transformierte Dokument sortiert werden soll.<\/p>\n Wichtig ist, dass das sort<\/b>-Element direkt wieder geschlossen wird, nicht also etwa erst mit einem schließenden Element vor dem schließenden Element des for-each<\/b>-Elements:<\/p>\n Die Artikel<\/b>-Elemente kommen nun nach dem Artikelnamen <\/b>sortiert im Zieldokument an:<\/p>\n Innerhalb der for-each<\/b>-Anweisung können Sie auch dafür sorgen, dass nur bestimmte Elemente ausgegeben werden. Dies legen Sie in der Definition des select<\/b>-Attributs des for-each<\/b>-Elements fest. Wenn Sie beispielsweise nur das Element mit dem Artikelnamen Chai <\/b>ausgeben möchten, definieren Sie den select<\/b>-Wert des for-each<\/b>-Elements wie folgt:<\/p>\n Sie legen also das Kriterium in eckigen Klammern fest. Das Ergebnis sieht wie gewünscht aus:<\/p>\n Nun wollen wir alle Artikel ausgeben, die mit dem Buchstaben C <\/b>beginnen. Unsere Access-SQL-Vorkenntnisse verführen uns zu folgendem Ansatz mit dem Vergleichswert C*<\/b>:<\/p>\n Dies fruchtet allerdings nicht – wir erhalten ein Dokument ohne Artikel<\/b>-Elemente:<\/p>\n Auch der Einsatz des Prozentzeichens (%<\/b>) als Platzhalter bringt kein anderes Ergebnis. Der Grund ist, dass XPath schlicht ganz andere Ausdrücke für solche Fälle verwendet. In diesem Fall handelt es sich um eine Art Funktion und der Ausdruck in eckigen Klammern heißt starts-with(Artikelname, “C“)<\/b>:<\/p>\n Damit erhalten wir nun eine Liste wie zuvor, allerdings mit allen Artikeln, deren Artikelname mit dem Buchstaben C <\/b>beginnt. Weitere Möglichkeiten hierzu finden Sie im Beitrag VBA und XPath <\/b>(www.access-im-unternehmen.de\/1050<\/b>).<\/p>\n Es gibt noch eine Alternative zum vorherigen Aussortieren der nicht gewünschten Elemente. Dabei fassen Sie die auszugebenden Elemente, die in Abhängigkeit von einer bestimmten Bedingung ausgegeben werden sollen, in das Element if <\/b>ein.<\/p>\n Das if<\/b>-Element verwendet ein Attribut namens test<\/b>, mit dem Sie den Ausdruck festlegen, nach dem entschieden werden soll, ob die eingeschlossenen Elemente ausgegeben werden sollen oder nicht. Für einen ersten Versuch nutzen wir wieder das Kriterium Artikelname=“Chai“<\/b>:<\/p>\n Dies liefert auch die erwartete Ausgabe.<\/p>\n Nun hoffen wir, dass wir hier die von SQL gewohnten Vergleichsausdrücke nutzen können, und verwenden etwa einen Ausdruck wie Artikelname=“C*“<\/b> oder alternativ Artikelname=“C%“<\/b>. Dies gelingt allerdings auch im if<\/b>-Element nicht.<\/p>\n Stattdessen müssen wir auch hier eine Funktion nutzen – in diesem Fall zur Ausgabe aller tblArtikel<\/b>-Elemente, deren Element Artikelname <\/b>mit dem Buchstaben C <\/b>beginnt:<\/p>\n Mit dem hier gezeigten if<\/b>-Element können Sie zwar eine Bedingung prüfen, aber nicht festlegen, was getan werden soll, wenn diese Bedingung nicht eintritt (außer, dass der Inhalt des öffnenden und schließenden if<\/b>-Elements nicht ausgegeben wird). Daher finden Sie unter XSLT auch ein Konstrukt, mit dem Sie If…Else…Then<\/b>-Bedingungen abbilden können, aber auch If…ElseIf…Else…Then<\/b>– oder If…ElseIf<\/b>-Bedingungen, wobei immer mehrere ElseIf<\/b>-Zweige möglich sind.<\/p>\n Der grundsätzliche Aufbau sieht wie folgt aus (immer innerhalb einer for-each<\/b>-Struktur zu verwenden):<\/p>\n Die in den when<\/b>-Elementen formulierten Bedingungen und das otherwise<\/b>-Element werden immer in ein choose<\/b>-Element eingefasst. Sie können mehr als eine when<\/b>-Bedingung angeben. Das otherwise<\/b>-Element darf nur einmal auftreten, kann aber auch weggelassen werden. Das folgende Beispiel sorgt dafür, dass je nach dem Einzelpreis für einen Artikel das Element Preisbereich <\/b>mit den Werten Günstig<\/b>, Mittel <\/b>und Teuer <\/b>zur Ausgabe des jeweiligen Artikel<\/b>-Elements hinzugefügt wird:<\/p>\n Der Vergleichsoperator muss dabei maskiert werden, wenn er Zeichen enthält, die auch in der Strukturierung von XML-Dokumenten zum Einsatz kommen – also etwa das Größer- und das Kleiner-Zeichen. Das Größer-Zeichen wird mit < <\/b>ersetzt, das Kleiner-Zeichen mit ><\/b>.<\/p>\n Das Ergebnis sieht wie erwartet aus:<\/p>\n Für unseren Anwendungsfall, wo wir es mit tblKategorie<\/b>-Elementen und untergeordneten tblArtikel<\/b>-Elementen zu tun haben, benötigen wir verschachtelte for-each<\/b>-Schleifen, um die beiden Hierarchie-Ebenen abzudecken und in das Zielformular zu übertragen.<\/p>\n Also verschachteln wir einfach zwei for-each<\/b>-Schleifen-Elemente ineinander. Das äußere soll sich wie im Beispiel von weiter oben, wo wir bereits einmal die tblKategorie<\/b>-Elemente durchlaufen haben, über das select<\/b>-Attribut mit dem Wert dataroot\/tblKategorien <\/b>auf die tblKategorie<\/b>-Elemente stürzen. Nach der Ausgabe des Kategorie<\/b>-Elements und des untergeordneten Transformations-Grundlagen<\/h2>\n
<xml version=\"1.0\" encoding=\"UTF-8\">\r\n<Kategorien>\r\n <Kategorie>\r\n <KategorieID>1<\/KategorieID>\r\n <Kategoriename>Kategorie 1<\/Kategoriename>\r\n <Artikel>\r\n <ArtikelID>1<\/ArtikelID>\r\n <Artikelname>Artikel 1<\/Artikelname>\r\n <\/Artikel>\r\n <Artikel>\r\n <ArtikelID>2<\/ArtikelID>\r\n <Artikelname>Artikel 2<\/Artikelname>\r\n <\/Artikel>\r\n <\/Kategorie>\r\n <Kategorie>\r\n <KategorieID>2<\/KategorieID>\r\n <Kategoriename>Kategorie 2<\/Kategoriename>\r\n <Artikel>\r\n <ArtikelID>3<\/ArtikelID>\r\n <Artikelname>Artikel 3<\/Artikelname>\r\n <\/Artikel>\r\n <Artikel>\r\n <ArtikelID>4<\/ArtikelID>\r\n <Artikelname>Artikel 4<\/Artikelname>\r\n <\/Artikel>\r\n <\/Kategorie>\r\n<\/Kategorien><\/pre>\n
\n
Public Function <\/span>Transformieren(strQuelle As String<\/span>, strXSLT As String<\/span>, strZiel As String<\/span>, _\r\n Optional<\/span> strFehler As String<\/span>) As Long<\/span>\r\n Dim <\/span>objQuelle As <\/span>MSXML2.DOMDocument60\r\n Dim <\/span>objXSLT As <\/span>MSXML2.DOMDocument60\r\n Dim <\/span>objZiel As <\/span>MSXML2.DOMDocument60\r\n Set<\/span> objQuelle = New<\/span> MSXML2.DOMDocument60\r\n objQuelle.Load strQuelle\r\n If <\/span>objQuelle.parseError = 0 Then<\/span>\r\n Set<\/span> objXSLT = New<\/span> MSXML2.DOMDocument60\r\n objXSLT.Load strXSLT\r\n If <\/span>objXSLT.parseError = 0 Then<\/span>\r\n Set<\/span> objZiel = New<\/span> MSXML2.DOMDocument60\r\n objQuelle.transformNodeToObject objXSLT, objZiel\r\n objZiel.Save strZiel\r\n Else<\/span>\r\n Transformieren = objXSLT.parseError.errorCode\r\n strFehler = \".xslt-datei: \" & vbCrLf<\/span> & strXSLT & vbCrLf<\/span> & objXSLT.parseError.reason\r\n End If<\/span>\r\n Else<\/span>\r\n Transformieren = objQuelle.parseError.errorCode\r\n strFehler = \"Quelldatei: \" & vbCrLf<\/span> & strQuelle & vbCrLf<\/span> & objQuelle.parseError.reason\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nAufruf der Funktion „Transformieren“<\/h2>\n
Transformieren <Quelldokument>, <XSLT-Dokument>, <Zieldokument><\/pre>\n
Public Sub <\/span>TestTransformieren()\r\n Dim <\/span>strQuelle As String<\/span>\r\n Dim <\/span>strXSLT As String<\/span>\r\n Dim <\/span>strZiel As String<\/span>\r\n Dim <\/span>strFehler As String<\/span>\r\n Dim <\/span>lngFehler As Long<\/span>\r\n Dim <\/span>objAdditionalData As <\/span>AdditionalData\r\n Set<\/span> objAdditionalData = Application.CreateAdditionalData\r\n objAdditionalData.Add \"tblArtikel\"\r\n strQuelle = CurrentProject.Path & \"\\KategorienUndArtikel_Untransformiert.xml\"\r\n Application.ExportXML acExportTable, \"tblKategorien\", strQuelle, AdditionalData:=objAdditionalData\r\n strXSLT = CurrentProject.Path & \"\\KategorienUndArtikel.xslt\"\r\n strZiel = CurrentProject.Path & \"\\KategorienUndArtikel_Transformiert.xml\"\r\n lngFehler = Transformieren(strQuelle, strXSLT, strZiel, strFehler)\r\n If <\/span>Not<\/span> lngFehler = 0 Then<\/span>\r\n MsgBox<\/span> strFehler\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nXSLT<\/h2>\n
XSLT deklarieren<\/h2>\n
<xsl:stylesheet version=\"1.0\"\r\n xmlns:xsl=\"http:\/\/www.w3.org\/1999\/XSL\/Transform\"\r\n xmlns=\"http:\/\/www.w3.org\/TR\/REC-html40\"><\/pre>\n
<xml version=\"1.0\" encoding=\"UTF-8\"><\/pre>\n
Das template-Element<\/h2>\n
<xml version=\"1.0\" encoding=\"utf-8\">\r\n<xsl:stylesheet version=\"1.0\"\r\n xmlns:xsl=\"http:\/\/www.w3.org\/1999\/XSL\/Transform\"\r\n xmlns=\"http:\/\/www.w3.org\/TR\/REC-html40\">\r\n <blabla>blub<\/blabla>\r\n <xsl:template match=\"\/\">\r\n <\/xsl:template>\r\n<\/xsl:stylesheet><\/pre>\n
<xsl:stylesheet version=\"1.0\" ...>\r\n <xsl:template match=\"\/\">\r\n <blabla>blub<\/blabla>\r\n <\/xsl:template>\r\n<\/xsl:stylesheet><\/pre>\n
<xsl:stylesheet version=\"1.0\" ...>\r\n <xsl:template match=\"\/\">\r\n <Bestellverwaltung>\r\n <\/Bestellverwaltung>\r\n <\/xsl:template>\r\n<\/xsl:stylesheet><\/pre>\n
<xml version=\"1.0\" encoding=\"UTF-16\">\r\n<Bestellverwaltung ...><\/Bestellverwaltung><\/pre>\n
Zeilenumbruch herstellen<\/h2>\n
<xsl:stylesheet version=\"1.0\" ...>\r\n <xsl:template match=\"\/\">\r\n <Bestellverwaltung>\r\n <xsl:text>
<\/xsl:text>\r\n <\/Bestellverwaltung>\r\n <\/xsl:template>\r\n<\/xsl:stylesheet><\/pre>\n
<xml version=\"1.0\" encoding=\"UTF-16\">\r\n<Bestellverwaltung xmlns=\"http:\/\/www.w3.org\/TR\/REC-html40\">\r\n<\/Bestellverwaltung><\/pre>\n
Kommentare<\/h2>\n
<xsl:comment>\r\n... auszukommentierender Bereich\r\n<\/xsl:comment><\/pre>\n
Daten aus dem Originaldokument ausgeben<\/h2>\n
<xml version=\"1.0\" encoding=\"UTF-8\">\r\n<dataroot xmlns:od=\"urn:schemas-microsoft-com:officedata\" generated=\"2016-07-09T10:30:28\">\r\n <tblKategorien>\r\n <KategorieID>1<\/KategorieID>\r\n <Kategoriename>Getränke<\/Kategoriename>\r\n <Beschreibung>Alkoholfreie Getränke, Kaffee, Tee, Bier<\/Beschreibung>\r\n <Abbildung>...<\/Abbildung>\r\n <tblArtikel>\r\n <ArtikelID>1<\/ArtikelID>\r\n <Artikelname>Chai<\/Artikelname>\r\n <LieferantID>1<\/LieferantID>\r\n <KategorieID>1<\/KategorieID>\r\n <Liefereinheit>10 Kartons x 20 Beutel<\/Liefereinheit>\r\n <Einzelpreis>9<\/Einzelpreis>\r\n <Lagerbestand>39<\/Lagerbestand>\r\n <BestellteEinheiten>0<\/BestellteEinheiten>\r\n <Mindestbestand>10<\/Mindestbestand>\r\n <Auslaufartikel>0<\/Auslaufartikel>\r\n <\/tblArtikel>\r\n <tblArtikel>\r\n <ArtikelID>2<\/ArtikelID>\r\n <Artikelname>Chang<\/Artikelname>\r\n ...\r\n <\/tblArtikel>\r\n ...\r\n <\/tblKategorien>\r\n <tblKategorien>\r\n <KategorieID>2<\/KategorieID>\r\n <Kategoriename>Gewürze<\/Kategoriename>\r\n <Beschreibung>Süße und saure Soßen, Gewürze<\/Beschreibung>\r\n <Abbildung>...<\/Abbildung>\r\n <tblArtikel>\r\n <ArtikelID>3<\/ArtikelID>\r\n <Artikelname>Aniseed Syrup<\/Artikelname>\r\n ...\r\n <\/tblArtikel>\r\n ...\r\n <\/tblKategorien>\r\n ...\r\n<\/dataroot><\/pre>\n
...\r\n<Bestellverwaltung>\r\n <xsl:text>
<\/xsl:text>\r\n <xsl:value-of select=\"dataroot\/tblKategorien\/Kategoriename\"\/>\r\n <xsl:text>
<\/xsl:text>\r\n<\/Bestellverwaltung>\r\n...<\/pre>\n
<xml version=\"1.0\" encoding=\"UTF-16\">\r\n<Bestellverwaltung xmlns=\"http:\/\/www.w3.org\/TR\/REC-html40\">\r\nGetränke\r\n<\/Bestellverwaltung><\/pre>\n
...\r\n<xsl:template match=\"\/\">\r\n <Bestellverwaltung>\r\n <xsl:text>
<\/xsl:text>\r\n <Kategorie>\r\n <xsl:text>
<\/xsl:text>\r\n <Kategoriename>\r\n <xsl:value-of select=\"dataroot\/tblKategorien\/Kategoriename\"\/>\r\n <\/Kategoriename>\r\n <xsl:text>
<\/xsl:text>\r\n <\/Kategorie>\r\n <xsl:text>
<\/xsl:text>\r\n <\/Bestellverwaltung>\r\n<\/xsl:template>\r\n...<\/pre>\n
<xml version=\"1.0\" encoding=\"UTF-16\">\r\n<Bestellverwaltung xmlns=\"http:\/\/www.w3.org\/TR\/REC-html40\">\r\n <Kategorie>\r\n <Kategoriename>Getränke<\/Kategoriename>\r\n <\/Kategorie>\r\n<\/Bestellverwaltung><\/pre>\n
Attributwerte transformieren<\/h2>\n
<xsl:value-of select=\"Artikel\/@ArtikelID\"><\/pre>\n
Elemente per Schleife durchlaufen<\/h2>\n
...\r\n<xsl:template match=\"\/\">\r\n <Bestellverwaltung>\r\n <xsl:for-each select=\"dataroot\/tblKategorien\">\r\n <Kategorie>\r\n <Kategoriename>\r\n <xsl:value-of select=\"Kategoriename\"\/>\r\n <\/Kategoriename>\r\n <\/Kategorie>\r\n <\/xsl:for-each>\r\n <\/Bestellverwaltung>\r\n<\/xsl:template>\r\n...<\/pre>\n
<xml version=\"1.0\" encoding=\"UTF-16\">\r\n<Bestellverwaltung ...>\r\n <Kategorie>\r\n <Kategoriename>Getränke<\/Kategoriename>\r\n <\/Kategorie>\r\n <Kategorie>\r\n <Kategoriename>Gewürze<\/Kategoriename>\r\n <\/Kategorie>\r\n...\r\n<\/Bestellverwaltung><\/pre>\n
Andere Elemente exportieren<\/h2>\n
...\r\n<Bestellverwaltung>\r\n <xsl:for-each select=\"dataroot\/tblKategorien\/tblArtikel\">\r\n <Artikel>\r\n <Artikelname>\r\n <xsl:value-of select=\"Artikelname\"\/>\r\n <\/Artikelname>\r\n <\/Artikel>\r\n <\/xsl:for-each>\r\n<\/Bestellverwaltung>\r\n...<\/pre>\n
<xml version=\"1.0\" encoding=\"UTF-16\">\r\n<Bestellverwaltung ...>\r\n <Artikel>\r\n <Artikelname>Chai<\/Artikelname>\r\n <\/Artikel>\r\n <Artikel>\r\n <Artikelname>Chang<\/Artikelname>\r\n <\/Artikel>\r\n <Artikel>\r\n <Artikelname>Guaran\u00e1 Fant\u00e1stica<\/Artikelname>\r\n <\/Artikel>\r\n <Artikel>\r\n <Artikelname>Sasquatch Ale<\/Artikelname>\r\n <\/Artikel>\r\n ...\r\n<\/Bestellverwaltung><\/pre>\n
Sortierung nach Elementinhalten<\/h2>\n
...\r\n<xsl:for-each select=\"dataroot\/tblKategorien\/tblArtikel\">\r\n <xsl:sort select=\"Artikelname\"\/>\r\n <Artikel>\r\n <Artikelname>\r\n <xsl:value-of select=\"Artikelname\"\/>\r\n <\/Artikelname>\r\n <\/Artikel>\r\n<\/xsl:for-each>\r\n...<\/pre>\n
<xml version=\"1.0\" encoding=\"UTF-16\">\r\n<Bestellverwaltung ...>\r\n <Artikel>\r\n <Artikelname>Alice Mutton<\/Artikelname>\r\n <\/Artikel>\r\n <Artikel>\r\n <Artikelname>Aniseed Syrup<\/Artikelname>\r\n <\/Artikel>\r\n ...\r\n<\/Bestellverwaltung><\/pre>\n
Filtern nach Elementinhalten in for-each<\/h2>\n
<xsl:for-each select=\"dataroot\/tblKategorien\/ tblArtikel[Artikelname=''Chai']\">\r\n ...\r\n<\/xsl:for-each><\/pre>\n
<xml version=\"1.0\" encoding=\"UTF-16\">\r\n<Bestellverwaltung ...>\r\n <Artikel>\r\n <Artikelname>Chai<\/Artikelname>\r\n <\/Artikel>\r\n<\/Bestellverwaltung><\/pre>\n
<xsl:for-each select=\"dataroot\/tblKategorien\/ tblArtikel[Artikelname=''C*']\">\r\n ...\r\n<\/xsl:for-each><\/pre>\n
<xml version=\"1.0\" encoding=\"UTF-16\">\r\n<Bestellverwaltung ...>\r\n<\/Bestellverwaltung><\/pre>\n
<xsl:for-each select=\"dataroot\/tblKategorien\/tblArtikel[starts-with(Artikelname,''C'')]\"><\/pre>\n
Alternative Variante zum Filtern: if<\/h2>\n
<xsl:for-each select=\"dataroot\/tblKategorien\/tblArtikel\">\r\n <xsl:if test=\"Artikelname=''Chai''\">\r\n <Artikel>\r\n <Artikelname>\r\n <xsl:value-of select=\"Artikelname\"\/>\r\n <\/Artikelname>\r\n <\/Artikel>\r\n <\/xsl:if>\r\n<\/xsl:for-each><\/pre>\n
<xsl:for-each select=\"dataroot\/tblKategorien\/tblArtikel\">\r\n <xsl:if test=\"starts-with(Artikelname,''C'')\">\r\n <Artikel>\r\n <Artikelname>\r\n <xsl:value-of select=\"Artikelname\"\/>\r\n <\/Artikelname>\r\n <\/Artikel>\r\n <\/xsl:if>\r\n<\/xsl:for-each><\/pre>\n
Ersatz für If…Then: choose-when-otherwise<\/h2>\n
<xsl:choose>\r\n <xsl:when test=\"<Bedingung>\">\r\n ...\r\n <\/xsl:when>\r\n ... weitere when-Elemente\r\n <xsl:otherwise>\r\n ...\r\n <\/xsl:otherwise>\r\n<\/xsl:choose><\/pre>\n
<xsl:for-each select=\"dataroot\/tblKategorien\/tblArtikel\">\r\n <xsl:sort select=\"Artikelname\"\/>\r\n <Artikel>\r\n <Artikelname>\r\n <xsl:value-of select=\"Artikelname\"\/>\r\n <\/Artikelname>\r\n <Einzelpreis>\r\n <xsl:value-of select=\"Einzelpreis\"\/>\r\n <\/Einzelpreis>\r\n <xsl:choose>\r\n <xsl:when test=\"Einzelpreis < 10\">\r\n <Preisbereich>Günstig<\/Preisbereich>\r\n <\/xsl:when>\r\n <xsl:when test=\"Einzelpreis < 20\">\r\n <Preisbereich>Mittel<\/Preisbereich>\r\n <\/xsl:when>\r\n <xsl:otherwise>\r\n <Preisbereich>Teuer<\/Preisbereich>\r\n <\/xsl:otherwise>\r\n <\/xsl:choose>\r\n <\/Artikel>\r\n<\/xsl:for-each><\/pre>\n
<xml version=\"1.0\" encoding=\"UTF-16\">\r\n<Bestellverwaltung ...>\r\n <Artikel>\r\n <Artikelname>Alice Mutton<\/Artikelname>\r\n <Einzelpreis>19.5<\/Einzelpreis>\r\n <Preisbereich>Mittel<\/Preisbereich>\r\n <\/Artikel>\r\n <Artikel>\r\n <Artikelname>Aniseed Syrup<\/Artikelname>\r\n <Einzelpreis>5<\/Einzelpreis>\r\n <Preisbereich>Günstig<\/Preisbereich>\r\n <\/Artikel>\r\n <Artikel>\r\n <Artikelname>Carnarvon Tigers<\/Artikelname>\r\n <Einzelpreis>31.25<\/Einzelpreis>\r\n <Preisbereich>Teuer<\/Preisbereich>\r\n <\/Artikel>\r\n ..\r\n<\/Bestellverwaltung><\/pre>\n
Verschachtelte for-each-Schleife<\/h2>\n