Datenbanken: Prozedurales SQL

Datenbanken: Prozedurales SQL Anwendungsentwicklung für relationale Datenbanken setzt voraus, dass prozedurale Abläufe programmiert werden können! (Endanwendern ist nicht zuzumuten, SQL zu lernen und selbst Anfragen oder Manipulationsstatements zu formulieren) Es gibt zwei Ansätze: 1. SQL erweitern um prozedurale Sprachkonstrukte Ergebnis: Standard SQL-99 Erweiterung um Trigger, Module und Prozeduren 2. bestehende 3GLs erweitern um die Möglichkeit, SQL Statements zu verarbeiten Ergebnis: Standard SQL-99 Call Level Interface und Realisierungen in C (ODBC), C++, Java (JDBC), etc.... 1

SQL-99 Standard Erweiterung um prozedurale Konstrukte: Im Standard SQL-99 werden prozedurale Erweiterungen an 3 Stellen behandelt: 1. Im Zusammenhang mit Triggern 2. Im Zusammenhang mit Persistent Stored Modules (PSM) 3. Im Zusammenhang mit SQL Invoked Routines 2

Trigger Trigger sind Ereignis gesteuerte Programme, die einer Tabelle zugeordnet sind und beim Eintreten des Ereignisses für diese Tabelle den programmierten Code ausführen. Mögliche Ereignisse sind: insert bzgl. der dem Trigger zugeordneten Tabelle; update bzgl. der dem Trigger zugeordneten Tabelle; delete bzgl. der dem Trigger zugeordneten Tabelle; 3

Trigger Beispiel (PostgreSQL): create or replace function proc_doznr returns trigger as $proc_doznr$ begin new.doznr := nextval( doznr_seq ); return new; end; $proc_doznr$ language plpgsql; / create or replace trigger t_doznr before insert on dozent for each row execute procedure proc_doznr(); / 4

Trigger Beispiel (Oracle): create or replace trigger t_doznr before insert on dozent for each row Begin select doznr_seq.nextval into :new.doznr from dual; End; / 5

Trigger Trigger sind Datenbankobjekte, die also über ein create trigger Statement erzeugt, und ein drop trigger Statement gelöscht werden. Standard SQL-99 Syntax: create trigger <triggername> BEFORE AFTER < trigger event > ON < Table name > [ REFERENCING { OLD NEW } [ ROW ] [ AS ] < alias name > ] < triggered action >; < trigger event > ::= INSERT DELETE UPDATE [ OF < column comma list > ] < triggered action> ::= [ FOR EACH ROW ] [ WHEN < search condition > ] SQL Statement BEGIN ATOMIC { SQL Statement } END 6

Trigger Beispiel: CREATE TRIGGER t_personentab AFTER delete ON Personentab REFERENCING OLD AS del_row FOR EACH ROW BEGIN ATOMIC insert into Protokoll values ('Ein Datensatz in Personentab wurde gelöscht', current_date); insert into Personentab_save values (del_row.persnr, del_row.name); END; Warnung: Die Syntax beim Datenbankhersteller ORACLE und PostgreSQL ist etwas anders!! (siehe später) 7

Trigger Erläuterungen: CREATE TRIGGER t_personentab AFTER delete ON Personentab CREATE TRIGGER t_personentab AFTER delete ON Personentab CREATE TRIGGER t_personentab AFTER delete ON Personentab CREATE TRIGGER t_personentab AFTER delete ON Personentab REFERENCING OLD AS del_row Zündzeitpunkt für den Trigger. Hier: nach dem delete Ereignis, auf das der Trigger reagiert. Hier: delete Tabelle der der Trigger zugeordnet ist. Hier: Personentab Mit welchem Alias kann der Datensatz im Fokus des Triggers referenziert werden: del_row Bei delete kann nur OLD verwendet werden, bei insert nur NEW, bei update beides! 8

