Oracle - Java, XML. Integration in Oracle9i GERMAN

Rudolf Jansen Oracle, Java, XML Integration in Oracle9i Rudolf Jansen Oracle, Java, XML Integration in Oracle9i Soft...

Author: Rudolf Jansen

305 downloads 971 Views 3MB Size Report

This content was uploaded by our users and we assume good faith they have the permission to share this book. If you own the copyright to this book and it is wrongfully on our website, we offer a simple DMCA procedure to remove your content from our site. Start by pressing the button below!
Report copyright / DMCA form

DOWNLOAD PDF

Rudolf Jansen Oracle, Java, XML Integration in Oracle9i

Rudolf Jansen

Oracle, Java, XML Integration in Oracle9i

Software & Support Verlag 2003

Jansen, Rudolf: Oracle, Java, XML. Integration in Oracle9i Frankfurt, 2003 ISBN 3-935042-33-7

© 2003 Software & Support Verlag GmbH

http://www.software-support.biz http://www.entwickler.com/buecher/oracle9i Bibliografische Information Der Deutschen Bibliothek Die Deutsche Bibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.ddb.de abrufbar.

Umschlaggestaltung: Tobias Friedberg Korrektorat: Rüdiger Glaum Belichtung, Druck und Bindung: M.P. Media-Print Informationstechnologie GmbH, Paderborn. Alle Rechte, auch für Übersetzungen, sind vorbehalten. Reproduktion jeglicher Art (Fotokopie, Nachdruck, Mikrofilm, Erfassung auf elektronischen Datenträgern oder andere Verfahren) nur mit schriftlicher Genehmigung des Verlags. Jegliche Haftung für die Richtigkeit des gesamten Werks kann, trotz sorgfältiger Prüfung durch Autor und Verlag, nicht übernommen werden. Die im Buch genannten Produkte, Warenzeichen und Firmennamen sind in der Regel durch deren Inhaber geschützt.

Inhaltsverzeichnis

Inhaltsverzeichnis VORWORT...................................................................................................................... 11 1

EINLEITUNG.......................................................................................................... 13 1.1 ZIELGRUPPE ....................................................................................................... 13 1.2 LERNWEGE ......................................................................................................... 14 1.3 HISTORIE ............................................................................................................ 16 1.3.1 Entwicklung .......................................................................................... 16 1.3.2 Oracle-Versionen .................................................................................. 17 1.4 BUCHINHALT ...................................................................................................... 18 1.4.1 Oracle und Java..................................................................................... 18 1.4.2 Oracle und XML ................................................................................... 20

2

ORACLE UND JAVA............................................................................................. 23 2.1 JDBC ................................................................................................................. 25 2.2 SQLJ .................................................................................................................. 25 2.3 ORACLE JVM ..................................................................................................... 26

3

JDBC......................................................................................................................... 29 3.1 JDBC-TREIBERTYPEN ........................................................................................ 29 3.1.1 Oracle-JDBC-Treiber............................................................................ 30 3.2 PROGRAMMIERUNG MIT JDBC........................................................................... 32 3.2.1 Einleitendes JDBC-Beispiel.................................................................. 33 3.2.2 Laden des JDBC-Treibers..................................................................... 34 3.2.3 Verbindungsaufbau ............................................................................... 35 3.2.4 Anlegen von SQL-Anweisungen .......................................................... 37 3.2.5 Verarbeiten von Abfrageergebnissen mit ResultSets ........................... 47 3.2.6 Exception-Behandlung.......................................................................... 50 3.3 ORACLE-JDBC-ERWEITERUNGEN ..................................................................... 53 3.3.1 Package oracle.jdbc............................................................................... 53 3.3.2 Package oracle.sql................................................................................. 58

4

SQLJ ......................................................................................................................... 71 4.1 EINFÜHRUNG ...................................................................................................... 71 4.2 INSTALLATION.................................................................................................... 75 4.3 ÜBERSETZUNG ................................................................................................... 75 4.3.1 Java- und SQLJ-Syntaxcheck ............................................................... 77 4.3.2 SQL-Überprüfungen ............................................................................. 77 4.3.3 Code-Generierung................................................................................. 79 4.3.4 Kompilieren der Java-Dateien .............................................................. 83 4.3.5 Profile-Customizing .............................................................................. 83 5

Inhaltsverzeichnis

4.4 KERNBESTANDTEILE .......................................................................................... 83 4.4.1 Deklarationsanweisungen ..................................................................... 83 4.4.2 Ausführbare Anweisungen.................................................................... 92 4.4.3 Hostvariablen ........................................................................................ 93 4.5 FORTGESCHRITTENE TECHNIKEN ....................................................................... 97 4.5.1 Übersicht ............................................................................................... 97 4.5.2 Dynamische SQL-Anweisungen........................................................... 97 4.6 JPUBLISHER ...................................................................................................... 100 4.6.1 Installation........................................................................................... 101 4.6.2 Konfiguration ...................................................................................... 101 4.6.3 Anwendungsbeispiele ......................................................................... 103 4.7 VERGLEICH JDBC UND SQLJ.......................................................................... 108 5

JAVA IN DER DATENBANK............................................................................. 111 5.1 5.2 5.3 5.4

MOTIVATION .................................................................................................... 111 ÜBERSICHT ....................................................................................................... 111 INSTALLATION.................................................................................................. 113 LADEN UND AUSFÜHREN VON JAVA-KLASSEN ................................................ 114 5.4.1 loadjava und dropjava ......................................................................... 114 5.4.2 Aufruf über Java Stored Procedures ................................................... 120 5.4.3 Resolving ............................................................................................ 123 5.5 SQLJ IN DER DATENBANK ............................................................................... 126 5.6 ADMINISTRATION UND PERFORMANCETUNING ................................................ 133 5.6.1 Speicherverwaltung............................................................................. 133 5.6.2 Statische Variablen ............................................................................. 135 5.6.3 Kompilierung ...................................................................................... 137 5.6.4 Threading ............................................................................................ 138 5.7 SICHERHEITSKONZEPT...................................................................................... 139 5.7.1 Aufruf-Rechte ..................................................................................... 140 5.7.2 Runtime-Java-Rechte .......................................................................... 140 6

JAVA STORED PROCEDURES ........................................................................ 143 6.1 ÜBERSICHT ....................................................................................................... 143 6.2 BEISPIELE ......................................................................................................... 144 6.2.1 Aufruf einer Prozedur ohne Parameter ............................................... 146 6.2.2 Aufruf einer Funktion mit Parametern................................................ 150 6.2.3 Einsatz in SELECT-Statements .......................................................... 152 6.2.4 Einsatz innerhalb eines Triggers ......................................................... 153 6.3 DATENTYP-MAPPING ....................................................................................... 154

7

VERGLEICH VON JAVA UND PL/SQL .......................................................... 157 7.1 7.2 7.3 7.4

6

JAVA AUßERHALB DER DATENBANK ................................................................ 158 PL/SQL............................................................................................................ 158 JAVA IN DER DATENBANK ................................................................................ 159 ANWENDUNGSGEBIETE FÜR JAVA STORED PROCEDURES ................................ 160

Inhaltsverzeichnis

7.4.1 Zugriff auf Betriebssystem-Ressourcen.............................................. 161 7.4.2 Anbindung externer Systeme .............................................................. 161 7.5 ZUSAMMENFASSUNG ........................................................................................ 162 8

XML-EINSATZ IN ORACLE-PRODUKTEN .................................................. 165 8.1 EINFÜHRUNG .................................................................................................... 165 8.1.1 Integrationsansätze.............................................................................. 165 8.1.2 Oracles XML-Historie ........................................................................ 166 8.2 XML DB.......................................................................................................... 168 8.2.1 Architektur .......................................................................................... 168 8.2.2 Installation........................................................................................... 170 8.2.3 Vorteile der XML-Integration............................................................. 170 8.3 XML DEVELOPER‘S KIT .................................................................................. 171 8.4 WEITERE ORACLE-KOMPONENTEN .................................................................. 172

9

XML-DB ................................................................................................................. 175 9.1 DATENTYP XMLTYPE ..................................................................................... 175 9.1.1 Tabellendefinition ............................................................................... 175 9.1.2 Select-Abfragen .................................................................................. 177 9.1.3 Update von XML-Daten ..................................................................... 177 9.1.4 Weitere SQL-Features......................................................................... 179 9.1.5 Speicher-Optionen .............................................................................. 182 9.1.6 XMLType-Methoden .......................................................................... 184 9.2 XPATH-ABFRAGEN .......................................................................................... 186 9.2.1 existsNode() ........................................................................................ 188 9.2.2 extractValue()...................................................................................... 189 9.2.3 extract() ............................................................................................... 189 9.2.4 XMLSequence().................................................................................. 190 9.2.5 Einsatz in PL/SQL .............................................................................. 192 9.3 XML-SCHEMA-UNTERSTÜTZUNG.................................................................... 192 9.3.1 Registrieren von XML-Schema .......................................................... 193 9.3.2 Objektrelationale Speicherobjekte ...................................................... 199 9.3.3 Package DBMS_XMLSCHEMA ....................................................... 206 9.3.4 Oracle-spezifische Attribute ............................................................... 210 9.3.5 Generierung von XML-Schema.......................................................... 217 9.4 XSL-TRANSFORMATIONEN .............................................................................. 218

10

GENERIERUNG VON XML........................................................................... 219 10.1 ÜBERBLICK ...................................................................................................... 219 10.1.1 Testdaten ............................................................................................. 220 10.2 ORACLE-SQL-FUNKTIONEN ............................................................................ 222 10.2.1 SYS_XMLGEN .................................................................................. 222 10.2.2 SYS_XMLAGG.................................................................................. 229 10.3 DBMS_XMLGEN-PACKAGE .......................................................................... 231 10.3.1 Bestandteile des DBMS_XMLGEN-Packages................................... 234 7

Inhaltsverzeichnis

10.4 SQLX-FUNKTIONEN ........................................................................................ 236 10.4.1 SQLX-Standard................................................................................... 236 10.4.2 XMLElement ...................................................................................... 237 10.4.3 XMLForest.......................................................................................... 240 10.4.4 XMLAgg ............................................................................................. 242 10.4.5 XMLConcat ........................................................................................ 247 10.5 URL-ZUGRIFF ÜBER DEN DATENTYP URITYPE ............................................... 249 10.5.1 UriFactory ........................................................................................... 250 10.5.2 UriType ............................................................................................... 253 10.5.3 DBUriType.......................................................................................... 254 10.5.4 HttpUriType ........................................................................................ 259 10.5.5 XDBUriType....................................................................................... 260 10.6 XMLTYPE VIEWS ............................................................................................ 261 11

XML-REPOSITORY ........................................................................................ 265 11.1 EINFÜHRUNG .................................................................................................... 265 11.1.1 Installation von Windows-Webordnern.............................................. 265 11.2 ANLEGEN VON RESSOURCEN ........................................................................... 269 11.2.1 Anlegen von Verzeichnissen............................................................... 270 11.2.2 Anlegen von Inhalten .......................................................................... 271 11.2.3 Externer Eintrag von Dateien.............................................................. 274 11.3 ZUGRIFFSMÖGLICHKEITEN ............................................................................... 278 11.3.1 Package DBMS_XDB......................................................................... 279 11.3.2 RESOURCE_VIEW und PATH_VIEW ............................................ 281 11.4 SICHERHEITSKONZEPT...................................................................................... 287 11.5 XML-DB-VERSIONING .................................................................................... 291 11.6 KONFIGURATION .............................................................................................. 296

12

XML DEVELOPER’S KITS............................................................................ 301 12.1 ÜBERBLICK ...................................................................................................... 301 12.1.1 Komponenten ...................................................................................... 301 12.1.2 Installation........................................................................................... 302 12.2 XML-PARSER .................................................................................................. 303 12.2.1 Einleitung ............................................................................................ 303 12.2.2 DOM-Parser-Beispiel.......................................................................... 304 12.2.3 Kommandozeilentool oraxml.............................................................. 307 12.2.4 XML-Schema-Prozessor..................................................................... 309 12.3 XSLT-PROZESSOR ........................................................................................... 310 12.3.1 Umwandlung über XSLProcessor-Klasse........................................... 310 12.3.2 Umwandlung über oraxsl-Tool ........................................................... 313 12.4 XML-CLASS-GENERATOR ............................................................................... 314 12.5 XML SQL UTILITY (XSU) .............................................................................. 322 12.5.1 Installation........................................................................................... 323 12.5.2 Generierung von XML........................................................................ 323 12.5.3 DML-Operationen............................................................................... 333

8

Inhaltsverzeichnis

