Oracle PL/SQL Programmierung Handbuch

de
he
sc e e
ut ab ag
De usg Aufl
A .
Oracles prozedurale Programmiersprache
r3
Oracle
PL/SQL
Programmierung
Steven Feuerstein
mit Bill Pribyl
Deutsche Übersetzung von Dorothea Reder
2. AUFLAGE
Oracle PL/SQL Programmierung
Steven Feuerstein
mit Bill Pribyl
Deutsche Übersetzung von
Dorothea Reder
Beijing · Cambridge · Farnham · Köln · Paris · Sebastopol · Taipei · Tokyo
Die Informationen in diesem Buch wurden mit größter Sorgfalt erarbeitet. Dennoch können Fehler
nicht vollständig ausgeschlossen werden. Verlag, Autoren und Übersetzer übernehmen keine juristische
Verantwortung oder irgendeine Haftung für eventuell verbliebene Fehler und deren Folgen.
Alle Warennamen werden ohne Gewährleistung der freien Verwendbarkeit benutzt und sind
möglicherweise eingetragene Warenzeichen. Der Verlag richtet sich im wesentlichen nach den
Schreibweisen der Hersteller. Das Werk einschließlich aller seiner Teile ist urheberrechtlich
geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung,
Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.
Kommentare und Fragen können Sie gerne an uns richten:
O’Reilly Verlag
Balthasarstr. 81
50670 Köln
Tel.: 0221/9731600
Fax: 0221/9731608
E-Mail: [email protected]
Copyright der deutschen Ausgabe:
© 2003 by O’Reilly Verlag GmbH & Co. KG
1. Auflage 1999
2. Auflage 2003
1., korr. Nachdruck 2005
Die Originalausgabe erschien 2002 unter dem Titel
Orcale PL/SQL Programming, 3rd Edition im Verlag O’Reilly & Associates, Inc.
Die Darstellung von Ameisen im Zusammenhang mit dem Thema
Oracle PL/SQL ist ein Warenzeichen von O’Reilly & Associates, Inc.
Oracle® und alle Oracle-basierten Warenzeichen und Logos sind Warenzeichen oder eingetragene Warenzeichen
der Oracle Corporation, Inc. in den USA und in anderen Ländern. Der O’Reilly Verlag GmbH & Co. KG ist unabhängig von der Oracle Corporation, Inc. Java™ und alle Java-basierten Warenzeichen und Logos sind Warenzeichen oder eingetragene Warenzeichen von Sun Microsystems, Inc. in den USA und in anderen Ländern. Der
O’Reilly Verlag GmbH & Co. KG ist unabhängig von Sun Microsystems, Inc. Microsoft®, Windows® und alle anderen Microsoft-basierten Warenzeichen und Logos sind Warenzeichen oder eingetragene Warenzeichen von
Microsoft, Inc. in den USA und in anderen Ländern. Der O’Reilly Verlag GmbH & Co. KG ist unabhängig von
Microsoft, Inc.
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.
Übersetzung und deutsche Bearbeitung: Dorothea Reder, Bonn
Lektorat: Alexandra Follenius, Köln
Fachgutachten: Dr. Wolfgang Gabriel, Leinfelden-Echterdingen
Korrektorat: Sibylle Feldmann, Düsseldorf
Satz: Tung Huynh, reemers publishing services gmbh, Krefeld; www.reemers.de
Umschlaggestaltung: Edie Freedman & Hanna Dyer, Boston
Produktion: Karin Driesen & Geesche Kieckbusch, Köln
Belichtung, Druck und buchbinderische Verarbeitung:
Druckerei Kösel, Kempten; www.koeselbuch.de
ISBN 3-89721-184-X
Dieses Buch ist auf 100% chlorfrei gebleichtem Papier gedruckt.
Für meine Frau Veva, meine Eltern Sheldon und Joan Feuerstein
und die Kinder in meinem Leben: Liana Belle Rosenthal,
Markus Finnbar Walsh, Danielle und Benjamin DeUrso,
Timnah und Masada Sela, Nicolas Silva,
Ian und Michaela McCauseland, Ciera, Brian,
Michael Daniels und Marc Silva
und natürlich meine eigenen beiden Jungs: Eli und Chris.
– Steven Feuerstein
Für meinen Vater, der mir oft sagte
»Wer den Blick nach vorne richtet, kennt keine Hürde«
bis sich dieser Satz fest in meinem Kopf eingeprägt hatte.
– Bill Pribyl
Inhalt
Vorwort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . XIII
I
Programmieren mit PL/SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1
Einführung in PL/SQL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Was ist PL/SQL? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Die Ursprünge von PL/SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Das ist PL/SQL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
PL/SQL-Versionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Ressourcen für PL/SQL-Entwickler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Einige Ratschläge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2
PL/SQL-Code schreiben und ausführen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
SQL*Plus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Wichtige PL/SQL-Tasks ausführen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
PL/SQL-basierte Entwicklungswerkzeuge von Oracle. . . . . . . . . . . . . . . . . . . . . . .
PL/SQL von anderen Sprachen aus aufrufen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Und was gibt es sonst noch? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
32
47
55
58
63
Grundlagen der Sprache PL/SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
Die Blockstruktur von PL/SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Der Zeichensatz von PL/SQL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Bezeichner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Literale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Das Semikolon als Trennzeichen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Kommentare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Das Schlüsselwort PRAGMA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Label . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
64
74
75
80
83
83
85
86
|
VII
II Die Struktur von PL/SQL-Programmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
4
Bedingte und sequentielle Steuerung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
IF-Anweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
CASE-Anweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
Die GOTO-Anweisung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
Die NULL-Anweisung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
5
Schleifen
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
Grundlegendes über Schleifen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
Die einfache Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
Die WHILE-Schleife. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
Die numerische FOR-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
Die Cursor-FOR-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
Schleifen-Label. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
Tips zur Verwendung von PL/SQL-Schleifen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
6
Exception-Handler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
Wie PL/SQL mit Fehlern umgeht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
Exceptions definieren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
Exceptions auslösen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
Exceptions behandeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
III Die Programmdaten von PL/SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
7
Die Arbeit mit Programmdaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
Programmdaten benennen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
Überblick über PL/SQL-Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
Programmdaten deklarieren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
Programmiererdefinierte Subtypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
Konvertierung zwischen Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
8
Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
Der Einfluß der Zeichensätze. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
String-Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
String-Probleme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
String-Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
NLS-Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238
VIII
| Inhalt
9
Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241
Numerische Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241
Zahlenkonvertierungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248
Numerische Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
10 Datumswerte und Zeitstempel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272
Datentypen für Datum und Uhrzeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273
Datums- und Zeitstempel-Konvertierungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283
Datums-/Uhrzeit-Arithmetik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312
Datums-/Uhrzeit-Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325
11 Datensätze und Collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343
Datensätze in PL/SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343
Collections in PL/SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358
Collection-Typen und Collections deklarieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364
Einsatzgebiete für Collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368
Built-in-Methoden für die Arbeit mit Collections . . . . . . . . . . . . . . . . . . . . . . . . . . 373
Die Arbeit mit Collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382
Pseudofunktionen für Collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409
Die Verwaltung von Collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417
Einen Collection-Typ auswählen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 418
12 Weitere Datentypen
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 421
Der Datentyp BOOLEAN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 421
Der Datentyp RAW . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 423
Die Datentypen UROWID und ROWID. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 423
Die LOB-Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429
Die Arbeit mit LOBs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 432
Vordefinierte Objekt-Typen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456
IV SQL in PL/SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 467
13 DML und Transaktionsverwaltung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 469
DML in PL/SQL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 470
Gruppen-DML mit der FORALL-Anweisung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 481
Transaktionsverwaltung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 490
Autonome Transaktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 495
Inhalt
|
IX
14 Abruf von Daten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 509
Cursor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 510
Implizite Cursor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 520
Explizite Cursor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527
BULK COLLECT. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 542
SELECT...FOR UPDATE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 548
Cursor-Variablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553
Cursor-Ausdrücke (Oracle9i) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 567
15 Dynamisches SQL und dynamisches PL/SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 571
NDS-Anweisungen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 572
Mehrzeilen-Abfragen mit Cursor-Variablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 577
Variablen binden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 584
Umgang mit Objekten und Collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 590
Anwendungen mit NDS. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593
Das Package NDS Utility . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 601
Vergleich zwischen NDS und DBMS_SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 602
V Anwendungen mit PL/SQL erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 605
16 Prozeduren, Funktionen und Parameter
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 607
Modularer Code. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 608
Prozeduren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 610
Funktionen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 613
Parameter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 622
Lokale Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 634
Das Überladen von Modulen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 639
Vorwärts-Deklarationen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 644
Fortgeschrittene Themen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 645
Gehet hin und modularisieret Euch! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 661
17 Packages
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 663
Wozu Packages?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 663
Regeln für den Aufbau von Packages. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 670
Regeln für den Aufruf von Package-Elementen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 678
Der Umgang mit Package-Daten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 679
Wann nutzt man Packages? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 689
Packages und Objekt-Typen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 696
X
|
Inhalt
18 Trigger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 697
DML-Trigger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 698
DDL-Trigger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 723
Datenbankereignis-Trigger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 732
INSTEAD OF-Trigger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 740
AFTER SUSPEND-Trigger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 746
Wartung von Triggern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 754
19 Verwaltung von PL/SQL-Anwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 758
Code in der Datenbank verwalten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 759
Gespeicherten Code schützen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 764
Native Kompilierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 767
PL/SQL-Programme testen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 769
Fehlerbehebung in PL/SQL-Programmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 777
Tuning von PL/SQL-Programmen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 785
Anwendungs-Performance verbessern. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 793
VI PL/SQL für Fortgeschrittene . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 805
20 Die Laufzeitarchitektur von PL/SQL
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 807
Hinter den Kulissen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 808
Verwaltung der Abhängigkeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 818
Speichernutzung von PL/SQL im Oracle-Server . . . . . . . . . . . . . . . . . . . . . . . . . . . 830
Verarbeitung von PL/SQL auf der Serverseite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 847
PL/SQL-Code auf dem Client . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 850
Modelle für Ausführungsrechte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 859
Hardware für PL/SQL: größer = besser? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 868
Was wirklich wichtig ist . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 870
21 Objektorientierte Aspekte von PL/SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 872
Einführung in die Objekt-Features von Oracle . . . . . . . . . . . . . . . . . . . . . . . . . . . . 873
Ein erweitertes Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 875
Objekt-Views . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 916
Wartung von Objekt-Typen und -Views . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 929
Weitergehende Überlegungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 932
Inhalt
|
XI
22 Java von PL/SQL aus aufrufen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 935
Oracle und Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 935
Java in Oracle nutzen: Vorbereitungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 937
Eine einfache Demonstration. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 941
Verwendung von loadjava . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 947
Verwendung von dropjava . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 950
Java in der Datenbank verwalten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 951
Verwendung von DBMS_ JAVA. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 953
Java in PL/SQL zugänglich machen und benutzen . . . . . . . . . . . . . . . . . . . . . . . . . 958
23 Externe Prozeduren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 973
Einführung in externe Prozeduren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 974
Die Oracle Net-Konfiguration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 978
Erstellen einer Oracle-Bibliothek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 981
Die Aufrufspezifikation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 983
Eine Exception aus dem aufgerufenen C-Programm auslösen . . . . . . . . . . . . . . . . 994
Nicht-standardmäßige Agenten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 997
Die Pflege von externen Prozeduren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 998
Index
XII
|
Inhalt
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1003
Vorwort
Tausende von Anwendungsentwicklern und Datenbankadministratoren auf der ganzen
Welt verwenden die von der Firma Oracle entwickelte und vertriebene Software, um
komplexe Systeme zu schaffen, die riesige Datenmengen verwalten. Im Inneren eines großen Teils der Software von Oracle arbeitet PL/SQL, eine Programmiersprache, die prozedurale Erweiterungen der relationalen Datenbanksprache SQL und eine ständig
wachsende Zahl von Entwicklungswerkzeugen bereitstellt.
In fast jedem neuen Produkt der Oracle Corporation kommt PL/SQL als zugrundeliegender Technologie eine herausragende Rolle zu. Entwickler können PL/SQL für viele Programmieraufgaben verwenden, darunter die folgenden:
• Regeln zur Bearbeitung von Geschäftsvorfällen im Oracle-Server mit PL/SQL-basierten gespeicherten Prozeduren und Datenbank-Triggern implementieren.
• XML-Dokumente vollständig innerhalb der Datenbank erzeugen und verwalten.
• Eine Webseite mit einer Oracle-Datenbank verbinden.
• Aufgaben der Datenbankadministration implementieren und automatisieren, angefangen von der Sicherheit auf Zeilenebene bis hin zur Verwaltung von Rollback-Segmenten in PL/SQL-Programmen.
PL/SQL ist Ada1 nachempfunden, einer Programmiersprache, die für das US-amerikanische Verteidigungsministerium entwickelt wurde. Ada ist eine High-Level-Sprache, die
besonders wichtige Elemente moderner Entwurfsstrategien wie Datenabstraktion und
Verbergen von Informationen betont.
Dieses gute Design macht PL/SQL zu einer mächtigen Programmiersprache, die viele der
fortgeschrittensten Elemente prozeduraler Sprachen enthält:
1 Die Sprache heißt Ada zu Ehren von Ada Lovelace, einer Mathematikerin, die von vielen als erste Computer-Programmiererin der Welt angesehen wird. Mehr über Ada erfahren Sie unter http://www.adahome.com.
|
XIII
• Eine breite Palette an Datentypen für Zahlen und Zeichen, einschließlich komplexer Datenstrukturen wie Datensätze (Records), die den Zeilen einer relationalen
Tabelle gleichen, Collections, die Arrays von Oracle, und sogar XMLType zur Verwaltung von XML-Dokumenten in Oracle und mit PL/SQL.
• Eine explizite und hervorragend lesbare Blockstruktur, die die Wartung und Pflege
von PL/SQL-Anwendungen erleichtert.
• Bedingte, iterative und sequentielle Steuerungsstrukturen, darunter eine CASEAnweisung und drei verschiedene Arten von Schleifen.
• Exception-Handler für die ereignisbasierte Exceptions-Behandlung.
• Benannte, wiederverwendbare Code-Elemente, darunter Funktionen, Prozeduren,
Trigger, Objekt-Typen (ähnlich den Klassen in der objektorientierten Programmierung) und Packages (Zusammenfassungen verwandter Programme und Variablen).
PL/SQL ist voll in Oracle-SQL integriert: Sie können SQL-Anweisungen direkt aus Ihrem
prozeduralen Code heraus ohne den Umweg über eine zwischengeschaltete API (Application Programming Interface) wie JDBC (Java DataBase Connectivity) oder ODBC
(Open DataBase Connectivity) aufrufen. Andersherum können Sie auch PL/SQL-Funktionen aus SQL-Anweisungen heraus aufrufen.
Oracle-Entwickler, die auch im 21. Jahrhundert noch Erfolg haben wollen, müssen sich
um eine vollständige Beherrschung von PL/SQL bemühen. Dieser Lernprozeß gliedert
sich in zwei Schritte: Zunächst muß man den gesamten Sprachumfang lernen, um dann,
wenn man die einzelnen Sprachmerkmale beherrscht, zu verstehen, wie man diese Konstrukte zur Programmierung komplexer Anwendungen zusammensetzt.
Aus diesen und anderen Gründen benötigen Oracle-Entwickler ein solides und umfassendes Buch über die Grundlagen von PL/SQL. Dazu gehören nicht nur die Grundbestandteile von PL/SQL, sondern auch Beispiele, damit Sie nicht sämtliche Erfahrungen
über den Weg von »Versuch und Irrtum« machen müssen. Wie bei jeder anderen Programmiersprache gibt es auch bei PL/SQL einen richtigen und viele falsche (oder zumindest nicht ganz so richtige) Wege, um etwas zu erreichen. Die Autoren hoffen, daß dieses
Buch Ihnen hilft, PL/SQL so schnell und wirkungsvoll zu lernen, wie nur irgend möglich.
Ziele des Buchs
Wobei hilft Ihnen dieses Buch nun genau?
Es hilft Ihnen, den kompletten Funktionsumfang von PL/SQL zu nutzen.
Die Oracle-Referenz beschreibt vielleicht alle Sprachmerkmale der Programmiersprache PL/SQL, sagt Ihnen aber nicht, wie Sie diese dann anwenden. Manchmal
können Sie sich schon glücklich schätzen, wenn Sie überhaupt verstanden haben,
wie man ein bestimmtes Sprachmerkmal anwendet, nachdem Sie sich durch die
Syntax-Diagramme gekämpft haben. Bücher und Schulungen behandeln üblicher-
XIV
|
Vorwort
weise immer die gleichen Themen auf immer die gleiche eingeschränkte Weise. In
diesem Buch werden wir uns in die Außenbezirke der Sprache wagen, in den Bereich
der nicht mehr so alltäglichen Möglichkeiten, mit denen ein bestimmtes Sprachmerkmal so zurechtgebogen werden kann, daß ein gewünschtes Resultat erreicht
wird.
Es hilft Ihnen, PL/SQL einzusetzen, um Probleme zu lösen.
Schließlich bringen Sie ja nicht Tage und Nächte mit dem Schreiben von PL/SQLModulen zu, um ein besserer Mensch zu werden. Sie verwenden PL/SQL, um für
Ihre Firma oder Ihre Kunden Probleme zu lösen. In diesem Buch versuche ich Ihnen
bei der Lösung echter Probleme zu helfen, also der Art von Problemen, denen Entwickler täglich ausgesetzt sind (oder doch zumindest die mit Software gelöst werden können). Dazu habe ich dieses Buch reichlich mit Beispielen versehen – nicht
einfach nur Code-Schnipsel, sondern vollständige Anwendungskomponenten, die
Sie unmittelbar in eigenen Projekten einsetzen können. Das Buch selbst enthält
schon eine ganze Menge an Code, und auf der zugehörigen Website gibt es noch
viel mehr. Ich führe Sie in diesem Buch durch den analytischen Prozeß, im Zuge
dessen man zu einer Lösung kommt. Damit hoffe ich, daß Sie möglichst konkret
sehen können, wie PL/SQL-Sprachmerkmale und auch undokumentierte Anwendungen dieser Merkmale in einer bestimmten Situation angewendet werden können.
Es hilft Ihnen, effizienten, wartbaren Code zu schreiben.
PL/SQL und die anderen Oracle-Produkte haben das Potential zu gewaltiger Produktivität beim Programmieren. Aber wenn Sie nicht sorgfältig arbeiten, schaufeln
Sie sich mit diesen Möglichkeiten zur beschleunigten Entwicklung ein Loch, tiefer
und dunkler als alle, in denen Sie bisher gesessen haben. Ich würde dieses Buch als
einen Fehlschlag betrachten, wenn es Programmierern nur dazu dienen würde,
mehr Code in kürzerer Zeit als vorher zu schreiben. Ich möchte Ihnen dabei helfen,
Kenntnisse und Techniken zu erwerben, mit denen Sie Module schreiben können,
die sich leicht und schnell an veränderte Anforderungen anpassen lassen und die
leicht zu verstehen und zu warten sind. Ich möchte Ihnen umfassende Strategien
und Code-Architekturen nahebringen, mit denen Sie PL/SQL bei vielen Problemen,
denen Sie gegenüberstehen, in mächtigen, generellen Verfahren einsetzen können.
Die Struktur des Buchs
Wir (die Autoren und O’Reilly) betrachten es als unsere Aufgabe, eine umfassende und
nützliche Beschreibung zu PL/SQL zu liefern, solange es diese Sprache gibt. Die erste
amerikanische Auflage dieses Buchs behandelte die meisten Sprachmerkmale von
PL/SQL bis einschließlich Version 2.3. In der zweiten amerikanischen Auflage (der ersten
deutschen Auflage) kamen die neuen Sprachmerkmale von Oracle8 hinzu, diese wurden
aber getrennt vom Rest des Buchs behandelt. Die dritte Auflage, die Sie nun übersetzt in
Vorwort
|
XV
Händen halten, verfolgt einen anderen Ansatz. Sie enthält sämtliche Merkmale von
PL/SQL bis einschließlich Oracle9i Release 2 (9.2). Es ist also egal, ob Sie noch Oracle
7.3.4 einsetzen (hoffentlich tun Sie dies nicht mehr lange!) oder Oracle9i: Dieses Buch
wird Ihre Fragen beantworten und bietet Informationen in integrierter Form. Es gibt also
keinen getrennten Teil zu Oracle9i, sondern einfach einen Buchabschnitt, in dem Sie das
gesuchte Sprachmerkmal für die unterschiedlichen Versionen nachschlagen können.
Als Steven Feuerstein 1994 begann, Bücher über PL/SQL zu verfassen, war es noch möglich, eine umfassende Darstellung in einem einzigen, wenn auch sehr dicken Buch unterzubringen. Im Jahr 1997 ging das schon nicht mehr. Deshalb veröffentlicht O’Reilly noch
eine Vielzahl weiterer Bücher über Themen wie die von Oracle bereitgestellten Packages
(z.B. DBMS_SQL). Mehr über diese Bücher erfahren Sie in Kapitel 1 unter »Die PL/SQLReihe von O’Reilly«. Im Jahr 2002 haben wir uns gefragt: Wie können wir ein Buch über
PL/SQL schreiben, das Benutzerhandbuch und Referenz zugleich ist, ohne einen Wälzer
zu erschaffen, der sich körperlich wie geistig gar nicht mehr »stemmen« läßt?
Also gestalteten wir das Buch in folgenden Schritten:
• Zuallererst nahmen wir wichtige Inhalte auf, die seit Jahren fehlen, allen voran die
Behandlung von Datenbank-Triggern.
• Als nächstes beschlossen wir, das Internet stärker zu berücksichtigen. Wir wollten
nicht mehr seitenlange, umfangreiche (und oft schwer verdauliche) Code-Beispiele
im Buch unterbringen – diese haben wir lieber auf die Website zu diesem Buch verlagert, die Sie bei O’Reilly unter http://www.oreilly.com/catalog/oraclep3/ bzw.
http://www.oreilly.de/catalog/oraclep3ger/ erreichen (Einzelheiten finden Sie im
Abschnitt »Download der Codebeispiele und ergänzender Kapitel aus dem Web«).
Keine Sorge, das Buch ist immer noch vollgepackt mit Code, er ist nur ein bißchen
knapper gehalten als in der Vergangenheit.
• Mit einigem Bauchgrimmen haben wir ganze Kapitel aus der letzten Auflage ausgegliedert und auf die Website verlagert. Dazu gehören das Kapitel 17, PL/SQL-Funktionen von SQL aus aufrufen, und das Kapitel 5 des deutschen Erweiterungsbands,
Tips zum Code-Design. (Entwurfstips werden auch in dem Buch Oracle PL/SQL Best
Practices ausführlich behandelt.)
• Etliche Kapitel wurden umorganisiert, um den Aufbau des Buchs zu verbessern und
die Gesamtseitenzahl zu verringern. So behandeln wir beispielsweise Zeichendaten
nicht mehr getrennt von den Zeichenfunktionen, sondern sagen in einem einzigen
Kapitel alles über Strings. Mehrere Kapitel, insbesondere die Kapitel 7 bis 9 des
Erweiterungsbands zur vorigen deutschen Auflage über Debugging, Tuning und
Tracing, wurden zu einem einzigen Kapitel zusammengefaßt. Große Textteile, vor
allem die Anekdoten, wurden nicht mehr in die dritte Auflage übernommen und
stehen jetzt auf der Website.
XVI
|
Vorwort
• Ein neueres, kompakteres Buchlayout von O’Reilly sparte rund zehn Prozent der
Seiten gegenüber dem vorherigen Layout ein. Dadurch paßt jetzt auch mehr Code in
eine Zeile bzw. auf eine Seite.
Wir sind mit dem Ergebnis sehr zufrieden und hoffen, Sie sind es auch. Das Buch enthält
mehr Informationen denn je, und dennoch haben wir es geschafft, unser »Markenzeichen« beizubehalten: einen humorvollen Plauderton, der über die Jahre in vielen Leserzuschriften gelobt wurde, weil er das Buch besser lesbar, verständlicher und ausgesprochen
nützlich macht.
Noch ein Wort zur Art der Darstellung: Vielleicht fällt Ihnen auf, daß wir manchmal in
der Wir-Form und manchmal in der Ich-Form schreiben. Ein Merkmal dieses Buchs (und
eines, das viele Leser loben) ist die persönliche Darstellung, die untrennbar mit dem Text
verbunden ist. Daher haben wir auch nach der Einbeziehung von Koautoren und – insbesondere in der vorliegenen Auflage – noch mehreren anderen Mitarbeitern beschlossen,
die Ich-Form zu wählen, wenn ein Autor für sich selbst spricht.
Damit Sie nun aber nicht rätseln müssen, wer dieser »Ich« denn nun in einem bestimmten Kapitel ist, hier eine kurze Übersicht für die, die es interessiert:
: Kapitel
Autor
Kapitel
Autor
1
Steven
13
Steven
2
Bill
14
Steven
3
Bill und Steven
15
Steven
4
Jonathan und Steven
16
Steven
5
Steven
17
Steven
6
Steven
18
Darryl
7
Steven
19
Steven
8
Jonathan und Steven
20
Bill
9
Jonathan und Steven
21
Bill
10
Jonathan und Steven
22
Steven
11
Steven und Bill
23
Bill
12
Jonathan
Zum Inhalt
Die vorliegende Auflage von Oracle PL/SQL Programmierung gliedert sich in sechs Teile:
Teil I, Programmieren mit PL/SQL
In Kapitel 1 fangen wir ganz am Anfang an: Woher kommt PL/SQL? Wozu dient es?
Wir gehen dabei ganz kurz die wichtigsten Merkmale von PL/SQL durch. Kapitel 2
soll Sie in die Lage versetzen, möglichst schnell mit der PL/SQL-Programmierung zu
Vorwort
|
XVII
beginnen. Es enthält klare und deutliche Anleitungen, wie Sie in SQL*Plus und einigen anderen gebräuchlichen Umgebungen PL/SQL-Code ausführen. Kapitel 3 gibt
einen Überblick über die Grundlagen von PL/SQL: Was zu einer Anweisung in
PL/SQL gehört, wie die Blockstruktur aussieht, wie Sie Kommentare einfügen usw.
Teil II, Programmstruktur in PL/SQL
Die Kapitel 4 bis 6 beschreiben bedingte (IF und CASE) und sequentielle (z.B. GOTO
und NULL) Steuerungsanweisungen, Schleifen und die Exceptions-Behandlung in
PL/SQL. Hier lernen Sie, Codeblöcke zu konstruieren, die den komplexen Anforderungen Ihrer Anwendungen gerecht werden.
Teil III, Daten in PL/SQL-Programmen
Jedes Programm verarbeitet Daten, und viele dieser Daten sind lokal in Ihrer
PL/SQL-Prozedur oder -Funktion definiert. In den Kapiteln 7 bis 12 werden die verschiedenen Arten von Programmdaten, die Sie in PL/SQL definieren können, vollständig erläutert. Dazu gehören Zahlen, Strings, Datensätze und Collections. Sie
lernen auch die neuen Datentypen aus Oracle9i kennen, darunter INTERVAL,
TIMESTAMP, XMLType und andere mehr. Zudem werden in diesen Kapiteln die
diversen eingebauten Funktionen zur Verarbeitung und Änderung von Daten
erklärt.
Teil IV, SQL in PL/SQL
Die Kapitel 13 bis 15 behandeln eines der wichtigsten Elemente der Codeerstellung
mit PL/SQL: die Verbindung mit einer zugrundeliegenden Datenbank über SQL.
Hier wird beschrieben, wie Sie Transaktionen definieren, um Datenbanktabellen zu
ändern, einzufügen oder zu löschen, wie Sie Informationen aus der Datenbank abrufen, um sie in einem PL/SQL-Programm zu verarbeiten, und wie Sie SQL-Anweisungen mit Native Dynamic SQL (NDS), das mit Oracle8i eingeführt wurde, dynamisch
ausführen.
Teil V, PL/SQL-Anwendungen erstellen
Hier schließt sich der Kreis. Sie wissen jetzt alles über die Deklaration und Behandlung von Variablen und sind Experte in Fehlerbehandlung und Schleifenkonstruktion. Nun lernen Sie in den Kapiteln 16 bis 19, wie Sie Anwendungsblöcke
gestalten, zu denen Prozeduren, Funktionen, Trigger und Packages gehören. In
Kapitel 19 wird erklärt, wie Sie die Codebasis von PL/SQL verwalten. Hier finden
Sie auch Vorschläge, wie Sie den Code debuggen und tunen können.
Teil VI, PL/SQL für Fortgeschrittene
Ist eine Sprache erst so ausgereift und reichhaltig wie PL/SQL, so hat sie auch eine
Fülle von Funktionen, die Sie zwar vermutlich nicht jeden Tag nutzen werden, aber
die gelegentlich auch über Wohl und Wehe Ihrer Arbeit entscheiden. Kapitel 20
untersucht die Architektur des Laufzeitsystems von PL/SQL einschließlich seiner
Speicherverwendung und den Unterschieden zwischen PL/SQL auf der Serverseite
und auf der Clientseite. Kapitel 21 behandelt ausführlich die objektorientierten
XVIII
|
Vorwort
Merkmale von Oracle (Objekt-Typen und Objekt-Views). Die Kapitel 22 und 23 zeigen Ihnen, wie Sie in Java und C geschriebenen Code aus Ihren PL/SQL-Anwendungen heraus aufrufen können.
Wenn Sie bereits ein erfahrener Programmierer sind, der eben nur PL/SQL noch nicht so
gut kennt, dann sollten Sie dieses Buch von Anfang bis Ende lesen, um Ihre Fähigkeiten
und Ihr Verständnis zu vertiefen. Wenn Sie bereits professionell mit PL/SQL umgehen,
ist es besser, immer den jeweils passenden Abschnitt herauszusuchen, der Ihnen bei Ihrer
augenblicklichen Anwendung weiterhilft. Egal ob Sie dieses Buch als Lehrbuch oder als
Referenz nutzen: Wir hoffen, daß es Ihnen hilft, PL/SQL wirkungsvoll einzusetzen.
Was dieses Buch nicht behandelt
Dieses Buch ist zwar umfangreich, kann aber nicht jedes Thema abdecken. Die OracleUmgebung ist groß und komplex, und in diesem Buch haben wir uns auf den Kern von
PL/SQL selbst konzentriert. Die folgenden Themen gehören daher nicht in dieses Buch
und werden entweder gar nicht oder nur oberflächlich behandelt:
Die Programmiersprache SQL
Wir gehen davon aus, daß Sie SQL bereits kennen und wissen, wie Sie SELECTs,
UPDATEs, INSERTs und DELETEs schreiben müssen.
Administration von Oracle-Datenbanken
DBAs können hier lernen, wie sie PL/SQL-Anweisungen formulieren, um Datenbanken zu erstellen und zu pflegen, aber sie finden nicht alle Details der Data Definition Language (DDL) von Oracles SQL.
Anwendungen und Datenbanken optimieren
Tuning wird in diesem Buch nicht ausführlich behandelt, obwohl in Kapitel 19 auch
das Tracen, Tunen und Debuggen von PL/SQL-Programmen beschrieben wird. Das
Tuning von Oracle-Anwendungen wird in anderen Büchern in allen Einzelheiten
dargestellt.
Spezifische Technologien für andere Oracle-Tools als PL/SQL
Dieses Buch zeigt Ihnen nicht, wie Sie Anwendungen in einem Tool wie dem Forms
Developer von Oracle erstellen, auch wenn dieser mit PL/SQL implementiert ist.
Wir konzentrieren uns auf die Kernfähigkeiten der Sprache, insbesondere darauf,
was Sie aus einer Datenbank heraus mit PL/SQL machen können. Doch das meiste,
was Sie in diesem Buch lesen, können Sie mit PL/SQL auch im Forms Developer
oder Reports Developer machen.
National Language Support in Oracle
Der National Language Support (NLS) von Oracle, der Fähigkeiten zur Entwicklung von Anwendungen für mehrere natürliche Sprachen bietet, wird in diesem Buch nicht behandelt.
Vorwort
|
XIX
Schriftkonventionen
In diesem Buch werden die folgenden Konventionen verwendet:
Kursiv
wird für Datei- und Verzeichnisnamen, für URLs und für die Hervorhebung neuer
Begriffe verwendet.
Nichtproportionalschrift
wird für Codebeispiele verwendet.
Nichtproportionalschrift fett
wird in Beispielen, die eine Interaktion verlangen, für die Benutzereingabe verwendet und hebt in manchen Beispielen die zuvor besprochenen Anweisungen hervor.
Nichtproportionalschrift kursiv
zeigt in manchen Codebeispielen ein Element (wie beispielsweise einen Dateinamen) an, das Sie eingeben müssen.
GROSSBUCHSTABEN
werden in Codebeispielen für PL/SQL-Schlüsselwörter verwendet.
kleinbuchstaben
werden in Codebeispielen für benutzerdefinierte Elemente wie Variablen, Parameter usw. verwendet.
Sonderzeichen
müssen in Codebeispielen exakt wie angegeben eingegeben werden.
Einrückung
hilft dabei, Ihnen die Struktur von Codebeispielen zu verdeutlichen, ist aber nicht
notwendig.
--
In Codebeispielen leitet ein doppelter Strich einen einzeiligen Kommentar ein, der
sich bis zum Zeilenende erstreckt.
/* und */
In Codebeispielen begrenzen diese Zeichen einen mehrzeiligen Kommentar.
.
In Codebeispielen und dazugehörigen Texten trennt ein Punkt einen Objektnamen
von einem Komponentennamen in qualifizierten Verweisen. Beispielsweise wird die
Punkt-Notation verwendet, um Felder in einem Datensatz und Deklarationen in
einem Package zu bezeichnen.
[ ]
In Syntax-Beschreibungen schließen eckige Klammern optionale Elemente ein.
{ }
In Syntax-Beschreibungen schließen geschweifte Klammern eine Reihe von Elementen ein, aus denen Sie nur ein einziges auswählen dürfen.
XX
| Vorwort
|
In Syntax-Beschreibungen trennt ein senkrechter Strich die in geschweiften Klammern stehenden Elemente, wie in {TRUE | FALSE}.
...
In Syntax-Beschreibungen zeigen Auslassungspunkte an, daß Anweisungen oder
Klauseln, die für die aktuelle Diskussion nicht relevant sind, weggelassen wurden.
Zeigt einen Rat, Vorschlag oder allgemeinen Hinweis an. So teilen wir
Ihnen z.B. mit, ob eine bestimmte Einstellung versionsspezifisch ist.
Zeigt eine Warnung an, beispielsweise für den Fall, daß eine bestimmte
Einstellung negative Auswirkungen auf das System haben kann.
Welche Plattform oder Version?
Im allgemeinen sind die Beschreibungen und Beispiele in diesem Buch unabhängig von
der verwendeten Maschine und dem verwendeten Betriebssystem. In den wenigen Fällen,
in denen ein Merkmal in irgendeiner Form versionsabhängig ist, erwähne ich das im Text
– beispielsweise dann, wenn Sie es nur in Oracle8i oder Oracle9i nutzen können.
Es gibt viele Versionen von PL/SQL, und es kann sogar sein, daß Sie bei Ihrer Entwicklungsarbeit mit verschiedenen Versionen gleichzeitig arbeiten. Kapitel 1 beschreibt
detailliert die verschiedenen Versionen von PL/SQL und was Sie darüber wissen müssen;
lesen Sie dazu den Abschnitt »Mit mehreren Versionen von PL/SQL arbeiten«.
Download der Codebeispiele und
ergänzender Kapitel aus dem Web
Sämtlichen Code aus diesem Buch stellen wir auf folgenden Websites zur Verfügung:
http://www.oreilly.de/catalog/oraclep3ger/
http://www.oreilly.com/catalog/oraclep3
Hier klicken Sie auf den Link »Beispiele« (bzw. »Examples«), um das Begleitmaterial zu
diesem Buch aufzurufen.
Um auf der Website ein bestimmtes Beispiel zu finden, suchen Sie nach dem im Text
angegebenen Dateinamen. Viele Dateinamen haben die folgende Form und stehen am
Anfang des Beispiels in einem Kommentar.
/* Datei im Web: vollername.pkg */
Vorwort
|
XXI
Wie bereits erwähnt, finden Sie auf den oben genannten O’Reilly-Websites auch den
kompletten Inhalt einiger Kapitel der vorigen Auflage dieses Buchs, die aus der vorliegenden Auflage ausgeliedert wurden – auf der deutschen Website die deutschsprachigen
Kapitel, auf der amerikanischen Site die englischsprachigen. Diese Kapitel sind besonders
für die Leser interessant, die noch mit älteren Versionen von Oracle arbeiten.
Danksagungen
Da Oracle PL/SQL Programming erstmals im Jahre 1995 herauskam, hat es bereits eine
bewegte und produktive Geschichte als Referenzwerk über die Benutzung von PL/SQL.
Dafür danken wir zuallererst unseren Lesern.
Dafür zu sorgen, daß Oracle PL/SQL Programming ein präzises, gut lesbares und aktuelles Referenzwerk zu PL/SQL bleibt, war von Anfang an ein hartes Stück Arbeit und
wuchs uns zugegebenermaßen auch manchmal über den Kopf. Es dennoch zu schaffen
wäre unmöglich gewesen, wenn uns nicht viele Oracle-Spezialisten, Freunde und Familienmitglieder und nicht zuletzt auch das exzellente Team von O’Reilly dabei geholfen hätten.
Weiter unten finden Sie ausführliche Danksagungen an all jene, die an der dritten Auflage von Oracle PL/SQL Programming mitgewirkt haben. Darunter danken wir auch den
vielen Menschen, die bei der ersten und zweiten Auflage des Buchs mitgeholfen haben.
Den vollständigen Text der Danksagungen aus diesen Auflagen finden Sie auf der Website.
An allererster Stelle danken wir Jonathan Gennick, Darryl Hurley, Bryn Llewellyn und
Steve Adams, vier hervorragenden Oracle-Spezialisten, für ihre wichtigen Beiträge zu diesem Buch. Jonathan hat fünf Kapitel geschrieben oder stark überarbeitet, und Darryl
arbeitete an dem schönen Kapitel über Datenbank-Trigger mit und erklärte vieles über
die Internationalisierungsfunktionen von Oracle. Bryn Llewellyn, der PL/SQL Product
Manager von Oracle, lieferte wichtige Informationen über neue Funktionen in Oracle9i,
beantwortete mit Engelsgeduld endlose Fragen über diverse PL/SQL-Funktionen und
begutachtete viele der Kapitel. Steve Adams gab uns sehr gutes und ausführliches Feedback zur Laufzeitarchitektur von PL/SQL.
Für dieses umfangreiche Buch waren eine Menge Gutachter notwendig, vor allem um
jeden Code-Schnipsel und jedes Programm im Buch zu testen und dadurch die Fehler in
der Druckversion auf ein absolutes Minimum zu drücken. Unser Dank gebührt folgenden Männern und Frauen aus der Welt von Oracle PL/SQL dafür, daß sie Stunden ihres
Lebens opferten, damit Oracle PL/SQL Programming so gut wie nur irgend möglich
wurde: Don Bales, Dick Bolz, Dan Clamage, Steve Cosner, Gerard Hartgers, Dwayne
King, Larry Elkins, Chandrasekharan Iyer, Vadim Loevski, Giovanni Jaramillo, Rakesh
Patel, James Padfield, Peter Linsley, Christopher Racicot, Alex Romankevich, Scott
XXII
|
Vorwort
Sowers, JT Thomas, Edward Van Hatten, Simon St. Laurent, Tony Crawford, Geoff Chester und Andre Vergison.
Als wir mit dem technischen Inhalt endlich zufrieden waren, schlug die Stunde für das
bemerkenswerte Team von O’Reilly. Unter der Führung unserer guten Freundin
Deborah Russell wurde aus unseren vielen Kapiteln und Codebeispielen ein Buch, das
des O’Reilly Verlags würdig ist. Unser Dank geht an Emily Quill, Production Manager
für dieses Buch, Rob Romano, der die guten Abbildungen erstellte, Julie Flanagan, die
fähige Lektoratsassistentin, die uns bei dem gesamten Projekt zur Seite stand, und an den
Rest der Crew.
Und dies sind die vielen Menschen, denen wir für ihren Beitrag zur ersten und zweiten
Auflage gedankt haben (und auch weiterhin dankbar sind):
Jennifer Blair, Eric Camplin, Joe Celko, Avery Cohen, Thomas Dunbar, R. James Forsythe, Mike Gangler, Gabriel Hoffman, Karen Peiser, Pete Schaffer, David Thompson, Cailein Barclay, Sunil Bhargava, Boris Burshteyn, Gray Clossman, Radhakrishna Hari, James
Mallory, Nimesh Mehta, Jeff Muller, Dave Posner, Chris Racicot, Peter Vasterd, Zona
Walcott, Sohaib Abassi, Per Brondum, Ivan Chong, Bill Dwight, Steve Ehrlich, Bushan
Fotedar, Ken Jacobs, Nimish Mehta, Steve Muench, Sri Rajan, Mark Richter, Bill Hinman, Tony Ziemba, John Cordell, Beverly Gibson, Mike Sierra, Gigi Estabrook, Edie
Freedman, Donna Woonteiler, Chris Reilley, Michelle Willey, Debby Cunha, Michael
Deutsch, John Files, Juliette Muellner, Cory Willing, Seth Maislin, Kismet McDonough
Chan, Clairemarie Fisher O’Leary, Eric Givler, Bert Scalzo, John Beresniewicz, Tom
White, Steve Hilker, Thomas Kurian, Radhakrishna Hari, Shirish Puranik, Kannan
Muthukkaruppan, Jane Ellin, Kimo Carter, Madeleine Newell, Rob Romano, Nancy
Priest, Seth Maislin, Fred Polizo, Donald Herkimer, Ervan Darnell, Gary Cernosek,
Patrick Pribyl, Bill Watkins, Debra Luik und Leo Lok.
Steven dankt außerdem seiner Frau, Veva Silva, und seinen beiden Söhnen, Chris Silva
und Eli Feuerstein, für ihre Unterstützung und Nachsicht, daß er so viel Zeit und Aufmerksamkeit auf dieses Buch verwandte.
Auch Bill dankt seiner Familie von ganzem Herzen dafür, daß sie seine Arbeit in den späten Abendstunden tolerierte (»Mami, Papa ist schon wieder am Computer eingeschlafen!«) und für all ihre Liebe und ihren Humor.
Vorwort
|
XXIII
TEIL I
I.
Programmieren mit PL/SQL
Dieser erste Teil des Buchs führt in PL/SQL ein, erklärt, wie Sie mit PL/SQL Code schreiben und ausführen, und stellt die Grundlagen der Sprache vor. In Kapitel 1 werden die
zentralen Fragen gestellt: Woher kam PL/SQL? Wozu ist es gut? Was sind seine Hauptmerkmale? Kapitel 2 soll Sie möglichst rasch in die Lage versetzen, PL/SQL-Programme
zu schreiben und auszuführen. Es enthält klare und einfache Anleitungen, wie Sie
PL/SQL-Code in SQL*Plus und einigen anderen gebräuchlichen Umgebungen ausführen.
Kapitel 3 beantwortet elementare Fragen zur Struktur der Sprache und ihren Schlüsselwörtern: Was gehört zu einer PL/SQL-Anweisung? Wozu ist die Blockstruktur von
PK/SQL da? Wie werden Kommentare in PL/SQL verfaßt?
Kapitel 1, Einführung in PL/SQL
Kapitel 2, PL/SQL-Code schreiben und ausführen
Kapitel 3, Grundlagen der Sprache PL/SQL
KAPITEL 1
Einführung in PL/SQL
In diesem Kapitel werden PL/SQL, seine Ursprünge und seine diversen Versionen vorgestellt. Außerdem erfahren Sie, welche anderen Ressourcen für PL/SQL-Entwickler es
gibt, und erhalten einige Ratschläge.
Was ist PL/SQL?
PL/SQL steht für »Procedural Language extensions to SQL«, also etwa »prozedurale
Spracherweiterungen für SQL«. SQL ist sowohl für die Abfrage als auch die Änderung
relationaler Datenbanken überall verbreitet. Oracle hat PL/SQL eingeführt, um Funktionen hinzuzufügen, die in SQL fehlen, und um eine umfassendere Programmiersprache
für diejenigen Entwickler zu schaffen, die auf der Oracle-Datenbank unternehmenswichtige Anwendungen ausführen müssen.
PL/SQL hat folgende Wesensmerkmale:
Es ist eine hochstrukturierte, lesbare und zugängliche Sprache.
Das an Ada angelehnte PL/SQL hat ein ultramodernes Design. Wenn Sie Programmieranfänger sind, ist PL/SQL ein idealer Ausgangspunkt. Haben Sie jedoch bereits
Erfahrungen mit anderen Programmiersprachen gemacht, werden Sie rasch mit der
neuen Syntax zurechtkommen. Mit »Zugänglichkeit« ist gemeint, daß Ihr Code sich
leicht warten und pflegen läßt, ein Aspekt, der für eine hochwertige Software von
großer Bedeutung ist.
PL/SQL ist eine standardisierte und portierbare Sprache für die Oracle-Entwicklung.
Wenn Sie eine PL/SQL-Prozedur oder -Funktion schreiben, die innerhalb der Personal Oracle-Datenbank auf Ihrem Notebook ausgeführt werden soll, können Sie dieselbe Prozedur auf eine Datenbank in Ihrem Firmennetzwerk übertragen und dort
ohne weitere Änderung ausführen (vorausgesetzt, die Oracle-Versionen sind kompatibel). »Einmal schreiben, überall ausführen« war schon lange vor Java das Leitmotiv von PL/SQL. Allerdings bedeutet »überall« bei PL/SQL: »Überall dort, wo es
eine Oracle-Datenbank gibt«.
|
3
PL/SQL ist eine eingebettete Sprache.
PL/SQL ist nicht als »selbständige« Sprache, sondern für eine »Host«-Umgebung
konzipiert. Sie können also z.B. PL/SQL-Programme innerhalb der Datenbank (etwa
über das SQL*Plus-Interface) ausführen. Alternativ können Sie PL/SQL-Programme
aber auch innerhalb eines Oracle Developer-Formulars oder -Berichts ausführen
(hier spricht man von »PL/SQL auf der Clientseite«). Sie können aber keine
PL/SQL-»Executable« erstellen, die von selbst läuft. In Kapitel 2 erfahren Sie alles,
was Sie wissen müssen, um diese eingebettete Sprache nutzen zu können.
PL/SQL ist eine Datenbanksprache mit hoher Leistung und starker Integration.
Heutzutage haben Sie viele Wahlmöglichkeiten, wenn Sie Programme schreiben
möchten, die auf der Oracle-Datenbank laufen. Sie können Java und JDBC (oder
SQLJ) verwenden; Sie können Visual Basic und ODBC einsetzen, oder Sie können
Delphi, C++ oder andere benutzen. Sie werden jedoch feststellen, daß es mit
PL/SQL viel einfacher als mit jeder anderen Sprache ist, hocheffizienten Code für
die Arbeit mit Oracle-Datenbanken zu schreiben. Vor allem bietet Oracle bestimmte
PL/SQL-spezifische Verbesserungen wie beispielsweise die FORALL-Anweisung,
mit denen Sie die Datenbank-Performance um eine Größenordnung oder mehr steigern können.
Die Ursprünge von PL/SQL
Oracle kann auf eine lange Geschichte der Einführung von deklarativen, nicht-prozeduralen Ansätzen zum Entwurf sowohl von Datenbanken als auch von Anwendungen
zurückblicken. Die Oracle-Server-Technologie gehört zu den fortschrittlichsten, mächtigsten und stabilsten relationalen Datenbanken der Welt. Die Werkzeuge zur Anwendungsentwicklung wie Oracle Forms ermöglichen eine hohe Produktivität, die durch den
»Male-Dein-Formular«-Ansatz erreicht wird, bei dem ausführliche Default-Möglichkeiten dem Entwickler größere spezielle Programmierarbeiten ersparen.
Die Anfangszeit von PL/SQL
In den frühen Jahren stellte dieser deklarative Ansatz in Verbindung mit der bahnbrechenden relationalen Technologie die Entwickler schon zufrieden. Aber mit der Zeit wurden die Erwartungen und Anforderungen immer anspruchsvoller. Die Entwickler
mußten unter die Oberfläche der Produkte gelangen können. Sie mußten in ihre Formulare und Datenbankprozeduren komplizierte Formeln, Ausnahmen und Regeln einbauen
können.
1988 veröffentlichte Oracle die Oracle-Version 6.0, was ein großer Fortschritt in der
Technologie der relationalen Datenbanken war. Eine der Schlüsselkomponenten war die
sogenannte prozedurale Option, also PL/SQL. Ungefähr zur gleichen Zeit veröffentlichte
Oracle das lange erwartete Upgrade zu SQL*Forms 2.3. (Dieses Produkt ist nunmehr
4 |
Kapitel 1: Einführung in PL/SQL
unter dem Namen Oracle Forms oder Forms Developer bekannt.) SQL*Forms 3.0 enthielt als erstes Entwicklungswerkzeug die PL/SQL-Maschine, mit der die Entwickler ihre
prozedurale Logik in einer natürlichen und einfachen Art und Weise programmieren
konnten.
Die erste Version von PL/SQL war in ihren Möglichkeiten sehr eingeschränkt. Auf der
Server-Seite konnte man PL/SQL nur für die Programmierung von Skripten zur »Stapelverarbeitung« prozeduraler oder SQL-Anweisungen verwenden. Man konnte also keine
Prozeduren oder Funktionen zur späteren Ausführung ablegen. Außerdem konnte man
keine modulare Anwendung schreiben oder komplexe Geschäftsregeln im Server hinterlegen. Auf der Client-Seite konnte man mit SQL*Forms 3.0 Prozeduren und Funktionen
erzeugen, aber die Unterstützung von Funktionen war nicht dokumentiert und wurde
daher von vielen Programmierern jahrelang nicht benutzt. Außerdem fehlte in dieser Version von PL/SQL die Unterstützung von Arrays, und man konnte nicht zu Ein- und Ausgabezwecken mit dem Betriebssystem arbeiten. PL/SQL war zu diesem Zeitpunkt noch
weit von einer vollständigen Programmiersprache entfernt.
Trotz all dieser Einschränkungen wurde PL/SQL von der Entwicklergemeinde freudig, ja
sogar begeistert aufgenommen. Der Bedarf, eine einfache IF-Anweisung in SQL*Forms
programmieren zu können, war groß, der Bedarf nach Stapelverarbeitung mit mehreren
SQL-Anweisungen überwältigend.
Nur wenigen Entwicklern war zu diesem Zeitpunkt klar, daß die eigentliche Motivation
und die treibende Vision hinter PL/SQL der Wunsch war, Programmsteuerung in Produkten wie SQL*Forms anbieten zu können. Schon früh in der Produktgeschichte der
Oracle-Datenbank und der dazugehörigen Werkzeuge hatte die Firma Oracle zwei
Hauptschwächen ihrer Architektur erkannt: mangelnde Portierbarkeit und Probleme mit
der Ausführungsberechtigung.
Bessere Portierbarkeit der Anwendungen durch PL/SQL
Die Bedenken hinsichtlich der Portierbarkeit mögen denjenigen, die mit den Marketingund technischen Strategien der Oracle Corporation vertraut sind, merkwürdig vorkommen. Schließlich war eines der herausragenden Merkmale der Oracle-Lösung seit den
frühen achtziger Jahren ihre Portierbarkeit. Zu dem Zeitpunkt, als PL/SQL erschien, lief
das C-basierte RDBMS auf vielen verschiedenen Betriebssystemen und Hardware-Plattformen. SQL*Plus und SQL*Forms ließen sich leicht an eine Reihe von Terminalkonfigurationen anpassen. Und trotzdem gab es immer noch viele Anwendungen, die eine
bessere Kontrolle benötigten, wie sie Sprachen wie COBOL, C und FORTRAN bieten.
Aber sobald ein Entwickler sich außerhalb der plattformunabhängigen Oracle-Werkzeuge bewegte, war die resultierende Anwendung nicht mehr portierbar.
Die Sprache PL/SQL zielt darauf ab, daß immer mehr Anwendungsanforderungen vollständig in betriebssystemunabhängigen Entwicklungswerkzeugen implementiert werden
können. Mittlerweile haben auch Java und andere Programmiersprachen die Portierbar-
Die Ursprünge von PL/SQL
|
5
keit stark erhöht. Dennoch bleibt PL/SQL auf diesem Gebiet immer noch der Vorreiter
und ermöglicht den Entwicklern natürlich nach wie vor, äußerst portierbare Anwendungen zu schreiben.
Verbesserte Ausführungsberechtigungen und Transaktionsintegrität
Ein noch größeres Problem als das der Portierbarkeit war das der Ausführungsberechtigung. In RDBMS und der Sprache SQL können Sie Zugriff und Änderungen auf jeder
Datenbanktabelle sehr fein einstellen. Beispielsweise können Sie mit dem GRANT-Befehl
sicherstellen, daß nur bestimmte Rollen und Benutzer die Daten einer Tabelle mit einer
UPDATE-Operation ändern können. Auf der anderen Seite kann diese GRANT-Anweisung nicht sicherstellen, daß auch alle UPDATE-Anweisungen, die ein Benutzer oder
eine Anwendung ausführen möchte, korrekt ausgeführt werden. Mit anderen Worten:
Die Datenbank kann nicht die Integrität einer Transaktion garantieren, die sich über
mehr als eine Tabelle erstreckt, wie es bei den meisten Geschäftstransaktionen der Fall
ist.
Das Geheimnis hinter dieser Ebene der Transaktionsintegrität ist das Konzept der Ausführungsberechtigung (execution authority, auch run authority). Anstatt einer Rolle oder
einem Benutzer das Recht zuzugestehen, eine Tabelle ändern zu dürfen, gestehen Sie nur
das Recht zu, eine Prozedur auszuführen. Diese Prozedur kontrolliert nicht nur den
Zugriff auf die zugrundeliegenden Datenstrukturen, sondern stellt ihn auch bereit. Sie
gehört einem speziellen Oracle RDBMS-Benutzer, der wiederum über die eigentlichen
Änderungsberechtigungen für die betroffenen Tabellen verfügt. Die Prozedur wird damit
zu einem »Torwächter« für den Übertragungsvorgang. Ein Programm (unabhängig
davon, ob es nun eine Oracle Forms-Anwendung oder ein Pro*C-Programm ist) kann die
Übertragung ausschließlich über die Prozedur ausführen. Als Resultat wird die Transaktionsintegrität garantiert.
Bescheidene Anfänge, stetige Verbesserungen
Während Oracle daran arbeitete, aus Java eine Alternative zu PL/SQL für Datenbanken
zu machen, wurde gleichzeitig PL/SQL stetig und von Grund auf verbessert. Oracle fügte
eine Vielzahl von Built-in-Packages hinzu, die PL/SQL in die verschiedensten Richtungen
erweiterte. Außerdem bekam die Sprache objektorientierte Fähigkeiten, diverse Arrayähnliche Datenstrukturen und ganz allgemein mehr Umfang und Tiefe.
SQL mag vielleicht sehr mächtig sein, aber nicht mächtig und flexibel genug, um vollständige Anwendungen damit zu schreiben. Mit PL/SQL von Oracle ist sichergestellt,
daß Sie in der betriebssystemunabhängigen Oracle-Umgebung bleiben und dennoch
hocheffiziente Anwendungen entwickeln können, die den Anforderungen der Benutzer
gerecht werden.
6 |
Kapitel 1: Einführung in PL/SQL
">