Oracle9i. Programowanie w języku PL/SQL

Wydawnictwo Helion

ul. Chopina 6

44-100 Gliwice

tel. (32)230-98-63

e-mail: [email protected]

PRZYK£ADOWY ROZDZIA£PRZYK£ADOWY ROZDZIA£

IDZ DOIDZ DO

ZAMÓW DRUKOWANY KATALOGZAMÓW DRUKOWANY KATALOG

KATALOG KSI¥¯EKKATALOG KSI¥¯EK

TWÓJ KOSZYKTWÓJ KOSZYK

CENNIK I INFORMACJECENNIK I INFORMACJE

ZAMÓW INFORMACJEO NOWO�CIACH

ZAMÓW INFORMACJEO NOWO�CIACH

ZAMÓW CENNIKZAMÓW CENNIK

CZYTELNIACZYTELNIA

FRAGMENTY KSI¥¯EK ONLINEFRAGMENTY KSI¥¯EK ONLINE

SPIS TRE�CISPIS TRE�CI

DODAJ DO KOSZYKADODAJ DO KOSZYKA

KATALOG ONLINEKATALOG ONLINE

Oracle9i. Programowanie

w jêzyku PL-SQL

Autor: Scott Urman

T³umaczenie: Rados³aw Meryk

ISBN: 83-7361-065-0

Format: B5, stron: 536

Wykorzystanie wbudowanego w system Oracle jêzyka PL/SQL w znacz¹cy sposób

zwiêksza wydajno�æ programisty systemów bazodanowych. PL/SQL ³¹czy w sobie

mo¿liwo�ci i elastyczno�æ jêzyka czwartej generacji (4GL) SQL z konstrukcjami

proceduralnymi jêzyka trzeciej generacji (3GL). Konstrukcje proceduralne s¹ w pe³ni

zintegrowane z Oracle SQL, co daje w rezultacie jêzyk strukturalny o ogromnym

potencjale. Programy napisane w tym jêzyku umo¿liwiaj¹ obs³ugê danych zarówno

w samym systemie Oracle, jak i w zewnêtrznych aplikacjach.

Ksi¹¿ka „Oracle9i. Programowanie w jêzyku PL/SQL” wyja�nia g³ówne w³a�ciwo�ci

jêzyka oraz ró¿nice w PL/SQL dla ró¿nych wersji bazy danych. Dziêki niej nauczysz siê

projektowaæ, testowaæ i uruchamiaæ aplikacje PL/SQL dzia³aj¹ce w wielu �rodowiskach,

jak równie¿ poznasz szczegó³y zastosowania jêzyków SQL i PL/SQL, obs³ugi b³êdów,

zbioru podprogramów i pakietów, a tak¿e wiele zaawansowanych w³a�ciwo�ci.

Niniejsza pozycja umo¿liwia:

• Zapoznanie siê z ró¿nymi �rodowiskami programistycznymi jêzyka PL/SQL,

których kopie znajduj¹ siê na do³¹czonej p³ycie CD

• Poznanie szczegó³ów sk³adni jêzyka PL/SQL: zmienne, typy danych, wyra¿enia,

operatory oraz struktury steruj¹ce

• Zapewnienie spójno�ci danych dziêki instrukcjom sterowania transakcjami

dostêpnym w SQL-u

• Wykorzystanie kursorów, które pozwalaj¹ na tworzenie zapytañ zwracaj¹cych

wiele wierszy oraz jawn¹ kontrolê przetwarzania instrukcji SQL

• Tworzenie programów PL/SQL, które wykrywaj¹ i inteligentnie reaguj¹ na b³êdy

fazy wykonania

• Wykorzystanie mo¿liwo�ci tworzenia kolekcji wielopoziomowych w systemie

Oracle9i

• Tworzenie i korzystanie z procedur, funkcji i pakietów

• Tworzenie wyzwalaczy DML zastêpuj¹cych i systemowych w celu wymuszania

z³o¿onych ograniczeñ danych

• Korzystanie z zalet jêzyka PL/SQL, takich jak: procedury zewnêtrzne, wbudowany

dynamiczny SQL, masowe powi¹zania oraz typy obiektowe

http://helion.pl/view/2547w



http://helion.pl/add/2547w/or9pls




mailto:[email protected]

http://helion.pl/view/2547w/or9pls.htm

Spis treści

O Autorze.................................................................................................................13

Wstęp......................................................................................................................15

Część I Wstęp i środowiska programisty ...........................................21

Rozdział 1. Wprowadzenie do języka PL/SQL............................................................23Dlaczego język PL/SQL?............................................................................................... 23PL/SQL a praca w sieci............................................................................................ 25Normy.................................................................................................................... 26

Właściwości języka PL/SQL.......................................................................................... 26Struktura bloku ....................................................................................................... 26Obsługa błędów....................................................................................................... 27Zmienne i typy danych............................................................................................. 27Instrukcje warunkowe.............................................................................................. 28Konstrukcje pętli ..................................................................................................... 29Kursory .................................................................................................................. 29Procedury i funkcje ................................................................................................. 30Pakiety ................................................................................................................... 31Kolekcje ................................................................................................................. 32

Konwencje stosowane w książce .................................................................................... 32Wersje języka PL/SQL oraz bazy danych Oracle........................................................ 32Czcionki ................................................................................................................. 34Dokumentacja Oracle .............................................................................................. 34Kod dostępny na płycie CD...................................................................................... 34

Przykładowe tabele ....................................................................................................... 35Podsumowanie.............................................................................................................. 40

Rozdział 2. Środowiska programisty oraz wykonawcze..............................................41Modele aplikacji a PL/SQL............................................................................................ 41Model dwuwarstwowy............................................................................................. 41Model trójwarstwowy.............................................................................................. 45Połączenie z bazą danych......................................................................................... 46

Narzędzia programisty PL/SQL...................................................................................... 47Program SQL*Plus.................................................................................................. 48Program Rapid SQL ................................................................................................ 52Program DBPartner Debugger .................................................................................. 56Program SQL Navigator........................................................................................... 60Program TOAD....................................................................................................... 64Program SQL-Programmer....................................................................................... 68Program PL/SQL Developer..................................................................................... 71Narzędzia programistyczne — podsumowanie ........................................................... 73

Podsumowanie.............................................................................................................. 74

6 Oracle9i. Programowanie w języku PL/SQL

Część II Podstawowe właściwości języka PL/SQL..............................75

Rozdział 3. Podstawy języka PL/SQL .......................................................................77Blok PL/SQL................................................................................................................ 77Podstawowa struktura bloku..................................................................................... 82

Jednostki leksykalne ...................................................................................................... 84Identyfikatory ......................................................................................................... 84Ograniczniki ........................................................................................................... 87Literały................................................................................................................... 87Komentarze ............................................................................................................ 89

Deklaracje zmiennych.................................................................................................... 91Składnia deklaracji .................................................................................................. 91Inicjowanie zmiennych ............................................................................................ 93

Typy danych w języku PL/SQL...................................................................................... 93Typy skalarne ......................................................................................................... 94Typy złożone ........................................................................................................ 103Typy odnośników.................................................................................................. 103Typy LOB............................................................................................................ 103Typy obiektowe .................................................................................................... 104Wykorzystanie atrybutu %Type.............................................................................. 104Podtypy definiowane przez użytkownika ................................................................. 105Konwersja pomiędzy typami danych....................................................................... 106Zakres i widoczność zmiennej ................................................................................ 108

Wyrażenia i operatory.................................................................................................. 109Przypisanie ........................................................................................................... 109Wyrażenia ............................................................................................................ 110

Struktury sterowania PL/SQL ...................................................................................... 113Instrukcja IF-THEN-ELSE..................................................................................... 113Instrukcja CASE ................................................................................................... 117Pętle..................................................................................................................... 121Instrukcje GOTO oraz etykiety ............................................................................... 125Dyrektywy pragma................................................................................................ 127

Rekordy w języku PL/SQL .......................................................................................... 128Przypisanie rekordu............................................................................................... 129Zastosowanie operatora %ROWTYPE.................................................................... 131

Styl programowania w języku PL/SQL ......................................................................... 131Wprowadzanie komentarzy .................................................................................... 132Styl nazw zmiennych............................................................................................. 133Stosowanie dużych liter ......................................................................................... 133Stosowanie odstępów............................................................................................. 133Ogólne uwagi dotyczące stylu programowania ......................................................... 134

Podsumowanie............................................................................................................ 134

Rozdział 4. SQL w języku PL/SQL ..........................................................................135Instrukcje SQL ........................................................................................................... 135Wykorzystanie instrukcji SQL w języku PL/SQL..................................................... 136Stosowanie dynamicznego SQL.............................................................................. 137

Stosowanie instrukcji DML w języku PL/SQL............................................................... 137Instrukcja SELECT ............................................................................................... 139Instrukcja INSERT................................................................................................ 141Instrukcja UPDATE .............................................................................................. 142Instrukcja DELETE............................................................................................... 143Klauzula WHERE ................................................................................................. 144Wiązania zbiorcze ................................................................................................. 147Klauzula RETURNING......................................................................................... 149

Spis treści 7

Odnośniki do tabel................................................................................................. 150Powiązania bazy danych ........................................................................................ 151Synonimy ............................................................................................................. 151

Pseudokolumny .......................................................................................................... 152Pseudokolumny CURRVAL oraz NEXTVAL.......................................................... 152Pseudokolumna LEVEL......................................................................................... 153Pseudokolumna ROWID........................................................................................ 153Pseudokolumna ROWNUM................................................................................... 154

Instrukcje GRANT i REVOKE. Uprawnienia ................................................................ 154Uprawnienia obiektowe a uprawnienia systemowe ................................................... 155Instrukcje GRANT oraz REVOKE.......................................................................... 155Role ..................................................................................................................... 157

Sterowanie transakcjami .............................................................................................. 159Instrukcja COMMIT a instrukcja ROLLBACK........................................................ 159Punkty zachowania................................................................................................ 160Transakcje a bloki ................................................................................................. 161Transakcje autonomiczne ....................................................................................... 162

Podsumowanie............................................................................................................ 167

Rozdział 5. Wbudowane funkcje SQL......................................................................169Wstęp ........................................................................................................................ 169Funkcje znakowe zwracające wartości znakowe............................................................. 170Funkcje SUBSTR, SUBSTRB, SUBSTRC, SUBSTR2 oraz SUBSTR4 ..................... 173SOUNDEX........................................................................................................... 174

Funkcje znakowe zwracające wartości liczbowe............................................................. 175Funkcje INSTR, INSTRB, INSTRC, INSTR2 oraz INSTR4 ..................................... 176Funkcje LENGTH, LENGTHB, LENGTHC, LENGTH2 ? oraz LENGTH4............... 177

Funkcje NLS .............................................................................................................. 178Funkcje numeryczne ................................................................................................... 180Funkcja WIDTH_BUCKET................................................................................... 181

Funkcje związane z datą .............................................................................................. 182Arytmetyka dat ..................................................................................................... 184

Funkcje konwersji ....................................................................................................... 186Funkcja TO_CHAR (daty lub etykiety) ................................................................... 189Funkcja TO_CHAR (liczby)................................................................................... 191Funkcja TO_DATE............................................................................................... 193Funkcja TO_NUMBER ......................................................................................... 193Funkcje TO_TIMESTAMP oraz TO_TIMESTAMP_TZ .......................................... 194

Funkcje agregacji oraz funkcje analityczne .................................................................... 194Inne funkcje ............................................................................................................... 196Funkcja DUMP..................................................................................................... 199Funkcja USERENV............................................................................................... 201

Podsumowanie............................................................................................................ 202

Rozdział 6. Kursory ...............................................................................................203Czym jest kursor? ....................................................................................................... 203Przetwarzanie kursorów jawnych............................................................................ 204Przetwarzanie kursorów niejawnych ....................................................................... 212

Pętle pobierania danych kursora ................................................................................... 214Pętle proste........................................................................................................... 214Pętle WHILE........................................................................................................ 216Pętle FOR kursora................................................................................................. 217Wyjątek NO_DATA_FOUND a atrybut %NOTFOUND.......................................... 219Kursory z klauzulą FOR UPDATE instrukcji SELECT............................................. 219


Zmienne kursora ......................................................................................................... 223Deklaracja zmiennej kursora................................................................................... 224Przydzielenie obszaru pamięci dla zmiennych kursora .............................................. 225Otwieranie zmiennej kursora dla zapytania .............................................................. 226Zamykanie zmiennych kursora ............................................................................... 227Pierwszy przykład zmiennej kursora ....................................................................... 227Drugi przykład zmiennej kursora ............................................................................ 229Ograniczenia użycia zmiennych kursora .................................................................. 230

Podsumowanie............................................................................................................ 231

Rozdział 7. Obsługa błędów ...................................................................................233Czym jest wyjątek? ..................................................................................................... 233Deklarowanie wyjątków......................................................................................... 235Zgłaszanie wyjątków ............................................................................................. 239Obsługa wyjątków................................................................................................. 240Dyrektywa pragma EXCEPTION_INIT.................................................................. 246Zastosowanie funkcji RAISE_APPLICATION_ERROR .......................................... 247

Propagacja wyjątków .................................................................................................. 250Wyjątki wywołane w sekcji wykonania ................................................................... 250Wyjątki zgłaszane w sekcji deklaracji...................................................................... 252Wyjątki zgłaszane w sekcji wyjątków...................................................................... 254

Wskazówki dotyczące wyjątków .................................................................................. 256Zakres wyjątków................................................................................................... 256Unikanie nieobsługiwanych wyjątków..................................................................... 257Maskowanie lokalizacji błędu................................................................................. 258

Ogólny program obsługi błędów................................................................................... 259Podsumowanie............................................................................................................ 266

Rozdział 8. Kolekcje..............................................................................................267Deklaracje i stosowanie typów kolekcji ......................................................................... 267Tabele indeksowane .............................................................................................. 268Tabele zagnieżdżone.............................................................................................. 272Tablice VARRAY ................................................................................................. 276Kolekcje wielopoziomowe ..................................................................................... 278Porównanie pomiędzy typami kolekcji .................................................................... 279

Kolekcje w bazie danych ............................................................................................. 281Implikacje dotyczące kolekcji zapisanych w bazie danych......................................... 281Modyfikowanie całych kolekcji .............................................................................. 285Działania z indywidualnymi elementami kolekcji ..................................................... 291

Metody kolekcji .......................................................................................................... 297EXISTS ............................................................................................................... 297COUNT ............................................................................................................... 299LIMIT.................................................................................................................. 300FIRST i LAST...................................................................................................... 301NEXT i PRIOR..................................................................................................... 301EXTEND ............................................................................................................. 302TRIM................................................................................................................... 304DELETE.............................................................................................................. 306

Podsumowanie............................................................................................................ 308

Część III Dodatkowe właściwości języka PL/SQL ..............................309

Rozdział 9. Tworzenie procedur, funkcji i pakietów.................................................311Procedury i funkcje ..................................................................................................... 311Tworzenie podprogramu ........................................................................................ 312Parametry podprogramów ...................................................................................... 318

Spis treści 9

Instrukcja CALL ................................................................................................... 336Procedury a funkcje............................................................................................... 339

Pakiety....................................................................................................................... 339Specyfikacja pakietu .............................................................................................. 339Treść pakietu ........................................................................................................ 341Pakiety i zakres ..................................................................................................... 343Przeciążanie podprogramów pakietowych................................................................ 345Inicjalizacja pakietu ............................................................................................... 348