12.5.4 Mappingregeln .................................................................................... 342 12.5.5 Einschränkungen ................................................................................. 345 12.6 XSQL-SERVLET ............................................................................................... 346 12.6.1 Überblick............................................................................................. 346 12.6.2 Installation........................................................................................... 346 12.6.3 Einfaches Beispiel............................................................................... 348 12.6.4 Beispiel mit XSLT-Umwandlung ....................................................... 349 12.6.5 Fortgeschrittenes Beispiel ................................................................... 351 12.7 WEITERE XDK-KOMPONENTEN ...................................................................... 354 12.7.1 XDK JavaBeans .................................................................................. 354 12.7.2 Oracle SOAP....................................................................................... 355 12.7.3 TransX Utility ..................................................................................... 355 INDEX ............................................................................................................................ 357

9

Vorwort

Vorwort Java und XML gehören zu den interessantesten und derzeit auch sehr häufig eingesetzten Technologien bei der Softwareentwicklung. In meiner Arbeit als freiberuflicher Softwareentwickler habe ich mich in der Vergangenheit verstärkt mit diesen Themen beschäftigt. Da ich schwerpunktmäßig im Oracle-Datenbank-Umfeld tätig bin, stand auch die Kombination von Java-, XML- und Oracle-Technologien häufig im Mittelpunkt meiner Arbeit. Aus diesen Anforderungen in meiner täglichen Projektarbeit ist die Idee für das vorliegende Buch entstanden. Meine Informationssuche zu den Integrationsfragen auf diversen Internetseiten war zwar meist erfolgreich, was mir als Softwareentwickler aber häufig fehlte, war eine zentrale Stelle, an der die technischen Aspekte anhand von SourcecodeBeispielen vorgestellt sowie die Vor- und Nachteile der verschiedenen Architekturansätze objektiv verglichen werden. Dieses Buch soll Ihnen eine solche Zusammenstellung von technischer Information mit Marketing-freier Beurteilung der Integrationsmöglichkeiten bieten. Der Schwerpunkt soll dabei nicht auf der Dokumentation aller Details liegen. Dies würde den Umfang eines solchen Buches sprengen. Ziel des Buches ist stattdessen, Ihnen als Leser die zur Beurteilung der vorhandenen Java- und XML-Integrationsmöglichkeiten nötigen Kenntnisse zu vermitteln und Sie in die Lage zu versetzen, anhand von Anforderungen eines konkreten Projektes die für Sie relevanten Technologien auszuwählen. Die beiliegende CD enthält den Sourcecode der im Buch behandelten Beispiele und soll Ihnen als Ausgangsbasis für Ihre eigenen Testprogramme dienen. Für Fragen und Anregungen stehe ich Ihnen unter der Mailadresse [email protected] gerne zur Verfügung. Bedanken möchte ich mich bei den Mitarbeitern des Software & Support Verlags, insbesondere bei Nicole Bechtel und Sebastian Meyen für die inhaltliche und technische Unterstützung bei der Realisierung dieses Buchprojektes. Außerdem geht ein Dank an meinen Studienkollegen Guido Schryen, der als Korrekturleser Teile des Manuskriptes überarbeitet hat. Der größte Dank gilt meiner Frau Gabi, die mich neben ihrer aktiven Beteiligung als Korrekturleserin vor allem durch ihre Geduld und ihr Verständnis während der Erstellung des Buchmanuskriptes unterstützt hat.

Rudolf Jansen

11

Einleitung

1 Einleitung 1.1

Zielgruppe

Gibt es nicht schon genügend Literatur zum Thema XML? Schon wieder ein Buch über Java? Und auch zum Thema Oracle gibt es doch schon viele Nachschlagewerke? Wenn Sie gerade in einer Buchhandlung stehen und zum ersten Mal in diesem Buch blättern, werden Sie sich möglicherweise diese oder ähnliche Fragen stellen. Direkt am Anfang soll daher das Themengebiet dieses Buches beschrieben werden. Zunächst soll klar herausgestellt werden, was dieses Buch nicht ist: • Dieses Buch ist keine Einführung in XML. • Es ist auch keine Einführung in Java. • Und auch Grundkenntnisse über relationale Datenbanken sollten beim Leser bereits vorhanden sein. Zu jedem der drei aufgeführten Themen gibt es umfangreiche Einführungswerke, deren Seitenzahlen den Umfang dieses Buches bei weitem übersteigen. Aus diesem Grunde wurde auf einführende Erläuterungen zu diesen Themen bewusst verzichtet. Auf der einen Seite wäre eine Kurzeinführung für komplette Neueinsteiger auf keinen Fall ausreichend und für erfahrene Anwender überflüssig. Auf der anderen Seite würde eine detaillierte Java-, XML- und Datenbankeinführung den Umfang dieses Buches sprengen. Für wen ist das Buch also gedacht? Wenn Sie zu einer der folgenden Gruppen gehören, dann werden Sie in diesem Buch fündig werden: • Sie suchen eine passende Architektur für eine Anwendung, bei der die Datenhaltung innerhalb einer Oracle-Datenbank fest vorgeschrieben ist. • Sie suchen die passende Datenbank für ein Projekt, bei der die Realisierung in Java sowie der Datenaustausch innerhalb des Systems und/oder für die Schnittstelle zu anderen Systemen in XML vorgesehen ist und wollen sich darüber informieren, was Oracle in diesem Bereich zu bieten hat. • Sie haben bereits Grundkenntnisse in einer JDBC-Anbindung an relationale Datenbanken im Allgemeinen bzw. Oracle im Speziellen und wollen Ihre Kenntnisse auf diesem Gebiet vertiefen sowie alternative Architekturmodelle für Ihre zukünftigen Datenbankapplikationen kennen lernen. • Sie stehen vor der Aufgabe, externe Anwendungen an Ihre bestehende Datenbankapplikation anzubinden und wollen dazu XML als Datenaustauschformat einsetzen. • Sie wollen eine Webanbindung an Ihre Datenbankapplikation über XMLTechnologien realisieren. • Sie wollen eine Anwendung bereitstellen, bei der die Endbenutzer keine SQLKenntnisse benötigen, um auf die Daten zugreifen zu können, sondern dies stattdessen über die aus der Windows-Welt bekannten Tools wie z.B. Browser oder Windows Explorer tun können.

13

Lernwege

• • • •

• •

• • •

1.2

Sie haben bereits eine Oracle-Anwendung mit Java- und XML-Technologien realisiert, sind aber mit der Performance dieser Anwendung nicht zufrieden und wollen sich daher über alternative Features für Ihre Anforderungen informieren. Sie setzen derzeit noch eine ältere Datenbankversion ein und wollen sich darüber informieren, ob sich aufgrund der Java- und XML-Integrationsmöglichkeiten ein Umstieg auf eine neuere Version lohnt. Sie kennen sich sowohl mit Java-Programmierung als auch mit PL/SQLProgrammierung aus und wollen diese beiden Sprachen nun verbinden. Sie wollen sich herstellerunabhängig über die Oracle-Features bezüglich Java- und XML-Integration informieren und dabei auch die Portabilität Ihrer Anwendungen sicherstellen, indem Sie nur eine lose Kopplung zwischen Java-Anwendung und Datenbank bzw. XML-Anwendung und Datenbank anstreben, um zu einem späteren Zeitpunkt ohne aufwändige Migrationsarbeiten einen Datenbankwechsel vornehmen zu können. Sie sehen sowohl Java als auch XML als Standards im Bereich Programmiersprachen bzw. Datenaustauschformat und interessieren sich dafür, was Oracle in diesen Technologien zu bieten hat. Sie arbeiten bisher mit frei verfügbaren Datenbanken und wollen sich darüber informieren, ob sich aufgrund der in diesem Buch beschriebenen Java- und XMLIntegrationsmöglichkeiten ein Umstieg auf eine kommerzielle Datenbank wie Oracle lohnt. Sie haben zwar schon einiges über Java- und XML-Integrationsmöglichkeiten von Datenbanken aus den Marketingabteilungen der Hersteller gehört, wollen sich aber nun aus unabhängiger Quelle über die technischen Details informieren. Sie haben zwar kein unmittelbar bevorstehendes Projekt im Themenbereich dieses Buches, wollen sich aber auf jeden Fall auf dem neuesten Stand der Softwaretechnologie halten. Sie haben zwar schon grundlegende Kenntnisse in Java, XML und relationalen Datenbanken, wollen aber nun auch eine konkrete Implementierung sehen, bei der diese Technologien verknüpft werden. Mögliche Fragestellungen, die Sie in diesem Zusammenhang interessieren, sind: 1. Welche Schritte sind für eine JDBC-Anbindung an eine Oracle-Datenbank erforderlich? 2. Wie kann ich ohne viel manuellen Programmieraufwand aus meinen relational abgespeicherten Daten XML-Dokumente generieren? 3. Welche Tools unterstützen mich beim Eintrag von in XML-Format vorliegenden Daten in ein relationales Schema von Oracle? 4. Native XML-Datenbanken ermöglichen ein Abspeichern meiner Daten direkt in XML-Format. Geht das auch mit Oracle?

Lernwege

Welche Informationsmöglichkeiten gibt es für Software-Entwickler und -Architekten, die sich in mindestens einer der aufgeführten Interessengruppen wiederfinden? 14

Einleitung

Wie bei allen technischen Fragestellungen, die sich mit der Oracle-Datenbank beschäftigen, ist natürlich eine der ersten Anlaufstellen die Oracle-eigene Dokumentation. Diese ist entweder im Lieferumfang einer Datenbank enthalten oder kann von den OracleWebseiten heruntergeladen werden. Zentrale Stelle für alle technischen Fragen ist hierbei die Startseite des Oracle Technology Network (OTN) http://otn.oracle.com, auf der neben vielen anderen Themen auch die Bereiche Java und XML nicht zu kurz kommen. Jeder Oracle-Interessent findet dort neben White Papers, Sourcecode-Beispielen, FAQListen sowie Diskussionsforen auch die vollständige Dokumentation zum aktuellen Datenbankrelease sowie weiterer älterer Versionen. Tabelle 1.1 zeigt eine Auflistung der Dokumentationen für die Themengebiete dieses Buches, die auf den OTN-Seiten für die Version Oracle9i Release 2 (9.2.0.1.0) verfügbar sind. Oracle-Dokumentation

Seitenzahl (PDF-Version)

Java Developer’s Guide

216

Java Stored Procedures Developer’s Guide

128

JDBC Developer’s Guide and Reference

584

Jpublisher User’s Guide

236

SQLJ Developer’s Guide and Reference

682

XML API Reference – XDK and Oracle XML DB

1246

XML Database Developer's Guide – Oracle XML DB

908

XML Developer's Kits Guide – XDK

774

Summe

4774

Tab. 1.1: Zugrunde liegende Oracle-Dokumentation

Auf diesen fast 5000 Seiten werden alle in diesem Buch vorgestellten Komponenten sowie einige weitere fortgeschrittene Techniken detailliert inklusive aller Optionen und Methoden vorgestellt. Alleine schon aufgrund des Vergleiches des Umfanges dieses Buches mit der Gesamtseitenzahl der zugehörigen Oracle-eigenen Dokumentation wird schnell klar, dass dieses Buch nicht alle Features vorstellen kann, die Oracle auf dem Java- und XML-Gebiet zur Verfügung stellt. Das vorliegende Buch kann und soll also keine Übersetzung der Oracle-Dokumentation und auch kein Ersatz für diese Dokumentation sein. Stattdessen sollte es zusammen mit der Oracle-Dokumentation eingesetzt werden. Wer sich einen Überblick über die Architekturmöglichkeiten verschaffen möchte sowie anhand kleiner Sourcecode-Beispiele den Umgang mit den Techniken lernen will, der muss nicht lange in den fast 5000 Seiten der Oracle-Dokumentation suchen, sondern kann dies mit diesem Buch machen. Darauf aufbauende Schritte bestehen darin, selber 15

Historie

anhand der auf der beiliegenden CD enthaltenen Sourcecode-Beispiele die Java- und/oder XML-Integrationsmöglichkeiten zu testen sowie die Beispiele an individuelle Anforderungen eines konkreten Projektes anzupassen. An diesem Punkt sollte dann für detaillierte Beschreibungen der Parameter von Kommandozeilentools bzw. der Methoden der zur Verfügung gestellten Klassen auch die Oracle-Dokumentation hinzugezogen werden, insbesondere wenn fortgeschrittene Techniken benötigt werden, die aus Platzgründen hier nur kurz vorgestellt werden konnten. Um die Bedeutung der Java-, XML- und Oracle-Technologie hervorzuheben, wird im Folgenden kurz auf die Historie dieser drei Themengebiete eingegangen.

1.3

Historie