Trigger Erläuterungen: CREATE TRIGGER t_personentab AFTER delete ON Personentab REFERENCING OLD AS del_row FOR EACH ROW Wie oft der Trigger zünden soll: für jedes Statement einmal (default), oder für jede Zeile einmal. Beispiel: Annahme: in der Tabelle Personentab gibt es 10 Datensätze mit dem Namen Meier. Das Statement: delete from Personentab where name = Meier ; wird ausgeführt. a) FOR EACH ROW ist spezifiziert: der Trigger zündet 10 mal (und schreibt 10 Datensätze in die Tabelle Protokoll. b) FOR EACH ROW ist nicht spezifiziert: der Trigger zündet nur einmal. 9

Trigger Erläuterungen: CREATE TRIGGER t_personentab AFTER delete ON Personentab REFERENCING OLD AS del_row FOR EACH ROW WHEN gebdat < '01.01.1950' Genauere Spezifikation, wann der Trigger zünden soll. (optional!!) Im Beispiel: ist die obige WHEN Klausel spezifiziert, wird das delete Statement auf jeden Fall ausgeführt, der Trigger zündet aber nur, wenn die Bedingung erfüllt ist, d.h. wenn Datensätze gelöscht werden von Personen, deren Geburtsdatum vor dem 1.1.1950 liegt! 10

Trigger Erläuterungen: CREATE TRIGGER t_personentab AFTER delete ON Personentab REFERENCING OLD AS del_row FOR EACH ROW WHEN gebdat < '01.01.1950' BEGIN ATOMIC... END Angabe der Aktion, die der Trigger ausführen soll. Ist nur ein Statement angegeben, das der Trigger ausführen soll, kann die Klammer BEGIN ATOMIC... END weggelassen werden: CREATE TRIGGER t_personentab AFTER delete ON Personentab REFERENCING OLD AS del_row FOR EACH ROW insert into Personentab_save values (del_row.persnr, del_row.name); Sollen mehrere Statements ausgeführt werden, müssen diese von BEGIN ATOMIC und END umklammert werden. 11

Trigger Erläuterungen: CREATE TRIGGER t_personentab AFTER delete ON Personentab REFERENCING OLD AS del_row FOR EACH ROW BEGIN ATOMIC... END Angabe der Aktion, die der Trigger ausführen soll. ATOMIC bedeutet: es müssen alle Statements des Triggers ausführbar sein! Kann eines nicht ausgeführt werden, wird keines ausgeführt und alle bis dahin bereits ausgeführten Statements werden wieder zurückgenommen, inklusive des auslösenden SQL-Statements!! 12

Trigger Erläuterungen: CREATE TRIGGER t_personentab AFTER delete ON Personentab REFERENCING OLD AS del_row FOR EACH ROW BEGIN ATOMIC... END Angabe der Aktion, die der Trigger ausführen soll. Ist im Trigger BEFORE spezifiziert, sind folgende Statements als Triggeraction möglich: DECLARE CURSOR, OPEN, CLOSE, FETCH, SELECT (single row), FREE LOCATOR, HOLD LOCATOR, RETURN, GET DIAGNOSTICS. Ist im Trigger AFTER spezifiziert, sind folgende Statements als Triggeraction möglich: Alle Statements wie bei BEFORE, zusätzlich: INSERT, UPDATE, DELETE, CALL (Aufruf einer beliebigen SQL invoked routine) 13

Trigger Es scheint so zu sein, dass alle Sprachkonstrukte, die im Zusammenhang mit Persistent Stored Modules (PSM) im Standard definiert sind (LOOP, IF, etc....), in Triggern und SQL-Invoked Routines möglich sind. Aktionen sollten nur dann durch Trigger ausgeführt werden, wenn sie nicht bereits durch Constraints realisierbar sind! (Constraints beachten Gegenwart und Zukunft bzgl. der Daten, Trigger nur zukünftige Datenänderungen) Die Implementierung eines Triggerkonzepts ist bei den verschiedenen Datenbankherstellern durchaus unterschiedlich in Umfang und Syntax! Trigger können gelöscht werden durch das Statement: DROP TRIGGER < trigger name >; bzw. ALTER TABLE <tabname> DROP TRIGGER < trigger name>; 14