Podsumowanie............................................................................................................ 350

Rozdział 10. Zastosowanie procedur, funkcji i pakietów...........................................351Położenie podprogramów............................................................................................. 351Podprogramy składowane oraz słownik danych........................................................ 351Podprogramy lokalne ............................................................................................. 354Podprogramy składowane a podprogramy lokalne .................................................... 359

Zagadnienia dotyczące podprogramów składowanych i pakietów .................................... 360Zależności pomiędzy podprogramami ..................................................................... 360Stan pakietów w czasie wykonywania ..................................................................... 370Uprawnienia i podprogramy składowane ................................................................. 375

Stosowanie składowanych funkcji w instrukcjach SQL................................................... 385Poziomy czystości ................................................................................................. 386Parametry domyślne .............................................................................................. 393Wywołanie funkcji składowanych z instrukcji SQL w systemie Oracle8i.................... 393

Przytwierdzanie obiektów w obszarze wspólnym ........................................................... 396KEEP................................................................................................................... 397UNKEEP ............................................................................................................. 398SIZES .................................................................................................................. 398ABORTED_REQUEST_THRESHOLD ................................................................. 398

Podsumowanie............................................................................................................ 398

Rozdział 11. Wyzwalacze.........................................................................................399Rodzaje wyzwalaczy ................................................................................................... 399Tworzenie wyzwalaczy................................................................................................ 403Tworzenie wyzwalaczy DML................................................................................. 403Tworzenie wyzwalaczy zastępujących..................................................................... 413Tworzenie wyzwalaczy systemowych ..................................................................... 419Inne zagadnienia związane z wyzwalaczami ............................................................ 426Wyzwalacze a słownik danych ............................................................................... 430

Tabele mutujące.......................................................................................................... 432Przykład tabeli mutującej ....................................................................................... 434Rozwiązanie problemu błędu tabeli mutującej.......................................................... 435

Podsumowanie............................................................................................................ 438

Rozdział 12. Zaawansowane właściwości ................................................................439Właściwości języka ..................................................................................................... 439Procedury zewnętrzne............................................................................................ 439Wbudowany dynamiczny SQL ............................................................................... 442Masowe powiązania............................................................................................... 447Typy obiektowe .................................................................................................... 454Duże obiekty......................................................................................................... 458Potokowe funkcje tabel.......................................................................................... 461

Zaawansowane pakiety ................................................................................................ 462DBMS_SQL......................................................................................................... 462DBMS_PIPE ........................................................................................................ 463DBMS_ALERT .................................................................................................... 465


UTL_FILE ........................................................................................................... 466UTL_TCP ............................................................................................................ 467UTL_SMTP ......................................................................................................... 468UTL_HTTP.......................................................................................................... 469UTL_INADDR..................................................................................................... 470DBMS_JOB ......................................................................................................... 470DBMS_LOB......................................................................................................... 472

Podsumowanie............................................................................................................ 475

Dodatki ...............................................................................................477

Dodatek A Pakiety dostępne w języku PL/SQL ......................................................479Opis pakietów............................................................................................................. 479DBMS_ALERT .................................................................................................... 479DBMS_APPLICATION_INFO.............................................................................. 480DBMS_AQ........................................................................................................... 480DBMS_AQADM .................................................................................................. 480DBMS_AQELM ................................................................................................... 480DBMS_BACKUP_RESTORE ............................................................................... 481DBMS_DDL ........................................................................................................ 481DBMS_DEBUG ................................................................................................... 481DBMS_DEFER .................................................................................................... 482DBMS_DEFER_QUERY ...................................................................................... 482DBMS_DEFER_SYS............................................................................................ 482DBMS_DESCRIBE .............................................................................................. 482DBMS_DISTRIBUTED_TRUST_ADMIN............................................................. 483DBMS_FGA......................................................................................................... 483DBMS_FLASHBACK........................................................................................... 483DBMS_HS ........................................................................................................... 483DBMS_HS_PASSTHROUGH............................................................................... 484DBMS_IOT.......................................................................................................... 484DBMS_JAVA....................................................................................................... 484DBMS_JOB ......................................................................................................... 484DBMS_LDAP ...................................................................................................... 485DBMS_LIBCACHE.............................................................................................. 485DBMS_LOB......................................................................................................... 485DBMS_LOCK...................................................................................................... 485DBMS_LOGMNR ................................................................................................ 485DBMS_LOGMNR_CDC_PUBLISH...................................................................... 486DBMS_LOGMNR_CDC_SUBSCRIBE.................................................................. 486DBMS_LOGMNR_D............................................................................................ 486DBMS_METADATA............................................................................................ 486DBMS_MVIEW (DBMS_SNAPSHOT)................................................................. 487DBMS_OBFUSCATION_TOOLKIT..................................................................... 487DBMS_ODCI....................................................................................................... 487DBMS_OFFLINE_OG.......................................................................................... 487DBMS_OFFLINE_SNAPSHOT ............................................................................ 487DBMS_OLAP ...................................................................................................... 488DBMS_ORACLE_TRACE_AGENT...................................................................... 488DBMS_ORACLE_TRACE_USER......................................................................... 488DBMS_OUTLN ................................................................................................... 488DBMS_OUTLN_EDIT ......................................................................................... 488DBMS_OUTPUT ................................................................................................. 489DBMS_PCLXUTIL .............................................................................................. 489

Spis treści 11

DBMS_PIPE ........................................................................................................ 489DBMS_PROFILER............................................................................................... 489DBMS_RANDOM................................................................................................ 490DBMS_RECTIFIER_DIFF.................................................................................... 490DBMS_REDIFINITION........................................................................................ 490DBMS_REFRESH................................................................................................ 490DBMS_REPAIR................................................................................................... 490DBMS_REPCAT, DBMS_REPCAT_ADMIN, DBMS_REPCAT_ INSTANTIATE,DBMS_REPCAT_RGT oraz DBMS_REPUTIL.................................................... 491DBMS_RESOURCE_MANAGER i DBMS_RESOURCE_ MANAGER_PRIVS....... 491DBMS_RESUMABLE .......................................................................................... 491DBMS_RLS ......................................................................................................... 492DBMS_ROWID.................................................................................................... 492DBMS_SESSION ................................................................................................. 492DBMS_SHARED_POOL ...................................................................................... 492DBMS_SPACE i DBMS_SPACE_ADMIN............................................................. 493DBMS_SQL......................................................................................................... 493DBMS_STANDARD i STANDARD...................................................................... 493DBMS_STATS..................................................................................................... 493DBMS_TRACE.................................................................................................... 493DBMS_TRANSACTION ...................................................................................... 494DBMS_TRANSFORM.......................................................................................... 494DBMS_TTS ......................................................................................................... 494DBMS_TYPES..................................................................................................... 494DBMS_UTILITY ................................................................................................. 495DBMS_WM ......................................................................................................... 495DBMS_XMLQUERY, DBMS_XMLSAVE i XMLGEN.......................................... 495DEBUG_EXTPROC............................................................................................. 495SDO_CS, SDO_GEOM, SDE_LRS, SDO_MIGRATE i SDO_TUNE ....................... 495UTL_COLL ......................................................................................................... 496UTL_ENCODE .................................................................................................... 496UTL_FILE ........................................................................................................... 496UTL_HTTP.......................................................................................................... 496UTL_INADDR..................................................................................................... 497UTL_PG .............................................................................................................. 497UTL_RAW........................................................................................................... 497UTL_REF ............................................................................................................ 497UTL_SMTP ......................................................................................................... 498UTL_TCP ............................................................................................................ 498UTL_URL............................................................................................................ 498

Dodatek B Słowa kluczowe w języku PL/SQL.........................................................499Tablica zarezerwowanych słów .................................................................................... 499

Dodatek C Słownik danych ...................................................................................503Czym jest słownik danych? .......................................................................................... 503Standardy nazewnictwa.......................................................................................... 503Uprawnienia ......................................................................................................... 504Rodzaje perspektyw .............................................................................................. 504

Zestawienie dostępnych perspektyw ............................................................................. 505Relacyjne klastry, tabele i perspektywy ................................................................... 505Kolekcje, obiekty LOB oraz typy obiektowe............................................................ 507Perspektywy wprowadzone w systemach Oracle8i oraz Oracle9i .............................. 508Inne obiekty bazy danych....................................................................................... 510Partycje i podpartycje ............................................................................................ 511


Indeksy ................................................................................................................ 513Materializowane perspektywy, podsumowania i migawki.......................................... 514Podprogramy, metody i wyzwalacze ....................................................................... 516Kody źródłowe i błędy kompilacji........................................................................... 517Zależności i ograniczenia ....................................................................................... 518Statystyki i audyt................................................................................................... 518

Uprawnienia i ich nadawanie........................................................................................ 519

Skorowidz .............................................................................................................521

Rozdział 11.

Wyzwalacze

Wyzwalacze stanowią czwarty typ bloków nazwanych PL/SQL. Posiadają wiele właści-

wości charakterystycznych dla podprogramów (które omówiono w poprzednich dwóch

podrozdziałach), ale także różnią się od nich w istotny sposób. W niniejszym rozdziale

Czytelnik zapozna się ze sposobem tworzenia wyzwalaczy oraz z niektórymi możliwymi

zastosowaniami tych obiektów.

Rodzaje wyzwalaczy

Wyzwalacze są podobne do procedur lub funkcji pod tym względem, że są nazwanymi

blokami PL/SQL, w których występują sekcje deklaracji, wykonania i obsługi wyjątków.

Podobnie jak pakiety, wyzwalacze muszą być składowane jako samodzielne obiekty

w bazie danych i nie mogą występować lokalnie w bloku lub w pakiecie. Jak napisano

w ostatnich dwóch rozdziałach, procedura jest wykonywana jawnie z innego bloku za

pośrednictwem wywołania procedury, które daje możliwość przekazania argumentów.

Wyzwalacz natomiast jest wykonywany niejawnie, jeśli wystąpi zdarzenie wyzwalają-

ce. Poza tym wyzwalacz nie akceptuje argumentów. Rozpoczęcie wykonywania wyzwa-

lacza jest nazywane uruchamianiem wyzwalacza (firing). Zdarzeniem wyzwalającym mo-

że być operacja DML (instrukcje ��, �� lub ��) wykonywana dla tabeli bazy

danych lub odpowiedniego rodzaju perspektyw. W systemie Oracle8i rozszerzono możli-

wości uruchamiania wyzwalaczy o zdarzenia systemowe, takie jak: uruchomienie lub za-

mknięcie bazy danych, a także określone rodzaje operacji DDL. Zdarzenia wyzwalające

zostaną szczegółowo omówione w dalszej części tego rozdziału.

Wyzwalacze można stosować do wielu celów, przykładowo:

� Utrzymywanie złożonych więzów integralności, niemożliwych do uzyskania

przez więzy deklaracji uaktywniane podczas tworzenia tabeli.

� Kontrola danych w tabeli przez rejestrowanie dokonywanych zmian oraz autorów

tych zmian.

� Automatyczne przekazywanie do innych programów informacji, że jest wymagane

podjęcie określonych działań w razie dokonania zmian w tabeli.

� Publikowanie informacji na temat różnego rodzaju zdarzeń w środowisku

publikowanie-subskrypcja.

400 Część III � Dodatkowe właściwości języka PL/SQL

Istnieją trzy podstawowe rodzaje wyzwalaczy: DML, zastępujące (instead-of) oraz syste-

mowe. W następnych podrozdziałach będzie omówiony każdy z tych typów, szczegó-

łowo w podrozdziale „Tworzenie wyzwalaczy”.

W systemie Oracle8i oraz w wersjach wyższych istnieje możliwość pisania wyzwalaczy

zarówno w języku PL/SQL, jak i innych. Wyzwalacze te można następnie wywołać ja-

ko procedury zewnętrzne. Więcej informacji na ten temat znajduje się w podrozdziale

„Treść wyzwalaczy”, a także w rozdziale 12.

Wyzwalacze DML

Wyzwalacze DML są uruchamiane przez instrukcje DML, a typ wyzwalacza DML jest

określany przez typ instrukcji. Można je definiować dla operacji ��, �� lub ��,uruchamiać przed operacją lub po niej, a także w związku z operacjami dotyczącymi wier-

sza lub instrukcji.

Przykładowo, może zachodzić potrzeba śledzenia danych statystycznych, dotyczących róż-

nych specjalności, włącznie z liczbą studentów zarejestrowanych i liczbą zaliczeń. Dane te

mogą być przechowywane w tabeli � � �� :

Dostępne na płycie CD jako część skryptu tabele.sql.

�� !"�� #$�� !"��%

W celu zapewnienia ciągłej aktualności danych z tabeli �� można utworzyć wy-

zwalacz dla tabeli � ��, który będzie poprawiał tę pierwszą po każdej zmianie dokona-

nej w tabeli � ��. Zadanie to może wykonywać poniższy wyzwalacz �� . Po każdej operacji DML wykonanej na tabeli � �� nastąpi uruchomienie

wyzwalacza. Zawartość wyzwalacza wykonuje zapytanie na tabeli � �� i uaktualniastatystykę w �� :

Dostępne na płycie CD w skrypcie UaktualnijSpecStats.sql.

��&��'��())��!�*�#��+��+��,-�.��/��0�10��*�#��23��4�� /5�/�$��0��6�$�*��6/��/��4��#$��7�-,��8��( +��&��9��&��!'9��& ��#$��9��!�+&��* +��6�6*��(+��+��&! ��-�� #$��+!"�4�� 8�&"��#$��)�&!'��:��%

Rozdział 11. � Wyzwalacze 401