1.3.1 Entwicklung An der Entstehung von Java und XML war die Firma Oracle zunächst nicht direkt beteiligt. Die Entwicklung von Java begann Anfang der neunziger Jahre durch ein Team bei der Firma Sun Microsystems unter der Leitung von James Gosling, der daher häufig als der „Erfinder von Java“ bezeichnet wird. Die Entwicklung von Java ist eng mit der rasanten Verbreitung des Internets verbunden. Der große Durchbruch gelang Java im Jahr 1995, als über Java-Applets dynamische Elemente in die bis dahin rein statischen HTMLSeiten des Internets aufgenommen werden konnten. Java hat seither eine rasante Entwicklung genommen. Dabei steht inzwischen nicht nur die Programmiersprache Java im Vordergrund, die eine ähnliche Verbreitung wie andere populäre Programmiersprachen wie z.B. C und C++ vorweisen kann. Java kann auch als Programmierplattform angesehen werden, die sich mit Einführung der J2EE (Java 2 Enterprise Edition) auch im Serverbereich etabliert hat. In der bekannten 3-SchichtenArchitektur hat sich Java also von der Clientschicht aus immer weiter auch auf der mittleren Applikationsserver-Schicht durchgesetzt. Und auch in der Datenbankschicht kann Java inzwischen eingesetzt werden, wie die Kapitel 5 bis 7 dieses Buches erläutern werden. XML ist ein W3C-Standard, dessen Version 1.0 im Jahr 1998 zunächst ohne OracleBeteiligung verabschiedet wurde. Insbesondere als Datenaustauschformat, aber auch als inzwischen nahezu in allen neuen Softwaresystemen vertretenes Format für Konfigurationsdateien sowie zur Weiterverarbeitung in andere Formate wie z.B. HTML oder ASCII wurde XML schnell zum Standard auf diesen Gebieten und wird von allen großen Softwareunternehmen unterstützt. Auch Oracle erkannte schnell die wachsende Bedeutung von XML und setzte XML zunächst in der internen Entwicklung ein. Aufgrund der offensichtlichen Vorteile bei der Anbindung externer Softwaresysteme blieb es allerdings nicht lange beim rein internen Einsatz von XML. Beginnend mit der Datenbankversion 8i hielten XML-Features Einzug in die Oracle-Datenbank.

16

Einleitung

1.3.2 Oracle-Versionen Die hier vorgestellten Features und Sourcecode-Beispiele beruhen auf der zum Zeitpunkt der Erstellung dieses Buches aktuellen Datenbankversion 9i Release 2. Insbesondere im XML-Bereich sind gerade mit dieser Version einige interessante Erweiterungen eingeführt worden, die in den folgenden Kapiteln vorgestellt werden. Aber auch Benutzer, die noch ältere 8i- oder 9i-Versionen der Datenbank einsetzen, werden in diesem Buch fündig werden. Bei allen vorgestellten Funktionen, die erst in den neueren Versionen der Datenbank verfügbar sind, ist dies vermerkt, sodass auch für ältere Versionen die Menge der darin enthaltenen Java- und XML-Integrationsmöglichkeiten erkennbar ist. Der Vergleich der bereits in älteren Versionen verfügbaren Möglichkeiten mit denen aus den aktuelleren Versionen sollte den Leser auch zu einer Entscheidung über die Frage bringen, ob sich ein Umstieg auf eine aktuellere Version der Datenbank lohnt. Neben der Datenbank ist ein weiterer bedeutender Bestandteil der Oracle-Produktpalette der Application-Server Oracle9i AS. Dieser enthält als zentrale Komponente der mittleren Schicht auch Java- und XML-Komponenten. Das vorliegende Buch beschäftigt sich allerdings mit den Java- und XML-Integrationsmöglichkeiten der Oracle-Datenbank. Während sich die Oracle-Datenbank inzwischen als einer der Marktführer im Datenbankmarkt durchgesetzt hat, gibt es im Application-Server-Markt eine wesentlich größere Zahl von konkurrierenden Anbietern. Als Folge dieser Marktsituation wird die OracleDatenbank in Unternehmen auch mit Application-Servern anderer Hersteller, frei verfügbaren Systemen wie z.B. dem Webserver Apache und/oder der Servlet-Engine Tomcat oder auch in reinen Client-Server-Architekturen eingesetzt. Um dieser Tatsache Rechnung zu tragen, konzentriert sich das vorliegende Buch auf die Oracle-Datenbank und stellt daher Architekturmodelle vor, die nicht nur in Verbindung mit dem Oracle9i AS Application-Server, sondern mit allen anderen am Markt verfügbaren Systemen eingesetzt werden können. Ein wichtiger Bestandteil eines Vergleiches von mehreren zur Verfügung stehenden Architekturmodellen ist die Frage der Performance der Gesamtanwendung. Bei der Vorstellung der verschiedenen Integrationsmöglichkeiten wird daher auch stets auf die möglichen Auswirkungen auf die Performance eingegangen. Darin enthalten ist auch immer die Frage, in welcher Konstellation bzw. bei welchen Anforderungen eine bestimmte Architektur welche Vorteile und welche Nachteile hat. Quantitative Performancetests, deren Ergebnis eine Faustformel der Art „Architektur A ist x % schneller als Architektur B“ wäre, sind allerdings nicht im Buch enthalten. Solche Performancetests sind neben der eingesetzten Hardware auch sehr von den konkreten Gegebenheiten innerhalb eines Projektes abhängig. Beispiele für solche einflussreichen Faktoren sind die zur Verfügung stehenden Netzwerkressourcen sowie deren parallele Nutzung durch andere Systeme beim JDBC-Performancetest oder die Komplexität von XML-Schema-Definitionen bei XML-Verarbeitungsschritten. Anstelle solcher nur eingeschränkt auf andere Projekte übertragbarer Tests soll das Buch den Leser in die Lage versetzen, mittels der vorgestellten Features für ein anstehendes Projekt eine Vorauswahl an Architekturmodellen zu treffen und diese dann anhand der konkreten Projektanforderungen zu evaluieren. Gegenstand einer solchen Evaluierung ist immer auch eine Gegen17

Buchinhalt

überstellung von Vorteilen durch zusätzliche Verarbeitungsmöglichkeiten mit potenziellen Nachteilen hinsichtlich der Performance. Als Beispiel sei an dieser Stelle schon die Wahlmöglichkeit bzgl. der Speicherung von auf XML-Schema-Definitionen beruhenden XML-Dokumenten erwähnt, die im Kapitel 9.1.5 vorgestellt wird. Hierbei sind beispielsweise denkbare Performanceeinbußen beim Eintrag und Aufsplitten großer XMLDokumente zu beachten, die dann aber durch einen wesentlich performanteren Zugriff auf Einzelelemente innerhalb von SELECT- oder UPDATE-Operationen ausgeglichen werden.

1.4

Buchinhalt

Das vorliegende Buch teilt sich in zwei große Teile auf. Im ersten (Kapitel 2 bis 7) werden die Java-Integrationsmöglichkeiten vorgestellt. Der zweite Teil (Kapitel 8 bis 12) beschäftigt sich mit den Möglichkeiten, XML-Verarbeitung innerhalb und außerhalb der Datenbank zu realisieren.

1.4.1 Oracle und Java Der Java-Teil dieses Buches beginnt im Kapitel 2 mit einer Einleitung in das Thema, indem die in den folgenden Kapiteln detailliert beschriebenen Möglichkeiten kurz vorgestellt werden. Mithilfe dieser Einleitung soll ein Gesamtüberblick über die vorhandenen Funktionalitäten gegeben werden, anhand derer der Leser bereits eine Vorauswahl der für ihn relevanten Techniken treffen kann. Die bekannteste Möglichkeit zur Java-Anbindung an eine (Oracle-)Datenbank ist die JDBC (Java DataBase Connectivity)-Technologie. Dabei handelt es sich um eine Sammlung von Java-Klassen und Schnittstellen. Der Datenbankzugriff wird über APIMethoden realisiert, die eigentliche Umsetzung auf die konkrete Datenbank erfolgt über einen herstellerspezifischen JDBC-Treiber, der zur Laufzeit im CLASSPATH der Anwendung enthalten sein muss. Im Kapitel 3 werden zunächst die JDBC-Grundlagen vorgestellt. Neben einer Beschreibung der verschiedenen JDBC-Treibertypen handelt es sich dabei insbesondere um die grundlegenden Techniken zur JDBC-Anbindung an (beliebige) Datenbanken. Bei Einsatz dieser Standard-JDBC-Klassen bleibt die Portabilität der Anwendung erhalten, d.h., ein Austausch der Datenbank zu einem späteren Zeitpunkt kann durch Austausch des zugehörigen JDBC-Treibers im CLASSPATH realisiert werden. Neben diesen Standard-JDBC-Funktionen gibt es allerdings auch bei Oracle eine Reihe von herstellerspezifischen Erweiterungen. Diese dienen zur Verarbeitung von Oraclespezifischen Datentypen sowie zu Performanceverbesserungen, da beim Datenbankzugriff in diesem Fall die speziellen Gegebenheiten der Oracle-Datenbank berücksichtigt werden. Kapitel 3 enthält einige Beispiele für solche Oracle-spezifischen Erweiterungen. Kapitel 4 beschäftigt sich mit SQLJ. Dabei handelt es sich um einen herstellerübergreifenden Standard, der auf JDBC aufsetzt und gemäß dem aus anderen Programmiersprachen bekannten Precompilerprinzip arbeitet. Dabei werden die im Java-Sourcecode ent18

Einleitung

haltenen SQL-Anweisungen bereits zur Compilezeit überprüft. Syntax- und Semantikfehler werden im Gegensatz zu JDBC bei Einsatz von SQLJ nicht erst zur Laufzeit erkannt und ersparen dem Programmierer damit einen zeitaufwendigen Wechsel zwischen Fehlererkennung zur Laufzeit und Fehlerbehebung in der Entwicklungsphase. Beispiele für solche bereits zur Compilezeit erkannte Syntax- und Semantikfehler sind Tippfehler innerhalb der SQL-Syntax, falsche Spaltennamen sowie fehlende Zugriffsrechte für die in der SQL-Anweisung enthaltenen Tabellen. Wie bei der Verwendung von JDBC, so gibt es auch beim SQLJ-Ansatz ein SQLJStandard-konformes Vorgehen, das die Portabilität der Anwendung bezüglich des Datenbankaustausches sicherstellt. Problem dieses Standard-Modus ist die zusätzliche SQLJSchicht, die zur Laufzeit noch vor der JDBC-Schicht durchlaufen wird und damit zu Performancenachteilen im Vergleich zur direkten Codierung über JDBC führen kann. Wer sich allerdings auf Oracle als Datenbank festlegt, kann über einen speziellen OracleModus des Precompilers diese Performanceprobleme umgehen, da in diesem Fall eine direkte Umsetzung auf Oracle-JDBC-Code erfolgt und somit der zusätzliche SQLJ-Layer zur Laufzeit nicht mehr benötigt wird. Ein weiterer in der Vergangenheit häufig aufgeführter Nachteil von SQLJ war die Einschränkung auf statisches SQL. Vor Oracle9i mussten alle Bestandteile der SQL-Anweisungen bereits zur Laufzeit feststehen. Ab Oracle9i existiert diese Einschränkung nicht mehr. SQLJ kann nun auch dynamisches SQL verarbeiten, bei dem beispielsweise die innerhalb eines SELECT-Statements auszulesenden Spalten erst zur Laufzeit vom Benutzer ausgewählt werden oder Bestandteile der WHERE-Klausel erst zur Laufzeit hinzugefügt werden. Ein anderer Architekturansatz wird im Kapitel 5 vorgestellt. Seit Oracle8i gibt es die Möglichkeit, Java-Anwendungen auch in einer Java Virtual Machine (JVM) laufen zu lassen, die in den Datenbankkern integriert ist. Insbesondere die Tatsache, dass in dieser Konstellation das Programm dort läuft, wo auch die Daten liegen, kann bei datenintensiven Anwendungen zu Performancevorteilen führen, da der Netzwerkzugriff aus dem externen Java-Programm zur Datenbank entfällt. Java-Anwendung und Datenbank laufen in dieser Architektur im selben Adressraum. Kapitel 5 beschreibt neben den Administrationsmöglichkeiten dieser Datenbank-internen JVM anhand einiger Beispiele auch, wie Java-Sourcecode sowie vorkompilierte Java-Klassen in die Datenbank eingetragen werden können. Auch einige Besonderheiten wie z.B. das Resolving-Konzept, das das CLASSPATH-Konzept von „normalen“ Java-Anwendungen innerhalb der Datenbank zur Lokalisierung von referenzierten Klassen ersetzt, sowie das zugrunde liegende Sicherheitskonzept werden im Kapitel 5 beschrieben. Aufgerufen werden Java-Klassen innerhalb der Datenbank über Java Stored Procedures. Diese werden im Kapitel 6 vorgestellt. Sie stellen eine Erweiterung der aus der OracleWelt bekannten PL/SQL-Programme dar. Hierbei werden die Vorteile der PL/SQLSprache, die insbesondere in der Datenbank-internen (Vor-)verarbeitung der Daten liegen, um die Vorteile der Java-Programmiersprache erweitert. Der Java-Teil dieses Buches endet im Kapitel 7 mit einer Gegenüberstellung von PL/SQL und Java Stored Procedures. Dabei werden Empfehlungen gegeben, bei welchen Anforderungen die Java Stored Procedures eine Verbesserung gegenüber reinem PL/SQL bieten. 19

