UČEBNÍ TEXTY OSTRAVSKÉ UNIVERZITY __________________________________________________ Přírodovědecká fakulta
ÚVOD DO DATABÁZÍ II (DISTANČNÍ VÝUKOVÁ OPORA)
Zdeňka Telnarová
_____________________________________________ Ostravská univerzita
OBSAH 1 Databázové struktury v Oracle............................................................................................ 4 1.1 Tabulky......................................................................................................................... 4 1.1.1 Vestavěné datové typy .............................................................................................. 4 1.1.2 Abstraktní datové typy .............................................................................................. 5 1.2 Indexy........................................................................................................................... 7 1.3 Shluky........................................................................................................................... 7 1.4 Sekvence....................................................................................................................... 7 1.5 Uživatelé a oprávnění................................................................................................... 8 1.6 Synonyma..................................................................................................................... 8 1.7 Programové jednotky ................................................................................................... 8 1.8 Triggery........................................................................................................................ 9 1.9 Databázová propojení................................................................................................... 9 1.10 Segmenty.................................................................................................................... 9 1.11 Snímky, materializované pohledy .............................................................................. 9 2 Nástroje pro administraci a práci s daty ............................................................................ 11 2.1 SQL*Plus ................................................................................................................... 11 2.1.1 Příkazy jazyka SQL................................................................................................. 11 2.1.2 Programové bloky v jazyce PL/SQL....................................................................... 13 2.2.3 Příkazy konzolové aplikace..................................................................................... 14 2.2 Konzolová aplikace TOAD ........................................................................................ 15 2.2.1 Několik příkladů použití aplikace TOAD ............................................................... 15 3 Jazyk SQL ......................................................................................................................... 17 3.1 Části jazyka SQL........................................................................................................ 17 3.2 Základní příkazy DDL ............................................................................................... 17 3.3 Přehled Syntaxe některých příkazů jazyka SQL ........................................................ 18 4 Jazyk PL/SQL – struktura jazyka, základy syntaxe, řízení průběhu programu, ošetření chyb, kurzory, databázové triggery ...................................................................................... 20 4.1 Struktura jazyka.......................................................................................................... 20 4.2 Základy syntaxe.......................................................................................................... 20 4.2.1 Konstanty, proměnné, funkce.................................................................................. 20 4.2.2 Řízení průběhu programu........................................................................................ 22 4.2.3 Přístupové proměnné............................................................................................... 25 4.3 Kurzory....................................................................................................................... 26 4.3.1 Použití explicitních kurzorů .................................................................................... 26 4.3.2 Deklarace kurzoru ................................................................................................... 26 4.3.3 Otevření kurzoru ..................................................................................................... 26 4.3.4 Načtení záznamů ..................................................................................................... 27 4.3.5 Uzavírání kurzoru.................................................................................................... 27 4.3.6 Aktualizační operace s kurzorem ............................................................................ 28 4.3.7 Atributy explicitních kurzorů .................................................................................. 28 4.3.8 Cykly FOR s kurzory .............................................................................................. 29 4.4 Chyby a nestandardní stavy........................................................................................ 30 4.5 Procedury, funkce, balíky........................................................................................... 30 4.5.1 Vytvoření procedury nebo funkce........................................................................... 31 4.5.2 Provádění uložených procedur ................................................................................ 32 4.5.3 Zrušení procedury ................................................................................................... 32 4.6 Balíky (sady) .............................................................................................................. 32 4.6.1 Vytvoření specifikace sady ..................................................................................... 33 4.6.2 Vytvoření těla sady.................................................................................................. 33
2
4.6.3 Přístup ke konstrukcím sady ................................................................................... 34 4.6.4 Zrušení sady ............................................................................................................ 35 4.7 Databázové triggery ................................................................................................... 35 4.7.1 Vytvoření databázového triggeru ............................................................................ 35 4.7.2 Prefixy v databázových triggerech.......................................................................... 36 4.7.3 Postup při spouštění databázového triggeru............................................................ 37 4.7.4 Aktivace a deaktivace triggerů................................................................................ 37 4.7.5 Korespondenční úkol.......................................... Chyba! Záložka není definována. 5 Použitá literatura ............................................................................................................... 39
3
1 Databázové struktury v Oracle Cíl: Jak již bylo vysvětleno, databázová technologie je založena na manipulaci s daty, která jsou uložena do předem vytvořených struktur. Jednou ze základních struktur je databázová tabulka. Ovšem schéma databáze v ORACLE je podstatně složitější a využívá dalších struktur jako jsou indexy, pohledy, shluky, posloupnosti, synonyma, atd. V této kapitole se budeme databázovým strukturám v ORACLE věnovat podrobněji.
1.1 Tabulky Tabulky slouží jako uložiště dat, mají pevný počet sloupců, každý sloupec je definován nad danou doménou, tzn. je mu přiřazen datový typ, event. další podmínky platnosti.
1.1.1 Vestavěné datové typy Následující tabulka obsahuje přehled datových typů platných pro ORACLE 8, 8i a 9i. Datový typ CHAR NCHAR
VARCHAR2 NVARCHAR2
DATE
INTERVAL DAY TO SECOND
INTERVAL YEAR TO MONTH
TIMESTAMP
Popis Znakový atribut s pevnou délkou (až 2000 B) Atribut s pevnou délkou pro vícebajtové znakové sady. Maximální velikost je 2000 znaků nebo 2000 bajtů na řádek v závislosti na typu znakové sady. Výchozí hodnota je 1B. Znakový atribut s proměnnou délkou (až 4000 znaků) Znakový atribut s proměnnou délkou pro vícebajtové znakové sady. Maximální velikost je 2000 znaků nebo 2000 bajtů na řádek v závislosti na typu znakové sady. Výchozí hodnota je 1B. 7 bajtový atribut s pevnou délkou sloužící k uložení všech kalendářních dat. Čas je uložen jako součást data. Formát je implicitně DD-MMM-RR. Tento formát lze změnit pomocí parametru NLS_DATE_FORMAT. Časové období s pevnou délkou 11 bajtů představující dny, hodiny, minuty a sekundy. Hodnoty přesnosti určují počet číslic v poli DAY a zlomkovém poli SECOND kalendářního data. Výchozí hodnota přesnosti pro dny je 2 a pro sekundy je 6. Tyto hodnoty lze měnit od 0 do 9. Časové období s pevnou délkou 5 bajtů představující roky a měsíce. Hodnota přesnosti určuje počet číslic v poli YEAR kalendářního data. Výchozí hodnota přesnosti pro roky je 2, ale lze ji měnit od 0 do 9. Hodnota mezi 7 a 10 bajty představující datum a čas. Závisí na hodnotě systémových hodin. Hodnota přesnosti určuje počet číslic ve zlomkové části atributu typu SECOND kalendářního data. Výchozí hodnota přesnosti pro sekundy je 6, ale lze ji měnit
4
TIMESTAMP WITH TIME ZONE
TIMESTAMP WITH LOCAL TIME
NUMBER
LONG RAW LONG RAW BLOB CLOB NCLOB NCLOB BFILE ROWID
UROWID
od 0 do 9. Hodnota s pevnou délkou 13 bajtů zastupující datum a čas a příslušné nastavení časového pásma. Časové pásmo může představovat posun vůči času GMT nebo název oblasti. Hodnota mezi 7 a 11 bajty. Tento datový typ má podobnou funkci jako datový typ TIMESTAMP WITH TIME ZONE. Rozdíl je v tom, že datum je u tohoto typu při ukládání přizpůsobeno časovému pásmu databáze a při načítání časovému pásmu klienta. Číslo s proměnnou délkou. Povoleny jsou kladné a záporné hodnoty a nula. Interní úložiště pro hodnotu NUMBER vyžaduje místo, jehož hodnota v bajtech odpovídá přibližně polovině počtu platných číslic v hodnotě NUMBER. Atribut s proměnnou délkou (až 2 GB). Atribut s proměnnou délkou (až 2000 bajtů) používaný pro binární data. Atribut s proměnnou délkou (až 2 GB bajtů) používaný pro binární data. Binární objekt velkého rozsahu (až 4GB). Znakový objekt velkého rozsahu (až 4GB). Znakový objekt velkého rozsahu (až 4 GB). Datový typ CLOB pro vícebajtové znakové sady (délka až 4GB). Externí binární soubor, jehož velikost je omezena operačním systémem. Binární data představující identifikátor OiwID. Všechny identifikátory RowID pro běžné indexy tabulkách bez oddílů, místní indexy v tabulkách s oddíly a ukazatele řádků používané pro zřetězené nebo přesunuté řádky mají velikost 6 bajtů. Pouze identifikátor RowID pro globální indexy v tabulkách s oddíly má velikost 10 bajtů. Binární data používaná k adresování dat. Jejich délka může dosáhnout až 4000 bajtů a mohou podporovat logické a fyzické hodnoty identifikátoru RowID a cizí tabulky, ke kterým lze získat přístup prostřednictvím brány.
1.1.2 Abstraktní datové typy ORACLE od verze 8 umožňuje definovat vlastní datové typy. Těmito typy je typ objekt, pole a vestavěná tabulka.
Příklad definice datového typu objekt a jeho využití při definování struktury tabulky. 5
CREATE TYPE osoba AS OBJECT (jmeno varchar2(15), prijmeni varchar2(15), telefon varchar2(20)); CREATE TABLE student (osobni_cislo varchar2(10) primary key, os_udaje osoba);
Příklad definice datového typu pole a jeho využití při definování struktury tabulky. CREATE TYPE ceny AS varray(10) of number (12,2); CREATE TABLE zbozi (kod number prodano ceny);
primary key,
Příklad definice datového typu vestavěná tabulka. CREATE TYPE adresa AS TABLE (ulice varchar2(20), cislo varchar2(10), město varchar2(20));
Příklad vložení dat do tabulky student Nejdříve upravíme strukturu tabulky student vložením atributu bydliste ALTER TABLE student ADD bydliste adresa; INSERT INTO student VALUES (’R0001’, osoba(’Jan’, ’Novák’,’ +420596160111’),adresa(’Dlouhá’,’300’,’Ostrava’)); Po zavedení abstraktního datového typu se v systému ORACLE automaticky vytvoří metoda nazývaná konstruktor, která podporuje jazyk DML pro sloupec, který používá daný datový typ. Např. datovému typu osoba odpovídá konstruktor s názvem osoba a jeho atributy jsou parametry příslušné metody.
6
1.2 Indexy Index je databázová struktura, kterou slouží k rychlému vyhledávání řádků tabulky. ORACLE rozeznává tři základní druhy indexů. Indexy shluků (shluky viz. 2.3), indexy tabulek a bitmapové indexy. ORACLE automaticky vytvoří index na tabulku v případě, když příkaz create table obsahuje klauzuli UNIQUE nebo PRIMARY KEY. Vlastní indexy může uživatel vytvářet pomocí příkazu CREATE INDEX. Indexy lze vytvářet pro jeden nebo více sloupců tabulky. ORACLE využívá při tvorbě indexů metody B-stromů. Problém indexů spočívá v tom, že zrychlení vyhledávání dat je doprovázeno zpomalením aktualizačních operací, protože vedle zápisu dat do příslušné tabulky je třeba také aktualizovat indexy. ORACLE odstraňuje některé nevýhody klasických indexů pomocí indexů bitmapových. Vhodnost využití bitmapových indexů nastává v tom případě, jsou-li data velmi podobná (rozdíly mezi hodnotami ve sloupci jsou malé). Bitmapové indexy jsou nejvhodnější pro statická data.
1.3 Shluky Shluk umožňuje alternativní metodu uložení dat do databáze. Definování shluků neovlivňuje logiku dat uložených v databázi, může však významně ovlivnit dobu zpracování jednotlivých databázových operací. Shluky je rozumné vytvořit na tabulky, na které se často dotazujeme (tzn. na které často uplatňujeme operaci spojení). Shluk drží takto definované tabulky pohromadě a tato skutečnost způsobí zvýšení výkonu minimalizací počtu nutných V/V operací. Sloupce sdružených tabulek se nazývají klíč shluku (klíč shluku je vazebním klíčem mezi těmito tabulkami), na tento klíč shluku je vytvořen index. Index shluku je společný nad všemi tabulkami, které jsou do shluku zařazeny. Každá nová hodnota klíče shluku způsobí vytvoření nového logického bloku. U dotazů, založených na ekvivalenci (např. SELECT * FROM pacient WHERE rc=’8201011234’) je výhodné používat hašované shluky (využití funkce hash pro určení fyzického místa uložení záznamu).
1.4 Sekvence Sekvence je objekt, který generuje automaticky se zvyšující čísla (identifikátory jednotlivých řádků tabulek). Mnoho aplikací tuto potřebu má, hlavně pokud se jedná o aplikace, se kterými pracuje více uživatelů. Uživatel má k dispozici dvě funkce: NEXTVAL (vygeneruje další hodnotu sekvence) a CURVAL (vrátí aktuální hodnotu sekvence).
Příklad Vytvoříme tabulku zamestnanec CREATE TABLE zamestnanec (os_cislo number not null, jmeno varchar2(15), prijmeni varchar2(15) plat number); Vytvoříme sekvenci, která vygeneruje první hodnotu = 1 a další sekvence budou narůstat s krokem 1. CREATE SEQUENCE seq_id; 7
Vložíme data do tabulky INSERT INTO zamestnanec VALUES (seq_id.nextval, ‚Jan‘, ‚Novák’); INSERT INTO zamestnanec VALUES (seq_id.nextval, ‚Pavel‘, ‚Dlouhý’); INSERT INTO zamestnanec VALUES (seq_id.nextval, ‚Jana‘, ‚Nováková’); INSERT INTO zamestnanec VALUES (seq_id.nextval, ‚Eva‘, ‚Malá’); Příkaz SELECT * FROM zamestnanec pak vypíše následující data Os_cislo 1 2 3 4
jmeno Jan Pavel Jana Eva
prijmeni Novák Dlouhý Nováková Malá
1.5 Uživatelé a oprávnění Uživatelský účet nepatří mezi fyzické struktury databáze, ale má důležité vazby s objekty databáze, protože uživatelé jsou vlastníky databázových objektů. Objekty vytvořené v databázi jsou přiřazeny k uživatelským účtům. Databázová platforma ORACLE je typickým příkladem víceuživatelského prostředí. Proto je velmi důležité definovat přístupová práva jednotlivým uživatelům k databázovým strukturám a specifikovat rozsah jejich oprávnění.
Příklad vytvoření nového uživatele CREATE USER přihlašovací_jméno IDENTIFIED BY heslo
Příklad definice oprávnění k databázovým strukturám GRANT oprávnění [, oprávnění] to uživatel [, uživatel]
1.6 Synonyma Synonymum je úplná specifikace databázového objektu. Může např. obsahovat název hostitelského počítače, název instance, vlastníka objektu a název objektu. Aby nemusel uživatel všechny tyto údaje vypisovat, je možné nadefinovat příslušné synonymum. Synonyma jsou tedy ukazatele na tabulky, pohledy, procedury, funkce, balíky a sekvence. Mohou ukazovat na objekty v rámci lokální databáze nebo ve vzdálených databázích.
1.7 Programové jednotky Jedná se o společné označení uložených podprogramů (procedury a funkce) a jejich balíky. Programová jednotka je popsána pomocí jazyka PL/SQL a po přeložení je uložena do databáze v systémovém katalogu a zveřejněna pro opakované použití libovolnými aplikacemi. Je možno definovat vlastní procedury a funkce a soustřeďovat je do logických seskupení, tzv. balíků. Kromě toho existují standardní, komerčně dodávané, balíky.
8
1.8 Triggery Triggery jsou procedury, které se spouštějí v případě, že dojde ke specifikované události. Existují dva typy triggerů: • triggery příkazů – spustí se jednou při každém odpovídajícím příkazu • triggery řádků – spustí se jednou pro každý řádek tabulky, nad kterým probíhá nějaký příkaz. Mezi podporované události patří příkazy INSERT, UPDATE a DELETE. Lze vytvořit např. trigger BEFORE INSERT, AFTER INSERT, INSTEAD OF INSERT. Triggery jsou základními nástroji pro zachování integrity databáze.
1.9 Databázová propojení Databáze ORACLE se mohou odkazovat na data uložená mimo lokální databázi.Chceme-li zadat přístupovou cestu k vzdálenému objektu (např. při definování synonym), musíme nejdříve vytvořit databázové spojení.
Příklad vytvoření databázového spojení CREATE public DATABASE LINK me_spojeni CONNECT TO přihlašovací_jméno identified BY heslo USING ‘název_služby’ Názvy služeb jsou ukládány v konfiguračních souborech, které používá ORACLE NET. Konfigurační soubor, který uchovává názvy služeb se nazývá tnsnames.ora.
1.10 Segmenty Segmenty jsou fyzické protějšky logických databázových objektů, které uchovávají data. Segment musí být přidělen k tabulkovému prostoru v databázi. Segmenty se skládají z částí nazývaných rozsahy, což jsou souvislé sady bloků. Pokud do stávajících rozsahů segmentu již nebude možné vkládat nová data, obdrží segment další rozsah. Z důvodu zachování konzistentního čtení a kvůli možnosti odvolání transakce má ORACLE mechanizmus pro zrekonstruování databáze po nepotvrzené transakci. Tento mechanizmus je založen na tzv. návratových segmentech, do kterých se ukládají předchozí podoby v databázi před započetím transakce.
1.11 Snímky, materializované pohledy Snímek je objekt, který obsahuje repliku základní tabulky, která je umístěna ve vzdálené databázi. Základní tabulka může mít libovolné množství replik. Replika je uživatelům dostupná pouze pro dotazování, aktualizační operace se provádějí vždy na základní tabulkou. Na rozdíl od snímků, materializované pohledy umožňují provádět i aktualizační operace nad replikami. Ke zrychlení procesu replikace lze použít protokol materializovaného pohledu.
9
Pojmy k zapamatování: Vestavěné datové typy Abstraktní datové typy Indexy Shluky Sekvence Synonyma Programové jednotky Segmenty Snímky, pohledy
10
2 Nástroje pro administraci a práci s daty Cíl: Pro práci s daty prostřednictvím jazyka SQL potřebujeme nejméně nějakou konzolovou aplikaci, prostřednictvím které můžeme jednak zadávat příkazy a také sledovat odezvy databázového serveru. Konzolová aplikace představuje jednoduchého prostředníka mezi uživatelem a databázovým serverem. Na tomto místě popíšeme dvě konzolové aplikace, jedna z nich od firmy Oracle, která je dodávaná a nainstalována spolu s databázovým serverem Oracle 9i, kterou je aplikace SQL*Plus a další konzolovou aplikací bude aplikace TOAD od firmy QUEST SOFTWARE (www.quest.com).
2.1 SQL*Plus Po spuštění konzolové aplikace je třeba se přihlásit k databázovému serveru. K tomu potřebujeme znát uživatelské jméno a heslo a také přihlašovací řetězec. Tento přihlašovací řetězec je ve tvaru: název_počítače:číslo_portu:název_databáze Pokud přihlašovací řetězec nezadáme, bude se konzolová aplikace přihlašovat k lokální databázi.
Příklad Přihlášení by mohlo vypadat např. takto:
Příkazy, zadávané pomocí konzolové aplikace, je možno rozdělit do dvou základních skupin: • příkazy jazyka SQL či programové bloky jazyka PL/SQL • příkazy samotné konzole
2.1.1 Příkazy jazyka SQL Příkazy jazyka SQL se ukončují středníkem. Syntaxe příkazů jsou uvedeny v kapitole 4. Zadávání příkazů jazyka SQL si ukážeme na příkladech
11
Příklad Vytvořte tabulku pokus, která bude obsahovat atribut id datového typu numer a atribut jmeno datového typu vharvar2 na 15 znaků Primárním klíčem tabulky bude id.
Příklad Vypište strukturu tabulky pokus
Příklad Vložte do tabulky pokus dva řádky dat.
Příklad Vypište obsah tabulky pokus.
12
2.1.2 Programové bloky v jazyce PL/SQL Pravidla pro zápis programových bloků příkazů jazyka PL/SQL jsou prakticky stejná jako pro jazyk SQL. Programový blok je oddělen znakem tečka nebo je možno použít lomítko na novém řádku.
Příklad Napište program, který pro čísla z intervalu <1, 5> určí, které z nich je sudé a které liché. set serverout on size 10000 begin for i in 1..5 loop if mod(i,2) = 0 then dbms_output.put_line (‘Cislo ‘ || i || ‘ je sude‘); else dbms_output.put_line (‘Cislo ‘ || i || ‘ je liche‘); end if; end loop; end; Výpis z konzoly SQL*Plus
13
2.2.3 Příkazy konzolové aplikace Konzolové aplikace mají vestavěný velmi jednoduchý systém nápověd, který lze spustit příkazem konzoly HELP INDEX Spuštění příkazového souboru Symbol @ (zavináč) umožňuje provádět příkazy, uložené v souboru (s přípolou .sql). Syntaxe je jednoduchá: @ specifikace_souboru, která může být specifikací k souboru, který je uložen na lokálním počítači (např. @c:\pokus.sql) nebo zadáním URL, pokud se soubor nachází na serveru http nebo FTP (např. @http://albert.osu.cz/pokus.sql). Tímto spouštěním lze rovněž předávat parametry. Máme-li ve skriptu např. použity parametry následujícím způsobem: Select * from zaměstnanec where jmeno like ‚&1%’ or jmeno like ‚&1%’ Můžeme tyto parametry předat pomocí argumentů u příkazu @: @c:\pokus.sql A B
Výsledkem budou všichni zaměstnanci, jejichž jméno začíná píslemen A nebo B. Přesměrování výstupu do souboru K přesměrování výstupu SQL příkazu z konzoly do souboru, můžeme použít příkaz SPOOL Výpis struktury databázové tabulky DESCRIBE [schéma.]tabulka Provedení příkazu/programového bloku EXECUTE příkaz Měření časového intervalu TIMING START začátek měření času TIMING STOP ukončení měření času. Mezi těmito dvěma příkazy umístíme příkazy jazyka SQL, jejichž dobu trvání změříme. Výstupem je čas ve tvaru hh:mm:ss.
14
2.2 Konzolová aplikace TOAD Konzolová aplikace TOAD nám umožňuje snadnější administraci databáze a nabízí velké množství funkcí. Toto způsobuje, že aplikace je velmi oblíbená mezi vývojáři aplikací v jazyce PL/SQL.
2.2.1 Několik příkladů použití aplikace TOAD
Příklad Vytvořte tabulku pokus1, která bude obsahovat atribut id datového typu numer a atribut jmeno datového typu vharvar2 na 15 znaků Primárním klíčem tabulky bude id. Vložte do tabulky dva řádky. Vypište strukturu tabulky a vypište obsah tabulky. Příkazy, zapsané v TOAD:
Výpisy v TOAD:
Příklad Prohlédněte si objekty databáze
15
Příklad Prohlédněte si strukturu tabulky pokus1
Příklad Prohlédněte si data v tabulce pokus1
Pojmy k zapamatování: Konzolové aplikace SQL*Plus Toad
16
3 Jazyk SQL Cíl: Cílem následující kapitoly je uvést základní přehled příkazů jazyka SQL, seznámit čtenáře s nejčastěji používanými příkazy definičního, manipulačního a dotazovacího jazyka. Důraz je kladen hlavně na dotazování. Obecná syntaxe je doplněna konkrétními příklady včetně řešení. Kapitola je zakončena korespondenčním úkolem
3.1 Části jazyka SQL Jazyk SQL (jako většina databázových jazyků) se skládá z následujících částí: • Jazyk pro definování dat (Data Definition Language) – DDL. • Jazyk pro manipulaci s daty (Data Manipulation Language) – DML. • Dotazovací jazyk (Data Query Language) – DQL. • Jazyk pro správu dat (Data Control Language) – DCL.
3.2 Základní příkazy DDL Poznámky k syntaxi: velkým písmem odtrženě () [] ... {}
klíčová slova defaultní hodnota údaj je nutno zapsat do () volitelný údaj více výrazů stejného typu, jako před čárkou výběr z uvedených možností
CREATE TABLE
Syntaxe: CREATE TABLE jméno_tabulky (atribut datový-typ [NOT NULL] [,...] [PRIMARY KEY (atribut, ..)] [FOREIGN KEY jméno (atribut, ...) REFERENCES nadřazená-tabulka [ON DELETE {RESTRICT, CASCADE, SET NULL}]]) Vytvoří schéma tabulky včetně primárního a cizích klíčů. CREATE INDEX Syntaxe: CREATE [UNIQUE] INDEX jméno_indexu ON jméno-tabulky (atribut [{ ASC, DESC}][, ...] ) Vytvoří index na primární, alternativní nebo inverzní klíč. UNIQUE - vytvoří index na alternativní klíč implicitně - inverzní klíč ALTER TABLE
Syntaxe: 17
ALTER TABLE jméno_tabulky DROP COLUMN atribut [ ,...] ADD (atribut datový_typ[NOT NULL]) RENAME COLUMN atribut TO nový_atribut MODIFY (atribut {nový_datový-typ, NULL, NOT NULL}) Změní strukturu tabulky smazáním, přidáním nebo přejmenováním atributu (ů), resp. změní jejich datový typ (doménu). Příkaz lze rovněž použít pro přejmenování tabulky. CREATE VIEW Syntaxe: CREATE VIEW jméno_pohledu [(atribut [,...])] AS SELECT Vytvoří pohled na základě výběru dat z existující tabulky či tabulek. Specifikace výběru je zapsána za klauzulí SELECT. K takto vytvořeným pohledům je možno vytvořit různá přístupová práva. DROP
Syntaxe: DROP {TABLE jméno-tabulky, VIEW jméno-pohledu, INDEX jméno-indexu} Zruší ze schématu databáze tabulku, pohled nebo index.
3.3 Přehled Syntaxe některých příkazů jazyka SQL CREATE TABLE jméno_tabulky (atribut datový_typ [DEFAULT][attribut_constraint] [, atribut datový_typ [DEFAULT] [attribut_constraint]], ... ) kde attribut_constraint má tvar: [CONSTRAINT jméno_omezení] { [NOT] NULL| { UNIQUE | PRIMARY KEY } | REFERENCES jméno_tabulky [(atribut)] [ ON DELETE CASCADE] | CHECK (podmínka) } ALTER TABLE jméno_tabulky [ADD { atribut datový_typ [DEFAULT] [attribut_constraint] | table_constraint }] [MODIFY atribut datový_typ [DEFAULT] [atribut_constraint], ...] kde table_constraint má tvar: [CONSTRAINT jméno_omezení] { { UNIQUE | PRIMARY KEY } (atribut [,atribut] ... ) | FOREIGN KEY (atribut [,atribut] ...) REFERENCES jméno_tabulky [(atribut [,atribut] ... ) ] } CREATE [UNIQUE] INDEX jméno_indexu 18
ON jméno_tabulky (atribut [ASC] | [DESC][, atribut [ASC] | [DESC] ] ...) DROP INDEX
jméno_indexu
DROP TABLE jméno_tabulky [CASCADE CONSTRAINT]
Pojmy k zapamatování: SQL – Structured Query Language DDL – Data Definition Language DML – Data Manipulation Language DQL – Data Query Language
19
4 Jazyk PL/SQL – struktura jazyka, základy syntaxe, řízení průběhu programu, ošetření chyb, kurzory, databázové triggery Cíl: Jazyk SQL je jazykem deklarativním, který neobsahuje procedurální příkazy jako jsou cykly, podmínky, procedury, funkce, atd. Rozšířením jazyka SQL o proceduralitu od společnosti ORACLE je jazyk PL/SQL (Processing Language/Structured Query Language). Jazyk PL/SQL umožňuje deklarovat konstanty, proměnné a kurzory, podporuje transakční zpracování, řeší chybové stavy pomocí výjimek. PL/SQL podporuje modularitu
4.1 Struktura jazyka Typická struktura programového bloku se skládá ze tří částí: • deklarační část • výkonná část • část pro zpracování výjimek (ošetření chyb a nestandardních stavů) Deklarační část obsahuje deklarace proměnných, konstant, kurzorů, atd. Výkonná část funkční logiku (algoritmus programového bloku), část výjimek řeší vzniklé chyby. Povinná je pouze část výkonná. Strukturu znázorníme na následujícím obrázku DECLARE Deklarace proměnných, konstant a kurzorů
BEGIN Výkonné příkazy
EXCEPTION Ošetření nestandardních stavů
END;
4.2 Základy syntaxe 4.2.1 Konstanty, proměnné, funkce PL/SQL podporuje používání konstant a proměnných. Deklarují se v deklarační části (DECLARE) a po té je můžeme používat v rámci daného bloku a ve všech vnořených blocích. Deklarujeme-li konstantu (constant), přiřazujeme dané položce hodnotu, kterou již nelze měnit. 20
Příklad deklarace konstanty DECLARE p_nasob constant number(3,2) :=1.15; p_plat number(7,2); p_bonus number(9,2); BEGIN p_bonus := p_plat*p_nasob; . . . END;
Příklad použití funkce DECLARE p_jmeno char(5); BEGIN SELECT upper(jmeno) INTO p_jmeno FROM zaměstnanec; END; Tato procedura poskytne všechny hodnoty atributu jmeno z tabulky zamestnanec, převede písmena na velká a uloží do proměnné p_jmeno, deklarované v části declare. Pokud bychom chtěli hodnoty proměnné p_jmeno vypsat na konzolu, museli bychom proceduru doplnit následovně: DECLARE p_jmeno char(15); BEGIN SELECT upper(jmeno) INTO p_jmeno FROM zaměstnanec; dbms_output.put_line (p_jmeno); END; A ještě před spuštěním procedury bychom museli aktivovat výpis na konzolu příkazem SET SERVEROUT ON. Příkaz mdbs_output.put_line je příkaz balíku mdbs_output, což je standardní balík ORACLE pro výpis textu. Takto zapsaná procedury i s aktivací výpisu na konzolu by vrátila správný výsledek pouze v případě, že by v tabulce zamestnanec byl jediný řádek a tudíž v proměnné p_jmeno byla pouze jedna hodnota.
21
Nyní si upravíme proceduru (s využitím cyklu a kurzoru, které probereme později) tak, aby výpis fungoval nezávisle na tom, kolik řádků má tabulka zamestnanec. DECLARE p_jmeno char(15); CURSOR k1 IS SELECT upper(jmeno) FROM zamestanec; BEGIN OPEN k1; LOOP FETCH k1 INTO p_jmeno; dbms_output.put_line (p_jmeno); EXIT WHEN k1% NOTFOUND; END LOOP; CLOSE k1; END;
4.2.2 Řízení průběhu programu Průběh procedury lze ovládat různými způsoby – pomocí podmíněného nebo iteračního řízení. Podmíněné řízení zajišťuje příkaz IF a CASE, iterační řízení příkaz LOOP. Syntaxe příkazu IF IF podmínka THEN příkazy_1; ELSIF podmínka THEN příkazy_2; . . . ELSE příkazy_n; END IF;
Příklad použití příkazu IF Příklad bude vkládat řádky do tabulky titultab na základě obsahu řádků v tabulce osoby DECLARE p_pohlavi char(1); p_jmeno char(15); p_stav char(1); CURSOR k2 IS SELECT jmeno, pohlavi, stav FROM osoby; BEGIN OPEN k2; LOOP
22
FETCH k2 INTO p_jmeno, p_pohlavi, p_stav; EXIT WHEN k2%NOTFOUND; IF p_pohlavi ‚M’ THEN INSERT INTO titultab (jmeno, pohlavi, stav, titul) VALUES (p_jmeno,p_pohlavi,p_stav,’Pan’); ELSEIF (p_pohlavi ‚Z’ and p_stav ‘M’) then INSERT INTO titultab (jmeno, pohlavi, stav, titul) VALUES (p_jmeno,p_pohlavi,p_stav,’Paní’); ELSE INSERT INTO titultab (jmeno, pohlavi, stav, titul) VALUES (p_jmeno,p_pohlavi,p_stav,’Slečna’); END IF; END LOOP; COMMIT; CLOSE k2; END; Syntaxe příkazu CASE CASE proměnná WHEN výraz_1 THEN příkazy_1; WHEN výraz_2 THEN příkazy_2; WHEN výraz_3 THEN příkazy_3; WHEN výraz_n THEN příkazy_n; ELSE příkazy_n+1 END CASE
Příklad SET SERVEROUT ON size 10000 DECLARE znamka constant number(1):=1; BEGIN CASE znamka WHEN 1 THEN dbms_output.put_line(‘Výborný’); WHEN 2 THEN dbms_output.put_line(‘Chvalitebný’); WHEN 3 THEN dbms_output.put_line(‘Dobrý’); WHEN 4 THEN dbms_output.put_line(‘Dostatečný’); WHEN 5 THEN dbms_output.put_line(‘Nedostatečný’); ELSE dbms_output.put_line(‘Známka mimo stupnici’); END CASE; END; Cykly Cykly zajišťují iterační řízení průběhu programu. PL/SQL pro cykly má tyto příkazy LOOP.
23
Základní LOOP LOOP příkaz_1; příkaz_2; příkaz_3; atd. END LOOP;
Příklad LOOP pocet:= pocet +1 IF pocet =100 THEN EXIT; END IF; END LOOP; Cykly FOR LOOP For i IN start..konec LOOP příkaz_1; příkaz_2; příkaz_3; atd. END LOOP;
Příklad FOR pocet IN 1..100 LOOP pocet:= 1; END LOOP; Cyklus WHILE LOOP WHILE podmínka LOOP příkaz_1; příkaz_2; příkaz_3; atd. END LOOP;
24
Příklad Tento příklad vyhledá zaměstnance, který je nejblíže nadřízený zaměstnanci 7000 a má plat vyšší než 12000. DECLARE p_plat number(7,2); p_cissefa number(4); start_cispra constant number(4):=7000; p_prijmeni char(15); BEGIN SELECT plat, cissefa, prijmeni INTO p_plat, p_cissefa, p_prijmeni FROM zamestnanec WHERE cispra=start_cispra; WHILE p_plat < 12000 LOOP SELECT plat, cissefa, prijmeni INTO p_plat, p_cissefa, p_prijmeni FROM zamestnanec WHERE cispra=p_cissefa; END LOOP; INSERT INTO zamest VALUES (p_plat, p_prijmeni); COMMIT; END;
4.2.3 Přístupové proměnné Přístupová proměnná je struktura, která obsahuje elementární části nazývané položky. Vybereme-li z tabulky, pohledu nebo pomocí kurzoru sloupce, ukládáme obsah těchto sloupců do proměnných, které byly všechny deklarovány v části DECLARE. Přístupová proměnná nahrazuje nutnost deklarace všech proměnných pro všechny položky z tabulek. Definice přístupové proměnné DECLARE jmeno_promenne tabulka%ROWTYPE;
Příklad Z tabulky zamestnanec vyberte všechny položky a uložte je do přístupové proměnné. DECLARE zamest_zaznam zamestnanec%ROWTYPE BEGIN SELECT * INTO zamest_zaznam FROM zamestnanec; END;
25
4.3 Kurzory Při provádění příkazů SQL potřebuje PL/SQL “pracovní oblast” (nazývanou oblast kontextu), v níž jsou uloženy informace týkající se právě prováděného příkazu SQL. Aby bylo možné používat informace uchovávané v oblasti kontextu, je této oblasti přiřazen název. Této pracovní oblasti, resp. oblasti kontextu, se říká kurzor. Každý kurzor má tedy název, který určuje oblast kontextu v níž budeme hledat právě prováděný příkaz. Existují tři typy kurzorů: explicitní kurzory, implicitní kurzory, interní kurzory. Implicitní a interní kurzory jsou v režii ORACLE, uživatel si může definovat a využívat kurzory explicitní.
4.3.1 Použití explicitních kurzorů Pokud lze předpokládat, že příkaz SELECT vrátí více než jeden řádek, musíme výsledek vyhodnocení dotazu vložit do pracovní oblasti (oblasti kontextu) a využít k tomu explicitní kurzor. Použití explicitních kurzorů probíhá ve čtyřech krocích: deklarace, otevření, načtení záznamů, uzavření.
4.3.2 Deklarace kurzoru Tento krok přiřazuje kurzoru název a spojuje s ním příslušný příkaz SELECT. Deklarace kurzorů je součástí části DECLARE společně s deklaracemi proměnných. Syntaxe: CURSOR název_kurzoru IS příkaz_select;
p_jmeno p_prijmeni p_datum
Příklad DECLARE char(15); char(15); date;
CURSOR k1 IS SELECT * FROM zamestnanec;
4.3.3 Otevření kurzoru Tento krok provádí příkaz spojený s otevíráním kurzoru, který zakládá pracovní množinu ntic (řádků), která může být dále naplněna příslušnými n-ticemi příkazem FETCH. Příkaz OPEN musí být umístěn v části výkonných příkazů (mezi BEGIN a END) nebo v části ošetření nestandardních stavů (EXCEPTION). Syntaxe: OPEN název_kurzoru
Příklad OPEN k1;
26
4.3.4 Načtení záznamů Načtení n-tic příslušného SELECTu do b loku PL/SQL se provádí příkazem FETCH. Příkaz FETCH načte vždy jeden řádek příslušného SELECTu. Z toho důvodu se příkaz FETCH vkládá do cyklu. Musí být zajištěno, aby vybraný seznam položek příkazem SELECT byl shodný se seznamem proměnných v příkaze FETCH (pořadí a odpovídající domény musí být shodné). Příkaz FETCH je umístěn do části BEGIN nebo EXCEPTION. Syntaxe: BEGIN OPEN název_kurzoru; LOOP FETCH název_kurzoru INTO seznam_proměnných . . . END LOOP; END;
p_jmeno p_prijmeni p_datum
Příklad DECLARE char(15); char(15); date;
CURSOR k1 IS SELECT * FROM zamestnanec; BEGIN OPEN k1; LOOP FETCH k1 INTO p_jmeno, p_prijmeni,p_datum; . . . END LOOP; CLOSE k1; END;
4.3.5 Uzavírání kurzoru Příkaz CLOSE uzavírá kurzor a nadále znepřístupňuje množinu dat vybranou příkazem SELECT. Příkaz CLOSE je součástí BEGIN nebo EXCEPTION. Kurzor rovněž uzavírá příkaz EXIT nebo GOTO (který vede výstup z cyklu).
27
4.3.6 Aktualizační operace s kurzorem Přesunutá n-tice do kurzoru může být z databázové tabulky vymazána, resp. aktualizována. Pokud chceme využít této možnosti, je nutné, aby byl kurzor deklarován FOR UPDATE OF (pro aktualizaci), resp. v příkazu FETCH uvedena klauzule WHERE CURRENT OF pro mazání.
Příklad Příklad vymaže z databáze všechny záznamy, kde datum je < 1.1.1930 a u šech záznamů, kde je datum < 1.1.1940 změní hodnotu položky plat na plat *1,2 DECLARE p_jmeno char(15); p_prijmeni char(15); p_datum date; CURSOR k1 IS SELECT * FROM zamestnanec WHERE datum < 1.1.1940 FOR UPDATE OF datum; BEGIN OPEN k1; LOOP FETCH k1 INTO p_jmeno, p_prijmeni,p_datum; IF p_datum < 1.1.1930 THEN DELETE zamestnanec WHERE CURRENT OF k1; ELSE UPDATE zamestnanec SET plat = plat *1,2 WHERE CURRENT OF k1; END IF; END LOOP; CLOSE k1; END;
4.3.7 Atributy explicitních kurzorů %NOTFOUND a %FOUND Atribut %NOTFOUND nabývá hodnoty TRUE, pokud právě provedený příkaz FETCH nenalezl další n-tici odpovědi. Opakem je atribut %FOUND, který v tomto případě nabývá hodnoty FALSE.
Příklad OPEN k1; LOOP FETCH k1 INTO x,y,z; EXIT WHEN k1%NOTFOUND; END LOOP; CLOSE k1;
28
%ROWCOUNT vrací počet řádků dosud načtených příkazem FETCH s množiny n-tic získaných příslušným SELECTem.
Příklad LOOP FETCH k1 INTO x,y,z; IF k1%ROWCOUNT < 15 THEN INSERT INTO jméno_tabulky VALUES (….); ELSE EXIT; END IF; END LOOP; Tento příklad opouští cyklus po načtení prvních 14 řádků tabulky odpovědi. %ISOPEN vrací hodnotu TRUE, pokud je již specifikovaný kurzor otevřen, jinak vrací FALSE.
4.3.8 Cykly FOR s kurzory Tento typ příkazu LOOP umožňuje zpracovávat n-tice vrácené příkazem SELECT, aniž by bylo třeba používat příkaz OPEN, FETCH a CLOSE. Obvyklá deklarace kurzoru je však nutná.
Příklad DECLARE vysledek zpravy.cissl1%TYPE; CURSOR c1 IS SELECT n1,n2,n3 FROM tabulka WHERE cislo=1; BEGIN FOR c1_zaznam IN c1 LOOP vysledek:=c1_zaznam.n2/(c1_zaznam.n1-c1_zaznam.n3); INSERT INTO zprávy(cissl1) VALUES(vysledek); END LOOP; COMMIT; END; C1_zaznam struktura přístupových proměnných, do které se ukládají položky vrácené příkazem FETCH pro kurzor. Na položky přístupové proměnné se lze odkazovat pomocí tečkové notace (např. c1_zaznam.n2).
29
4.4 Chyby a nestandardní stavy Existují dva hlavní způsoby, jak definovat vlastní nestandardní stav. První z nich vyžaduje, aby byl definován a použit příkaz RAISE k předání řízení části EXCEPTION bloku PL/SQL. Druhý z nich rovněž vyžaduje definici, ale zpracovává se interně. Nestandardní stav je třeba nejdříve v části DECLARE deklarovat. DECLARE objednavka
EXCEPTION;
Jakmile je nestandardní stav definován, můžeme pomocí příkazu RAISE v části BEGIN tento stav vyvolat. V tomto okamžiku přejde řízení do části EXCEPTION. BEGIN IF počet_na_sklade < limit THEN RAISE objednavka; EXEPTION WHEN objednavka THEN INSERT INTO tab_obj ….
Příklad Napište příkazový soubor, který přijímá tři parametry (&1, &2, &3) reprezentující číslo oddělení, jméno oddělení a místo. Nastavte EXCEPTION pro číslo oddělení = 33. Není-li číslo oddělení 33, zapište číslo oddělení, jméno a místo do tabulky nove_oddeleni. Je-li číslo oddělení = 33, zapište vhodnou zprávu do tabulky zpravy. Řešení: DECLARE p_cisodd number; oddel_33 EXCEPTION; BEGIN IF &p_cisodd = 33 THEN RAISE oddel_33; END IF; INSERT INTO nove_oddeleni (cisodd,jmeno,misto) VALUES (&p_cisodd, ‘&jmeno’, ‘&misto’); COMMIT; EXCEPTION WHEN oddel_33 THEN INSERT INTO zpravy (text) VALUES (‘Pokus vytvorit oddeleni 33’); COMMIT; END;
4.5 Procedury, funkce, balíky Bloky příkazů jazyka PL/SQL lze pojmenovat a uložit ve spustitelné formě do databáze. Těmto blokům říkáme procedury, resp. funkce.
30
Vlastnosti procedur a funkcí: - Jsou uloženy v zkompilovaném tvaru v databázi. - Mohou volat další procedury či funkce, či samy sebe. - Lze je volat ze všech prostředí klienta. Rozdíl mezi procedurou a funkcí není třeba zdůrazňovat, pouze pro připomenutí, funkce, na rozdíl od procedury, vrací jedinou hodnotu (procedura může vracet hodnot více, resp. žádnou).
4.5.1 Vytvoření procedury nebo funkce CREATE PROCEDURE jméno_procedury [(formální_parametry)] AS [lokální deklarace] BEGIN [výkonné příkazy] [EXCEPTION ošetření nestandardních stavů] END; CREATE FUNCTION jméno_funkce [(formální_parametry)] RETURN typ_návratové_proměnné AS [lokální deklarace] BEGIN [výkonné příkazy] [EXCEPTION ošetření nestandardních stavů] END; Formální parametry: Jméno_parametru [IN OUT IN OUT] typ_paramertu [:= hodnota] • • •
Specifikace jednotlivých parametrů v seznamu jsou odděleny čárkou. Parametry mohou být vstupní, výstupní a vstupně-výstupní. Pouze vstupní parametry mohou být inicializovány. K inicializaci můžeme použít buď klauzuli DEFAULT nebo přiřadit hodnotu (:=)
Příklad Vytvořte proceduru, jejímž vstupem je číslo zaměstnance a která příslušného zaměstanance vymaže z tabulky zamestnanec. CREATE PROCEDURE vymaz_zamestnance (kod number) AS BEGIN DELETE FROM zamestnanec WHERE cispra = kod; COMMIT; END; Pozn. Zapsanou proceduru v SQL*PLUS můžete uložit do databáze např. následujícím způsobem: • zapište poslední příkaz procedury 31
• •
na nový řádek napište tečku zkompilujte a uložte proceduru do databáze příkazem RUN
Zdrojový kód procedur si můžete prohlédnout v tabulce USER_SOURCE např. následujícím způsobem: SQL> select text from user_source where name='VYMAZ_ZAMESTNANCE'; TEXT -----------------------------------------------------------------PROCEDURE vymaz_zamestnance (kod number) IS BEGIN DELETE FROM Zamestnanec WHERE cispra = kod; COMMIT; END; SQL>
4.5.2 Provádění uložených procedur Provedení uložené procedury lze provést následujícími způsoby: • Zevnitř bloku PL/SQL vymaz_zamestnance (cispra) • Z nějakého nástroje ORACLE ( např. SQL*PLUS, TOAD) EXECUTE vymaz_zamestnance (777) • Z anonymního bloku BEGIN vymaz_zamestnance (777) ;END;
4.5.3 Zrušení procedury Proceduru lze zrušit příkazem DROP PROCEDURE jméno_procedury;
4.6 Balíky (sady) Balík (sada) je databázový objekt, který sdružuje související programové konstrukce. Může obsahovat: • Procedury • Funkce • Definice kurzorů • Proměnné a konstanty • Definice nestandardních stavů Balík má dvě části – specifikaci a tělo. Specifikace balíku deklaruje konstrukce sady, včetně jmen a parametrů veřejně dostupných procedur a funkcí. Tělo může deklarovat další, soukromé konstrukce balíku, které nejsou obecně přístupné, definuje všechny konstrukce balíku Existují veřejné a soukromé konstrukce v sadách. Veřejné konstrukce se deklarují ve specifikaci sady a jsou přístupné komukoli. Kdo může sadu spouštět. Soukromé konstrukce se deklarují v těle sady a jsou přístupné pouze ostatním konstrukcím sady uvnitř těla sady.
32
4.6.1 Vytvoření specifikace sady CREATE PACKAGE jméno_sady AS specifikace_sady END;
Příklad /* Specifikace sady pro nástup a propouštění pracovníků*/ CREATE PACKAGE nastup_propust AS /*Deklarace veřejné procedury*/ PROCEDURE nastup_prac( cispra NUMBER, zjmeno VARCHAR2, cissefa NUMBER, plat NUMBER, premie NUMBER, cisodd NUMBER); PROCEDURE propusteni_prac( id_prac NUMBER); /*deklarace globální proměnné*/ platne VARCHAR2(1); END nastup_propust;
4.6.2 Vytvoření těla sady CREATE [OR REPLACE]PACKAGE BODY jméno_sady AS tělo_sady END;
Příklad /*Tělo sady, obsahující procedury pro nástup a propouštění pracovníků.*/ CREATE PACKAGE BODY nastup_propust AS /*Procedura pro nástup pracovníka*/ PROCEDURE nastup_prac( cispra NUMBER, zjmeno VARCHAR2, cissefa NUMBER, plat NUMBER, premie NUMBER, cisodd NUMBER) IS BEGIN /*platne je specifikováno ve specifikaci sady*/ platne:=kontr_cis(cispra); /* je-li Cipra platné, přidat pracovníka*/ 33
IF platne = ‚T‘ THEN INSERT INTO zamest(cipra, zájmeno, cissefa, plat, premie, cisodd) VALUES (cipra, zájmeno, cissefa, plat, premie, cisodd) ENDIF; END; /*Procedura pro propuštění pracovníka*/ PROCEDURE propuštěni_prac( kod NUMBER) IS BEGIN DELETE FROM zamest WHERE cipra=kod; END; /*Funkce pro kontrolu, zda je číslo pracovníka platné. Soukromá pro tělo sady*/ FUNCTION kontr_cis(cipra NUMBER) RETURN VARCHAR2 IS odpoved VARCHAR2; BEGIN odpověď:=‘T‘; IF cipra <0 THEN odpoved:= ‘F‘; END IF; RETURN (odpoved); END; END nastup_propust; /*Konec sady*/
4.6.3 Přístup ke konstrukcím sady Ke konstrukcím sady lze přistupovat zevnitř procedury
Příklad PROCEDURE sprava_zamest ….. /*Předpokládá se, že akce a id pracovníka byly zadány již dříve*/ ….. IF akce = ‘NASTUP‘ THEN nastup_propust.nastup_prac (zaměstnanec, zjmeno, cissefa, plat, premie, cisodd); IF nastup_propust.platne=‘T‘ THEN /* sport_klub je jiná sada, která zpracovává členství ve sportovním klubu organizace*/ sport_klub.pridat (zaměstnanec);
34
END IF; ELSEIF akce=‘PROPUSTENI‘ THEN nastup_propust.propusteni_prac (zaměstnanec); sport_klub.odstranit(zaměstnanec); ………….
4.6.4 Zrušení sady Příkaz DROP PACKAGE ruší specifikaci i tělo sady. DROP PACKAGE jméno_sady
4.7 Databázové triggery Databázový trigger je uživatelsky definovaný blok PL/SQL sdružený s určitou tabulkou. Je implicitně spuštěn (proveden), jestliže je nad tabulkou prováděn aktualizační příkaz. Databázový trigger má čtyři části: - typ triggeru (BEFORE/AFTER) - spouštěcí událost (INSERT/UPDATE/DELETE) - omezení triggeru (nepovinná klauzule WHEN) - akce triggeru (blok PL/SQL) Na každou tabulku lze vytvořit až 12 databázových triggerů: - INSERT/UPDATE/DELETE - BEFORE/AFTER - STATEMENT/ROW (příkazový/řádkový) Příkazový trigger se spustí jedenkrát pro příkaz, bez ohledu na počet aktualizovaných řádků. Řádkový trigger se spustí pro každý aktualizovaný řádek tabulky.
4.7.1 Vytvoření databázového triggeru K vytvoření slouží příkaz CREATE TRIGGER Syntaxe: CREATE [OR REPLACE]TRIGGER jméno typ_triggeru spouštěcí_akce [OF sloupec, sloupec, …] ON tabulka [FOR EACH ROW] [WHEN podmínka] BEGIN . . . END;
Příklad CREATETRIGGER jmeno BEFORE INSERT OR UPDATE OF zjmeno ON zamest FOR EACH ROW 35
BEGIN . . . END;
4.7.2 Prefixy v databázových triggerech Pro odkazy na staré a nové hodnoty sloupců v řádkových triggerech se používají prefixy :OLD a :NEW.
Příklad IF :NEW.plat < :OLD.plat THEN Poznámky: - hodnoty :NEW a :OLD jsou použitelné pouze v řádkových triggerech - obě hodnoty jsou použitelné v příkazu UPDATE - :OLD u příkazu INSERT je NULL - :NEW u příkazu DELETE je NULL - v klauzulích WHEN se vynechává středník Příklad databázových triggerů (AFTER DELETE, AFTER UPDATE) na tabulku pece_cenik. Nejdříve definice struktury tabulky pece_cenik, na které je závislá tabulka dodatecna_pece. CREATE TABLE pece_cenik ( pece_cenik_id SMALLINT NOT NULL, nazev_cenik CHAR(18) NULL, priplatek DECIMAL(7,2) NULL, popis_cenik CHAR(18) NULL ); ALTER TABLE Pece_cenik ADD ( PRIMARY KEY (pece_cenik_id) ) ; create trigger tD_Pece_cenik after DELETE on pece_cenik for each row declare numrows INTEGER; begin /* pece_cenik R/7 dodatecna_pece ON PARENT DELETE RESTRICT */ select count(*) into numrows from dodatecna_pece where dodatecna_pece.pece_cenik_id = :old.pece_cenik_id; if (numrows > 0) then raise_application_error(-20001,
36
'Cannot DELETE pece_cenik because dodatecna_pece exists.' ); end if; end; / create trigger tU_Pece_cenik after UPDATE on pece_cenik for each row declare numrows INTEGER; begin /* pece_cenik R/7 dodatecna_pece ON PARENT UPDATE RESTRICT */ if :old.pece_cenik_id <> :new.pece_cenik_id then select count(*) into numrows from dodatecna_pece where dodatecna_pece.pece_cenik_id = :old.pece_cenik_id; if (numrows > 0) then raise_application_error(-20005, 'Cannot UPDATE pece_cenik because dodatecna_pece exists.' ); end if; end if; end; /
4.7.3 Postup při spouštění databázového triggeru Postup při spouštění databázové triggeru je následující: - do ORACLE je předán příkaz INSERT, UPDATE nebo DELETE - provede se příkazový trigger BEFORE - pro každý řádek, kterého se příkaz SQL týká: o se provede řádkový trigger BEFORE o změní se řádek a provedou se kontroly integritního omezení o se provede řádkový trigger AFTER - dokončí se odložené kontroly IO s ohledem na přechodná porušení - orivede se příkazový trigger AFTER - návrat do aplikace
4.7.4 Aktivace a deaktivace triggerů Po nadefinování triggerů jsou tyty implicitně aktivní. Je-li třeba trigger deaktivovat, resp. zpět aktivovat, lze použít příkazu: ALTER TRIGGER jméno_triggeru ENABLE | DISABLE; Resp. lze deaktivovat či aktivovat všechny triggery, definované nad konkrétní tabulkou: ALTER TABLE jméno_tabulky ENABLE | DISABLE ALL TRIGGERS; 37
Pojmy k zapamatování: Konstanty, proměnné, funkce Cykly Přístupové proměnné Kurzory Chyby a nestandardní stavy Procedury, funkce, balíky Databázové triggery
38
5 Použitá literatura 1. Date, C.J. : An Introduction to Database Systems. Addison Company, USA, 1990
- Wesley Publishing
2. Gruber, M.: Understanding SQL, Sybex, USA, 1990 3. Korth, H.F., Silberschatz, A. : Database system concepts. McGraw-Hill, Inc., 1991 4. Lacko, L.: Oracle – Správa, programování a použití databázového systému.Computer Press, 2003 5. Loney, K., Theriault, M.: Mistrovství v Oracle, Oracle Press, 2002 6. Pokorný, J. : Dotazovací jazyky v databázových systémech. Skripta MFF UK v Praze, SPN Praha, 1986 7. Pokorný, J. : Databázové‚ systémy a jejich použití v informačních systémech. Academia, Praha, 1992 8. Pokorný, J., Halaška, I. : Databázové‚ systémy. Vybrané‚ kapitoly a cvičení. Skripta el. fakulty ČVUT, Praha, 1992 9. Pokorný, J.: Dotazovací jazyky, Science, 1994 10. Pokorný, J.: Základy implementace souborů a databází, Karolinum Praha, 1997 11. Telnarová, Z.: Úvod do databází. Skripta OU Ostrava, 2002 12. Telnarová, Z.: Relační databáze. Skripta OU, Ostrava, 2002 13. Ullman, D.J.: Principles of database and knowledge-base systems, Volume I, Computer Sc. Press, 1988 14. Ullman, D.J.: Principles of database and knowledge-base systems, Volume II, Computer Sc. Press, 1989 15. Wagner, G.: Foundations of Knowledge Systems, Kluwer, London 1998
39