Datenbanken: PL / SQL (ORACLE) Trigger Bei der Implementierung des Trigger Konzepts des Herstellers ORACLE sind alle prozeduralen Sprachkonstrukte als triggered action erlaubt! Das single row select Statement ist realisiert als select into. Begin ATOMIC hat Oracle nicht implementiert! insert, update, delete oder select Statements im Trigger auf die Tabelle, der der Trigger zugeordnet ist, sind verboten! Transaktions-Statements im Trigger sind verboten. Die Referenz-Aliasnamen für OLD und NEW müssen mit einem vorangestellten Doppelpunkt versehen sein (wie host Variable): CREATE TRIGGER t_personentab AFTER delete ON Personentab REFERENCING OLD AS del_row FOR EACH ROW BEGIN insert into Personentab_save values (:del_row.persnr, :del_row.name); END; 15

Datenbanken: PL / SQL (ORACLE) Trigger In einem Trigger können mehrere Ereignisse behandelt werden: create trigger t_personentab after insert or delete or update on Personentab for each row Begin if inserting then < action statements >... end if; if deleting then < action statements >... end if; if updating then < action statements >... end if; End; 16

Datenbanken: PL / SQL (ORACLE) Trigger Trigger können vorübergehend deaktiviert und wieder aktiviert werden: Alter Trigger < trigger name > DISABLE; Alter Trigger < trigger name > ENABLE; Um Trigger zu erzeugen, braucht man das Systemrecht create trigger: als DBA: grant create trigger to < user >; PL / SQL Objekte können mit dem SQLDeveloper entwickelt werden! Zur Erzeugung kann das create or replace Statement für alle Datenbankobjekte benutzt werden. Dabei werden eventuell bereits existierende Objekte überschrieben. Wie im Standard darf ein Trigger keine DDL - und keine Transaktions - Statements enthalten. Die triggered action wird in die Transaktion des auslösenden SQL- Statements eingebettet. 17

Datenbanken: PL / SQL (ORACLE) Trigger Beispiel: create table watch_protokoll (protnr integer, Aktion varchar(10), Benutzer varchar2(15), persnr integer, name_alt varchar2(30), name_neu varchar2(30), Löschdatum date); create sequence protnr_seq; create or replace trigger t_watchdog after delete or update of name on Person for each row begin if deleting then insert into watch_protokoll (select protnr_seq.nextval, 'Delete', user, :old.persnr, :old.name, NULL, sysdate from dual); end if; if updating then insert into watch_protokoll (select protnr_seq.nextval, 'Update', user, :old.persnr, :old.name, :new.name, sysdate from dual); end if; End; / 18

Datenbanken: PL / SQL (PostgreSQL) Trigger Ein Trigger kann nur eine sogenannte user-defined Trigger-Function ausführen! Diese enthält das Programm, das der Trigger ausführen soll. Das single row select Statement ist realisiert als select into. Begin ATOMIC hat PostgreSQL nicht implementiert! insert, update, delete oder select Statements im Trigger auf die Tabelle, der der Trigger zugeordnet ist, sind verboten! Transaktions-Statements im Trigger sind verboten. Verwendung von OLD und NEW bzw. ihre Referenz-Aliasnamen ohne vorangestellten Doppelpunkt! 19

Datenbanken: PL / SQL (PostgreSQL) Trigger Beispiel: create or replace function proc_doz() returns trigger as $body$ begin update dozent irgend ein update where doznr = new.doznr; return null; end; $body$ language plpgsql; / create trigger t_doz after insert on pruefung for each row execute procedure proc_doz(); / 20