Buchinhalt

1.4.2 Oracle und XML Der wachsenden Bedeutung von XML als Standard insbesondere im Bereich Datenaustauschformat kommt Oracle seit Datenbankversion 8i mit der Einführung von XMLErweiterungen nach. Kapitel 8 stellt die XML-Integrationsmöglichkeiten vor. Neben Erläuterungen zur historischen Entwicklung dieser Integrationsansätze innerhalb der letzten Datenbankversionen werden auch die mit der Einführung des Datentyps XMLType in 9i Release 1 sowie der Einführung des XML-Repository in 9i Release 2 nun deutlich verbesserten Möglichkeiten kurz vorgestellt. Die grundlegenden Techniken der Oracle XML DB werden im Kapitel 9 anhand von Sourcecode-Beispielen erläutert. Oracle XML DB ist kein eigenständiges Produkt, sondern die „normale“ Oracle-Datenbank, in die XML-Features integriert wurden. Der Datentyp XMLType, der analog zu allen anderen Oracle-spezifischen Datentypen eingesetzt werden kann, bietet eine Vielzahl von Verarbeitungsmöglichkeiten, die im Kapitel 9 vorgestellt werden: • Speicherung als CLOB-Wert oder aufgesplittet in Einzelelemente über objektrelationale Konstrukte. • Kombination mit relational abgespeicherten Daten über Trigger und Fremdschlüsselbeziehungen. • Navigation innerhalb von XML-Dokumenten über XPath-Funktionen. • Verarbeitung von auf XML-Schema-Definitionen beruhenden XML-Dokumenten inklusive Validierung. Es sind allerdings auch Projekte denkbar, in denen eine solche enge Integration von XML und der Datenbank nicht möglich ist. Dabei kann es sich z.B. um Altanwendungen handeln, in denen die Daten relational abgespeichert wurden. Sollen solche Altanwendungen nun um eine XML-Schnittstelle für die Anbindung externer Systeme erweitert werden, so besteht meist die Anforderung, die (relationale) Speicherung der Daten unverändert zu belassen und die XML-Umwandlung über geeignete SQL-Befehle durchzuführen. Kapitel 10 beschreibt eine Reihe von Techniken zur Generierung von XML-Dokumenten aus relational vorliegenden Daten: • Oracle-eigene Funktionen SYS_XMLGEN und SYS_XMLAGG, die in SQL-Anweisungen auf Zeilenebene eingesetzt werden können. • PL/SQL-Package DBMS_XMLGEN zur Verarbeitung von SELECT-Abfragen über zusätzliche Methoden wie z.B. Formatierung des zu erzeugenden XML-Dokumentes. • SQLX-Funktionen. SQLX ist ein herstellerübergreifender Standard für die Schnittstelle zwischen XML und SQL, der zurzeit noch in der Entwicklung ist. Oracle9i Release 2 bietet allerdings schon eine Auswahl von SQLX-Funktionen. • Referenzierung von relational vorliegenden Daten über den Datentyp UriType, über den sowohl auf externe Datenquellen über URLs als auch auf Datenbankinhalte über URIs zugegriffen werden kann. Über das im Kapitel 11 vorgestellte XML-Repository ist ein dateibasierter Zugriff auf Datenbankinhalte möglich. Unterstützte Zugriffsprotokolle sind FTP, HTTP sowie Web20

Einleitung

DAV. Über die mit dem XML-Repository zur Verfügung stehenden Funktionen lässt sich ein für den Endanwender transparenter Zugriff auf innerhalb der Datenbank gespeicherte Dokumente bzw. aus Datenbankinhalten generierte Dokumente realisieren. Der Anwender greift in diesem Fall über seine – aus der Windows-Welt bekannten – Zugriffsmechanismen wie z.B. Webbrowser, Windows Explorer oder FTP-Client auf das XMLRepository innerhalb der Datenbank zu. Anhand einiger Screenshots sowie der zugrunde liegenden Administrationstools werden die XML-Repository-Funktionen vorgestellt. Auch Erläuterungen zum Sicherheitskonzept für den externen Zugriff auf die Datenbank sowie eine Vorstellung des XML-DB-Versioning-Konzeptes, das eine Art Versionskontrolle für XML-Repository-Ressourcen darstellt, sind im Kapitel 11 zu finden. Software-Architekten und -Entwickler, die in den bisher vorgestellten Integrationsmöglichkeiten eine zu enge Kopplung zwischen XML und Datenbank sehen, werden dann eher im Kapitel 12 fündig werden. Dort werden die Komponenten des XDK (XML Developer‘s Kits) vorgestellt. Das XDK stellt eine Sammlung von nützlichen Tools bereit, mit der eine lose Kopplung von XML und Datenbank realisiert werden kann. Einsatzgebiete für die XDK-Komponenten sind Altanwendungen, bei denen die relationale Datenhaltung unverändert bleiben soll und auch die Umwandlung in XMLFormat nicht in SQL-Befehlen, sondern komplett außerhalb der Datenbank vorgenommen werden soll. Aber auch bei Neuentwicklungen kann es Gründe geben, eine zu enge Kopplung von XML und Datenbank zu vermeiden. Hier ist beispielsweise die Bindung an den Datenbankhersteller zu nennen, die man eingeht, wenn man herstellerspezifische Erweiterungen wie den oben bereits erwähnten Datentyp XMLType einsetzt. Ein Datenbankwechsel zu einem späteren Zeitpunkt ist in diesem Fall mit umfangreichen Migrationsarbeiten verbunden. Bei Einsatz der Java-Version des XDK dagegen ist ein Wechsel der zugrunde liegenden Datenbank durch Austausch des JDBC-Treibers im CLASSPATH möglich, zumindest in den Fällen, in denen man keine herstellerspezifischen Datentypen oder Erweiterungen eingesetzt hat. Theoretisch können die XDK-Komponenten also auch mit anderen Datenbanken eingesetzt werden, für die ein entsprechender JDBC-Treiber zur Verfügung steht. Auch Standardsoftware, die auf jeden Fall mit mehreren Datenbanken zusammenarbeiten muss, wird in der Regel nicht über herstellerspezifische Erweiterungen realisiert und stellt daher ein mögliches Einsatzgebiet für die XDK-Komponenten dar. Auch das Einfügen von in XML-Format vorliegenden Daten in ein bestehendes relationales Schema muss möglich sein. Das XDK existiert für die Programmiersprachen Java, C, C++ und PL/SQL und stellt je nach eingesetzter Programmiersprache die folgenden Komponenten zur Verfügung: • • • • • • • •

XML Parser XSLT Prozessor XML Schema Prozessor XML Class Generator XML SQL Utility (XSU) XSQL Servlet XML Transviewer Java Beans TransXUtility

21

Buchinhalt •

•

Oracle SOAP Server XML Compressor

Die erstgenannten Komponenten XML Parser, XSLT Prozessor, XML Schema Prozessor und XML Class Generator enthalten in ihrer Grundform keine datenbankspezifischen Bestandteile und können daher auch in Anwendungen ohne Datenbankbezug eingesetzt werden. Sie dienen als Grundlage für die weiteren Komponenten. Das XML SQL Utility (XSU) ist eine Sammlung von Java-Klassen, mit denen diverse Umwandlungen zwischen der relationalen Datenbank und XML vorgenommen werden können. Das XSQL Servlet ist für den Einsatz innerhalb einer Webserver-Anwendung gedacht und dient dort als Schnittstelle zwischen der Clientschicht sowie der Datenbank. Viele XDK-Komponenten stehen einerseits in Form von Java-Klassen zur Verfügung, die in selbst geschriebene Java-Anwendungen integriert werden können, andererseits aber auch als Kommandozeilenskript für Offline-Arbeiten.

22

Oracle und Java

2 Oracle und Java Bei der Neuentwicklung einer Applikation, deren Datenhaltung in einer OracleDatenbank erfolgen soll und bei der entweder der gesamte Sourcecode oder zumindest Teile davon in Java erstellt werden sollen, ist eine der ersten und wichtigsten Aufgaben die Suche nach der geeigneten Architektur. Bereits in der Designphase ist hier eine Vielzahl von Kriterien zu beachten, bei denen u.a. die Performance und Skalierbarkeit der Zielapplikation im Mittelpunkt stehen. Gerade in datenintensiven Anwendungen ist dabei ein besonderes Augenmerk auf die Schnittstelle zwischen den Java-Komponenten und der Datenbank zu legen. Selbst eine bis in alle Einzelheiten im Hinblick auf Performance getunte Datenbank beseitigt noch nicht die potenziellen Probleme, die sich beim Zugriff auf diese Datenbank ergeben können. Als Engpass für das Gesamtsystem erweist sich nämlich häufig nicht die Datenbank, sondern der Netzwerkzugriff vom Rechner, auf dem die (Java-)Applikation läuft, zum Datenbankrechner. Applikationen ohne Schnittstelle zu anderen Systemen oder zu einem menschlichen Benutzer werden daher häufig direkt in der Datenbank realisiert und laufen dort als PL/SQL-Programm. Vorteil ist hier die Tatsache, dass das vorkompilierte Programm in dieser Konstellation genau da läuft, wo die Daten liegen, nämlich im Datenbankkern. Beispiele für solche Programme sind Statistikauswertungen über größere Datenmengen, die meist in (nächtlichen) Batchjobs ablaufen. Diese benötigen keine eigene Benutzeroberfläche oder Zugriffe auf Fremdsysteme und bieten daher in der Regel nur eine Schnittstelle nach außen in Form eines Aufrufskriptes, das von der Kommandozeile oder aus einem weiteren Skript heraus aufgerufen werden kann. Obwohl über die diversen PL/SQL-Packages, die inzwischen nach einer StandardInstallation der Oracle-Datenbank zur Verfügung stehen, eine Vielzahl von über die reine Datenverarbeitung hinausgehenden Möglichkeiten existiert, können diese PL/SQLErweiterungen nicht mit den Aussichten konkurrieren, die sich in der Java-Welt bieten. Beispielhaft sei hier nur auf die Möglichkeiten hingewiesen, die sich bzgl. XMLVerarbeitung, Anschluss an andere Systeme über die JCA (Java Connector Architecture)APIs sowie diverse andere im JCP (Java Community Process) entwickelte APIFunktionen ergeben. Wer also Funktionen, die über die reine Verarbeitung von Datenbankinhalten hinausgehen, in seinen Applikationen realisieren muss, der wird mit PL/SQL alleine nicht glücklich werden und sich stattdessen mit einer Realisierung des Systems in Java befassen. Diese Entscheidung für Java als Programmiersprache ändert aber natürlich nichts an der Tatsache, dass die Datenhaltung und eventuell auch ein Teil der Daten(vor-)verarbeitung weiterhin in der Oracle-Datenbank erfolgt. Die Frage nach der passenden Architektur bzgl. der Schnittstelle zwischen Java und Oracle bleibt also eine der zentralen Aufgaben in der Designphase. Abbildung 2.1 zeigt einen Überblick über die grundlegenden Architekturmodelle in der „Oracle und Java“-Welt.

23

Buchinhalt

Abb. 2.1: Oracle-Java-Architekturübersicht

Die wichtigste und weitreichendste Entscheidung, die für eine Oracle-Java-Applikation getroffen werden muss, ist die Frage, ob das Java-Programm innerhalb oder außerhalb der Datenbank ablaufen soll. Im „Normalfall“ laufen die Java-Komponenten in einer JVM (Java Virtual Machine) außerhalb der Datenbank, meist auch auf einem anderen Rechner als die Datenbank. Die Datenbankfunktionen haben hierbei keinen Einfluss auf die übrigen Funktionalitäten. Stattdessen ist die Schnittstelle zur Datenbank eine von möglicherweise mehreren Schnittstellen zu externen Anwendungen. Die Datenbankzugriffskomponenten werden meist in eigenen Klassen realisiert. Für den eigentlichen Zugriff auf die Datenbank stehen zwei Ansätze zur Verfügung: JDBC und SQL. Ein anderer Ansatz besteht in der Nutzung der Oracle JVM. Dabei handelt es sich um eine JVM, die in den Datenbankkern integriert ist, also im selben Adressraum wie die anderen Datenbankkomponenten läuft. Diese Java-Integration direkt in den Datenbankkern bietet Oracle seit der Datenbankversion 8.1.5 an. Sie ist bei weitem nicht so bekannt wie der oben beschriebene „Normalfall“, bietet allerdings völlig neue Möglichkeiten: • Aufnahme von Java-Bestandteilen in PL/SQL-Programme. • Performancevorteile aufgrund des in dieser Konstellation nicht mehr benötigten Netzwerkzugriffs aus dem Java-Programm zur Datenbank. • Nutzung der Java-APIs bei der (Vor-)Verarbeitung der Daten direkt an ihrem Speicherplatz in der Datenbank. Die drei Ansätze JDBC, SQLJ und Oracle JVM werden in den anschließenden Unterkapiteln zunächst kurz vorgestellt. Eine detaillierte Beschreibung anhand von Beispielen erfolgt darauf in den folgenden Kapiteln.