��)( ��,-� ��5/��0�##��;��/��5��4�� 7�+�/�$#��/6��5�/��6�6*��*��23�5��/�6�*��<��#$��=/��*5�2��2��-,��9��8�&"�� %��,-� ��;��4;$��/6*��;��$��*�>$��2��/��/��$�/��$��/��5��$��4�� -,��8&�� *�5$+��* +��6�6*��&&'��( +��( �&�� #$��!�+�� *�5$+��7�� *�5$+��7�� *�5$+��7�� #$��%�� 9��&&'%� 9�!�*�#��+��+��%

Wyzwalacz można uruchomić dla więcej niż jednego typu instrukcji wyzwalających.

Na przykład, wyzwalacz �� można uruchomić dla instrukcji ��,�� oraz ��. Zdarzenie wyzwalające określa jedną operację DML lub więcej, które

powinny spowodować uruchomienie wyzwalacza.

Wyzwalacze zastępujące

W systemie Oracle8 wprowadzono dodatkowy typ wyzwalacza. Wyzwalacze zastępujące

(Instead-of) mogą być definiowane tylko dla perspektyw (relacyjnych lub obiektowych).

Inaczej niż wyzwalacze DML, które uruchamiają się obok operacji DML, wyzwalacze za-

stępujące uruchamiają się zamiast wyzwalającej je instrukcji DML. Wyzwalacze zastę-

pujące działają na poziomie wierszy. Dla przykładu proszę przeanalizować perspektywę

��:

Dostępne na płycie CD jako część skryptu Zamiast.sql.

��&��'��(�?��5#6 �*��+��+��/6$��*#5��4#$6��*��*�� #��5��8�&"��*��5#6��?��*��7�*�� $�@��5#67�*�� $%

Bezpośrednia operacja wstawienia wierszy do tej perspektywy jest nieprawidłowa, ponie-

waż jest to złączenie dwóch tabel, a do wykonania operacji �� potrzebna jest mody-

fikacja obu tabel. Taką sytuację pokazano w poniższej sesji programu SQL*Plus:


+A�B��( +��( �&��5#6 �*��/6$��*#5��4#$6��*��*�� #��5��!�+��C"!.C��D��C�#$6��*�"#�6*�C��%( +��( �&��5#6 �*��/6$��*#5��4#$6��*��*�� #��5��-�EF9�/��DG&��H�DIIJG��>��$6K�*�/�3�/�;��>��$��4��4��/��25�$��/��5�*�6/6�4;$0��10��


Można jednak utworzyć wyzwalacz zastępujący, wykonujący poprawne operacje dla in-

strukcji ��, a mianowicie modyfikację obu tabel:


��())��(��5�)5#6'�*��( +��9�&8�( +��& ��5#6 �*��9�� *��(9��*��7�*�� $L�:'�%��)( ��HH� ��5/��*5�2��$��6K�*��5��*��#��+��*�� $��( �&�� *��(9��8�&"��*��?��4#$6��*�@�G��/74#$6��*�� 9��*�� #��5�@�G��/7�*�� #��5%

��HH��5��#�*�#��;��4��;��5#6��!'9��)�!':��+��*�� $�@�� *��(9��?��/6$��@�G��/7/6$�� 9�*#5�@�G��/7*#5%� 9�)5#6'�*��(��5�%

Dzięki wyzwalaczowi �� wykonanie instrukcji �� kończy się po-wodzeniem.

W obecnej postaci wyzwalacz )5#6'�*��(��5� nie sprawdza błędów. Niedogodność tazostanie zlikwidowana w dalszej części tego rozdziału, w podrozdziale „Tworzenie wy-zwalaczy zastępujących”.

Wyzwalacze systemowe

W systemie Oracle8i oraz w systemach wyższych wprowadzono trzeci typ wyzwalaczy

— wyzwalacze systemowe, które uruchamiają się w przypadku wystąpienia zdarzenia sys-

temowego, takiego jak uruchomienie lub zatrzymanie bazy danych, nie zaś w przypadku

wykonania instrukcji DML na tabeli. Wyzwalacz systemowy można także uruchomić

dla operacji DDL, jak np. utworzenia tabeli. Przykładowo, chęć zarejestrowania utwo-

rzenia obiektu słownika danych można zrobić poprzez następującą tabelę:

Dostępne na płycie CD jako część skryptu ZarejestrujOperTworzenia.sql.

��/�5�� $$��$ #�6�*�/��*��6 �4��*�#��/� �4��*�#��/�� 4��*�#��$�� #�/�5��9��%


Po sformułowaniu tej tabeli można utworzyć wyzwalacz systemowy, którego zadaniem bę-

dzie rejestrowanie interesujących informacji. Zadanie to wypełni wyzwalacz �� !��"��#�� — po każdej operacji $�� w bieżącym schemacie zarejestruje informa-

cje na temat właśnie utworzonego obiektu w tabeli "��#��:


��&��'��())��.�5��5#�&�5�/�5��8��& �9��+��)( ��( +��( �&��/�5�� $$��$ #�6�*�/��*��6 �4��*�#��/� �4��*�#��/�� 4��*�#��$�� #�/�5��!�+��!+��+:+79(��(& ��: &�M �:'��+:+79(��(& ��: &�M �"��+:+79(��(& ��: &�M &? ��+:+9��%� 9�.�5��5#�&�5�/�5��%

Tworzenie wyzwalaczy

Niezależnie od typu wszystkie wyzwalacze tworzy się za pomocą tej samej składni, która

— ogólnie — jest następująca:

��N&��'��O��())��P��8&��Q��8��Q�( +��9�&8R�� N��O�N?�� O�N8&��&?O��%

W składni �� jest nazwą wyzwalacza, �� określa

zdarzenie uruchamiające wyzwalacz (może również zawierać odwołanie do tabeli lub

perspektywy), natomiast �� jest głównym kodem wyzwalacza. Argument

�� jest wykorzystywany w celu odwołania do danych w modyfikowa-

nym wierszu pod inną nazwą. Najpierw następuje ocena warunku ��

w klauzuli %&��. Treść wyzwalacza jest wykonywana tylko wtedy, kiedy ten warunek

przyjmie wartość ��. Więcej przykładów różnych rodzajów wyzwalaczy przeanalizo-

wano w kolejnych podrozdziałach.

Rozmiar treści wyzwalacza nie może przekroczyć 32K. W przypadku większego wyzwa-

lacza można zredukować jego objętość poprzez przeniesienie fragmentów kodu do od-

dzielnie skompilowanych pakietów lub procedur składowanych i wywołanie ich z treści

wyzwalacza. Ze względu na dużą częstotliwość wykonywania dobrą praktyką jest utrzy-mywanie małego rozmiaru treści wyzwalaczy.

Tworzenie wyzwalaczy DML

Wyzwalacze DML są uruchamiane dla operacji ��, �� lub �� dotyczącychtabeli bazy danych. Następuje to przed wykonaniem określonej operacji lub po. Wyzwa-

lacze mogą być wykonane raz w stosunku do wiersza, którego operacja dotyczy lub raz


w stosunku do określonej operacji. Połączenie tych czynników określa rodzaj wyzwalacza.

W sumie istnieje 12 możliwych typów: 3 rodzaje instrukcji × 2 rodzaje czasów × 2 moż-

liwe poziomy. Przykładowo, wszystkie podane niżej typy wyzwalacza są prawidłowe:

� '�(!�� (przed) na poziomie instrukcji ��.

� (�� (po) instrukcji �� na poziomie wiersza.

� '�(!�� (przed) instrukcją �� na poziomie wiersza.

W tabeli 11.1 znajduje się zestawienie tych możliwości. Wyzwalacz jest także uruchamia-

ny dla więcej niż jednego typu instrukcji DML dla określonej tabeli, np. �� oraz ��.Kod w wyzwalaczu jest wykonywany razem z samą instrukcją wyzwalającą, jako część

tej samej transakcji.

Tabela 11.1. Typy wyzwalaczy

Kategoria Wartości Komentarz

Instrukcja ( +��, 9��, !'9�� Definiuje rodzaj instrukcji DML powodującej uruchomieniewyzwalacza.

Czas ��8&�� (przed) lub �8�� (po) Określa, czy wyzwalacz zostanie uruchomiony przed wykonanieminstrukcji czy też po jej wykonaniu.

Poziom Wiersz lub instrukcja Jeżeli dany wyzwalacz istnieje na poziomie wiersza, jesturuchamiany po jednym razie dla każdego wiersza, któregodotyczy instrukcja. Jeżeli dany wyzwalacz jest wyzwalaczemna poziomie instrukcji, to jest uruchamiany jeden raz — przedwykonaniem instrukcji albo po. Wyzwalacz na poziomie wierszajest identyfikowany przez klauzulę 8&��&? w definicjiwyzwalacza.

Dla tabeli można zdefiniować dowolną liczbę wyzwalaczy włącznie z możliwością zde-

finiowania więcej niż jednego wyzwalacza dla określonego rodzaju instrukcji DML, np.

można zdefiniować dwa wyzwalacze (��)�� poziomu instrukcji. Wszystkie wyzwa-

lacze tego samego typu będą uruchamiały się sekwencyjnie (więcej informacji na temat

kolejności uruchamiania wyzwalaczy znajduje się w następnym podrozdziale).

Przed wydaniem języka PL/SQL w wersji 2.1 (system Oracle7 wydanie 7.1) dla tabeli

można było zdefiniować tylko jeden wyzwalacz określonego typu — maksymalnie 12.

A zatem, aby można było definiować podwójne wyzwalacze tego samego typu dla okre-

ślonej tabeli, parametr inicjalizacji �&"'��(�� musi mieć wartość 7.1 lub wyższą (co jestniemal pewne).

Zdarzenie wyzwalające dla wyzwalacza DML określa nazwę tabeli (oraz kolumny), dla

której nastąpi uruchomienie wyzwalacza. W systemie Oracle8i oraz w wersjach wyższych

wyzwalacze można także uruchamiać dla kolumny tabeli zagnieżdżonej. Więcej informacji

na temat tabel zagnieżdżonych znajduje się w rozdziale 8.

Kolejność uruchamiania wyzwalaczy

Uruchamianie wyzwalaczy następuje podczas wykonywania instrukcji DML. Poniżej poda-

no algorytm ich wykonywania:


1. Wykonanie wyzwalacza '�(!�� na poziomie instrukcji, o ile taki istnieje.

2. Dla każdego wiersza, na którym wykonywana jest instrukcja:

� wykonanie wyzwalacza '�(!�� na poziomie wiersza, o ile taki istnieje;

� wykonanie samej instrukcji, o ile taka istnieje;

� wykonanie wyzwalacza (�� na poziomie wiersza, o ile taki istnieje.

3. Wykonanie wyzwalacza (�� na poziomie instrukcji, o ile taki istnieje.

Aby to zilustrować, proszę sobie wyobrazić, że utworzono wszystkie cztery rodzaje wy-

zwalaczy �� dla tabeli grupy — '�(!�� oraz (�� — na poziomie instrukcji oraz na

poziomie wiersza. Zostaną utworzone trzy wyzwalacze '�(!�� poziomu wiersza oraz dwa

wyzwalacze (�� poziomu instrukcji:

Dostępne na płycie CD w skrypcie KolejnoscUruchamiania.sql.

��+�A!� ��*�� /6�/��6��+��?(��D��( ��"� ��:�D%

��&��'��'��S�)��'�*��?6�/��6��+��HH�)��4��6��*�$��/6*�5�6��/�/6�/��<�� *� !"��%� 9�'�*��?6�/��6%

�� )( ��HH� ��5/��*��/6��5�/��67��'�*��?6�/��67� ��*�G@��%

��( +��( �&��4�� 6��*�� #��*�� *��!�+��*�� /6�/��67 �T��C��8&��5#*��G��*�@�C�QQ�'�*��?6�/��67� ��*�%

��HH��5��/�;*��/�5��23��$��$��*��/6�/��7��'�*��?6�/��67� ��*�G@�'�*��?6�/��67� ��*�U�D%� 9�)5#6�(��5#*��%

�� )( ��( +��( �&��4�� 6��*�� #��*�� *��!�+��*�� /6�/��67 �T��C�8��5#*��D7G��*�@�C�QQ�'�*��?6�/��67� ��*�%

��HH�./�;*��$��$��;��/6�/��7��'�*��?6�/��67� ��*�G@�'�*��?6�/��67� ��*�U�D%� 9�)5#6�(��5#*��D%


�� )( ��( +��( �&��4�� 6��*�� #��*�� *��!�+��*�� /6�/��67 �T��C�8��5#*��7G��*�@�C�QQ�'�*��?6�/��67� ��*�%

��HH�./�;*��*��$��;��/6�/��7��'�*��?6�/��67� ��*�G@�'�*��?6�/��67� ��*�U�D%� 9�)5#6�(��5#*��%

�� !��"�� #��)( ��( +��( �&��4�� 6��*�� #��*�� *��!�+��*�� /6�/��67 �T��C��8&��/��5��D7G��*�@�C�QQ�'�*��?6�/��67� ��*�%

��HH�./�;*��*��$��;��/6�/��7��'�*��?6�/��67� ��*�G@�'�*��?6�/��67� ��*�U�D%� 9�)5#6�?��5�D%

�� !��"�� #��)( ��( +��( �&��4�� 6��*�� #��*�� *��!�+��*�� /6�/��67 �T��C��8&��/��5��7G��*�@�C�QQ�'�*��?6�/��67� ��*�%

��HH�./�;*��*��$��;��/6�/��7��'�*��?6�/��67� ��*�G@�'�*��?6�/��67� ��*�U�D%� 9�)5#6�?��5��%

�� !��"$�� #��)( ��( +��( �&��4�� 6��*�� #��*�� *��!�+��*�� /6�/��67 �T��C��8&��/��5��7G��*�@�C�QQ�'�*��?6�/��67� ��*�%

��HH�./�;*��*��$��;��/6�/��7��'�*��?6�/��67� ��*�G@�'�*��?6�/��67� ��*�U�D%� 9�)5#6�?��5��%

�� !��"�� #��)( ��( +��( �&��4�� 6��*�� #��*�� *��!�+��*�� /6�/��67 �T��C�8��/��5��G��*�@�C�QQ�'�*��?6�/��67� ��*�%

��HH�./�;*��*��$��;��/6�/��7��'�*��?6�/��67� ��*�G@�'�*��?6�/��67� ��*�U�D%�� 9�)5#6�/��5�%


Teraz można wydać następującą instrukcję ��:

Dostępne na płycie CD jako część skryptu KolejnoscUruchamiania.sql.

!'9��5#6��+��4� ��@�V��?��/6$��( ��C�(+C��C( 8C�%

Powyższa instrukcja dotyczy czterech wierszy. Każdy z wyzwalaczy '�(!�� oraz (�� po-ziomu instrukcji jest wykonywany raz oraz wyzwalacze '�(!�� i (�� poziomu wiersza

są wykonywane po cztery razy. Jeżeli następnie będzie pobrany wiersze z tabeli �*�� +�#, to uzyska się następujący wynik:

Dostępne na płycie CD w skrypcie KolejnoscUruchamiania.sql.

+A�B�+��-��8�&"��4�� 6��&�9��:�*�� #�%��S&� !"��S&� . �SHHHHHHHHH��HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH��D��8&��5#*��G��*�@��8&��/��5��7G��*�@�D��8&��/��5��7G��*�@��V��8&��/��5��D7G��*�@��W��8��/��5��G��*�@�V��J��8&��/��5��7G��*�@�W��I��8&��/��5��7G��*�@�J��X��8&��/��5��D7G��*�@�I��Y��8��/��5��G��*�@�X��D��8&��/��5��7G��*�@�Y��DD��8&��/��5��7G��*�@�D��D��8&��/��5��D7G��*�@�DD��D��8��/��5��G��*�@�D��DV��8&��/��5��7G��*�@�D��DW��8&��/��5��7G��*�@�DV��DJ��8&��/��5��D7G��*�@�DW��DI��8��/��5��G��*�@�DJ��DX��8��5#*��7G��*�@�DI��DY��8��5#*��D7G��*�@�DX

Dla każdego uruchamianego wyzwalacza są widoczne zmiany dokonane przez wcześniej-

sze wyzwalacze, jak również inne zmiany w bazie danych dokonane za pomocą instrukcji.

Można to zauważyć, obserwując wartość licznika wyświetlaną przez każdy z wyzwalaczy

(więcej informacji na temat zastosowania zmiennych pakietowych znajduje się w roz-

dziale 10.).

Kolejność uruchamiania wyzwalaczy tego samego typu nie jest określona. Jak można za-

uważyć w powyższym przykładzie, dla każdego z wyzwalaczy są widoczne zmiany wyko-

nane przez wyzwalacz uruchomiony wcześniej. Jeżeli kolejność wykonywanych operacji

jest istotna, można je wszystkie połączyć w jednym wyzwalaczu.


Kiedy tworzy się migawkę rejestrującą dla tabeli, wówczas system Oracle automa-

tycznie utworzy wyzwalacz �8�� na poziomie wiersza, który będzie uaktualniał dzien-nik po wykonaniu każdej instrukcji DML. Należy o tym pamiętać, chcąc utworzyć dla tej

tabeli dodatkowy wyzwalacz �8�� na poziomie wiersza. Są jeszcze inne ograniczeniadotyczące wyzwalaczy i migawek (w systemie Oracle9i znanych pod nazwą materializo-

wanych perspektyw). Więcej informacji na ten temat znajduje się w dokumentacji Oracle

Server Replication.

Identyfikatory korelacji w wyzwalaczach na poziomie wiersza

Wyzwalacze na poziomie wiersza uruchamiają się raz dla wiersza przetwarzanego przez

instrukcję wyzwalającą. Wewnątrz wyzwalacza można uzyskać dostęp do danych w obec-

nie przetwarzanym wierszu. Można to zrobić za pomocą dwóch identyfikatorów korelacji

— ,�� oraz ,��". Identyfikator korelacji jest specjalnym rodzajem zmiennej dowiązanej

PL/SQL. Dwukropek na początku każdego z nich wskazuje, że są to zmienne dowiązane

w znaczeniu zmiennych hosta wykorzystywanych we wbudowanym PL/SQL i znak ten

określa, że nie są to zwykłe zmienne PL/SQL. Kompilator PL/SQL będzie traktował je ja-

ko rekordy typu:

�� L�&?�:'�%

Tu �� jest tabelą, dla której zdefiniowano wyzwalacz. Zatem odwołanie

postaci:

G��/7��

będzie prawidłowe tylko wtedy, gdy �� jest polem w tabeli wyzwalającej. Znaczenie

wartości ,�� oraz ,��" opisano w tabeli 11.2. Chociaż syntaktycznie identyfikatory kore-

lacji są traktowane jako rekordy, w rzeczywistości nie są nimi (zagadnienie to omówiono

w podrozdziale „Pseudorekordy”). Z tego powodu ,�� i ,��" nazywane są także pseudo-

rekordami.

Tabela 11.2. Identyfikatory korelacji :old oraz :new

Instrukcjawyzwalająca

Wartości %&'( Wartości %�!)

( +�� Nieokreślone — wszystkie pola mająwartość !��.

Wartości, które będą wstawione po wykonaniuinstrukcji.

!'9�� Oryginalne wartości wiersza przed

uaktualnieniem.

Nowe wartości, które będą uaktualnione

po wykonaniu instrukcji.

9�� Oryginalne wartości przed usunięciemwiersza.

Nieokreślone — wszystkie pola mają wartość !��.

Wartość G��$ jest nieokreślona dla instrukcji ( +��, a wartość G��/ jest nieokreślonadla instrukcji 9��. Kompilator PL/SQL nie wygeneruje błędu w razie zastosowaniaG��$ dla instrukcji ( +�� lub G��/ dla instrukcji 9��, ale wartości obydwóch pól wy-niosą !��.


W systemie Oracle8i zdefiniowano dodatkowy identyfikator korelacji — ,�� . Jeżeliwyzwalacz zdefiniowano dla tabeli zagnieżdżonej, to wartości ,�� oraz ,��" odnoszą siędo wierszy w tabeli zagnieżdżonej, podczas gdy wartość ,�� odnosi się do bieżącegowiersza w tabeli nadrzędnej. Więcej informacji na temat zastosowania identyfikatora

,�� znajduje się w dokumentacji systemu Oracle.

Zastosowanie identyfikatorów :old oraz :new

W wyzwalaczu %�� , którego kod przedstawiono w poniższym przykła-

dzie, wykorzystano wartość ,��". Jest to wyzwalacz typu '�(!�� na poziomie instrukcji

�� i ma służyć do wypełniania pola � tabeli � �� wartością generowaną z se-

kwencji � ��"��:

Dostępne na płycie CD jako część skryptu WygenerujIDstudenta.sql.

��&��'��())��?6��5#�(9+�#$��8&��( +��&��!'9��& ��#$��8&��&?��)( ��,-�?6�1��(9��4��#$��;�0�/�5��2��0��*/��#$�� */��7�(9��*��#��0��4��#$��G��/7(9��5�/�$1�/6��$/�1��7�-,��+��#$�� */��7��Z�[��( �&�%�!)*��8�&"�$#��%� 9�?6��5#�(9+�#$��%

Wyzwalacz %�� faktycznie modyfikuje wartość ,��"-�. Jest to jed-na z użytecznych cech wartości ,��" — w czasie wykonywania instrukcji zostaną zastoso-

wane bieżące wartości ,��". Dzięki wyzwalaczowi %�� można wydać na-

stępującą instrukcję ��:


( +��( �&��#$��/�*��!�+��C��C��C��5#C�%

Instrukcja ta jest wykonywana bez wygenerowania błędu. Nawet w przypadku nieokre-ślenia wartości klucza głównego kolumny � (co jest wymagane) wyzwalacz uzupełni

brakującą wartość. W rzeczywistości w razie zdefiniowania wartości dla kolumny � war-

tość ta zostanie zignorowana, ponieważ wyzwalacz ją zmieni. Podobnie będzie po wydaniu

poniższej instrukcji:


( +��( �&��#$��(9��/�*��!�+��HI��C.��$�C��C.��C�%


Kolumna � będzie wypełniona wartością � ��"��-��. /��, nie zaś wartością 01-

Z powyższego opisu wynika, że nie można zmienić wartości ,��" w wyzwalaczu (��na poziomie wiersza, ponieważ odpowiednia instrukcja została już wykonana. Uogólnia-

jąc, wartość ,��" jest modyfikowana tylko w wyzwalaczu '�(!�� na poziomie wiersza,

a wartość ,�� nigdy nie jest modyfikowana, tylko odczytywana.

Rekordy ,��" oraz ,�� są prawidłowe tylko wewnątrz wyzwalaczy na poziomie wier-

sza. Przy próbie odwołania się do tych wartości wewnątrz wyzwalacza na poziomie in-

strukcji wystąpi błąd kompilacji. Wyzwalacz na poziomie instrukcji jest wykonywany

tylko raz, nawet jeżeli dana instrukcja przetwarza wiele wierszy, a zatem wartości ,��" oraz,�� nie mają żadnego znaczenia. W takiej sytuacji nie istnieje bowiem żaden wiersz, do

którego wartości te mogłyby się odwołać.

Pseudorekordy

Chociaż wartości ,��" oraz ,�� są syntaktycznie traktowane jako rekordy typu �*��"�#"��2�!%�3��, to jednak w rzeczywistości nimi nie są. W efekcie operacje prawi-

dłowe dla rekordów nie są poprawne dla wartości ,��" oraz ,��, np. nie można przypi-

sywać ich wartości jako całych rekordów, jedynie uzyskać dostęp do indywidualnych pól.

Właściwość tę zilustrowano w poniższym przykładzie:

Dostępne na płycie CD jako skrypt Pseudorekordy.sql.

��&��'��())��!#��6��8&��9��& ��4�� 6��8&��&?9�� *�6��4�� 6��L�&?�:'�%��)( ��,-��5�/��5�6��/�>�G��$��/1�2��/��5�*�5$��7�-,��"+�!��,�"�%-�%&'(.

��,-�"�>��$��*�#�6*�3��K�*��5�6�#�0��/�5��2��=��6�<�=��$6��7�-,�� *�6��7*�� *�G@�G��$7*�� *%�� *�6��7*�� #��G@�G��$7*�� #�%� 9�!#��6��%

Ponadto nie jest możliwe przekazanie wartości ,�� oraz ,��" do procedur lub funkcji,które przyjmują argumenty typu �*��"�#"��2�!%�3��.

Klauzula REFERENCING

Jeżeli jest taka potrzeba, to wykorzystuje się klauzulę ��(��$�� w celu nadania in-

nych nazw wartościom ,��" oraz ,��. Klauzula ta występuje po zdarzeniu wyzwalają-

cym, a przed klauzulą %&�� i posiada następującą składnię:

��8�� ( )�N&�9��+��O�N �?��+��O


Wewnątrz treści wyzwalacza można wykorzystywać nazwy �� oraz ��

zamiast ,�� i ,��". Proszę zauważyć, że w nazwach identyfikatorów korelacji w klau-

zuli ��(��$�� nie używa się dwukropków. Poniżej znajduje się alternatywna wersja wy-

zwalacza %�� , gdzie wykorzystano klauzulę ��(��$�� w celu umożli-

wienia odwoływania się do identyfikatora ,��" jako ,��"�� :


��&��'��())��?6��5#�(9+�#$��8&��( +��&��!'9��& ��#$��!)��/��&)�+�� (!��8&��&?��)( ��,-�?6�1��(9��4��#$��;�0�/�5��2��0��*/��#$�� */��7�(9��*��#��0��4��#$��G��/7(9��5�/�$1�/6��$/�1��7�-,��+��#$�� */��7��Z�[��( �&�%�&)�+�� (!��*��8�&"�$#��%� 9�?6��5#�(9+�#$��%

Klauzula WHEN

Klauzula %&�� jest prawidłowa tylko dla wyzwalaczy na poziomie wiersza. Treść wyzwa-

lacza, o ile istnieje, może być wykonywana tylko dla tych wierszy, które spełniają warunek

określony przez tę klauzulę. Poniżej przedstawiono składnię klauzuli %&��:

?��

W niej �� jest wyrażeniem logicznym (boolowskim), sprawdzanym dla każdego wier-

sza. Istnieje możliwość odwoływania się do pseudorekordów ,��" i ,�� również wewnątrz

wyrażenia stanowiącego warunek, ale wtedy nie stosuje się znaku dwukropka. Uwzględnie-

nie znaku dwukropka jest prawidłowe tylko w treści wyzwalacza. Przykładowo, treść

wyzwalacza ��"�# ��#�� jest wykonywana tylko wówczas, gdy liczba bieżących za-

liczeń studenta jest większa niż 20:

��&��'��())��+5�/$�.��8&��( +��&��!'9��&8�4�� & ��#$��8&��&?��#��0�!)*1 !"��!+"�' �"!� ��2��34��)( ��,-��#��/��;��\3��5�23�/6�/��-,� 9%

Wyzwalacz ��"�# ��#�� można także zapisać w następujący sposób:

��&��'��())��+5�/$�.��8&��( +��&��!'9��&8�4�� & ��#$��8&��&?��)( ��%�!)*1 !"��!+"�' �"!� ��2��3��#��,-��#��/��;��\3��5�23�/6�/��-,��.� 9%


Korzystanie z predykatów wyzwalaczyINSERTING, UPDATING oraz DELETING

Omawiany już w niniejszym rozdziale wyzwalacz �� jest wyzwala-

czem na poziomie instrukcji ��, �� oraz ��. Wewnątrz wyzwalacza tego typu

(który jest uruchamiany dla różnych instrukcji DML) występują trzy funkcje logiczne

(boolowskie), które mogą służyć do określenia rodzaju operacji. Tymi predykatami są��, �� oraz ��. Sposób ich działania przedstawiono w poniższej tabeli.

Predykat Działanie

( +��( ) ��!�, jeżeli instrukcją wyzwalającą jest ( +��, w przeciwnym razie 8��+�.

!'9��( ) ��!�, jeżeli instrukcją wyzwalającą jest !'9��, w przeciwnym razie 8��+�.

9��( ) ��!�, jeżeli instrukcją wyzwalającą jest 9��, w przeciwnym razie 8��+�.

W systemie Oracle8i zdefiniowano dodatkowe funkcje, podobne do predykatów wy-

zwalacza, które można wywołać z treści wyzwalacza. Więcej informacji na ten tematznajduje się w podrozdziale „Funkcje — atrybuty zdarzeń”, w dalszej części niniejszego

rozdziału.

W wyzwalaczu �� +�� wykorzystano powyższe predykaty w celu zapisu

wszystkich zmian dokonywanych w tabeli #�� "�� . Oprócz tego wyzwa-lacz zapisuje identyfikator użytkownika wprowadzającego zmiany. Poszczególne rekordy

są przechowywane w tabeli �� . Poniżej przedstawiono kod służący do jej utworzenia:


��.+ �#$6�� 6��D�� &�� !�� 5��X�� &�� !��$�� 9�� &�� !��56 �#$�� $� !"��W��56 /6$��56 *#5�� !"��5� ��D��/6 �#$�� $�� !"��W��/6 /6$��/6 *#5�� !"��/� ��D��%

Wyzwalacz �� +�� jest tworzony za pomocą poniższego kodu:

Dostępne na płycie CD w skrypcie RejestrujZmianyZS.sql.

��&��'��())��5#�.��6.+��8&��( +��&��9��&��!'9��& ��5��5�/�� #$��8&��&?


9�� .��6��D�%��)( ��,-�.��/��C(C�$��5#*��( +��C9C�$��5#*��9��5��C!C�$��5#*��!'9��7�-,��/��#��"+5, ��%-�66.��/��#��"+5, ��%-�6�6.��/��"+5, ��%-�6�6.��.

��,-�.��/��4��.+ �#$6��/�6�*��6�$�*��/��4��5��5�/�� #$��7�.��/��K#�*��;�+:+9��$��/6��5�/��$��/��*��5��!+��/��#�#�6*��$��6K�*��5��4��>0��#>6�*�/��*�7�-,��( +��( �&�.+ �#$6�� 6�� 5��$�� 56 �#$�� $��56 /6$��56 *#5��5� ��/6 �#$�� $��/6 /6$��/6 *#5��/� ��!�+�� .��6��!+��+:+9��G��$7�#$�� $��G��$7/6$��G��$7*#5��G��$7��G��/7�#$�� $��G��/7/6$��G��/7*#5��G��/7��%� 9��5#�.��6.+%

Wyzwalacze zwykle są używane do prowadzenia kontroli zmian dokonywanych w danych,

jak następowało w przypadku powyższego wyzwalacza �� +�� . Chociaż ta-

kie działanie jest dostępne jako jedna z właściwości bazy danych, to jednak zastoso-

wanie wyzwalaczy pozwala na bardziej elastyczną kontrolę. Wyzwalacz �� +�� można zmodyfikować i prowadzić, przykładowo, zapis zmian wprowadzanych

tylko przez niektórych użytkowników. Mógłby również sprawdzać, czy użytkownicy są

uprawnieni do dokonywania zmian, a gdyby tak nie było, wywołać błąd (za pomocą pro-

cedury ��$��!��!�).

Tworzenie wyzwalaczy zastępujących

Inaczej niż wyzwalacze DML, które uruchamiają się dodatkowo, oprócz instrukcji ��,�� lub �� (przed tymi operacjami lub po nich), wyzwalacze zastępujące urucha-

miają się zamiast operacji DML. Ponadto zastępujące można definiować wyłącznie dla

perspektyw, podczas gdy wyzwalacze DML są definiowane dla tabel. Wyzwalacze zastę-

pujące wykorzystuje się w dwóch przypadkach:

� w celu umożliwienia modyfikowania perspektyw (bez wyzwalaczy zastępujących

byłoby to niemożliwe),

� w celu modyfikowania kolumn tabeli zagnieżdżonej będącej kolumną

w perspektywie.

Pierwszy z tych przypadków zostanie omówiony w tym podrozdziale. Więcej informacji

na temat tabel zagnieżdżonych znajduje się w rozdziale 8.


Perspektywy modyfikowalne a perspektywy niemodyfikowalne

Perspektywa modyfikowalna to taka, dla której można wydać instrukcję DML. Ogólnie— perspektywa jest modyfikowalna, jeżeli nie zawiera żadnego z poniższych elementów:

� operatorów zbioru (��!�, ��!�)��, 4��),

� funkcji agregacji (��4, 5� itp.),

� klauzul ��!��)'3, $!��$�)'3 lub ��)%��&,

� operatora ��$�,

� złączeń.

Istnieją jednak perspektywy zawierające złączenia, które są modyfikowalne. Następuje to

wówczas, gdy operacja DML dla tej perspektywy modyfikuje tylko jedną tabelę bazowąw danym czasie oraz jeżeli instrukcja DML spełnia warunki wymienione w tabeli 11.3

(więcej informacji na temat modyfikowalnych i niemodyfikowalnych perspektyw ze złą-czeniami znajduje się w Oracle Concepts). Jeżeli perspektywa jest niemodyfikowalna,

można zapisać dla niej wyzwalacz zastępujący, który wykonuje pożądane działania, tzn.umożliwia jej modyfikację. Wyzwalacz zastępujący można także zapisać dla perspektywy

modyfikowalnej w przypadku, gdy istnieje potrzeba wykonania dodatkowych działań.

Tabela 11.3. Modyfikowalne perspektywy ze złączeniami

Operacja DML Dozwolona, jeżeli:

( +�� Instrukcja nie odnosi się jawnie lub niejawnie do kolumn tabeli bez zachowania kluczy.

!'9�� Zmodyfikowane kolumny są odwzorowane na kolumny tabeli z zachowaniem kluczy.

9�� W złączeniu istnieje dokładnie jedna tabela z zachowaniem kluczy.

Tabela 11.3 odnosi się do tabel z zachowaniem kluczy (key-preserved tables). Tabela z za-chowaniem kluczy to taka, w której po złączeniu z inną tabelą, klucze w tej oryginalnej są

także kluczami w powstałym złączeniu. Więcej informacji na temat tabel z zachowaniemkluczy znajduje się w Application Developer’s Guide — Fundamentals.

Przykład wyzwalacza zastępującego

Proszę przeanalizować perspektywę ��, którą wprowadzono we wcześniejszej

części tego rozdziału:


��&��'��(�?��5#6 �*��+��+��/6$��*#5��4#$6��*��*�� #��5��8�&"��*��5#6��?��*��7�*�� $�@��5#67�*�� $%

Jak można się było wcześniej przekonać, przeprowadzenie operacji �� dla tej per-spektywy jest niedozwolone. Chociaż wykonywanie operacji �� i �� jest dla niejpoprawne, to jednak nie jest pewne, czy operacje te zostaną dobrze wykonane. Przykła-dowo, instrukcja ��)(�!4)�� spowoduje usunięcie wierszy z tabeli grupy.


Jakie działania instrukcji DML w odniesieniu do perspektywy �� jest prawi-

dłowe? To zależy od ustanowionych reguł. Warto jednak założyć, że operacje te mająnastępujące znaczenie:

Operacja Znaczenie

( +�� Przypisuje nowo wprowadzoną grupę do nowo wprowadzonego pokoju. Wynikiemtego działania jest uaktualnienie tabeli �5#6.

!'9�� Modyfikacja pokoju przypisanego do grupy. Wynikiem tego działania może byćmodyfikacja tabeli �5#6 lub �*��, w zależności od tego, które kolumny perspektywy�5#6 �*�� zmodyfikowano.

9�� Wyzerowanie identyfikatora pokoju z usuniętej grupy. Powoduje to uaktualnienietabeli �5#6 i ustawienie identyfikatora na wartość !��.

Wymienione wyżej reguły wymusza wyzwalacz �� +�� , dzięki czemu ope-

racje DML dla perspektywy �� mogą być wykonane poprawnie. Jest to pełniej-

sza wersja wyzwalacza �� , który pokazano w pierwszym podrozdziale

niniejszego rozdziału:

Dostępne na płycie CD w skrypcie GrupyPokojeZamiast.sql.

��&��'��())��)5#6'�*��.��( +��9�&8�( +��&��!'9��&��9��& ��5#6 �*��8&��&?9�� *��(9��*��7�*�� $L�:'�%�� !�*�#��)5#6��&&�� G@�8��+�%�� !�*�#��'�*��&&�� G@�8��+�%

��HH�8#�*��*��/5��0��$��6K�*��5��*��#��$��/��#��5#�4#$6�*#��HH��5��#��5#��*��#7��8#�*��/5��410$�&��H��>��HH��#��5#�4#$6�*#��#4��#��5#��*��#7��8! ��(& ��4��5�(9�*��#� �#$6��*�( ��*��74#$6��*L�:'�� *��( ��*��7�*�� #��5L�:'��!� ��*��7�*�� $L�:'��(+

�� *��(9��*��7�*�� $L�:'�%��)( ��+��*�� $��( �&�� *��(9��8�&"��*��?��4#$6��*�@� �#$6��*�� 9��*�� #��5�@� �*��%��!� �� *��(9%��T��'�(& ��?�� & 9�� 8&! 9�� (+� �''�(��(& ��&��H��C ��*��#C�%�� 9��4��5�(9�*��#%

��HH�'5��$#5��*��5�/$��0��6��5#��$��6K�*�/��5��HH� ?6$��5�� S#5��7��M�>��1��6��410$��HH�&��H��D7


��'�&��9!��5�/$�)5#�� ?6$��( ��5#67/6$��L�:'�� S#5�( ��5#67*#5L�:'��(+�� '�� !"��%��)( ��+��( �&�� '��8�&"��5#6��?��/6$��@� ?6$�� 9�*#5�@� S#5%��T��'�(& ��?�� & 9�� 8&! 9�� (+� �''�(��(& ��&��H��D�� ?6$��QQ�C�C�QQ� S#5�QQ�C��C�%�� 9�5�/$�)5#�%

��)( ��/��#��HH��K5��/��$��5�6�#��5#;�$��*5�2��*��#7��*��HH�K5��#��$��6��5�6�$*��]#�*�#��*��]��>��G�� 5/��HH��*5�2��;��$��6K�*��5��*��#G�� *��(9�G@��4��5�(9�*��#�G��/74#$6��*��G��/7�*�� #��5�%

��HH� ��;��#�*�#��4��;��5#6��/5�/�$��0��/6��$��6K�*��57��!'9��)�!':��+��*�� $�@�� *��(9��?��/6$��@�G��/7/6$�� 9�*#5�@�G��/7*#5%

��/��#��HH�+5�/$��6�#�*�#��;��4��;��5#6��6��4��;��*��7�� !�*�#��)5#6�G@��G��/7/6$��^@�G��$7/6$��&��G��/7*#5�^@�G��$7*#5�%�� !�*�#��'�*��G@��G��/74#$6��*�^@�G��$74#$6��*��&��G��/7�*�� #��5�^@�G��$7�*�� #��5�%

��(8�� !�*�#��)5#6�� HH�?��*��5�6�$*#��;��5#;�5�6��0�$��*5�2��HH��*��#7�� 5/�5�/$��0��6��/��5#��7��5�/$�)5#��G��/7/6$��G��/7*#5�%

��HH�'�45��$��6K�*��5��*��#�� *��(9�G@��4��5�(9�*��#�G��$74#$6��*��G��$7�*�� #��5�%

��HH�?6��5�/��*��#�$��5��5#6��!'9��5#6��+��*�� $�@� !��?��/6$��@�G��$7/6$�� 9�*#5�@�G��$7*#5%

��HH�?5��5�6��5��*��#�$��/��5#67��!'9��5#6��+��*�� $�@�� *��(9��?��/6$��@�G��/7/6$�� 9�*#5�@�G��/7*#5%�� 9�(8%

��(8�� !�*�#��'�*�� HH�?��6��K5��;#��*��#�$��$��5#67


��HH��*��K5��#��$��6��5�6�$*��]/��/��]��/6>��HH��6��>��;#��#�*�#��4��5#6�/�5��2��0�G��$��G��/7��HH� ��5/��>6��*5�2��3��$��6K�*��5��*��#7�� *��(9�G@��4��5�(9�*��#�G��/74#$6��*��G��/7�*�� #��5�%

��HH�!�*�#��4��5#6��5��/5�/�$��/��$��6K�*��5�7��!'9��)�!':��+��*�� $�@�� *��(9��?��/6$��@�G��$7/6$�� 9�*#5�@�G��$7*#5%�� 9�(8%

��/��HH�?��6��K5��;#��/6��5�/��5�6��5#6�$��*��#�4��HH�*��2��##/��/��5�6��/�0��6�<��4��7��!'9��5#6��+��*�� $�@� !��?��/6$��@�G��$7/6$�� 9�*#5�@�G��$7*#5%�� 9�(8%� 9�)5#6'�*��.��%

Klauzula 8&��&? dla wyzwalacza zastępującego jest opcjonalna. Wszystkie wy-zwalacze zastępujące są wyzwalaczami na poziomie wiersza, niezależnie od występo-

wania klauzuli.

Wyzwalacz �� +�� wykorzystuje predykaty wyzwalaczy w celu zidentyfiko-

wania wykonywanej operacji DML i podjęcia odpowiednich działań. Na rysunku 11.1przedstawiono początkową zawartość tabel ��, �� oraz perspektywy ��.

Rysunek 11.1.Początkowa zawartośćtabel grupy, pokojeoraz perspektywygrupy_pokoje

Proszę sobie wyobrazić, że wydano następnie taką instrukcję ��:

Dostępne na płycie CD jako część skryptu GrupyPokojeZamiast.sql.

( +��( �&��5#6 �*��!�+��C"!.C��D��C�#$6��*�"#�6*�C��%

Wyzwalacz powoduje, że tabela �� jest zmieniana zgodnie z nowym przypisaniem

grupy do pokoju. Zilustrowano to na rysunku 11.2.


Rysunek 11.2.Zawartość tabeli perspektywypo wykonaniuinstrukcji INSERT

Następnie wydano następującą instrukcję ��:


!'9��5#6 �*��+��/6$��@�C_:?C��*#5�@��I��?��4#$6��*�@�C�#$6��*�IC�� 9��*�� #��5�@��D%

Tabela �� została uaktualniona zgodnie z dokonanymi, nowymi zmianami. Teraz grupa

&�� )676 nie ma przypisanego pokoju, a 8�"��)971 ma przypisany pokój, który

pierwotnie przynależał grupie &�� )676. Sytuację tę zilustrowano na rysunku 11.3.

Rysunek 11.3.Zawartość tabeli perspektywypo wykonaniuinstrukcji UPDATE

Wreszcie można sobie wyobrazić, że wydano następującą instrukcję ��:


9��8�&"��5#6 �*��?��4#$6��*�@�C�#$6��*�JC%

Zmiany w tabeli �� polegają teraz na ustawieniu wartości pola �� na wartość ��dla tych grup, którym pierwotnie przypisano Budynek 6. Sytuację tę pokazano na rysun-

ku 11.4. Proszę zwrócić uwagę, że podczas wykonywania wszystkich tych operacji DML,

tabela �� pozostała niezmieniona, a uaktualniano jedynie tabelę ��.


Rysunek 11.4.Zawartość tabeli perspektywypo wykonaniuinstrukcji DELETE

Tworzenie wyzwalaczy systemowych

W poprzednim podrozdziale Czytelnik mógł się przekonać, że zarówno wyzwalacze DML,

jak i zastępujące uruchamiają się razem ze zdarzeniami DML, dokładniej instrukcjami

��, �� lub �� (bądź też zamiast nich). Natomiast wyzwalacze systemowe uru-

chamiają się w przypadku wystąpienia dwóch różnych rodzajów zdarzeń: DDL lub bazy

danych. Zdarzenia DDL obejmują instrukcje $��, �� lub �!�, natomiast zdarzenia

bazy danych obejmują uruchomienie (zatrzymanie) serwera, rejestrowanie (wyrejestrowa-

nie) użytkownika oraz błąd serwera. Składnia utworzenia wyzwalacza systemowego jest

następująca:

��N&��'��O��())��N��7O��P��8&��Q�8��R��P��Q��R��& �P9��+��Q�N��O+��"�R��N��O��%

— �� zawiera jedno zdarzenie DDL lub więcej (rozdzielonych słowem

kluczowym !�) natomiast �� zawiera jedno zdarzenie bazy da-

nych lub więcej (rozdzielonych słowem kluczowym !�).

W tabeli 11.4 opisano zdarzenia DDL oraz zdarzenia bazy danych wraz z dozwolonym

czasem wykonania ('�(!�� lub (��). Utworzenie systemowego wyzwalacza zastępują-

cego jest niedozwolone. Instrukcji ��$�� nie odpowiada żadne zdarzenie bazy danych.

Aby móc utworzyć wyzwalacz systemowy, trzeba posiadać uprawnienie systemowe

�9"( (+��9��+��())��. Więcej informacji na ten temat znajduje się w podrozdzia-le „Uprawnienia dotyczące wyzwalaczy”.

Wyzwalacze bazy danych a wyzwalacze schematu

Wyzwalacz systemowy można zdefiniować na poziomie bazy danych lub na poziomie

schematu. Wyzwalacz na poziomie bazy danych uruchomi się za każdym razem, kiedy

nastąpi zdarzenie wyzwalające, natomiast wyzwalacz poziomu schematu uruchomi się

tylko wtedy, gdy zajdzie zdarzenie wyzwalające dla określonego schematu. Słowa klu-

czowe �'�� lub �$&�4 określają poziom dla wybranego wyzwalacza systemowego.


Tabela 11.4. Systemowe zdarzenia DDL oraz zdarzenia bazy danych

Zdarzenie Dozwolonyparametr czasowy

Opis

+��!' �8�� Uruchamia się w momencie uruchomienia bazy danych.

+�!�9&? ��8&�� Uruchamia się w momencie zatrzymania bazy danych. Zdarzenie tomoże nie nastąpić w przypadku zatrzymania bazy danych w trybieawarii (np. anulowanie procesu zatrzymywania).

+��&� �8�� Uruchamia się w przypadku wystąpienia błędu.

�&)& �8�� Uruchamia się po pomyślnym połączeniu użytkownika z bazą danych.

�&)&88 ��8&�� Uruchamia się na początku procesu wyrejestrowania użytkownikaz bazy danych.

�� 8&��8�� Uruchamia się przed utworzeniem obiektu schematu lub po.

9�&' ��8&��8�� Uruchamia się przed usunięciem obiektu schematu lub po.

�� 8&��8�� Uruchamia się przed uaktualnieniem obiektu schematu lub po.

Jeżeli zastosuje się słowo kluczowe �$&�4, a nie określi schematu, domyślnym będzie ten

schemat, który zawiera wyzwalacz. Na przykład, będąc połączonym jako �#� ��"��,utworzono następujący wyzwalacz:

Dostępne na płycie CD jako część skryptu SchematBazyDanych.sql.

��&��'��())��.�5��5#�'��!�6�*��/�#�7��)( ��( +��( �&�5�6*��$7��4�� 6��!�+��D��C#5#�<��/6�/��.�5��5#�'��!�6�*�^C�%� 9�.�5��5#�'��!�6�*�%

Wyzwalacz �� #��#� � każdorazowo zapisze w tabeli �*�� +�#fakt połączenia użytkownika �#� ��"��. Można stworzyć podobny mechanizm dla

użytkownika �#� ��"��', budując poniższy wyzwalacz z pozycji połączonego jako

�#� ��"��':

Dostępne na płycie CD jako część skryptu SchematBazaDanych.sql.

��&��'��())��.�5��5#�'��!�6�*��/�#�7��)( ��( +��( �&�5�6*��$7��4�� 6��!�+��D��C#5#�<��/6�/��.�5��5#�'��!�6�*�^C�%� 9�.�5��5#�'��!�6�*�%

Wreszcie można utworzyć następujący wyzwalacz, będąc połączonym jako użytkownik

��#��. Wyzwalacz �� #%�#�� : zarejestruje wszystkie połączenia

z bazą danych, ponieważ jest to wyzwalacz poziomu bazy danych:


Dostępne na płycie CD jako część skryptu SchematBazaDanych.sql.

��&��'��())��.�5��5#�'��?�6�*��<��/��)( ��( +��( �&�5�6*��$7��4�� 6��!�+��D��C#5#�<��/6�/��.�5��5#�'��?�6�*��<^C�%� 9�.�5��5#�'��?�6�*��<%

Przed uruchomieniem powyższych przykładów najpierw należy utworzyć użytkowników

!�6�*�/��*� oraz !�6�*�/��*� i nadać im odpowiednie uprawnienia. Więcej informacjina ten temat znajduje się w skrypcie SchematBazyDanych.sql.

Analizując następującą sesję programu SQL*Plus, można teraz zaobserwować efekty dzia-

łania poszczególnych wyzwalaczy:

Dostępne na płycie CD jako część skryptu SchematBazyDanych.sql.

+A�B��!�6�*�/��*�,!�6�*�/��*�'�10��67

+A�B��!�6�*�/��*�,!�6�*�/��*�'�10��67

+A�B��5�6*��$,5�6*��$'�10��67

+A�B�+��-�8�&"��4�� 6��%S&� !"��S&� . �SHHHHHHHHH��HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH��#5#�<��/6�/��.�5��5#�'��?�6�*��<^��#5#�<��/6�/��.�5��5#�'��!�6�*�^��#5#�<��/6�/��.�5��5#�'��?�6�*��<^��#5#�<��/6�/��.�5��5#�'��?�6�*��<^��D��#5#�<��/6�/��.�5��5#�'��!�6�*�^

Wyzwalacz �� #%�#�� : uruchomił się trzy razy (po jednym razie dla

każdego z połączeń), natomiast wyzwalacze �� #��#� � oraz �� #��#� �', jak należało się spodziewać, uruchomiły się tylko raz.

Wyzwalacze +��!' oraz +�!�9&? można definiować jedynie na poziomie bazy danych.Tworzenie ich na poziomie schematu nie jest niepoprawne, a wyzwalacze po prostu nieuruchomią się.

Funkcje — atrybuty zdarzeń

Dla wyzwalaczy systemowych istnieje kilka funkcji — atrybutów zdarzeń. Podobnie jak

predykaty wyzwalaczy (��, �� oraz ��), pozwalają one uzyskać in-

formacje na temat zdarzenia wyzwalającego w treści wyzwalacza. Chociaż wywołanie tych


funkcji z innych bloków PL/SQL jest poprawne (niekoniecznie w treści wyzwalacza sys-temowego), to jednak funkcje te nie zawsze zwrócą poprawne wyniki. Funkcje — atry-

buty zdarzeń opisano w tabeli 11.5.

Tabela 11.5. Funkcje —atrybuty zdarzeń

Funkcja — atrybut Typ danych Zdarzenia, dlaktórych funkcjama zastosowanie

Opis

+:+�� Wszystkie zdarzenia. Zwraca zdarzenie systemowe, które uruchomiłowyzwalacz.

( +�� !" !"�� Wszystkie zdarzenia. Zwraca bieżący numer egzemplarza. O ile niepracuje się z klastrami Oracle Real ApplicationClusters, będzie to zawsze wartość 1.

9��+� �"� ��W�� Wszystkie zdarzenia. Zwraca nazwę bieżącej bazy danych.

+�� &� !"�� +��&� Przyjmuje pojedynczy argument typu !"��.Zwraca błąd znajdujący się na stosie błędów napozycji wskazywanej przez argument. Wartość 1oznacza wierzchołek stosu.

(+ +��&� �&&�� +��&� Pobiera numer błędu jako argument i zwracawartość ��!�, jeżeli wskazywany błąd systemuOracle znajduje się na stosie błędów.

�&)( !+�� Wszystkie zdarzenia. Zwraca identyfikator użytkownika, któryuruchomił wyzwalacz.

9(��(& ��: &�M �:'� �� , 9�&', �� Zwraca typ obiektu słownika, dla któregowykonano operację DDL, która spowodowałauruchomienie wyzwalacza.

9(��(& ��: &�M �"� �� , 9�&', �� Zwraca nazwę obiektu słownika, dla któregowykonano operację DDL, która spowodowałauruchomienie wyzwalacza.

9(��(& ��: &�M &? �� , 9�&', �� Zwraca właściciela obiektu słownika, dla któregowykonano operację DDL, która spowodowałauruchomienie wyzwalacza.

9�+ � ��:'��9 '�++?&�9

�� lub ��!+�� Zwraca hasło zaszyfrowane algorytmem DESutworzonego użytkownika lub użytkownika,dla którego zmodyfikowano dane.

Niektóre z funkcji — atrybutów wykorzystano w wyzwalaczu �� !��"��#��,który pojawił się na początku tego rozdziału. Inaczej niż predykaty wyzwalaczy, funk-

cje — atrybuty są samodzielnymi funkcjami PL/SQL, których właścicielem jest �3�.Nie zdefiniowano dla nich domyślnego synonimu, zatem w celu poprawnej identyfikacji

należy poprzedzić je prefiksem �3�:


��&��'��())��.�5��5#�&�5�/�5��8��& �+��"�


��)( ��( +��( �&��/�5�� $$��$ #�6�*�/��*��6 �4��*�#��/� �4��*�#��/�� 4��*�#��$�� #�/�5��!�+��!+��/8/*��8+��9+�8��:�/8/*��8+��9+��7�:��/8/*��8+��9+��+:+9��%� 9�.�5��5#�&�5�/�5��%

Wykorzystanie zdarzenia SERVERERROR

Zdarzenie ��5��!� można zastosować w celu śledzenia błędów powstałych w bazie

danych. Kod błędu jest dostępny wewnątrz wyzwalacza za pośrednictwem funkcji — atry-

butu ��5��!�. Funkcja ta pozwala na zidentyfikowanie kodu błędów znajdujących

się na stosie. Nie można jednak uzyskać komunikatów skojarzonych z tymi kodami.

Można temu zaradzić, posługując się procedurą '4��3-(!�4��!��$;.Chociaż sam wyzwalacz nie spowodował błędu, to jednak za pośrednictwem tej proce-

dury stos błędów jest dostępny z poziomu języka PL/SQL. Zilustrowano to w poniższym

przykładzie, gdzie błędy są zapisywane w specjalnie do tego celu zaprojektowanej tabeli.

Oto jej schemat:

Dostępne na płycie CD jako część skryptu ZarejestruBledy.sql.

��5��5�� 4��$�/��$��/��*��9��/� #�6�*�/��*��5�� !"��/� 4��6 $��6�<��W�� 4��$�/��%

Można teraz utworzyć wyzwalacz, który wstawia dane do powyższej tabeli:


��&��'��())��.�5��5#��$6��8��+��&��& �9��+��)( ��( +��( �&�5��5�� 4��$�/��!�+��+:+9��+:+7�&)( !+��+:+7( +�� !"��+:+79��+� �"��7/+��8*��7��+��+/��;�%� 9�.�5��5#��$6%

Na koniec wygeneruje się kilka błędów i sprawdzi, czy wyzwalacz �� '�� po-prawnie je rejestruje. Proszę zwrócić uwagę, że wyzwalacz przechwytuje błędy w instruk-

cjach SQL, błędy PL/SQL fazy wykonania oraz błędy kompilacji PL/SQL:



+A�B�+��-�8�&"�� 4��%+��-�8�&"�� 4��-�<=��)�' � ��%&��H��YV�G��4��#4��5�*�6/��+A�B��)( ��( +��( �&�� 4��!�+��C?��^C�%�� 9%��V��,��/�� ! �� !��+��1!'��>��/�06� �� !?64��@�<=��)�' � ��%��A3BCC3%�' � ��:��&' ,��C%'�+A33�3�%� (!��D ��&��6��/��9��+��6�, � �1�E�"(!�'��&)��A3BCC3%�' � ��:��&' ,��$%�F/G%��&'!�!� !�/G�&(�" �&�!

+A�B��)( ��HH��410$�6��*�6��6^��9��8�&"��#$��V�� 9%��W��,��.@�<=��)�' � �H%��A3BCC3%�' � ��H:��&' ,��%�/A33�3$%��&��&��,1&'�I��I��,:��(" !��&(" !)��&�� J��!(�!�&�"��J� �K��L%*�M�.��+N (!��D ��&�2N (!��D ��&�� J��)�� ("��OP)2:��"JQE�I�#��I�'�� ,&R' ) !� ��&�� "�, !� &�&��,1&'�I��I��I.I

+A�B�9�� .��#�<�/��%��)( ��V��HH��410$�/6*��^��W�� .��#�<�/�5�G@�C�4�$�KC%��J�� 9%��I��,��@�<=��)�' � ��%��A3BC3�%��F/G%�1OK(�� ,!��"��' 1�1OK(�)��&Q� %�"��,�O��1 D&��O�S� �L��"��P)*��A3BC��%�)�' � �C

+A�B�+��-��8�&"�5��5�� 4��$�/%

9��&? (S�� .?� !.:�S&? (S��).�"'��.�� .?� ��.: 9� :��HHHHHHHHH��HHHHHHHHHHHHHHHHHH��HHHHHHHHHHH��HHHHHHHHHHHHHHHHHH��&� +��SHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHD�H&��H�D��'�.:S��9��D��Y�D&��H��YV�G��4��#4��5�*�6/��7

D�H&��H�D��'�.:S��9��D��Y�D&��H�JWW�G��*��#��DWG'�+H��DG��$��6K�*��5�C (�(+� (�M�� C��#��463��$�*��5�/��6&��H�JWW�G��*��#��G'�,+A�G�'��+A��$5�#��


D�H&��H�D��'�.:S��9��D��Y�D&��H�JWW�G��V��*��#��DG'�+H��D��G� ��*��6�4��]� 9]��$��$��/��;��$��;#�0�6�<G7�`�%��!� ( ) a�$��6K�*��5Ba�$��6K�*��5�#�;�6�/��#$�61=/B��;23�]?��]9��#��>��/��*��6�#��6�4��]� 9]��]%]

D�H&��H�D��'�.:S��9��D��Y�D&��H�JW��G�'�,+A�G�410$��#��56��6��#4�/�5��2��G��46��16�4#K�5�$��0�#��*=/&��H�JWD�G�/��W

Wyzwalacze systemowe a transakcje

W zależności od zdarzenia wyzwalającego zmienia się działanie wyzwalacza systemowe-

go w transakcjach. Wyzwalacz systemowy uruchamia się jako oddzielna transakcja, która

jest zatwierdzana po pomyślnym wykonaniu wyzwalacza lub uruchamia się jako część

transakcji bieżącego użytkownika. Wyzwalacze ��, �&��!%�, ��5��!� oraz �!�!�uruchamiają się jako oddzielne transakcje, natomiast wyzwalacze �!�!(( oraz związane

z operacjami DDL uruchamiają się w ramach bieżącej transakcji.

Ważne jest, aby zdać sobie sprawę, że działania wykonane przez wyzwalacz będą za-

twierdzone niezależnie od innych czynników. W przypadku wyzwalacza DDL bieżąca

transakcja (instrukcja $��, �� lub �!�) jest zatwierdzana automatycznie, co równo-

cześnie zatwierdza działania wykonane przez wyzwalacz. Działanie wyzwalacza �!�!((również będzie zatwierdzone jako część końcowej transakcji w sesji.

Ponieważ wyzwalacze systemowe w zasadzie są zatwierdzane mimo wszystko, dekla-

rowanie ich jako autonomicznych nie będzie miało żadnego efektu.

Wyzwalacze systemowe a klauzula WHEN

Podobnie jak w przypadku wyzwalaczy DML, w wyzwalaczach systemowych można

stosować klauzulę %&�� w celu określenia warunków uruchomienia wyzwalacza. Istnieją

jednak ograniczenia rodzaju warunków, które można określić dla każdego rodzaju wyzwa-

laczy systemowych. Należą do nich:

� Dla wyzwalaczy �� i �&��!%� nie można określać żadnych warunków.

� W wyzwalaczach ��5��!� można także wykorzystywać zmienną ��! w celu

śledzenia tylko wybranego błędu.

� W wyzwalaczach �!�!� i �!�!(( można sprawdzać identyfikator i nazwę

użytkownika, posługując się zmiennymi �� oraz ��4�.

� W wyzwalaczach DDL można sprawdzać typ i nazwę modyfikowanego obiektu,

a także identyfikator i nazwę użytkownika.


Inne zagadnienia związane z wyzwalaczami

W tym podrozdziale będą omówione dodatkowe zagadnienia związane z wyzwalaczami,

tj. przestrzeń nazw dla nazw wyzwalaczy, różnorodne ograniczenia związane z wykorzy-

staniem wyzwalaczy oraz różne rodzaje treści wyzwalaczy. Podrozdział kończy się omó-wieniem uprawnień związanych z wyzwalaczami.

Nazwy wyzwalaczy

Przestrzeń nazw dla nazw wyzwalaczy różni się od przestrzeni nazw dla nazw podpro-

gramów. Przestrzeń nazw jest zbiorem poprawnych identyfikatorów, dostępnych do wy-

korzystania jako nazwy obiektu. Procedury, pakiety i tabele wspólnie korzystają z tej sa-mej przestrzeni nazw. Oznacza to, że w ramach schematu bazy danych wszystkie obiekty

w tej samej przestrzeni nazw muszą mieć niepowtarzalne nazwy. Przykładowo, nieprawi-

dłowe jest nadawanie tej samej nazwy procedurze i pakietowi.

Wyzwalacze posiadają jednak osobną przestrzeń nazw. Oznacza to, że wyzwalacz może

mieć tę samą nazwę, którą tabela lub procedura. Jednak wewnątrz jednego schematu dananazwa może być zastosowana tylko dla jednego wyzwalacza. Można na przykład utwo-

rzyć wyzwalacz o nazwie � � �� dla tabeli � � �� , jednak utworzenie

procedury, która także nazywa się � � �� , jest nieprawidłowe. Sytuację taką

przedstawiono w poniższej sesji programu SQL*Plus:

Dostępne na płycie CD w skrypcie TeSameNazwy.sql.

+A�B�HH'�5�/��/�>�/6�/��4��/6*�5�6�#�0�5=>��5��5��/+A�B��&��'��())�� 8&��( +��& �� )( ��V��( +��( �&��4�� 6��*�� *��W��!�+��C?6�/��#5#�<��6^C�%��J�� 9�� %��I��,?6�/��1�#�/�5��67

+A�B�HH� ��5�/��/�>�5��$#56��4��/6*�5�6�#�0�5=>��5��5��/+A�B��&��'��'�&��9!�� )( ��( +��( �&��4�� 6��*�� *��V��!�+��C'5��$#5;�/6/�1��^C�%��W�� 9�� %��J��,��&��'��'�&��9!�� +@�<=��)�' � ��.&��H��YWWG��0�6��4��*��#>6/��#��*��/6

Mimo że jest możliwe stosowanie takich samych nazw dla wyzwalacza i tabeli, taki spo-

sób programowania nie jest zalecany. Lepszą metodą jest nadawanie każdemu wy-

zwalaczowi niepowtarzalnej nazwy, identyfikującej jego funkcję oraz tabelę, dla której

został zdefiniowany lub stosowanie wspólnego prefiksu dla wyzwalacza, np. ?:.? .


Ograniczenia wyzwalaczy

Treść wyzwalacza jest blokiem PL/SQL (w systemie Oracle8i istnieje możliwość wyko-

rzystywania innych rodzajów treści wyzwalaczy — szczegółowe informacje znajdują się

w następnym podrozdziale). Każda instrukcja, która jest poprawna w bloku PL/SQL,

jest również właściwa w treści wyzwalacza. Wyzwalacze podlegają następującym ogra-

niczeniom:

� W wyzwalaczu nie można wydawać żadnych instrukcji sterowania transakcją

— $!44��, �!��'$; lub �5��!��. Kompilator języka PL/SQL zezwoli

na utworzenie wyzwalacza zawierającego te instrukcje, ale w czasie uruchamiania

wyzwalacza uzyska się błąd. Wynika to z faktu, iż wyzwalacz jest uruchamiany

jako część wykonania instrukcji wyzwalającej i należy do tej samej transakcji,do której instrukcja wyzwalająca. Kiedy instrukcja wyzwalająca jest zatwierdzana

lub wycofana, efekt działania wyzwalacza jest również zatwierdzany lub wycofany

(w systemie Oracle8i oraz w systemach wyższych można utworzyć wyzwalacz,

który uruchamia się jako transakcja autonomiczna. W takim przypadku działania

wykonywane w wyzwalaczu można zatwierdzić lub wycofać niezależnie od stanuinstrukcji wyzwalającej. Więcej informacji na temat transakcji autonomicznych

znajduje się w rozdziale 4.).

� Podobnie w procedurach lub funkcjach wywołanych w treści wyzwalacza

nie można wydawać żadnych instrukcji sterowania transakcją (chyba że one

również zostały zadeklarowane jako transakcje autonomiczne w systemie Oracle8ioraz w wersjach wyższych).

� W treści wyzwalacza nie można deklarować żadnych zmiennych typu �!�� lub�!��)�%. Również wartości ,��" oraz ,�� nie mogą odwoływać się do kolumn

typu �!�� lub �!��)�% w tabeli, dla której zdefiniowano wyzwalacz.

� W systemie Oracle8 oraz w wersjach wyższych w kodzie w treści wyzwalacza można

odwoływać się i wykorzystywać kolumny typu �!' (Large Objects — obiektyo dużym rozmiarze), ale nie można modyfikować wartości tych kolumn. Dotyczy

to również kolumn obiektowych.

Istnieją także pewne ograniczenia uzyskiwania dostępu do tabeli przez treść wyzwalacza.

W zależności od typu wyzwalacza i ograniczeń dla tabeli wybrana tabela może stać się ta-

belą mutującą. Sytuację taką omówiono szczegółowo w dalszej części niniejszego rozdziału,w podrozdziale „Tabele mutujące”.

Treść wyzwalaczy

Przed wydaniem systemu Oracle8i treść wyzwalacza musiała być blokiem PL/SQL.

W systemie Oracle8i oraz w wersjach wyższych treść wyzwalacza może się składać

z instrukcji $��. Wywołana procedura może być podprogramem składowanym PL/SQLlub osłoną (wrapper) dla procedury napisanej w języku C lub Java. Dzięki temu można

tworzyć wyzwalacze, w których kod funkcji pisany jest w języku Java. Proszę sobie wy-

obrazić zarejestrowanie połączenia i rozłączenia z bazą danych w następującej tabeli:



��#$6� ��/� #�6�*�/��*��5��$��/��*��9��%

Do rejestrowania połączeń i rozłączeń z bazą danych można zastosować następujący pakiet:

Dostępne na płycie CD jako część skryptu PakietDziennika1.sql.

��&��'��'��S�)��'�*��9��*��+��'�&��9!��5#�'�� !�6�*(9�( ��%��'�&��9!��5#�� !�6�*(9�( ��%� 9�'�*��9��*�%

��&��'��'��S�)��&9:�'�*��9��*��+��'�&��9!��5#�'�� !�6�*(9�( ��(+��)( ��( +��( �&��#$6� ��/� #�6�*�/��*��5��$��/��*��!�+�� !�6�*(9��C'&��.� (�C��+:+9��%�� 9��5#�'��%

��'�&��9!��5#�� !�6�*(9�( ��(+��)( ��( +��( �&��#$6� ��/� #�6�*�/��*��5��$��/��*��!�+�� !�6�*(9��C�&.��.� (�C��+:+9��%�� 9��5#��%� 9�'�*��9��*�%

Obie procedury — �� #��-�� #�� oraz �� #��-�� #��#�� — pobierają nazwę użytkownika jako argument i wstawiają wiersz do

tabeli �� #��. Procedury te można wywołać z wyzwalaczy �!�!� i �!�!(( w na-

stępujący sposób:

Dostępne na płycie CD jako skrypt RejestrowaniePolaczen.sql.

��&��'��())��5�/��'��8��&)& �& �9��+�� !��" !�� *�!�!�� &'��"!� �0/8/*��+�/��4,

��&��'��())��5�/��8��&)& �& �9��+�� !��" !�� *�!�!�� &"'��"!� �0/8/*��+�/��4,

Ponieważ ��5�/��'�� oraz ��5�/�� to wyzwalacze systemowena poziomie bazy danych (w odróżnieniu od wyzwalaczy na poziomie schematu), do ich

utworzenia jest potrzebne posiadanie uprawnienia systemowego �9"( (+��9��+��())��.


Treść obu wyzwalaczy — �� "��#�� oraz �� "��#��#�� — to

po prostu instrukcja $�� wywołująca odpowiednią procedurę. Jako argument tej proce-dury jest przekazywany bieżący użytkownik. W powyższym przykładzie obiektem in-

strukcji $�� jest standardowa procedura PL/SQL wchodząca w skład pakietu. Równie do-brze może to być jednak osłona dla zewnętrznej procedury napisanej w języku C lub Java.

Przykładowo załadowano do bazy danych następującą klasę Java:

Dostępne na płycie CD jako skrypt Rejestrator.java.

��5��[�7b�7-%��5��5��7�$4�7$5�[�57-%

#4��5��5�P�� 1' �� T& (��!�!��&)�� !�&'��"!�0/�� "��4��L�&)��/G�U�!�� &��V��,,�!�6*��$��62��10��M9��@��/�&5��95�[�5��7$�K�#��%

��+�5��(��5��@��]( +��( �&��#$6� ��/� #�6�*�/��*��5��$��/��*�]�U��]��!�+��c��C'&��.� (�C��+:+9��]%

��,,�'5�6��/��/6*��5#*��/5�/�$��0��$��$��4��6��'5��5�$+��(��5#*��(��5��@��75��5�+��(��5��%��(��5#*��(��5�7��+�5��D��#�6�*(9�%��(��5#*��(��5�7�Z��#��%��R

�� 1' �� T& (��!�!��&)�� !�&"'��"!�0/�� "��4��L�&)��/G�U�!�� &��V��,,�!�6*��$��62��10��M9��@��/�&5��95�[�5��7$�K�#��%

��+�5��(��5��@��]( +��( �&��#$6� ��/� #�6�*�/��*��5��$��/��*�]�U��]��!�+��c��C�&.��.� (�C��+:+9��]%

��,,�'5�6��/��/6*��5#*��/5�/�$��0��$��$��4��6��'5��5�$+��(��5#*��(��5��@��75��5�+��(��5��%��(��5#*��(��5�7��+�5��D��#�6�*(9�%��(��5#*��(��5�7�Z��#��%��RR

Następnie można utworzyć pakiet PakietDziennika jako osłonę dla tej klasy:

Dostępne na płycie CD jako część skryptu PakietDziennika2.sql.

��&��'��'��S�)��'�*��9��*��+��'�&��9!��5#�'�� !�6�*(9�( ��%��'�&��9!��5#�� !�6�*(9�( ��%� 9�'�*��9��*�%


��&��'��'��S�)��&9:�'�*��9��*��+��'�&��9!��5#�'�� !�6�*(9�( ��(+�� )!�)��M�� "��C��5��57��5�/��'��[�7��7+�5��C%��'�&��9!��5#�� !�6�*(9�( ��(+�� )!�)��M�� "��C��5��57��5�/��[�7��7+�5��C%� 9�'�*��9��*�%

W celu uzyskania pożądanego efektu można wykorzystać te same wyzwalacze. Więcej in-

formacji na temat procedur zewnętrznych znajduje się w rozdziale 12.

Predykaty wyzwalaczy, takie jak ( +��( ), !'9��( ) oraz 9��( ) oraz identyfikatorykorelacji G��$ i G��/ (a także G�5��) można zastosować tylko wtedy, gdy treść wy-zwalacza w całości jest blokiem PL/SQL, a nie instrukcją ��.

Uprawnienia dotyczące wyzwalaczy

Istnieje pięć uprawnień systemowych dotyczących wyzwalaczy. Uprawnienia te opisano

w tabeli 11.6. Oprócz nich właściciel wyzwalacza musi posiadać odpowiednie uprawnie-

nia obiektowe do obiektów, do których odwołuje się wyzwalacz. Wyzwalacz jest skom-

pilowanym obiektem, a zatem uprawnienia te muszą być nadane bezpośrednio, a nie za

pośrednictwem roli.

Tabela 11.6. Uprawnienia systemowe dotyczące wyzwalaczy

Uprawnienie systemowe Opis

��())�� Umożliwia użytkownikowi posiadającemu to uprawnienie tworzeniewyzwalacza w swoim schemacie.

�� :��())�� Umożliwia użytkownikowi posiadającemu to uprawnienie tworzeniewyzwalaczy w dowolnym schemacie, z wyjątkiem schematu +:+. Tworzeniewyzwalaczy dla tabel słownika danych nie jest zalecane.

�� :��())�� Umożliwia użytkownikowi posiadającemu to uprawnienie włączanie,wyłączanie lub kompilowanie wyzwalaczy bazy danych w dowolnymschemacie z wyjątkiem schematu +:+. Proszę zwrócić uwagę, że jeżeliposiadacz tego uprawnienia nie ma uprawnienia �� :��())��,to nie może modyfikować kodu wyzwalacza.

9�&'�� :��())�� Umożliwia użytkownikowi posiadającemu to uprawnienie usuwaniewyzwalaczy w dowolnym schemacie, z wyjątkiem schematu +:+.

�9"( (+��9��+��())�� Umożliwia użytkownikowi posiadającemu to uprawnienie tworzenielub modyfikację wyzwalacza systemowego na poziomie bazy danych(w odróżnieniu od bieżącego schematu). Posiadacz tego uprawnienia musirównież posiadać uprawnienie ��())�� lub �� :��())��.

Wyzwalacze a słownik danych

Niektóre perspektywy słownika danych zawierają informacje dotyczące wyzwalaczy i ich

statusu, podobnie jak w przypadku podprogramów składowanych. Perspektywy te zmie-

nia się za każdym razem, kiedy tworzy się lub usuwa wyzwalacz.


Perspektywy słownika danych

Po utworzeniu wyzwalacza jego kod źródłowy jest składowany w perspektywie słownika

danych �� (wyzwalacze użytkownika). W perspektywie tej znajduje się kod

wyzwalacza, dane określające klauzulę %&��, tabelę wyzwalającą oraz typ wyzwalacza.

Poniżej znajduje się przykładowy kod zapytania, które zwraca informację dotyczącą wy-

zwalacza �� :

+A�B�+��5��5 �6��4�� 5��5�� [��8�&"�#�5 �5��5��?��5��5 ��@�C!�S�!�� (M+'��+��C%

��())�� :'�� "��())��( ) �� HHHHHHHHHHHHHHH��HHHHHHHHHH��HHHHHHHHHHHHHHHHHHHHHHHHHH�8��+��"� ��+�!9� �(��( +��&��!'9��&��9��

Perspektywa �� zawiera informacje dotyczące wyzwalaczy należących do bie-

żącego użytkownika. Ponadto istnieją dwie dodatkowe perspektywy: perspektywa �� (zawiera informacje na temat wyzwalaczy dostępnych dla bieżącego użytkowni-

ka — które mogą należeć do innego użytkownika) i perspektywa �*�� (zawiera

informacje na temat wyzwalaczy w bazie danych). Więcej informacji dotyczących per-

spektyw słownika danych znajduje się w dodatku C.

Usuwanie i dezaktywacja wyzwalaczy

Podobnie jak procedury i pakiety, tak i wyzwalacze mogą być usuwane. Poniżej przed-

stawiono składnię odpowiedniego polecenia:

9�&'��())��%

gdzie �� jest nazwą usuwanego wyzwalacza. Wykonanie tego polecenia

powoduje trwałe usunięcie danego wyzwalacza ze słownika danych. Podobnie jak w przy-

padku podprogramów, w instrukcji tworzenia wyzwalacza $�� można określić klauzulę

!�)��$�. W takim przypadku po wydaniu omawianego polecenia najpierw następuje

usunięcie wyzwalacza, jeżeli taki istnieje.

Jednak w odróżnieniu od procedur i pakietów wyzwalacz może być dezaktywowany bez

konieczności jego usuwania. Jeśli wyzwalacz jest nieaktywny, to w dalszym ciągu istnieje

w słowniku danych, ale nie jest uruchamiany. W celu dezaktywowania wyzwalacza na-

leży użyć instrukcji ��)��.

��())��P9(+��Q� ��R%

— �� jest nazwą wyzwalacza. Wszystkie wyzwalacze są uaktywniane do-

myślnie po ich utworzeniu. Instrukcja ��)�� może służyć do dezaktywowania

i następnie do ponownego aktywowania wyzwalaczy. Na przykład, poniższy kod najpierw

dezaktywuje, a następnie ponownie aktywuje wyzwalacz �� :

+A�B��())��!�*�#��+��+��9(+��?6�/��1��67

+A�B��())��!�*�#��+��+�� %?6�/��1��67


Wszystkie wyzwalacze dla poszczególnych tabel mogą być aktywowane lub dezaktywo-

wane za pomocą polecenia ��)�'��. Można również zastosować klauzulę ��'��)�� (aktywacja wszystkichwyzwalaczy) lub ��'��)��)�� (dezaktywacja

wszystkich wyzwalaczy). Poniżej znajduje się odpowiedni przykład:

+A�B��#$�� ())��+%��4��1��7

+A�B��#$��9(+��())��+%��4��1��7

Kolumna � � �� (status) perspektywy �� zawiera wartość <��'��< (aktywny)

albo wartość <��'��< (nieaktywny), wskazując bieżący status wyzwalacza. Dezaktywa-

cja wyzwalacza nie usuwa go ze słownika danych, jak w przypadku usunięcia wyzwalacza.

Skompilowana forma wyzwalacza p-kod

Kiedy pakiet lub podprogram jest składowany w słowniku danych, oprócz kodu źró-

dłowego danego obiektu jest również składowana jego skompilowana forma — p-kod.

Dla wyzwalaczy jest podobnie. Oznacza to, że można wywołać wyzwalacze bez koniecz-

ności ich ponownej kompilacji oraz są zapisywane informacje o zależnościach. Dzięki temu

wyzwalacze mogą być automatycznie unieważniane w taki sam sposób jak pakiety i pod-

programy. Jeśli wyzwalacz zostanie unieważniony, będzie ponownie skompilowany przy

następnym uruchomieniu.

Tabele mutujące

Istnieją pewne ograniczenia tabel i kolumn, do których może mieć dostęp treść wyzwa-

lacza. W celu zdefiniowania tych ograniczeń konieczne jest zrozumienie pojęć tabeli wią-

żącej i mutującej. Tabela mutująca jest tabelą, która w danej chwili jest modyfikowana

przez instrukcję DML. W przypadku wyzwalacza jest to tabela, dla której zdefiniowano

wyzwalacz. Tabelami mutującymi mogą być także tabele, które mogą wymagać uaktual-

nienia w wyniku kaskadowego usuwania danych (��)$�$�) przy występujących

więzach integralności referencyjnej (więcej informacji dotyczących więzów integralności

referencyjnej znajduje się w dokumentacji Oracle Server Reference). Tabela wiążąca jest

tabelą, która może wymagać odczytu ze względu na więzy integralności referencyjnej. Dla

zilustrowania tych definicji proszę przeanalizować przykładową tabelę #�� "�� , która jest tworzona przez podany niżej kod:


��5��5�/�� #$��#$�� $�� !"��W�� &�� !��/6$�� &�� !��*#5�� !"�� &�� !��D��


�& +��( �� S��( ��C�C��C�C��C�C��C9C��C�C��& +��( �� #$�� $��8&��() �S�:��#$�� $��8�� +��#$��$��& +��( �� /6$�� *#5��8&��() �S�:��/6$��*#5��8�� +��5#6��/6$��*#5��%

Tabela #�� "�� zawiera dwie deklaracje więzów integralności refe-

rencyjnej. Zarówno tabela � ��, jak i tabela �� są tabelami wiążącymi dla tabeli

#�� "�� . Sama tabela #�� "�� podlega mutacji podczas

wykonywania dla niej instrukcji DML. Z powodu istniejących więzów tabela �� i tabela� �� również wymagają modyfikacji i (lub) wykonania zapytań przez instrukcję DML.

Instrukcje SQL znajdujące się w treści wyzwalacza nie mogą wykonywać następujących

operacji:

� Odczytywać lub modyfikować tabeli mutującej wskazanej w instrukcji wyzwalającej.

Zasada ta dotyczy samej tabeli wyzwalającej.

� Odczytywać lub modyfikować kolumny klucza głównego, unikatowego lub obcego

tabeli wiążącej dla tabeli wyzwalającej. Jednak w razie potrzeby instrukcje SQL

mogą przeprowadzać modyfikacje innych kolumn.

Powyższe ograniczenia dotyczą wszystkich wyzwalaczy na poziomie wiersza. W przypadku

wyzwalaczy na poziomie instrukcji ograniczenia te są prawdziwe tylko wtedy, gdy wy-

zwalacz na poziomie instrukcji jest uruchomiony w wyniku operacji kaskadowego usu-

wania (��)$�$�).

Jeżeli instrukcja ( +�� dotyczy tylko jednego wiersza, to wyzwalacze ��8&�� oraz �8��dla tego wiersza nie traktują tabeli wyzwalającej jako mutującej. Jest to jedyny przy-

padek, gdy wyzwalacz na poziomie wiersza może odczytywać lub modyfikować tabelę

wyzwalającą. Instrukcje takie jak:

( +��( �&��+��777

zawsze traktują tabele wyzwalającą jako mutującą, nawet jeżeli podzapytanie zwraca tylko

jeden wiersz.

Proszę przeanalizować poniższy wyzwalacz ;�� . Mimo że omawiany wyzwa-

lacz modyfikuje zarówno tabelę � ��, jak i tabelę ��, to jest on prawidłowy, po-

nieważ modyfikowane kolumny w tabelach � �� oraz �� nie są kluczami (w dal-

szej części niniejszego rozdziału podano przykład wyzwalacza nieprawidłowego):

Dostępne na płycie CD w skrypcie KaskadaZSinsert.sql.

��&��'��())��S�*�$�.+(��5��,-�!�5�6�#��/�6��<5��4��5��5�/�� #$��#$��5#67�-,��8&��( +��& ��5��5�/�� #$��8&��&?


9�� .��5#67��4� ��L�:'�%��)( ��HH�+5�/$��46��d�$��5#67��+��4� ��( �&�� .��8�&"��5#6��?��/6$��@�G��/7/6$�� 9�*#5�@�G��/7*#5%

��HH�"�$6K�*��4��>0�6�<��d�$��#$��7��!'9��#$��+��4�� @�4�� U�� .��?��(9�@�G��/7�#$�� $%

��HH�9�$��$��$��46��#$��=/�/��5#��7��!'9��5#6��+��4�� #$��/�@�4�� #$��/�U�D��?��/6$��@�G��/7/6$�� 9�*#5�@�G��/7*#5%� 9�S�*�$�.+(��5�%

Przykład tabeli mutującej

Można założyć, że dla każdej specjalności ograniczono liczbę studentów do 5. W takim

przypadku przydatne byłoby utworzenie wyzwalacza '�(!��)�� lub �� na po-ziomie wiersza dla tabeli � ��, tak jak pokazano poniżej:

Dostępne na płycie CD w skrypcie OgraniczSpec.sql.

��&��'��())��&�5��+��,-�9��*�>$��2��5��4;��#$��=/�$��W7�M�>��5��*5��6��/6/�1��6��410$��25�$��/��5��$#56��5�� 55�57�-,��8&��( +��&��!'9��&8��& ��#$��8&��&?9�� "�* � +�#$��/��& +�� !"��G@�W%�� +�#$��/� !"��%��)( ��HH�&*5�2��4��>0��46��#$��=/�$��2��7+��&! ��-��( �&�� +�#$��/��8�&"��#$��?��@�G��/7��%

��HH�M�>��/��6�<��/6/�1��41;$#7��(8�� +�#$��/�U�D�B�� "�* � +�#$��/�� (+� �''�(��(& ��&��H��C.��$#>��#$��=/�$��2��C�QQ�G��/7��%�� 9�(8%� 9�&�5��+��%


Wydawałoby się, że dzięki temu wyzwalaczowi można uzyskać pożądany wynik. Jednak

jeżeli uaktualni się tabelę � �� i uruchomi powyższy wyzwalacz, to wystąpią na-

stępujące błędy:

Dostępne na płycie CD jako część skryptu OgraniczSpec.sql.

+A�B�!'9��#$��+��@�C��5��C��?��(9�@�D��%!'9��#$��-�EF9�/��DG&��H�V�YDG��4��'�.:S��97+�!9� �+��#�#��>��463��/�$��$��/6�/��#4�K#�*��&��H�JWD�G�/�]'�.:S��97&)�� (�.+'��]��I&��H�V�XXG�410$��$��/6*��6/��/6�/��C'�.:S��97&)�� (�.+'��C

Wystąpienie błędu !��7=7>6 jest spowodowane wykonaniem przez wyzwalacz !��#�� zapytania na swojej własnej tabeli wyzwalającej, będącej w trakcie mutowania. Błąd

!��7=7>6 jest wywołany podczas uruchamiania wyzwalacza, a nie jego tworzenia.

Rozwiązanie problemu błędu tabeli mutującej

Tabela � �� mutuje tylko dla wyzwalacza na poziomie wiersza. Oznacza to, że na tej

tabeli nie można wykonać zapytania w wyzwalaczu na poziomie wiersza, ale można wy-

konać zapytanie w wyzwalaczu na poziomie instrukcji. Jednak nie można po prostu za-

mienić wyzwalacza na poziomie wiersza (!��#��) na wyzwalacz na poziomie in-

strukcji, ponieważ w treści wyzwalacza konieczne jest użycie wartości ,��"-��.Rozwiązaniem tej sytuacji jest utworzenie dwóch wyzwalaczy — na poziomie wiersza

i na poziomie instrukcji. W wyzwalaczu na poziomie wiersza można zapisać wartość ,��"-��, ale nie można wykonać zapytania na tabeli � ��. Zapytanie jest wy-

konywane w wyzwalaczu na poziomie instrukcji i w ten sposób jest wykorzystana wartość

zapisana w wyzwalaczu na poziomie wiersza.

W celu zapisania tej wartości najlepszym sposobem jest wykorzystanie tabeli PL/SQL

wewnątrz pakietu. Dzięki temu można zapisać wiele wartości w ciągu jednej operacji uak-

tualniania tabeli. Ponadto każda sesja tworzy własny egzemplarz zmiennych pakietowych,

zatem problem jednoczesnego uaktualniania danych w różnych sesjach jest rozwiązany.

Taką metodę zastosowano w pakiecie DaneStudenta oraz w wyzwalaczach %!��#�� oraz �!��#��:

Dostępne na płycie CD jako część skryptu Mutujace.sql.

��&��'��'��S�)��9��+�#$��+��:'�� +��(+��&8��#$��7��L�:'��( 9�T��:��( ��: ( ��)��%��:'�� (9�(+��&8��#$��7(9L�:'��( 9�T��:��( ��: ( ��)��%


�� +��+�#$��/�� +��%�� (9+�#$��/�� (9%�� 4�.��/��( ��: ( ��)��G@��%� 9�9��+�#$��%

��&��'��())��?&�5��+��8&��( +��&��!'9��&8��& ��#$��8&��&?��)( ��,-�.�5��5�/��/6�<�$��6�<�/��*��9��+�#$��7� ��$�*��#��;��/��4��#$��/��#�#��*��;��41;$#�&��HV�YD7�-,��9��+�#$��7� ��4�.��/�G@�9��+�#$��7� ��4�.��/�U�D%��9��+�#$��7� +��+�#$��/�9��+�#$��7� ��4�.��/��G@��G��/7��%��9��+�#$��7� (9+�#$��/�9��+�#$��7� ��4�.��/��G@�G��/7�$%� 9�?&�5��+��%

��&��'��())��(&�5��+��8��( +��&��!'9��&8��& ��#$��9�� "�* � +�#$��/��& +�� !"��G@�W%�� +�#$��/�� !"��%�� +�#$��(9��#$��7(9L�:'�%�� +��#$��7��L�:'�%��)( ��,-�';��$��*�>$��#$��*�=5��$��/5�/�$��$��4��6��#4��#�*�#��5�/$��6��5��*5��#7�-,��8&�� (�$�*'��( �D779��+�#$��7� ��4�.��/��&&'�� +�#$��(9�G@�9��+�#$��7� (9+�#$��/�� (�$�*'��%�� +��G@�9��+�#$��7� +��+�#$��/�� (�$�*'��%

��HH�&*5�2��4��>0��46��#$��=/�/��2��7��+��&! ��-��( �&�� +�#$��/��8�&"��#$��?��@�� +��%

��HH�M�>��e��1��41;$#7��(8�� +�#$��/�B�� "�* � +�#$��/�� (+� �''�(��(& ��&��H��C.��$#>��#$��=/�/��2��C�QQ�� +��QQ��C��/�$#��#$��C�QQ�� +�#$��(9�%�� 9�(8%�� 9��&&'%

��HH�?6��5�/��*��*��46�5�6��;�6��/6*��#�/6*�5�6�6/��/��$��7��9��+�#$��7� ��4�.��/�G@��%� 9�(&�5��+��%

Należy pamiętać, aby przed uruchomieniem powyższego skryptu usunąć nieprawidłowywyzwalacz &�5��+��.

Można teraz przetestować prawidłowość działania powyższych wyzwalaczy poprzez uak-

tualnianie tabeli � �� do momentu, kiedy będzie zbyt dużo studentów studiujących

przedmiot &�� :


+A�B�!'9��#$��+��@�C��5��C��?��(9�@�D��%D�/��5��1��$6K�*�/��67

+A�B�!'9��#$��+��@�C��5��C��?��(9�@�D��%D�/��5��1��$6K�*�/��67

+A�B�!'9��#$��+��@�C��5��C��?��(9�@�D��Y%!'9��#$��-�EF9�/��D%&��H��G�.��$#>��#$��=/��2��5��/�$#��#$��D��Y&��H�JWD�G�/�]'�.:S��97(&)�� (�.+'��]��DY&��H�V�XXG�410$��$��/6*��6/��/6�/��C'�.:SE�97(&)�� (�.+'��C

Zatem działanie powyższego kodu jest zgodne z założeniami i prawidłowe. Technika ta

jest przydatna przy występowaniu błędu !��=7>6, kiedy wyzwalacz na poziomie wiersza

ma odczytywać lub modyfikować tabelę mutującą. Zamiast przeprowadzania tego niepra-

widłowego przetwarzania w wyzwalaczu na poziomie wiersza, można je przekazać do

wyzwalacza (�� na poziomie instrukcji, gdzie będzie zachodziło prawidłowo. Tabele

pakietowe PL/SQL są używane do składowania zmodyfikowanych wierszy.

Stosując opisywaną technikę, należy pamiętać o kilku istotnych zagadnieniach:

� Tabele PL/SQL znajdują się w pakiecie, tak że będą widoczne dla wyzwalacza

zarówno na poziomie wiersza, jak i na poziomie instrukcji. Jedynym sposobem

zapewnienia globalności tych zmiennych jest umieszczenie ich w pakiecie.

� Wykorzystano zmienną licznika �� -#��#*� ��". Podczas tworzenia

pakietu zmienną zainicjowano wartością 0. Zmienna licznika jest inkrementowana

przez wyzwalacz na poziomie wiersza. Wyzwalacz na poziomie instrukcji

wywołuje ją i następnie zeruje jej wartość po przetworzeniu. Jest to konieczne,

aby następna instrukcja w tej sesji miała poprawną wartość.

� Sposób sprawdzania maksymalnej liczby studentów w wyzwalaczu �!��#��należy trochę zmienić. Obecnie jest to wyzwalacz (�� na poziomie instrukcji,

a zatem zmienna #�'��#�� " zawiera liczbę studentów danej specjalności

po wstawieniu lub uaktualnieniu danych, a nie przed tym zdarzeniem. Tak więc

sprawdzenie dla #�'��#�� ")?6, przeprowadzane w wyzwalaczu

!��#��, jest zastąpione przez zmienną #�'��#�� ".

� Zamiast tabel PL/SQL można zastosować tabelę bazy danych. Nie zaleca się

stosowania tej techniki, ponieważ wydawanie instrukcji �� w odbywających

się równocześnie sesjach powodowałoby powstawanie kolizji (w systemie Oracle8i

oraz w wersjach wyższych można zastosować tabelę tymczasową). Tabele PL/SQL

są niepowtarzalne między sesjami, dzięki czemu unika się tego problemu.


Podsumowanie

Jak można się było przekonać, wyzwalacze stanowią cenne uzupełnienie języka PL/SQL

i bazy danych Oracle. Mogą być stosowane w celu wymuszania ograniczeń danych o wiele

bardziej złożonych niż zwykłe więzy integralności referencyjnej. W systemie Oracle8i

rozszerzono właściwości wyzwalaczy o zdarzenia inne niż operacje DML dla tabel lub

perspektyw. Przedstawienie wyzwalaczy zamyka omawiane we wcześniejszych trzech roz-

działach zagadnienia dotyczące nazwanych bloków PL/SQL.

W ostatnim rozdziale omówiono kilka zaawansowanych możliwości języka PL/SQL.

Oracle9i. Programowanie w języku PL/SQL

Technology

Transcript of Oracle9i. Programowanie w języku PL/SQL