Datenbanken: PL / SQL (PostgreSQL) In einem Trigger können mehrere Ereignisse behandelt werden: create or replace function proc_personentab() returns trigger as $body$ begin if (TG_OP = INSERT ) then < action statements >... elsif (TG_OP = DELETE ) then < action statements >... Trigger elsif (TG_OP = UPDATE ) then < action statements >... end if; return null; end; $body$ language plpgsql; / create trigger t_personentab after insert or update or delete on personentab for each row execute procedure proc_personentab(); / 21

Routines Im Standard SQL-99 können Prozeduren oder Funktionen erzeugt werden, die SQL-Daten verarbeiten oder auch nicht. Was möglich ist, ist im Kapitel SQL - Invoked Routines definiert. Prozeduren oder Funktionen werden über ein create procedure / create function Statement erzeugt und sind damit Datenbankobjekte wie Tabellen oder Trigger. Prozeduren oder Funktionen können durch ein explizites CALL < routine name > aufgerufen werden oder implizit in einem SQL Statement durch Angabe des Namens und der optionalen Parameter (siehe später). Prozeduren oder Funktionen werden gelöscht mit dem Statement DROP { PROCEDURE FUNCTION } < name >; 22

Routines Syntax (vereinfachte Version): CREATE PROCEDURE CREATE FUNCTION < routine name > ( [ < parameter > < data type > [ {, < parameter > < data type > }... ] ] ) [ RETURNS < data type > ] [ LANGUAGE { ADA C COBOL FORTRAN... SQL } ] [ PARAMETER STYLE { SQL GENERAL } ] [ NO SQL CONTAINS SQL READS SQL DATA MODIFIES SQL DATA ] < SQL Statement > EXTERNAL [ NAME <external routine name > ] 23

Routines Erläuterungen: Bei Funktionen ist die RETURNS Deklaration Pflicht! Außerdem muss im routine body eine RETURN Anweisung stehen! LANGUAGE und PARAMETER STYLE Anweisungen sind nur interessant, wenn externe Prozeduren / Funktionen erzeugt werden bzw. darauf verwiesen wird. SQL Statement kann entweder ein einzelnes SQL Statement sein oder eine Gruppe von SQL Statements, eingeklammert durch BEGIN ATOMIC... END. Parameter können deklariert werden, es gibt 3 unterschiedliche Typen: IN, OUT oder INOUT. Default ist IN. Werden keine Parameter deklariert, muss trotzdem die Klammerung () stehen! In der Routine dürfen keine DDL- oder Transaktions-Statements stehen! 24

Routines Beispiele: CREATE PROCEDURE resetname() MODIFIES SQL DATA update Personentab set name = NULL; CREATE FUNCTION maxgebdat () RETURNS Date CONTAINS SQL RETURN (select max(gebdat) from Personentab ); CREATE PROCEDURE updatedb ( vpersnr integer, vgebdat date, vort varchar(40)) MODIFIES SQL DATA BEGIN ATOMIC update Personentab set gebdat = vgebdat where persnr = vpersnr; update Adressentab set ort = vort where persnr = vpersnr; 25 END;

Routines Aufruf der Routines: CREATE PROCEDURE resetname() MODIFIES SQL DATA update Personentab set name = NULL; CALL resetname(); CREATE FUNCTION maxgebdat () RETURNS Date CONTAINS SQL RETURN (select max(gebdat) from Personentab ); select * from Personentab where gebdat < maxgebdat(); 26

PSM Ein Persistent Stored Module (PSM) ist ein Datenbankobjekt, das eine oder mehrere Prozeduren enthält und einen eindeutigen Namen besitzt. Syntax (vereinfacht): CREATE MODULE < modul-name > < SQL-Invoked Routine >; END MODULE; ALTER MODULE < modul-name > { ADD DROP } < modul contents >; DROP MODULE < modul-name; 27

PSM Beispiel: CREATE MODULE Test_Modul DECLARE Procedure resetname() modifies SQL data update Personentab set name = NULL; DECLARE Function maxgebdat () RETURNS Date CONTAINS SQL RETURN (select max(gebdat) from Personentab ); END MODULE; 28