24

Oracle und Java

2.1

JDBC

JDBC (Java DataBase Connectivity) ist eine Sammlung von Java-API-Funktionen, über die ein Zugriff auf Datenbanken realisiert werden kann. Die auszuführenden SQLAnweisungen werden dabei als String-Parameter über die entsprechenden API-Methoden angegeben. Die Umsetzung auf die interne Darstellung für die jeweilige Datenbank übernimmt der JDBC-Treiber. Dieser muss im CLASSPATH der Anwendung enthalten sein. Da es sich bei JDBC um einen herstellerübergreifenden Standard handelt, ist JDBC-Code prinzipiell portabel, d.h., bei einem Wechsel auf eine andere Datenbank muss der Sourcecode nicht geändert werden. Einzige Änderung ist in diesem Fall die Aufnahme des zur neuen Datenbank passenden JDBC-Treibers. JDBC-Treiber werden von den Datenbankherstellern sowie unabhängigen Drittanbietern angeboten. Zusätzlich bieten viele Datenbankanbieter noch herstellerspezifische JDBCErweiterungen an, die auf die speziellen Anforderungen der Datenbank zugeschnitten sind. Bei diesen Erweiterungen kann es sich einerseits um Zugriffsmöglichkeiten auf herstellerspezifische Datenbankfeatures handeln, andererseits stehen aber häufig auch Performanceverbesserungen im Vordergrund, indem die JDBC-Zugriffe auf die spezielle Architektur der Datenbank zugeschnitten werden. Der erwähnte Vorteil der Portabilität von JDBC-Anwendungen bei Datenbankwechsel entfällt natürlich, wenn man herstellerspezifische JDBC-Erweiterungen einsetzt. Auch für eine Oracle-Datenbank stehen solche JDBC-Treiber zur Verfügung, und zwar sowohl im Standard-Format als auch in Form von speziellen Oracle-Erweiterungen. Im Kapitel 3 werden sowohl die Standard-JDBC-Methoden als auch einige Oracle-Erweiterungen anhand von Sourcecode-Beispielen vorgestellt.

2.2

SQLJ

SQLJ ist ein Standard, der im Jahre 1997 von einer Reihe führender Datenbankhersteller entworfen wurde und auf JDBC aufbaut. Während der Zugriff auf die Daten zur Laufzeit auch bei Verwendung von SQLJ über JDBC erfolgt, bietet SQLJ zur Entwicklungszeit einige Vorteile gegenüber reinem JDBC. Kernbestandteil von SQLJ ist das aus anderen Programmiersprachen bereits bekannte Precompilerprinzip. Dabei werden bereits zu Beginn des Compilevorganges sowohl Syntax als auch Semantik der eingesetzten SQL-Anwendungen überprüft. Genau dieser Punkt ist einer der gravierendsten Nachteile von JDBC, da JDBC die als String angegebenen SQL-Anweisungen ungeprüft zur Laufzeit an die Datenbank schickt mit der Folge, dass Syntax- und Semantikfehler innerhalb der SQL-Anweisungen erst zur Laufzeit erkannt werden können. Beispiele für solche Syntax- und Semantikfehler sind: • Falsche SQL-Syntax aufgrund von Tippfehlern • Falsche Spalten- oder Tabellennamen • Fehlende Zugriffsrechte auf die in den SQL-Anweisungen angegebenen Objekte (Tabellen, Views, PL/SQL-Packages, ...)

25

Oracle JVM

SQLJ bietet über einen dem eigentlichen Java-Compilerlauf vorangehenden Precompilerlauf die Möglichkeit, solche Syntax- und/oder Semantikfehler bereits in der Entwicklungsphase zu erkennen. Der zeitaufwendige Wechsel zwischen Fehlererkennung zur Laufzeit und Fehlerkorrektur in der Entwicklungsumgebung, der bei Verwendung von JDBC erforderlich ist, entfällt bei über SQLJ realisierten Datenbankzugriffen. Wer als Entwickler von JDBC-Anwendungen in der Vergangenheit bereits häufig solche zeitaufwendigen Fehleranalysen von in JDBC-API-Funktionen versteckten SQL-Anweisungen durchführen musste, wird diesen Vorteil zu schätzen wissen. Standardmäßig sind auch SQLJ-Anwendungen portabel, da die für den Datenbankzugriff erforderlichen Informationen in einer gesonderten Datei abgespeichert werden und erst zur Laufzeit auf die speziellen Anforderungen der eingesetzten Datenbank umgesetzt werden. Diese Portabilität durch den zusätzlichen SQLJ-Layer hat aber natürlich Performancenachteile gegenüber einer direkten Umsetzung über JDBC. Daher existiert auch für SQLJ eine herstellerspezifische Erweiterung durch die Einführung eines Oracle-Modus, der bei Aufruf des SQLJ-Precompilers angegeben werden kann. In diesem Modus erfolgt schon zur Compilezeit nach erfolgreicher Syntax- und Semantiküberprüfung eine Umsetzung auf Oracle-JDBC-Code. Dieser Performancegewinn wird aber wie bei direkter Verwendung von Oracle-JDBC-Methoden durch den Portabilitätsverlust bezahlt. Neben diesen Performancenachteilen bei Verwendung von Standard-SQLJ gab es vor Oracle9i einen weiteren Nachteil von SQLJ im Vergleich zu JDBC. Dieser bestand darin, dass SQLJ nur statische SQL-Anweisungen verarbeiten konnte, also Statements, die bereits zur Compilezeit vollständig vorlagen. Gerade in interaktiven (webbasierten) Anwendungen sind aber Szenarien denkbar, in denen Teile der SQL-Anweisungen erst zur Laufzeit vom Benutzer eingegeben werden, z.B. eine Liste der auszulesenden Spalten oder zusätzliche WHERE-Bedingungen. Vor Oracle9i war es nicht möglich, solche dynamischen SQL-Anweisungen über SQLJ zu verarbeiten. Aber auch dieser Nachteil liegt seit Einführung von Oracle9i nun nicht mehr vor. Ab dieser Version ist nämlich auch eine Verarbeitung von dynamischen SQL-Anweisungen über SQLJ möglich. Zusammen mit der Tatsache, dass bei Verwendung des SQLPrecompilers im Oracle-Modus auch keine Performancenachteile im Vergleich zu JDBC mehr zu erwarten sind, führt dies dazu, dass SQLJ als gleichwertige Alternative zu JDBC angesehen werden kann, die zur Compilezeit einige Vorteile gegenüber JDBC bietet. Jeder Enwickler von datenbankbasierten Java-Anwendungen sollte sich also neben JDBC auch mit den grundlegenden Konzepten von SQLJ auseinander setzen. Diese werden im Kapitel 4 vorgestellt.

2.3

Oracle JVM

Die Trennung von Java-Anwendung mit JDBC- bzw. SQLJ-Komponenten von der eigentlichen Datenhaltung in der Datenbank führt häufig dazu, dass die Schnittstelle zwischen Java-Anwendungen und Datenbank zum Performanceengpass der Gesamtapplikation wird. Insbesondere bei datenintensiven Anwendungen, bei denen neben dem Zugriff auf die Rohdaten auch zusätzliche Datenverarbeitungsschritte erforderlich sind, führt dies 26

Oracle und Java

zu hohen Anforderungen an die Netzwerkressourcen. Ein Weg zur Behebung dieser Engpässe ist eine Hardwareaufrüstung für die Netzwerkzugriffe. Aber auch auf der Softwareseite gibt es Lösungsmöglichkeiten. Seit Oracle 8.1.5 existiert eine Java Virtual Machine (JVM) im Datenbankkern. Somit gibt es die Möglichkeit, Java-Anwendungen direkt innerhalb der Datenbank ablaufen zu lassen. Das Programm läuft in dieser Konstellation also dort, wo auch die Daten liegen. Zusätzliche Netzwerkzugriffe für den Datentransfer sind in diesem Fall also nicht nötig. Für solche Datenverarbeitungsmethoden innerhalb der Datenbank wird im Oracle-Umfeld meist die Datenbankprogrammiersprache PL/SQL eingesetzt. Java-Anwendungen über die Datenbank-interne JVM sind allerdings nicht als Konkurrenz oder Ersatz für PL/SQL anzusehen. Es handelt sich vielmehr um eine Erweiterung von PL/SQL, über die es möglich ist, zusätzliche Funktionen, die PL/SQL nicht oder nur in eingeschränktem Umfang zur Verfügung stellt, durch Einsatz von Java-API-Schnittstellen zu realisieren. Die Grundkonzepte der Oracle-internen JVM werden im Kapitel 5 vorgestellt. Dabei wird erläutert, wie der Java-Code bzw. die Java-Klassen in die Datenbank gelangen, wie sie dort ausgeführt werden können und was bei der Administration von solchen JavaAnwendungen zu beachten ist. Kapitel 6 geht dann näher auf die Java Stored Procedures ein, über die Java-Anwendungen gestartet werden können. Als Abschluss des „Oracle und Java“-Teils dieses Buches enthält Kapitel 7 schließlich einen Vergleich zwischen PL/SQL und Java-basierter Implementierung innerhalb der Datenbank.

27

JDBC

3 JDBC Bei JDBC (Java DataBase Connectivity) handelt es sich um das Java-API für den Zugriff auf Datenbanken. Die zugehörigen Klassen und Schnittstellen unterstützen den Entwickler von Datenbankapplikationen, die Zugriffe auf die Datenbank in einer speziellen (JDBC-)Schicht zu implementieren. Gemäß dem JDBC-Ideal sind dazu zunächst keine Kenntnisse der Interna der zugrunde liegenden Datenbanken nötig. Die Abbildung der über die JDBC-API-Funktionen definierten Datenbankzugriffe auf das konkrete Datenbanksystem erfolgt durch die JDBCTreiber, die von den Datenbankherstellern sowie unabhängigen Herstellern angeboten werden. Ein Wechsel des zugrunde liegenden Datenbanksystems sollte also ohne Sourcecode-Änderungen einzig durch Austausch des passenden JDBC-Treibers möglich sein. Während diese Idealvorstellung bei kleinen Anwendungen, die nur grundlegende SQLOperationen verwenden, noch erfüllt sein dürfte, ist die Situation bei größeren Systemen in der Praxis eine andere: Viele Datenbanksysteme basieren zwar auf den SQLStandards, bieten aber zusätzlich individuelle Erweiterungen beim SQL-Umfang an. Diese Erweiterungen bieten häufig Performancevorteile, da sie speziell auf die Architektur des jeweiligen Datenbanksystems abgestimmt sind. Aufgrund dieser Vorteile werden solche Erweiterungen von Entwicklern auch gerne in ihre Applikationen eingebaut. Nachteil ist dabei natürlich der Verzicht auf 100%ige Portabilität bei einem späteren Datenbankwechsel, bei dem dann neben dem JDBC-Treiber-Austausch auch noch Sourcecode-Änderungen erforderlich sind. Die Wahl eines Datenbanksystems ist allerdings in den meisten Praxisprojekten eine sehr grundlegende Entscheidung, die daher auch nur selten rückgängig gemacht wird.

3.1

JDBC-Treibertypen

Es existieren vier verschiedene Typen von JDBC-Treibern. Allerdings bietet nicht jeder Hersteller auch jeden Typ für sein Datenbanksystem an. Bei der Suche nach einem bestimmten Treibertyp sollten daher auch unabhängige Drittanbieter von JDBC-Treibern aufgenommen werden. Tabelle 3.1 gibt zunächst einen allgemeinen Überblick über die vier Treibertypen. Treibertyp

Beschreibung

Typ 1 (JDBC-ODBC-Brücke)

Die Datenbankzugriffe aus JDBC heraus erfolgen hierbei über eine Verbindung zu ODBC (OpenDataBaseConnectivity)-Treibern. Voraussetzung ist daher die Existenz solcher ODBC-Treiber auf dem Clientrechner.

29

JDBC-Treibertypen Treibertyp

Beschreibung

Typ 2 (Native Treiber)

Die JDBC-Aufrufe werden zunächst in herstellerspezifische Anfragen umgewandelt, die dann an die Datenbank geschickt werden. Bei Oracle handelt es sich dabei um OCI (Oracle Call Interface)-Aufrufe. JDBC-Treiber vom Typ 2 erfordern daher – wie auch die Typ-1-Treiber – eine Installation der nativen Bibliotheken auf dem Clientrechner.