PSM Im Zusammenhang mit PSM sind unter anderem die folgenden prozeduralen Sprachkonstrukte im Standard definiert, die dann in im Modul deklarierten Prozeduren oder Funktionen verwendet werden können: [ < label >: ] BEGIN [ [NOT] ATOMIC ] [ < variable declaration >;... ] [ < DECLARE Cursor statement >;... ] [ < handler declaration >;... ] [ < Assignment Statement >;... ] [ < program control statement >... ] [ < SQL statement >;... ] END [ < label > ] Default für die BEGIN... END Klammer ist NOT ATOMIC. Ist ATOMIC gesetzt, dürfen keine Transaktionsstatements vorkommen! 29

PSM Beispiel: create module Test declare procedure testproc() testproclabel: begin atomic declare v integer; set v = 27; while x < 50 do set v = x + 1; end while; insert into testtab (nr) values (v); end testproclabel; end module; 30

PSM Zum BEGIN... END Block: Im Deklarationsteil sind möglich: Variablen-, Cursor- oder Handler- Deklaration Variablendeklaration: DECLARE < var-name > < var-typ > [ DEFAULT < value > ]; Beispiel: DECLARE pi double default 3.14; 31

PSM Zum BEGIN... END Block: Program Control Statements Im Standard SQL-99 sind folgende Kontrollstrukturen definiert: IF Statement LEAVE Statement LOOP Statement WHILE Statement REPEAT Statement FOR Statement CASE Statement ITERATE Statement 32

PSM Zum BEGIN... END Block: Program Control Statements IF Statement: IF < condition > THEN < SQL statement list > [ ELSEIF < condition > THEN < SQL statement list > ] [ ELSE < SQL statement list > ] END IF; LEAVE Statement: LEAVE < labelname >; 33

PSM Zum BEGIN... END Block: Program Control Statements LOOP Statement: [ < labelname > : ] LOOP < SQL statement list> < assignment > END LOOP [ < labelname > ]; WHILE Statement: [ < labelname > :] WHILE < condition > DO < SQL statement list > < assignment > END WHILE [ < labelname > ]; 34

PSM Zum BEGIN... END Block: Program Control Statements REPEAT Statement: [ < labelname > : ] REPEAT < SQL statement list> < assignment > UNTIL < condition > END REPEAT [ < labelname > ]; FOR Statement: [ < labelname > :] FOR < loop variable > AS [ < cursor name > [ ASENSITIVE SENSITIVE INSENSITIVE ] ] CURSOR FOR < select statement > [ ORDER BY clause ] [ FOR Update clause] DO < SQL statement list > < assignments > END FOR [ < labelname > ]; 35

PSM Zum BEGIN... END Block: Program Control Statements CASE Statement: CASE WHEN < condition > THEN < statements > [ WHEN < condition > THEN < statements >... ] [ ELSE < statements > ] END CASE; ITERATE Statement: ITERATE < labelname >; (Das ITERATE Statement kann nur innerhalb eines Loops stehen und bewirkt, dass zum Beginn des Loops (identifiziert über den Labelnamen) zurückgesprungen wird und der Loop neu ausgeführt wird.) 36