Typ 3

Typ-3-Treiber übersetzen die JDBC-Aufrufe zunächst in ein herstellerunabhängiges Netzprotokoll. Dieses wird dann erst im Datenbanksystem in ein datenbankspezifisches Protokoll übertragen und ist daher davon abhängig, ob der Datenbankhersteller eine solche Protokollumsetzung unterstützt.

Typ 4 (Thin-Treiber)

Typ-4-Treiber basieren vollständig auf Java und wandeln die JDBC-Aufrufe direkt in ein herstellerspezifisches Netzprotokoll auf Basis von Java-Sockets um. Großer Vorteil dieser Treiber ist die Tatsache, dass auf der Clientseite keine Installation zusätzlicher Software nötig ist. Daher eignen sich Typ-4-Treiber auch für den Einsatz in JavaApplets.

Tabelle 3.1: JDBC-Treiber-Übersicht

3.1.1 Oracle-JDBC-Treiber Oracle bietet insgesamt vier verschiedene Treiber an, jeweils zwei vom Typ 2 (OracleOCI-Treiber) und zwei vom Typ 4 (Oracle-Thin-Treiber). Jeder Treibertyp existiert in einer clientseitigen und einer serverseitigen Variante, wie die Übersicht in Tabelle 3.2 und Abbildung 3.1 zeigt. Oracle-Treiber

Beschreibung

OCI-Treiber (clientseitig)

Voraussetzung ist hier die Installation der Oracle-OCIBibliotheken auf dem Clientrechner. Die JDBC-Aufrufe werden über die C-Routinen aus den OCI-Bibliotheken an die Datenbank weitergeleitet.

Thin-Driver (clientseitig)

100%-Java-Treiber, der über das auf TCP/IP basierende Oracle-SQL*Net-Protokoll mit der Datenbank kommuniziert. Ansprechpartner auf der Serverseite ist der TCP/IPListener.

30

JDBC Oracle-Treiber

Beschreibung

Thin-Driver (serverseitig)

Diese Variante des Thin-Drivers ist gedacht für Anwendungen, die in der Oracle-JVM laufen und über diesen Treiber auf andere Datenbanken zugreifen können.

KPRB-Treiber (serverseitig)

Dient zum Datenzugriff aus Java-Anwendungen, die in der Oracle-internen JVM laufen und auf Daten derselben Datenbank zugreifen. Für diesen Treiber gelten einige Besonderheiten, die im Kapitel 5 näher erläutert werden. Aufgrund der Tatsache, dass dieser Treiber die Aufrufe über die serverinternen C-Routinen im selben Adressraum wie die SQL-Engine des Server-Prozesses durchführt, ergeben sich Performancevorteile gegenüber den anderen Konstellationen, da zusätzliche Netzwerkzugriffe vermieden werden. Aufgrund der Zugriffe auf native Methoden innerhalb der Datenbank gehört dieser Treiber zu den Typ-2-Treibern.

Tabelle 3.2: Oracle-JDBC-Treiber-Übersicht

Abb. 3.1: JDBC-Treiber-Übersicht

31

Programmierung mit JDBC

Der JDBC-Treiber muss im Classpath der Java-Anwendung vorhanden sein. Bei den von Oracle angebotenen JDBC-Treibern ist folgende Namenskonvention zu beachten: JDBC-Treiber für das JDK 1.1 sind in der Zip-Datei classes111.zip enthalten und unterstützen die JDBC-Version 1.0, in der die grundlegenden Datenzugriffsmethoden definiert sind (Paket java.sql). Zusätzlich sind hierin im Paket oracle.jdbc2 einige Oraclespezifische Erweiterungen enthalten, die bereits auf JDBC-2.0-Funktionen beruhen. JDBC-Treiber für das JDK 1.2 und 1.3 sind in der Zip-Datei classes12.zip enthalten und beinhalten folgende Pakete: • java.sql: JDBC-2.0-Core-API-Funktionen, aufbauend auf den JDBC-1.0-Funktionen, • javax.sql: JDBC-2.0-Optional-Package-API-Funktionen mit fortgeschrittenen Techniken wie z.B. Connection Pooling und JNDI, • oracle.jdbc und oracle.sql: Für den Umgang mit Oracle-spezifischen Erweiterungen wie z.B. Oracle-eigene Datentypen (VARRAY, Nested Tables) sowie speziell auf Oracle zugeschnittene Performanceverbesserungen. Beginnend mit den JDBC-Treibern für Oracle9i Release 2 hat Oracle die Namensbezeichnung für die JDBC-Treiber geändert. Während diese bisher als Zip-Datei mit dem Namen classes.zip vorlagen, sind sie nun in einem Jar-Archiv namens ojdbc.jar enthalten. Für das JDK 1.4 handelt es sich also um das JarArchiv ojdbc14.jar, das neben dem vollständigen JDBC-2.0-Support auch einige der neuen Features aus JDBC 3.0 zur Verfügung stellt: • Savepoints für Transaktionen, • Wechsel zwischen lokalen und globalen Transaktionen, • wiederverwendbare PreparedStatement: Ein PreparedStatement kann jetzt von mehreren Connections innerhalb eines Connection Pools wiederverwendet werden.

Hiermit können sich signifikante Performanceverbesserungen insbesondere auf der Application-Server-Schicht ergeben.

3.2


Wie bereits in den vorigen Kapiteln erwähnt, enthält der JDBC-Standard inzwischen eine große Zahl von Klassen und Schnittstellen. Daneben existiert auch noch eine Reihe von herstellerspezifischen Erweiterungen. Basis aller JDBC-Bestandteile sind einige grundlegende Schnittstellen. Hierbei sind vor allem die folgenden zu nennen: • • • • •

32

Connection Statement PreparedStatement CallableStatement ResultSet

JDBC

Bevor in den folgenden Kapiteln auf fortgeschrittene Techniken aus den JDBC-Standards und den Oracle-Erweiterungen eingegangen werden soll, werden zunächst diese grundlegenden Schnittstellen an einigen Sourcecode-Beispielen vorgestellt.

3.2.1 Einleitendes JDBC-Beispiel Anhand des anschließenden kleinen Java-Programms werden in den folgenden Abschnitten die JDBC-Bestandteile vorgestellt: /** Verwendung der JDBC-Statement-Schnittstelle */ package de.oracle_java_xml_buch.jdbc; import java.sql.*; public class StatementBeispiel { public static void main(String args[]) throws SQLException { Connection conn = null; String user = "test"; String password = "test"; ResultSet resSet; try { // JDBC-Treiber laden DriverManager.registerDriver(new oracle.jdbc.OracleDriver()); //JDBC-Verbindung aufbauen conn = DriverManager.getConnection ("jdbc:oracle:oci:"+user+"/"+password+"@TEST_DATENBANK"); // Statement anlegen Statement stmt = conn.createStatement() // Statement ausfuehren resSet = stmt.executeQuery("select prs_nr, prs_vorname, prs_nachname from person"); // Ergebnis ausgeben while (resSet.next()) { System.out.println("Nr:" + resSet.getInt(1)); System.out.println("Vorname:" + resSet.getString("prs_vorname"));

33

Programmierung mit JDBC System.out.println("Nachname:" + resSet.getString(3)); } stmt.close(); } catch(SQLException e) { System.out.println("SQL-Exception:"+e); } finally { // JDBC-Verbindung immer schliessen conn.close(); } } }

Das folgende kleine Kommandozeilenprogramm kann auf einem Windows-Rechner zum Übersetzen und Aufrufen der Anwendung verwendet werden. set APP_HOME=c:\oraclebuch\src set ORACLE_HOME=c:\Oracle\Ora92 set JAVA_HOME=c:\jdk1.4 cd %APP_HOME%\de\oracle_java_xml_buch\jdbc set classpath=%APP_HOME%;%ORACLE_HOME%\jdbc\lib\ojdbc14.zip %JAVA_HOME%\bin\javac StatementBeispiel.java cd %APP_HOME% %JAVA_HOME%\bin\java de.oracle_java_xml_buch.jdbc.StatementBeispiel pause

3.2.2 Laden des JDBC-Treibers Erster JDBC-Schritt ist das Laden des speziellen JDBC-Treibers. Dazu wird die JDBCKlasse java.sql.DriverManager verwendet. Dies kann auf unterschiedliche Arten erfolgen: 1. Unter Verwendung der Class.forName()-Methodik, mit der die JVM zum Suchen und Laden der angegebenen Klasse aufgefordert wird: Wurde die Treiberklasse im Classpath der Anwendung gefunden, so wird eine Instanz angelegt und diese beim Treibermanager DriverManager registriert. Zu beachten ist bei dieser Variante, dass die Class.forName-Methode eine ClassNotFoundException werfen kann, die daher über eine entsprechende try-catch-Konstellation abgefangen werden muss. 2. Durch Definition der Systemeigenschaft jdbc.drivers, entweder 34

JDBC a) beim Aufruf des Java-Programms java -Djdbc.drivers=oracle.jdbc.OracleDriver de.oracle_java_xml_buch.jdbc.StatementBeispiel

b) oder innerhalb des Sourcecodes System.setProperty("jdbc.drivers", "oracle.jdbc.OracleDriver");

Sollen mehrere Treiberklassen zur Verfügung gestellt werden, so ist dies bei beiden Varianten durch Angabe einer durch Doppelpunkte getrennten Liste möglich. 3. Durch expliziten Aufruf der registerDriver-Methode aus der Klasse DriverManager: Diese Variante wurde in obigem Beispiel gewählt: // JDBC-Treiber laden DriverManager.registerDriver(new oracle.jdbc.OracleDriver());

3.2.3 Verbindungsaufbau Nachdem der Treiber geladen ist, kann über den Treibermanager DriverManager eine Verbindung zur Datenbank hergestellt werden. Dazu wird die Methode getConnection der Klasse DriverManager benutzt. Über einen String-Parameter dieser Methode wird die konkrete Datenbankinstanz angegeben, zu der die Verbindung aufgebaut werden soll. Das Format dieses Strings sieht allgemein wie folgt aus: jdbc::Untername

Die konkrete Syntax ist abhängig von der gewählten Datenbank sowie dem JDBCTreibertyp. Am Beispiel Oracle sind zwei Möglichkeiten zu unterscheiden. Verbindung über Oracle-OCI-Treiber Bei Verwendung des Oracle-OCI-Treibers ist zunächst zu beachten, dass die Installation der Oracle-Client-Software SQL*Net auf dem Clientrechner Voraussetzung ist. Damit entfällt diese Möglichkeit bei einer JDBC-Anbindung innerhalb eines Internet-Applets, bei dem von beliebig konfigurierten Clientrechnern auf das Applet zugegriffen wird. Die Syntax für den JDBC-Connectstring bei Nutzung des OCI-Treibers lautet: jdbc:oracle:oci:[Benutzername/Kennwort]@

Der passende TNS1-Eintrag muss aus der Datei tnsnames.ora aus dem Verzeichnis $(ORACLE_HOME)/network/admin ermittelt werden. In dieser Datei sucht die Oracle-

1

Die Abkürzung TNS steht für Transparent Network Substrate.

35


SQL*Net-Software nach den benötigten Informationen, um auf eine angegebene Datenbank zugreifen zu können (Hostname, Netzwerkprotokoll, Port-Nummer). Das folgende Beispiel zeigt einen Auszug aus einer tnsnames.ora-Datei: TEST_DATENBANK = (DESCRIPTION = (ADDRESS_LIST = (ADDRESS = (PROTOCOL = TCP)(HOST = mein_rechner)(PORT = 1522)) ) (CONNECT_DATA = (SERVICE_NAME = TESTDB) ) )

Zu der so spezifizierten Datenbank mit dem TNS-Eintrag TEST_DATENBANK kann nun wie in obigem Beispiel implementiert eine Verbindung aufgebaut werden. //JDBC-Verbindung aufbauen conn = DriverManager.getConnection("jdbc:oracle:oci:"+user+"/"+ password+"@TEST_DATENBANK");

Verbindung über Oracle-Thin-Treiber Bei Verwendung des Oracle-Thin-Treibers lautet die Syntax jdbc:oracle:thin:[Benutzername/Kennwort]@::

Tabelle 3.3 beschreibt die Bedeutung der einzelnen Bestandteile: Bestandteil

Beschreibung

Benutzername DB-User, unter dem die Anmeldung erfolgen soll. Benutzername und Kennwort können auch über eine andere Form der getConnectionMethode als gesonderte Parameter angegeben werden: DriverManager.getConnection(connectstring, username, password) Kennwort

Kennwort des DB-Users, unter dem die Anmeldung erfolgen soll.

Hostname