PSM Zum BEGIN... END Block: CURSOR Cursordeklaration: DECLARE < cursor-name > [ < cursor sensitivity > ] [ SCROLL ] CURSOR FOR < cursor specification >; < cursor sensitivity >::= SENSITIVE INSENSITIVE ASENSITIVE < cursor specification >::= < select-statement > [ < order by clause > ] [ FOR { READ ONLY UPDATE [ OF < column list > ] ] SENSITIVE : arbeitet direkt auf der Tabelle des select-statements, d.h. Änderungen an dieser Tabelle sind für den Cursor sichtbar! INSENSITIVE : arbeitet mit einer Kopie der Tabelle des select-statements, d.h. Änderungen an dieser Tabelle sind für den Cursor nicht sichtbar! ASENSITIVE : Default! Ob mit einer Kopie gearbeitet wird und/oder Änderungen sichtbar sind, ist Implementierungs abhängig. 37

PSM Zum BEGIN... END Block: CURSOR Ist ein Cursor deklariert, kann im ausführbaren Teil mit den folgenden Operationen mit ihm gearbeitet werden: OPEN < cursorname >; FETCH [ <fetch orientation> ] FROM < cursorname > INTO < fetch variable list >; < fetch orientation >::= NEXT PRIOR FIRST LAST {ABSOLUTE RELATIVE } < value > Ist SCROLL gesetzt, sind alle fetch Orientierungen möglich. Sonst nur NEXT! CLOSE < cursorname >; 38

PSM Zum BEGIN... END Block: CURSOR Beispiel: BEGIN ATOMIC Declare c_test CURSOR for select name, vorname from personentab FOR UPDATE; Declare vname varchar(20); Declare vvname varchar(20); OPEN c_test; FETCH NEXT FROM c_test INTO vname, vvname; set vname = vname testname ; set vvname = vvname testvorname ; update personentab set name = vname, vorname = vvname where CURRENT OF c_test; END; close c_test; 39

PSM Zum BEGIN... END Block: Erläuterungen: CURSOR Der Beispielcursor hat als Ergebnistabelle alle Namen und Vornamen aus der Tabelle Personentab. Mit dem OPEN-Befehl wird das dem Cursor zugeordnete select Statement ausgeführt und ein Zeiger vor den ersten Datensatz der Ergebnistabelle gesetzt. Mit dem FETCH NEXT-Befehl wird hier der erste Datensatz in die Variablen vname und vvname eingefügt. Will man mit mehr Datensätzen arbeiten, muss man das FETCH in eine Schleife (LOOP) einbetten. Siehe später. Das update Statement ist ein sogenanntes positioniertes Update, d.h. da der Cursor FOR UPDATE gesetzt ist, kann im update Statement durch where CURRENT OF c_test auf den Datensatz Bezug 40 genommen werden, der gerade im Fokus des Cursors ist.

PSM Zum BEGIN... END Block: HANDLER (Exception handling) Handler Deklaration: DECLARE < handler type > HANDLER FOR < condition value list > < handler action >; < handler type > ::= CONTINUE EXIT UNDO < condition value list > ::= < value > [ {, < value > }... ] < value > ::= < sqlstate value > < condition name > SQLEXCEPTION SQLWARNING NOT FOUND < handler action > ::= < SQL statement > < assignment > 41

PSM Zum BEGIN... END Block: HANDLER (Exception handling) Beispiel: BEGIN Declare my_error CONDITION FOR 23000 ; Declare v char(12) DEFAULT okay ; Declare CONTINUE HANDLER FOR 22003 SET v = Overflow ; Declare EXIT HANDLER FOR my_error insert into protokoll(string) values ( Constraint Fehler ); Declare CONTINUE HANDLER FOR NOT FOUND SET v = Nix gefunden ; insert into Testtab1 (beschreibung) values(1234567); insert into Testtab2 (beschreibung) values(v); END; 42

PSM Zum BEGIN... END Block: HANDLER (Exception handling) Erläuterungen: Im ersten Declare Statement wird ein Nutzer-definierter Name für einen Wert von SQLSTATE deklariert (sqlstate ist eine 5 Zeichen lange Systemvariable, die den Zustand eines ausgeführten SQL Statements erfasst). Ist das Attribut beschreibung der Tabelle Testtab1 nur 5 Zeichen lang, wird durch das erste insert-statement eine Overflow-Exception ausgelöst, d.h. die Variable v erhält durch den Handler den Wert Overflow. Die Abarbeitung geht aber weiter, da es ein CONTINUE Handler ist! Wird während der Verarbeitung ein Constraint verletzt, wird der Handler für my_error ausgelöst und die Abarbeitung beendet (EXIT Handler). 43

Datenbanken: ORACLE: PL / SQL Der Datenbankhersteller ORACLE erlaubt die Verwendung aller Kontrollstrukturen in Triggern, Prozeduren und Funktionen. ORACLE kennt keine MODULEs, hier heißen sie PACKAGE. Die Erzeugung eines Package zerfällt in zwei Teile: CREATE PACKAGE... CREATE PACKAGE BODY... Die DECLARE Section muss vor dem BEGIN.. END - Block liegen. Das Exception-Handling wird in einem eigenen Block EXCEPTION innerhalb des BEGIN... END - Blocks formuliert. ORACLE stellt wesentlich mehr System-Exceptions zur Verfügung, als im Standard vorgesehen. 44

Datenbanken: ORACLE: PL / SQL In Prozeduren und Funktionen können lokale Variable deklariert werden, allerdings nur ohne das Schlüsselwort DECLARE! Hat eine Prozedur oder Funktion keine Parameter, darf keine Klammer hinter dem Namen stehen. Die CURSOR Deklaration hat eine andere Syntax. Der Quelltext zur Erzeugung eines PL/SQL Objekts muss in der letzten Zeile als einziges Zeichen einen Slash enthalten. Wird ein PL/SQL-Objekt mit Fehlern erstellt, kann man sich diese in der SQLPlus-Shell mit dem Befehl show errors anzeigen lassen. BEGIN ATOMIC... END ist nicht implementiert! 45

Datenbanken: ORACLE: PL / SQL Beispiele: Package create or replace package testpack as procedure Personselect; procedure Persondelete(vpersnr integer); end; / create or replace package body testpack as procedure Personselect is begin insert into testprotokoll (select persnr, vorname ' ' name from Person); end Personselect; procedure Persondelete(vpersnr integer) is begin delete from testprotokoll where persnr = vpersnr; end Persondelete; end testpack; / 46

Beispiele: Datenbanken: stored procedure ORACLE: PL / SQL create or replace procedure hauserein is i integer; Begin for i in 1..1000 loop insert into Personentab values(persnr_seq.nextval, 'Meier' i, 'Sabine' i, '01.07.19' substr(i,1,2),'w'); end loop; commit; End; / create or replace procedure delbypersnr(ipersnr integer) is Begin delete from adressentab where persnr = ipersnr; delete from hobbies where persnr = ipersnr; delete from ausbildungen where persnr = ipersnr; delete from beruf where persnr = ipersnr; delete from Personentab where persnr = ipersnr; End; / 47

Beispiele: Datenbanken: Exception handling ORACLE: PL / SQL DECLARE c varchar2(40); name1 Personentab.name%TYPE; name2 Personentab.vorname%TYPE; zulang exception; BEGIN select name, vorname into name1, name2 from Personentab where name like 'Z%'; c := substr(name2,1,1) '.' name1; IF length(c) > 40 THEN RAISE zulang; END IF; insert into test(string) values(c); EXCEPTION WHEN NO_DATA_FOUND THEN insert into test(string) values('nix da'); WHEN TOO_MANY_ROWS THEN insert into test(string) values('zuviel da'); WHEN zulang THEN c:= substr(name2,1,1) '.' substr(name1,1,37); insert into test(string) values(c); WHEN OTHERS THEN insert into test(string) values('unbekannter Fehler aufgetreten'); END; / 48

Beispiele: Datenbanken: Cursor ORACLE: PL / SQL create or replace procedure setgehalt(i_zuwachs number, i_abnahme number) is cursor c_gehalt is select gehalt from beruf where beendet is null FOR UPDATE of gehalt; v_gehalt beruf.gehalt%type; Begin open c_gehalt; loop fetch c_gehalt into v_gehalt; exit when c_gehalt%notfound; IF v_gehalt <= 3000 THEN update beruf set gehalt = gehalt + i_zuwachs where CURRENT OF c_gehalt; ELSIF v_gehalt > 3000 THEN update beruf set gehalt = gehalt - i_abnahme where CURRENT OF c_gehalt; END IF; end loop; close c_gehalt; End; / 49