Beginnend mit einem @-Zeichen wird hier der Rechnername angegeben, auf dem die Ziel-Datenbank läuft. Die Angabe des Rechnernamens kann durch den DNS-Hostnamen oder die konkrete IP-Adresse des Rechners erfolgen. Läuft die Datenbank auf dem lokalen Rechner, so kann hier @localhost angegeben werden.

36

JDBC Bestandteil

Beschreibung

Port

Die Nummer des Ports, auf dem der Listener-Prozess der Datenbank die Anfragen entgegennimmt.

SID

Der eindeutige Name der Datenbank. In obigem Beispiel würde der Connectstring bei Nutzung des Thin-Treibers wie folgt aussehen:

SID

jdbc:oracle:thin:testuser/testpwd@mein_rechner:1522: TEST_DATENBANK Beginnend mit Oracle-Version 8.1.7 wurde neben dem SID-Ansatz eine weitere Möglichkeit zur Identifizierung von Datenbankinstanzen eingeführt. Über diesen so genannten „Service-Ansatz“ wird die Datenbank über eine URL-ähnliche Notation identifiziert. Ab Version 9i Rel. 2 wird dieser Service-Ansatz nun auch innerhalb des JDBC-Connectstrings unterstützt. Die allgemeine Form eines solchen Connectstrings lautet jdbc:oracle:thin:[Benutzername/Kennwort]@//[: ]/ Beispiel: Jdbc:oracle:thin:testuser/testpwd@//myserver.com/ testdb Die Umstellung von SID auf Services wird von Oracle dringend empfohlen, da der SID-Ansatz ab einer der kommenden Releases nicht mehr unterstützt werden wird.

Tab. 3.3: JDBC-Thin-Treiber-Connectstring-Bestandteile

Unabhängig von der Wahl des JDBC-Treibers ist das Ergebnis eines erfolgreichen Verbindungsaufbaus ein Connection-Objekt. Die Verbindung sollte über die close-Methode wieder geschlossen werden, sobald sie nicht mehr benötigt wird, um keine unnötigen Ressourcen zu blockieren. In obigem Beispiel geschieht dies im finally-Block, damit der Verbindungsabbau unabhängig von eventuell auftretenden Laufzeitfehlern in jedem Fall durchgeführt wird.

3.2.4 Anlegen von SQL-Anweisungen Über das Connection-Objekt können nun für konkrete SQL-Anweisungen Objekte von einer der folgenden drei Schnittstellen erzeugt werden: • • •

Statement PreparedStatement CallableStatement

Diese drei Schnittstellen stehen in einer Vererbungshierarchie: PreparedStatement ist eine Sub-Schnittstelle von Statement, und CallableStatement ist eine Subschnittstelle von PreparedStatement. Die Verwendung dieser grundlegenden Schnittstellen 37


wird im Folgenden an Beispielen erläutert. Wie fast alle JDBC-Methoden können die dabei benutzten Methoden eine SQLException werfen, sodass in der Regel alle JDBCBestandteile innerhalb eines Java-Programms in einem geeigneten try-catch-Block enthalten sind. Verwenden der Statement-Schnittstelle Das Anlegen eines Statement-Objektes erfolgt über die createStatement-Methode des Connection-Objektes: // Statement anlegen Statement stmt = conn.createStatement();

Über das erzeugte Statement-Objekt können nun beliebige SQL-Operationen durchgeführt werden, also • DDL2-Operationen wie z.B. CREATE TABLE • •

SELECT INSERT UPDATE DELETE

• •

Die Schnittstelle Statement enthält eine Vielzahl von Methoden. Die wichtigsten sind in der folgenden Tabelle 3.4 aufgeführt. Methode

Parameter

Beschreibung

executeQuery

String

Die als Parameter übergebene SQL-Abfrage wird in der Datenbank ausgeführt. Rückgabewert ist ein ResultSetObjekt.

executeUpdate

String

Der als Parameter übergebene SQL-DML-Befehl (Insert, Update oder Delete) wird in der Datenbank ausgeführt. Rückgabewert ist die Anzahl der eingefügten, geänderten bzw. gelöschten Datensätze. Außerdem können als Parameter auch DDL-Befehle übergeben werden. In diesem Fall ist der Rückgabewert 0.

close

keine

Wird ein Statement-Objekt sowie sein zugehöriges ResultSet-Objekt nicht mehr benötigt, so sollte das Statement-Objekt explizit durch Aufruf der close()-Methode geschlossen werden. Ein eventuell vorhandenes zugehöriges ResultSet-Objekt wird dadurch ebenfalls geschlossen.

2

Die Abkürzung DDL steht für Data Definition Language.

38

JDBC Methode

Parameter

close (Forts.)

Beschreibung Damit werden alle Datenbank- und JDBC-Ressourcen, die durch das Statement und/oder ResultSet belegt waren, unmittelbar freigegeben. Da solche Ressourcen häufig nur eingeschränkt zur Verfügung stehen (z.B. durch eine maximal erlaubte Anzahl von gleichzeitig geöffneten Datenbank-Cursorn), sollte das explizite Schließen durch den Programmierer erfolgen und nicht erst beim nächsten Aufruf der Garbage Collection.

Tab. 3.4: Ausgewählte Methoden der Schnittstelle Statement

Das folgende Beispiel zeigt die Verwendung der executeUpdate-Methode zur Ausführung einer SQL-Update-Anweisung. /** Verwendung der JDBC-Statement-Schnittstelle für DML-Operationen */ package de.oracle_java_xml_buch.jdbc; import java.sql.*; public class UpdateStatementBeispiel { public static void main(String args[]) throws SQLException { Connection conn = null; String user = "test"; String password = "test"; try { // JDBC-Treiber laden DriverManager.registerDriver(new oracle.jdbc.OracleDriver()); //JDBC-Verbindung aufbauen conn = DriverManager.getConnection ("jdbc:oracle:thin:@localhost:1522:TEST_DATENBANK ", user, password); // Statement anlegen Statement stmt = conn.createStatement(); // Statement ausfuehren int anzahlUpdates = stmt.executeUpdate("update angestellter

39

Programmierung mit JDBC set ang_gehalt=ang_gehalt+100"); System.out.println( anzahlUpdates + " Eintraege geaendert" ); stmt.close(); } catch(SQLException e) { System.out.println("SQL-Exception:"+e); } finally { // JDBC-Verbindung immer schliessen conn.close(); } } }

Im Zusammenhang mit DML-Operationen ist immer auch die Transaktionskontrolle zu beachten. Über die Methode setAutoCommit(boolean) der Connection-Schnittstelle kann das Transaktionsverhalten aller DML-Operationen, die über ein ConnectionObjekt ausgeführt werden, beeinflusst werden. Default-Wert ist TRUE, wodurch alle DML-Operationen unmittelbar durch ein automatisches Commit abgeschlossen werden. Ist dieses Verhalten nicht erwünscht, so muss es zunächst durch den Aufruf conn.setAutoCommit(false);

abgeschaltet werden. Anschließend liegt es in der Verantwortung des Programmierers, offene Transaktionen bei syntaktischen oder semantischen Fehlern über die Connection.rollback-Methode rückgängig zu machen oder sie durch die Connection.commit-Methode freizugeben. Das folgende Beispiel zeigt ein solches Vorgehen, bei dem abhängig von einer benutzerdefinierten Regel eine explizite Transaktionssteuerung vorgenommen wird. /** Verwendung der JDBC-Statement-Schnittstelle für DML-Operationen mit Transaktionskontrolle */ package de.oracle_java_xml_buch.jdbc; import java.sql.*; public class TransaktionStatementBeispiel { public static void main(String args[]) throws SQLException { Connection conn = null; String user = "test";

40

JDBC String password = "test"; int max_gehalt = 0; final int GEHALTSOBERGRENZE_ANGESTELLTER = 4000; try { // JDBC-Treiber laden DriverManager.registerDriver(new oracle.jdbc.OracleDriver()); //JDBC-Verbindung aufbauen conn = DriverManager.getConnection ("jdbc:oracle:thin:@localhost:1522:TEST_DATENBANK", user, password); // AutoCommit abschalten conn.setAutoCommit(false); // Statement anlegen Statement updateStmt = conn.createStatement(); // Statement ausfuehren int anzahlUpdates = updateStmt.executeUpdate("update angestellter set ang_gehalt=ang_gehalt+100"); // Maximales Gehalt nach dem Update bestimmen Statement selectStmt = conn.createStatement(); ResultSet resSet = selectStmt.executeQuery("select max(ang_gehalt) from angestellter"); if (resSet.next()) { max_gehalt = resSet.getInt(1); } if ( max_gehalt > GEHALTSOBERGRENZE_ANGESTELLTER ) { System.out.println("Gehaltsobergrenze überschritten. Operation wird rückgängig gemacht"); conn.rollback(); } else { conn.commit(); } selectStmt.close(); updateStmt.close(); } catch(SQLException e) {

41

Programmierung mit JDBC System.out.println("SQL-Exception:"+e); } finally { // JDBC-Verbindung immer schliessen conn.close(); } } }

Nachteil bei der Verwendung der Statement-Schnittstelle ist die Tatsache, dass für SQL-Anweisungen bei jedem Aufruf in der Datenbank zunächst ein Parser-Lauf durchgeführt wird. Dieser Parser-Vorgang kann zeitintensiv sein. Für eine SQL-Anweisung, die nur genau einmal ausgeführt wird, ergeben sich noch keine Tuning-Möglichkeiten. Interessant wird diese Tatsache allerdings bei Statements, die mehrmals ausgeführt werden sollen. In solchen Situationen sollte in jedem Fall die Verwendung der PreparedStatement-Schnittstelle in Erwägung gezogen werden.

Verwenden der PreparedStatement-Schnittstelle Einsatzgebiet der PreparedStatement-Schnittstelle sind SQL-Anweisungen, die mit verschiedenen Parametern mehrmals ausgeführt werden sollen. Eine Select-Abfrage, die z.B. mit einem über eine Benutzerschnittstelle angegebenen Parameter während der Programmlaufzeit häufig aufgerufen wird, verursacht bei Verwendung der StatementSchnittstelle einen Parse-Vorgang bei jedem Aufruf. Unter Verwendung der PreparedStatement-Schnittstelle dagegen wird die parametrisierte SQL-Anweisung beim Anlegen einmal geparst und liegt dann in vorkompilierter Form in der Datenbank bereit. Bei allen folgenden Aufrufen kann diese vorkompilierte Anweisung wiederverwendet werden, sodass dann nur noch die aktuellen Werte für die Parameter eingesetzt werden müssen. Das folgende Beispiel zeigt die Verwendung der PreparedStatement-Schnittstelle. /** Verwendung der JDBC-PreparedStatement-Schnittstelle */ package de.oracle_java_xml_buch.jdbc; import java.sql.*; public class PreparedStatementBeispiel { public static void main(String args[]) throws SQLException { Connection conn = null; String user = "test"; String password = "test"; ResultSet resSet;

42

JDBC

try { // JDBC-Treiber laden DriverManager.registerDriver(new oracle.jdbc.OracleDriver()); //JDBC-Verbindung aufbauen conn = DriverManager.getConnection ("jdbc:oracle:oci:"+user+"/"+password+"@TEST_DATENBANK"); // Statement anlegen PreparedStatement pStmt = conn.prepareStatement("select prs_nr,prs_vorname, prs_nachname from person where prs_nr = ?"); for( int i = 1; i 2 * :old.ang_gehalt ) then raise_application_error(-20001,'Mehr als eine Verdopplung des Gehalts ist nicht erlaubt'); end if; end ang_gehalt_update_trigger; /

Ein Java-Programm mit Ausgabe der zur Verfügung stehenden Informationen bei einer Fehlermeldung hat folgendes Aussehen: /** Behandlung von SQLExceptions */ package de.oracle_java_xml_buch.jdbc; import java.sql.*; public class ExceptionBeispiel { public static void main(String args[]) throws SQLException { Connection conn = null; String user = "test"; String password = "test";

51


try { // JDBC-Treiber laden DriverManager.registerDriver(new oracle.jdbc.OracleDriver()); //JDBC-Verbindung aufbauen conn = DriverManager.getConnection ("jdbc:oracle:oci:"+user+"/"+password+ "@TEST_DATENBANK"); // Statement anlegen Statement stmt = conn.createStatement(); // Statement ausfuehren int anzahlUpdates = stmt.executeUpdate("update angestellter set ang_gehalt=ang_gehalt*3 where ang_nr=100"); System.out.println( anzahlUpdates + " Eintraege geaendert" ); stmt.close(); } catch(SQLException sqlExcep) { System.out.println("Message:" + sqlExcep.getMessage()); System.out.println("SQL state:" + sqlExcep.getSQLState()); System.out.println("Error code:" + sqlExcep.getErrorCode()); } finally { // JDBC-Verbindung immer schliessen conn.close(); } } }

Die Konsolenausgabe zeigt die vorhandenen Fehlerinformationen: java de.oracle_java_xml_buch.jdbc.ExceptionBeispiel Message:ORA-20001: Mehr als eine Verdopplung des Gehalts ist nicht erlaubt ORA-06512: in "TEST.ANG_GEHALT_UPDATE_TRIGGER", Zeile 10 ORA-04088: Fehler bei der Ausführung von Trigger 'TEST.ANG_GEHALT_UPDATE_TRIGGER' SQL state:72000 Error code:20001

52

JDBC

3.3

Oracle-JDBC-Erweiterungen

Neben den in den vorangegangenen Abschnitten beschriebenen Funktionalitäten, die im JDBC-Standard definiert wurden, bietet Oracle auch noch spezielle, auf die eigene Datenbank zugeschnittene Erweiterungen an. Die Benutzung dieser Oracle-spezifischen JDBC-Funktionen erweitert die Möglichkeiten bei der Erstellung von JDBC-Anwendungen, da nun direkt auf die Datenbankbesonderheiten zugegriffen werden kann. Außerdem sind Performancevorteile zu erwarten. Nicht vernachlässigt – und daher auch hier kurz erwähnt – werden sollte aber die Tatsache, dass damit die Portabilität verloren gehen kann. Während ein Grundsatz bei der Erstellung des JDBC-Standards die Unabhängigkeit von der Implementierung eines speziellen Herstellers war, bindet sich der Entwickler durch den Einsatz von herstellerspezifischen Erweiterungen wie den Oracle-JDBC-Erweiterungen an die Datenbank eines Herstellers. Wer sich an die Standard-JDBC-API-Funktionen hält, sollte – zumindest theoretisch – einen Datenbankwechsel einfach durch Austausch des jeweiligen JDBCTreibers vornehmen können. Hingegen muss Sourcecode, der spezielle Funktionen einer Datenbank verwendet, ggf. umgeschrieben werden. Während diese Frage aber in der Praxis wohl nur bei der Erstellung von Standardsoftware, die auf mehreren Datenbanken laufen soll, bedeutend ist, wird ein Datenbankwechsel bei Individualsoftware-Erstellung allerdings nur selten auftreten, sodass dieser Nachteil in den meisten Projekten wohl gerne in Kauf genommen wird. Die Vorteile bez. Performance und Funktionalitätserweiterung werden meist überwiegen. Die Oracle-Erweiterungen sind in den folgenden drei Packages zusammengefasst: • • •

oracle.sql oracle.jdbc oracle.jdbc2

Die Inhalte der ersten beiden Packages werden in den folgenden Abschnitten näher beschrieben. Das Package oracle.jdbc2 hat dagegen eher historische Bedeutung. Es wird in Verbindung mit den JDK-1.1.x-Klassen verwendet, in denen noch die JDBCVersion 1.x enthalten war. Das Package oracle.jdbc2 beinhaltet eine Untermenge aller Klassen und Schnittstellen aus JDBC 2.0, die bei Verwendung des JDK 1.1.x benutzt werden können. Auf dieses Package wird daher im Folgenden nicht näher eingegangen.

3.3.1 Package oracle.jdbc Mit den im Kapitel 3.2 vorgestellten grundlegenden JDBC-Klassen und -Schnittstellen wie z.B. Statement, PreparedStatement und ResultSet kann die Standard-JDBCFunktionalität in einem Java-Programm eingesetzt werden. In manchen Fällen ist es aber sinnvoll oder vielleicht sogar erforderlich, Oracle-spezifische Erweiterungen dieser Klassen einzusetzen.

53

Oracle-JDBC-Erweiterungen

Das Package oracle.jdbc ersetzt ab Oracle-Version 9i das nun als deprecated gekennzeichnete Package oracle.jdbc.driver und enthält u.a. die folgenden Klassen und Schnittstellen: • • • • • • • •

OracleCallableStatement OracleConnection OraclePreparedStatement OracleResultSet OracleResultSetCache OracleResultSetMetaData OracleStatement OracleTypes

Wird eine der in diesen Klassen und Schnittstellen enthaltenen Methoden benötigt, so muss eine explizite Typumwandlung auf die benötigte Klasse in folgender Form vorgenommen werden: oracle.jdbc.OraclePreparedStatement pStmt; pStmt = (oracle.jdbc.OraclePreparedStatement) conn.prepareStatement("...");

Während diese Oracle-JDBC-Erweiterungen beim Umgang mit Oracle-eigenen Datentypen noch Pflicht sind, hat der JDBC-Entwickler bei vielen Funktionalitäten die Wahl zwischen den JDBC-Standard-konformen Klassen und ihren Erweiterungen aus dem oracle.jdbc-Package. Während das Hauptargument für die Standard-JDBC-Klassen die Portabilität bei einem späteren Datenbankaustausch ist, liegen die Vorteile bei den Oracle-JDBC-Klassen meist im Performancebereich. Wer bereit ist, auf Portabilität zu verzichten, findet hier einiges an Optimierungspotenzial vor. Als Beispiel wird im Folgenden das Update-Batching beschrieben. Weitere Möglichkeiten sind in den Oracle-JDBC-Handbüchern sowie der JDBC-API-Dokumentation zu finden. Update-Batching Bei Anwendungen mit einer großen Anzahl von DML-Operationen (Insert, Update oder Delete) ist häufig die hohe Netzbelastung durch die zahlreichen DML-Befehle über JDBC die Performanceengstelle. Standardmäßig wird jeder DML-Befehl nach Aufruf der executeUpdate()-Methode sofort zur Datenbank geschickt. In der Regel findet man eine solche Konstellation bei PreparedStatements, über die durch Manipulation der Bind-Variablen eine ganze Reihe von Operationen durchgeführt werden.

54

JDBC

Idee des Update-Batching ist der Ansatz, dass mehrere DML-Operationen3 zunächst auf der Clientseite gesammelt und dann zu einem späteren Zeitpunkt als Paket über einen Netzwerkzugriff an die Datenbank geschickt werden. Seit JDBC 2.0 ist diese Funktionalität im JDBC-Standard enthalten und kann daher im Zusammenhang mit den Oracle-JDBC-Treibern genutzt werden. Zusätzlich bietet Oracle in seinen JDBC-Erweiterungen aber noch eine spezielle Update-Batching-Variante an, die dem Entwickler mehr Flexibilität und damit zusätzliche Performance-Tuningmöglichkeiten bietet. Während der Entwickler in der JDBC-Standard-Methode selber für den Zeitpunkt des Paketversands der gesammelten DML-Anweisungen verantwortlich ist, bieten die OracleJDBC-Erweiterungen zusätzlich die Möglichkeit, eine so genannte Batchgröße anzugeben. Diese kennzeichnet eine bestimmte Anzahl von DML-Statements. Ist diese Anzahl erreicht, so erfolgt automatisch ein Versand an die Datenbank. Vorteil dieser Lösung ist, dass der JDBC-Treiber in der Standard-Variante nicht weiß, wie viele Statements zunächst clientseitig gecacht werden müssen, während in der Oracle-Variante die Anzahl bekannt ist und das Cacheverhalten darauf abgestimmt werden kann. Während die Standard-Update-Batchvariante auf alle Arten von Statements angewandt werden kann, also auf Statement, CallableStatement und PreparedStatement, ist die Oracle-Variante auf OraclePreparedStatements beschränkt. Folgende Methoden von OraclePreparedStatements dienen zur Steuerung des Batchverhaltens: Methode

Beschreibung

int getExecuteBatch()

Gibt die aktuelle Batchgröße an, also die Anzahl der DML-Operationen, die zunächst auf der Clientseite gecacht werden und bei Erreichen dieser Größe über einen Netzwerkaufruf an die Datenbank verschickt werden.

setExecuteBatch(int size)

Setzt die aktuelle Batchgröße auf den Wert size. Defaultwert ist 1.

int sendBatch()

Über diese Methode hat der Entwickler die Möglichkeit, unabhängig von der Anzahl der gecachten Statements diese an die Datenbank zu senden. Dies entspricht der JDBC-Standard-Funktionalität. Gecachte Statements werden also an die Datenbank übertragen, wenn • die Batchgröße erreicht ist oder

3

Obwohl die Funktionalität als Update-Batching bezeichnet wird, sind neben Update-Operationen auch Insert- und Delete-Anweisungen möglich. Nur Select-Befehle dürfen nicht einbezogen werden, da alle Operationen, die ein ResultSet zurückliefern, zu einer Exception führen.

55

Oracle-JDBC-Erweiterungen Methode

Beschreibung

int sendBatch() (Forts.)

• explizit die sendBatch()-Methode aufgerufen wurde oder • ein (explizites oder Auto-)Commit durchgeführt wird4 oder • das Statement oder die Verbindung über die close()-Methode geschlossen wird. Rückgabewert von sendBatch() ist die Anzahl der ausgeführten Updates.

Tab. 3.6: Ausgewählte Methoden von OraclePreparedStatement

Zusätzlich zur individuellen Festlegung der Batchgröße über die OraclePreparedStatement.setExecuteBatch-Methode gibt es noch die Möglichkeit, über die SetDefaultExecuteBatch(int size)-Methode einer OracleConnection die Batchgröße aller OraclePreparedStatements, die über diese OracleConnection erzeugt werden, festzusetzen. Dieser Wert kann durch die OraclePreparedStatement.setExecuteBatch-Methode für einzelne OraclePreparedStatements überschrieben werden. Auch hierbei ist wieder zu beachten, dass ein JDBC-Standard-Objekt Connection diese Möglichkeit nicht anbietet und die Connection daher explizit auf eine OracleConnection gecastet werden muss. Das folgende Beispiel illustriert den Umgang mit dem Update-Batching: /** Update-Batching mit Oracle-JDBC-Erweiterungen */ package de.oracle_java_xml_buch.jdbc; import java.sql.*; import oracle.jdbc.*; public class UpdateBatchingBeispiel { public static void main(String args[]) throws SQLException { Connection conn = null; String user = "test"; String password = "test"; int anzahlInserts = 0;

4

Daher sollte Auto-Commit im Rahmen eines Batchprozesses immer abgeschaltet sein.

56

JDBC try { // JDBC-Treiber laden DriverManager.registerDriver(new oracle.jdbc.OracleDriver()); //JDBC-Verbindung aufbauen conn = DriverManager.getConnection ("jdbc:oracle:oci:"+user+"/"+password+"@TEST_DATENBANK"); // AutoCommit abschalten conn.setAutoCommit(false); // Statement anlegen OraclePreparedStatement pStmt = (OraclePreparedStatement) conn.prepareStatement("insert into person values (?,'test','test')"); // Batch-Grösse für das Statement setzen pStmt.setExecuteBatch(5); for( int i = 1; i

Oracle - Java, XML. Integration in Oracle9i GERMAN

Oracle9i XML Reference

Building Oracle XML Applications

Building Oracle XML Applications

Building Oracle XML Applications

Oracle Application Integration Architecture

Java and XML

Java and XML

Oracle Application Integration Architecture

Java i XML

Oracle - Introduction to Oracle9i - PL-SQL - Stude

Java Oracle Database Development

Java Oracle Database Development

Oracle and Java Development

Java, XML, and the JAXP

XML-программирование в технологии Java

XML-программирование в технологии Java

XML-программирование в технологии Java

Java and XML Data Binding

Java Programming with Oracle JDBC

Java Programming with Oracle JDBC

Oracle. Программирование на языке Java

Java Programming with Oracle SQLJ

Java Programming with Oracle JDBC

Java Programming with Oracle JDBC

Java and Flex Integration Bible

Service-Oriented Java Business Integration

Ajax und Java German

Java 5 Programmierhandbuch GERMAN

Java 2 Kompendium GERMAN

Oracle 8 Datenbankentwicklung in 21 Tagen GERMAN

Oracle - Java, XML. Integration in Oracle9i GERMAN

Oracle9i XML Reference

Building Oracle XML Applications

Building Oracle XML Applications

Building Oracle XML Applications

Oracle Application Integration Architecture

Java and XML

Java and XML

Oracle Application Integration Architecture

Java i XML

Oracle - Introduction to Oracle9i - PL-SQL - Stude

Java Oracle Database Development

Java Oracle Database Development

Oracle and Java Development

Java, XML, and the JAXP

XML-программирование в технологии Java

XML-программирование в технологии Java

XML-программирование в технологии Java

Java and XML Data Binding

Java Programming with Oracle JDBC

Java Programming with Oracle JDBC

Oracle. Программирование на языке Java

Java Programming with Oracle SQLJ

Java Programming with Oracle JDBC

Java Programming with Oracle JDBC

Java and Flex Integration Bible

Service-Oriented Java Business Integration

Ajax und Java German

Java 5 Programmierhandbuch GERMAN

Java 2 Kompendium GERMAN

Oracle 8 Datenbankentwicklung in 21 Tagen GERMAN

Recommend Documents