SQL přednáška č.? + 1 1/90
Poznámka CHECK a FOREIGN KEY integritní omezení jsou si podobná v tom, že kontrolují hodnoty vkládané do atributu Rozdíl spočívá ve způsobu, kterým se získává množina přípustných hodnot. FOREIGN KEY získává tento seznam z jiné tabulky CHECK má přípustné hodnoty vymezeny logickou podmínkou 2
Otázka Relace: PRODUKT (ID, BARVA, CENA)?BARVA(ID_BARVA, NAZEV)?BARVA(NAZEV) + ON UPDATE CASCADE kterou variantu použít? první nebude propagovat změny v názvu barvy do tabulky PRODUKT druhá nebude vyžadovat spojení v případě, že bude třeba zjistit barvu produktu 3
Změna a smazaní relace/atributu ALTER TABLE [ database_name. [ schema_name ]. schema_name. ] table_name { ALTER COLUMN column_name { [ type_schema_name. ] type_name [ ( { precision [, scale ] max xml_schema_collection } ) ] [ NULL NOT NULL ] [ COLLATE collation_name ] {ADD DROP } { ROWGUIDCOL PERSISTED } } [ WITH { CHECK NOCHECK } ] ADD {<column_definition> <computed_column_definition> < table_constraint> } [,...n ] DROP { [ CONSTRAINT ] constraint_name [ WITH ( <drop_clustered_constraint_option> [,...n ] ) ] COLUMN column_name } [,...n ] [ WITH { CHECK NOCHECK } ] { CHECK NOCHECK } CONSTRAINT { ALL constraint_name [,...n ] } { ENABLE DISABLE } TRIGGER { ALL trigger_name [,...n ] } SWITCH [ PARTITION source_partition_number_expression ] TO [ schema_name. ] target_table [ PARTITION target_partition_number_expression ] } [ ; ] <drop_clustered_constraint_option> ::= { MAXDOP = max_degree_of_parallelism ONLINE = {ON OFF } MOVE TO { partition_scheme_name ( column_name ) filegroup "default"} } 4
Změna a smazaní relace/atributu ALTER TABLE jméno_relace {ADD DROP} atribut datový_typ [NULL,..] ADD přidání nového atributu DROP odebrání exitujícího atributu z relace ALTER TABLE osoby ADD pocet_deti integer ALTER TABLE osoby DROP pocet_deti DROP TABLE jmeno_relace DROP TABLE osoby 5
Příklad, přidání atributu CREATE TABLE doc ( column_a INT ) ; ALTER TABLE doc ADD column_b VARCHAR(20); 6
Odebrání atributu CREATE TABLE doc ( column_a INT, column_b VARCHAR(20) ) ; ALTER TABLE doc DROP COLUMN column_b ; 7
Změna typu atributu CREATE TABLE doc ( column_a INT ) ; ALTER TABLE doc ALTER COLUMN column_a DECIMAL (5, 2) ; 8
Přidání IO CREATE TABLE doc ( column_a INT ) ; ALTER TABLE doc WITH NOCHECK ADD CONSTRAINT exd_check CHECK (column_a > 1) ; WITH NOCHECK zajistí, že při změně se nebudou kontrolovat existující záznamy proti novému CHECK 9
Odebrání IO CREATE TABLE doc ( column_a INT CONSTRAINT my_constraint UNIQUE) ; ALTER TABLE doc DROP CONSTRAINT my_constraint ; 10
Definice Indexů CREATE [UNIQUE] [CLUSTERED NONCLUSTERED] INDEX jméno_indexu ON jméno_relace (jméno_atributu [uspořádání] [, jméno_atributu [uspořádání]] ) CREATE UNIQUE INDEX rc ON osoby (rodne_cislo) CREATE INDEX jp ON osoby (jmeno,prijmeni) 11
Indexy II. CLUSTERED Pouze jeden index v tabulce lze definovat jako clustered Záznamy v primárním souboru jsou pak seřazeny podle toho sloupce (sloupců) NONCLUSTERED Soubor není na tomto atributu setříděn QNIQUE Každý atribut bude unikátní (porovnej s definicí primárního klíče) Klausule PRIMARY KEY může být pouze jednou v definici relace 12
CREATE DOMAIN Jedná se vlastně o vytvoření nové množiny hodnot, kterou pak lze použít v definici tabulek Create domain "rc" Char(13) Default 000000/0000; 13
Příklady- PostgreSQL Create table "Osoba" ( "id_osoba" Integer NOT NULL, "jmeno" Varchar(35) NOT NULL Default neni zadano, "prijmeni" Varchar(35) NOT NULL Default neni zadano, "rodne_cislo" Char(13) NOT NULL Default 000000/0000, primary key ("id_osoba") ) 14
ER -> relační databáze Jméno RC Plat Zaměstnanci CREATE TABLE Zamestnanci ( RC CHAR(12), Jmeno CHAR(30), Plat Integer, PRIMARY KEY (RC) ); 15
Create table "material" ( "id_material" Integer NOT NULL, "nazev" Varchar(20) NOT NULL Default ----, "pocet" Integer NOT NULL Default 0 Check (pocet>=0), primary key ("id_material") ) Create table "objednavka" ( "kod" Integer NOT NULL, "pocet_kusu" Char(20) NOT NULL Check (pocet_kusu<=(select pocet FROM material WHERE objednavka.id_material = material.id_material)), "id_material" Integer NOT NULL, primary key ("kod") ) Alter table "objednavka" add foreign key ("id_material") references "material" ("id_material") on update cascade on delete cascade; 16
17 příklad
Create table [Sailors] ( [sid] Integer NOT NULL, [sname] Varchar(32) NULL, [raiting] Integer NOT NULL CHECK (raiting>=1 AND raiting<=10), [age] Real NOT NULL CHECK (age>18), Primary Key ([sid]), ) Create table [Boats] ( [bid] Integer NOT NULL, [bname] Char(10) NOT NULL, [color] Char(10) NOT NULL, [bimage] Image NULL, Primary Key ([bid]) ) Create table [Reservers] ( [sid] Integer NOT NULL, [bid] Integer NOT NULL, [day] Datetime NOT NULL, foreign key([bid]) references [Boats] ([bid]), foreign key([sid]) references [Sailors] ([sid]), Primary Key ([sid],[bid]), CHECK ( interlake <> SELECT Boats.name FROM Boats WHERE Boats.bid=Reservers.bid) ) 18
Self relace Create table "Dokument" ( "cislo_dokumentu" Integer NOT NULL, "cislo_dokumentu_fk" Integer NOT NULL, "text" Text, primary key ("cislo_dokumentu"), foreign key ("cislo_dokumentu_fk") references "Dokument" ("cislo_dokumentu") on update restrict on delete restrict ) 19
Create table "Osoba"( ) Create table "objednavka"( ) Create table "objednavky"( "id_osoba" Integer NOT NULL, "kod" Integer NOT NULL, "datum" Date, primary key ("id_osoba","kod") ) Alter table "objednavky" add foreign key ("id_osoba") references "Osoba" ("id_osoba") on update cascade on delete cascade ; Alter table "objednavky" add foreign key ("kod") references "objednavka" ("kod") on update cascade on delete cascade ; 20
SQL II. SELECT, INSERT, DELETE, UPDATE, příklady přednáška č. 10 21
Spouště DML Řízení transakcí Vložené a dynamické SQL SQL DDL Integritní omezení Bezpečnost Přístupová práva 22
Úvod Doposud jsme provedli analýzu Návrh Implementaci (tedy vytvoření DB a souvisejících objektů) A teď chceme napsat aplikaci, která bude s daty v DB pracovat 23
Co potřebujeme? Data jsou v relačním modelu uložena v relacích (tabulkách) Vzhledem k nutnosti dodržovat normální formy, jsou relace dokomponovány Dekompozice jinými slovy znamená, že data nejsou v jedná tabulce. 24
Konstruktor SELECT SELECT [DISTINCT ALL] {* jméno_atributu1 [,jméno_atributu2] } FROM název_relace[,název_relace2] [WHERE podmínka] [GROUP BY atributy [HAVING podmínka_agregace]] [ORDER BY jméno_atributu1[,jméno_atributu2] ] 25
Manipulace dat v SQL Sémantika příkazu SELECT vytvoří se kartézský součin z relací FROM vyhodnotí se podmínka WHERE rozdělení do podskupin GROUP BY relace se omezí dle HAVING Uspořádá se pomocí ORDER BY 26
SELECT DISTINCT 27
Manipulace s daty v SQL PROJEKCE SELECT jmeno FROM osoby KARTÉZKÝ SOUČIN SELECT * FROM osoby,byty SELEKCE SELECT RC,jmeno FROM osoby WHERE jmeno= jan SPOJENÍ SELECT jmeno FROM osoby,byty WHERE osoby.rc=byty.rc 28
Spojení tabulek Jaká je nosnost automobilu s spz A- 36-15? Je třeba znovu složit dekomponované tabulky, abychom mohli tuto informaci dostat Spz Jméno Typ A-36-15 Karel 1 L-37-15 Petr 1 L-66-12 Jana 2 L-43-54 Eva 2 L-71-13 Jan 2 Typ Nosnost x y z 1 15 20 26 20 29 2 20 25 30 24
Spojení tabulek pomocí SQL SELECT nosnost,spz FROM Auta, Nosnosti WHERE Auta.Typ = Nosnosti.Typ AND Spz= A-36-15 30
Co to udělá? Nejprve např. spojíme tabulky Nosnosti a Auta Spz Typ Nosnost x y z A-36-15 1 15 20 26 20 L-37-15 1 15 20 26 20 L-66-12 2 20 25 30 24 L-43-54 2 20 25 30 24 L-71-13 2 20 25 30 24 31
Co to udělá? Pak vybereme řádky, které splňují podmínku na spz= A-36-15 Spz Typ Nosnost x y z A-36-15 1 15 20 26 20 32
Co to udělá? Následně vybereme požadované atributy nosnost a spz Spz Nosnost A-36-15 15 33
Kolik je řádků bude mít kartézký součin Auta = 5 tabulek? Nosnosti = 2 Auta*Nosnosti == 2*5 = 10 Spz Jméno Typ A-36-15 Karel 1 L-37-15 Petr 1 L-66-12 Jana 2 L-43-54 Eva 2 L-71-13 Jan 2 Typ Nosnost x y z 1 15 20 26 20 2 20 25 30 24 34
Spz Typ Nosnost x y z A-36-15 1 15 20 26 20 A-36-15 2 20 25 30 24 L-37-15 1 15 20 26 20 L-37-15 2 20 25 30 24 L-66-12 1 15 20 26 20 L-66-12 2 20 25 30 24 L-43-54 1 15 20 26 20 L-43-54 2 20 25 30 24 L-71-13 1 15 20 26 20 L-71-13 2 20 25 30 24 35
Proto je nutné říci, který atribut je určen pro spojení Proto SELECT nosnost,spz FROM Auta, Nosnosti WHERE Auta.Typ= Nosnosti.Typ AND Spz= A-36-15 36
Kartézský součin cid jmeno vek did kancelar patro 1 karel 23 2 petr 34 1 205a 2 3 308e 4 cid jmeno vek did kancelar patro 1 karel 23 1 205a 2 2 petr 34 3 308e 4 1 karel 23 3 308e 4 2 petr 34 1 205a 2 37
Spojení tabulek pomocí SQL Zadání: najdi režiséry jejichž filmy jsou rezervovány Předpokládejme existenci tabulek FILMY a REZERVACE SELECT DISTINCT reziser FROM Filmy, Rezervace WHERE Filmy.jmeno_f=Rezervace.jmeno_f 38
Varianty předchozího SELECT Rezervace.*,Filmy.* FROM Filmy, Rezervace WHERE Filmy.jmeno_f=Rezervace.jmeno_f SELECT DISTINCT Filmy.reziser FROM Filmy, Rezervace WHERE Filmy.jmeno_f=Rezervace.jmeno_f 39
Příklad na kartézský součin cid jmeno vek did kancelar patro 1 karel 23 2 petr 34 1 205a 2 3 308e 4 SELECT * FROM Clovek, Kancelar 40
Kartézský součin cid jmeno vek did kancelar patro 1 karel 23 2 petr 34 1 205a 2 3 308e 4 cid jmeno vek did kancelar patro 1 karel 23 1 205a 2 2 petr 34 3 308e 4 1 karel 23 3 308e 4 2 petr 34 1 205a 2 41
Spojení tabulek pomocí konstruktu JOIN SELECT produkt_c AS jmeno FROM tprodukty JOIN tceny ON (tprodukty.produkt_id=tceny.cena_pr) WHERE produkt_e LIKE %product% ORDER BY tprodukty.produkt_e UNION (spojení) INTERSECT(průnik)* EXCEPT(rozdíl)* Pozn. )* často není DB podporováno 42
Cross join T1 CROSS JOIN T2 Ekvivalent kartézského součinu Pokud budeme spojovat dvě tabulky o velikostech M a N, pak výsledná tabulka bude mít M.N řádků 43
Vnitřní spojení INNER JOIN Je to výchozí hodnota pro JOIN Ve výsledku budou jen ty řádky, které mají spojované tabulky společné 44
Vnější spojení OUTER JOIN Spojované tabulky mohou mít i různé hodnoty v řádcích. Kde hodnota nebyla dolní se automatický NULL 45
LEFT OUTER JOIN T1 LEFT OUTER JOIN T2 Provede se vnitřní spojení Pak se vezmou řádky z tabulky vlevo (tabulka T1) a do odpovídajících atributů tabulky pravé (T2) se doplní NULL 46
RIGHT OUTER JOIN T1 RIGHT OUTER JOIN T2 Provede se vnitřní spojení Pak se vezmou řádky z tabulky vpravo (T2) a do odpovídajících atributů tabulky levé (T1) se doplní NULL 47
FULL OUTER JOIN Provede se vnitřní spojení Pak se provede LEFT Následně RIGHT 48
Příklady t1 num name ----- +------ 1 a 2 b 3 c t2 num value ----- +------- 1 xxx 3 yyy 5 zzz 49
SELECT * FROM t1 CROSS JOIN t2; t1 num name ----- +------ 1 a 2 b 3 c t2 num value ----- +------- 1 xxx 3 yyy 5 zzz num name num value -----+------+-----+------- 1 a 1 xxx 1 a 3 yyy 1 a 5 zzz 2 b 1 xxx 2 b 3 yyy 2 b 5 zzz 3 c 1 xxx 3 c 3 yyy 3 c 5 zzz (9 rows) 50
SELECT * FROM t1 INNER JOIN t2 ON t1.num = t2.num; t1 num name ----- +------ 1 a 2 b 3 c t2 num value ----- +------- 1 xxx 3 yyy 5 zzz num name num value -----+------+-----+------- 1 a 1 xxx 3 c 3 yyy 51
SELECT * FROM t1 INNER JOIN t2 USING (num); t1 num name ----- +------ 1 a 2 b 3 c t2 num value ----- +------- 1 xxx 3 yyy 5 zzz num name value -----+------+------- 1 a xxx 3 c yyy 52
SELECT * FROM t1 NATURAL INNER JOIN t2; t1 num name ----- +------ 1 a 2 b 3 c t2 num value ----- +------- 1 xxx 3 yyy 5 zzz num name value -----+------+------- 1 a xxx 3 c yyy 53
SELECT * FROM t1 LEFT JOIN t2 ON t1.num = t2.num; t1 num name ----- +------ 1 a 2 b 3 c t2 num value ----- +------- 1 xxx 3 yyy 5 zzz num name num value -----+------+-----+------- 1 a 1 xxx 2 b NULL NULL 3 c 3 yyy 54
SELECT * FROM t1 RIGHT JOIN t2 ON t1.num = t2.num; t1 num name ----- +------ 1 a 2 b 3 c t2 num value ----- +------- 1 xxx 3 yyy 5 zzz num name num value -----+------+-----+------- 1 a 1 xxx 3 c 3 yyy NULL NULL 5 zzz 55
Artimetika a agregační funkce Aritmetické funkce +, -, *, / Agregační funkce COUNT, SUM, MAX, MIN, AVG 56
Aritmetika SELECT did,cena/23.45, kusu*23 FROM Nakup X, Zakaznik Y WHERE Y.jmeno= Karel Malina AND X.sid=34; 57
Agregační funkce SELECT Count(*) AS pocet FROM Zakaznik; SELECT Count(did) FROM Zakaznik; Celkový počet zakazníků SELECT SUM(DISTINCT jmeno_f) FROM Rezervace; Kolik je rezervováno filmů (jeden film může mít více rezervací) 58
Celková suma peněz ve výpůjčkách Karla SELECT SUM(X.cena) FROM Vypujcky X, Zakaznici Y WHERE Y.Jmeno= Karel AND X.cid=y.cid Jaká je průměrná cena v tabulce výpůjčky SELECT AVG(cena) FROM Vypujcky 59
GROUP BY Konstrukt GROUP BY a HAVING MIN se bude používat až na skupiny vytvořené pomocí GROUP BY SELECT S.rating, MIN(S.age) AS minage FROM Sailors S WHERE S.age>=18 GROUP BY S.rating HAVING COUNT (*) > 1 60
Vyhodnocení příkladu Sid sname rating age 22 Petr 7 45 29 Brutus 1 33 31 Karel 8 55 32 Andy 8 25 58 Kuba 10 35 64 Horacio 7 35 71 Jana 10 16 74 Pepa 9 40 85 Michala 3 25 95 Karolina 3 63 rating minage 7 45 1 33 8 55 8 25 10 35 7 35 9 40 3 25 3 25 rating minage 1 33 3 25 3 63 7 45 7 35 8 55 8 25 9 40 10 35 61
Výsledek příkladu rating minage 3 25 7 35 8 25 Sid sname rating age 22 Petr 7 45 29 Brutus 1 33 31 Karel 8 55 32 Andy 8 25 58 Kuba 10 35 64 Horacio 7 35 71 Jana 10 16 74 Pepa 9 40 85 Michala 3 25 95 Karolina 3 63 62
Množiny v SQL Predikáty: IN, ANY, ALL, SOME, EXISTS 63
IN jméno_atributu [ NOT] IN poddotaz Nebo jméno_atributu [ NOT] IN (seznam hodnot) 64
Příklady Najděte adresy kin, ve kterých dávají film Kolotoč SELECT adresa FROM Kina WHERE nazev_k IN (SELECT nazev_kina FROM Program WHERE jmeno_f= Kolotoč ); 65
Zadání množiny pomocí výčtu SELECT adresa FROM Kina WHERE nazev_k IN ( Kolotoč, Sprcha, Med ); 66
Vložené dotazy SELECT jmeno FROM Zakaznici WHERE rc IN ( SELECT rc FROM Rezervace WHERE Rezervace.jmeno_f NOT IN (SELECT F.jmeno FROM Filmy WHERE F.reziser= Sverak ) ); 67
Pozn. Chování IN nad prázdnou IN (0) vrací FALSE množinou 68
ANY, ALL, SOME SOME == ANY (v SQL92 obě) Najdi zaměstnance, který má plat větší než všichni zaměstnanci z Prahy SELECT did,jmeno FROM Zam WHERE plat > ALL (SELECT Zam.plat FROM Zam WHERE Zam.adresa LIKE %Praha% ); 69
Manipulace s množinami p IN A p je prvkem množiny A množinu tvoří výčet nebo SELECT-FROM-WHERE SELECT * FROM osoba,byt WHERE (osoba.rc=byt.rc) AND (byt.ulice IN ( Hálkova, Pražská )) SELECT * FROM osoba,byt WHERE (osoba.rc=byt.rc) AND ( byt.ulice IN ( SELECT * FROM byt WHERE (ulice LIKE H% ))) 70
Manipulace dat v SQL Prázdné hodnoty Rozšíření RMD Agregační funkce aplikované na prázdnou množinu vracejí NULL Zakázáno : spojení přes NULL, dotaz bydliste=null, spec.příkaz IS NULL 71
Syntaxe INSERT INSERT [LOW_PRIORITY DELAYED HIGH_PRIORITY] [IGNORE] [INTO] tbl_name [(col_name,...)] VALUES ({expr DEFAULT},...),(...),... [ ON DUPLICATE KEY UPDATE col_name=expr,... ] INSERT INTO osoba (jmeno,prijmeni) VALUES ( Jan, Novak ) INSERT INTO osoba SELECT * FROM tab Pozor zde není values 72
Syntaxe UPDATE UPDATE [LOW_PRIORITY] [IGNORE] tbl_name SET col_name1=expr1 [, col_name2=expr2...] [WHERE where_definition] [ORDER BY...] [LIMIT row_count] UPDATE osoba SET jmeno= Jan WHERE jmeno= Honza 73
Syntaxe DELETE DELETE [LOW_PRIORITY] [QUICK] [IGNORE] FROM tbl_name [WHERE where_definition] [ORDER BY...] [LIMIT row_count] DELETE FROM osoba WHERE jmeno= Jan 74
Definice pohledů Virtuální relace, pohled na aplikaci uživatelskýma očima CREATE VIEW jméno_pohledu [(njméno_atr1[,njméno_atr2]...)] AS SELECT [DISTINCT] {* jméno_atr1[,jméno_atr2]...} FROM jméno_relace1[,jméno_relace2]... [WHERE podmínka1] [WITH CHECK OPTION] [GROUP BY gjméno_atr1[,gjméno_atr2]... [HAVING podmínka2]] [ENABLE UPDATE] CREATE VIEW pohled AS SELECT * FROM t1 WHERE a > 0; DROP VIEW jméno_pohledu; 75
Pohledy II. (SQL-92) Logická datová nezávislost rychlost (optimalizátor může používat stále stejný plán) Bezpečnost UPADTE Updatable views pouze nad jednou tabulkou INSERT NULLs kde není definováno -? Co prim. Klíč? WITH CHECK OPTION kontrola, zda bude vložená n-tice vidět v pohledu DELETE 76
Ochrana dat Požadavek více uživatelského SŘBD Přístup k relaci(pohledu), definice práv GRANT {ALL {DELETE INSERT SELECT UPDATE [(atribut1[, atribut2] )]} } ON relace TO {PUBLIC uživatel1[,uživatel2] } Odebrání práv REVOKE 77
Manipulace dat v SQL Systémový katalog Informace o SŘBD SYSTABLE jméno relace, zakladatele,počet atributů,... SYSCOLUMNS jméno atributu,jméno relace,... SYSINDEXES jméno indexu, jméno relace,... COMMENT Komentáře 78
Group By SELECT "column_name1", SUM("column_name2") FROM "table_name" GROUP BY "column_name1" Store_Information store_name Sales Date Los Angeles $1500 Jan-05-1999 San Diego $250 Jan-07-1999 Los Angeles $300 Jan-08-1999 Boston $700 Jan-08-1999 SELECT store_name, SUM(Sales) FROM Store_Information GROUP BY store_name store_name SUM(Sales) Los Angeles $1800 San Diego $250 Boston $700 79
Having SELECT "column_name1", SUM("column_name2") FROM "table_name" GROUP BY "column_name1" HAVING (arithmetic function condition) Store_Information store_name Sales Date Los Angeles $1500 Jan-05-1999 San Diego $250 Jan-07-1999 Los Angeles $300 Jan-08-1999 Boston $700 Jan-08-1999 SELECT store_name, SUM(sales) FROM Store_Information GROUP BY store_name HAVING SUM(sales) > 1500 Result: store_name SUM(Sales) Los Angeles $1800 80
Užitečné odkazy http://www.cs.vsb.cz/amalka/tomica/sql/index.h tml http://home.zcu.cz/~kotouc/vyuka/dbm1/pr11.h tml http://msdn.microsoft.com/library/ http://www.oracle.com/technology/documentati on/index.html http://dev.mysql.com/doc/ 81
SQL III. Stored procedures Triggers
Triggers Trigger (spoušť) je procedura která je automaticky spuštěna DBMS jako reakce na specifikovanou akci v databázi Aktivní databáze: DB, která obsahuje definici spouští 83
Popis spouště Event (událost) - změna v DB, která vyvolá spuštění Condition (podmínka) dotaz nebo test, který je proveden pokud je spoušť aktivována Action (akce) procedura, která je provedena při spuštění a pokud je splněna podmínka 84
85
Event (akce) INSERT UPDATE DELETE Nezáleží na to kdo (který uživatel) provede akci Uživatel si není vědom aktivity spouští v DB 86
Příklad použití Mějme DB studentů (STUDENT) Mějme dále tabulku obsahující informace o počtu studentů mladších 18 let Při vložení nového záznamu do tabulky STUDENT je aktivována spoušť, která zvýší atribut v tabulce obsahující počet studentů mladších 18 let 87
After x before Podle funkce je možné tuto změnu provést před nebo po provedení změn nad tabulkou STUDENT 88
Triggers in SQL CREATE TRIGGER init_count BEFORE INSERT ON Students/* event */ DECLARE count INTEGER; BEGIN count:=0; /* action */ END 89
CREATE TRIGGER inc_count AFTER INSERT ON Students /* event */ WHEN (new.age<18) /* condition */ FOR EACH ROW BEGIN /* action */ count:=count+1; END 90
Jak zjistím, kterou hodnotou je v DB pracováno? New Označuje nově vkládanou/upravovanou n-tici (řádek) do relace v DB Old Pokud byla hodnota n-tice v DB měněna pak se lze pomocí new odkázat na nově vložená data Old data před změnou 91
Trigery x Omezení Spouště slouží v DB k zajištění konzistence dat v DB IO slouží ke stejnému účelu, zachování konzistenci dat vždy Spouště jsou aktivovány pouze na určité stimuly 92
Příklad, kdy je lépe použít Trigger Mějme relaci Objednavky (oid,počet,idzakaznika, jednotkovacena) Při založení objednávky jsou první tři atributy vyplněny zákazníkem (případně prodavačem na pokladně) Atribut jednotkovacena je vyplněn podle jiné relace produkty 93
Atribut jednotkovacena je však nutné vyplnit, aby byla objednávka kompletní! Pokud by nebyla uvedena, pak by při pozdější změně (např. sleva), byla změněna i ve všech objednávkách již uzavřených 94
Napíšeme trigger, který nám tuto hodnotu z tabulku produkty zjistí a vloží do tabulky objednávky Je to vhodné vzhledem k ušetření práce prodavače a zároveň to minimalizuje možnost vzniku chyby při vkládání dat a tím pádem i vzniku nekonzistence v DB 95
Mějme dále za úkol provést ještě další kontroly Například při platbě chtějme kontrolovat, zda-li celková cena není větší než, zůstatek na účtu zákazníka To se dá provést pomocí triggeru, ale i CHECK 96
Nicméně použití triggeru nám umožní implementovat i složitější kontrolní mechanizmy Např. můžeme dovolit zákazníkovi překročit jeho limit účtu o ne více než 10%, pokud má zákazník u naší společnosti záznam déle než 1 rok. Dále pak můžeme požadovat přidání zákazníka do tabulky pro zvýšení limitu platby 97
Condition (podmínka) true/false statement (věk>18) Dotaz Pokud dotaz vrátí neprázdnou množinu jako výsledek, pak odpovídá TRUE Jinak FALSE 98
SQL Oracle syntax CREATE [OR REPLACE] TRIGGER <trigger_name> {BEFORE AFTER} {INSERT DELETE UPDATE} ON <table_name> [REFERENCING [NEW AS <new_row_name>] [OLD AS <old_row_name>]] [FOR EACH ROW [WHEN (<trigger_condition>)]] <trigger_body> 99
Trigger granularita FOR EACH ROW Provede se tolikrát, kolik je řádek v množině ovlivněných záznamů. Pokud je třeba odkazovat/používat konkrétní řádku/řádky z množiny ovlivněných záznamů, pak použít FOR EACH ROW. Příklad: pokud chceme porovnávat hodnoty nově vložených a starých záznamů v případě AFTER UPDATE triggeru. FOR EACH STATEMENT Provede se jednou pro celý trigger/událost. Pokud je množina ovlivněných záznamů prázdná (např. pokud není splněná podmínka pro UPDATE, DELELE, či INSERT), pak FOR EACH ROW trigger se neprovede vůbec FOR EACH STATEMENT trigger se spustí/provede. 100
Příkladudržování počtu zaměstnanců pomocí FOR EACH ROW CREATE TRIGGER NEW_HIRED AFTER INSERT ON EMPLOYEE FOR EACH ROW UPDATE COMPANY_STATS SET NBEMP = NBEMP + 1 101
To samé s FOR EACH STATEMENT CREATE TRIGGER NEW_HIRED AFTER INSERT ON EMPLOYEE REFERENCING NEW_TABLE AS NEWEMPS FOR EACH STATEMENT UPDATE COMPANY_STATS SET NBEMP = NBEMP + (SELECT COUNT(*) FROM NEWEMPS) 102
Aktivace Triggeru BEFORE, AFTER aktivaci/provedení spouště. Například, aktivace následují spouště je po (AFTER) provedení operace INSERT nad tabulkou employee 103
CREATE TRIGGER NEW_HIRE AFTER INSERT ON EMPLOYEE FOR EACH ROW UPDATE COMPANY_STATS SET NBEMP = NBEMP + 1 104
Before Pokud je jako čas aktivace zvoleno BEFORE, akce spouště jsou aktivovány pro každý řádek ovlivněných záznamů před provedení vlastního dotazu nad databází. Z toho vyplývá, že tabulka, nad kterou se provádí dotaz, bude modifikována až po provedení všech operací BEFORE spouště. Pozn. BEFORE spoušť musí mít granularitu FOR EACH ROW. 105
After Akce spouště jsou aktivovány for each row v množině ovlivněných záznamů nebo pro daný příkaz (záleží na granularitě spouště). Spoušť je aktivována až po provedení všech kontrol integritních omezení, které může spoušť (akce ve spoušti) ovlivnit. Pozn. AFTER spouště mohou mít granularitu FOR EACH ROW FOR EACH STATEMENT. 106
107
Pokud jsou nad tabulkou definovány jak before tak i after spouště, pak se jako první provedou všechny before spouště První spoušť, která je spuštěna vezme jako vstup množinu záznamů, které budou ovlivněný dotazem (UPDATE, INSERT, DELETE) a provede veškeré změny definované v rámci spouště. Výstup první before spouště je pak vstupem následující before spouště. Jakmile jsou aktivovány a dokončeny všechny before spouště, jsou všechny změny provedeny na databázových objektech (včetně vlastního dotazu co spoušť aktivoval) Následně jsou aktivovány všechny after spouště asociované s danou akcí. After spouště pak mohou modifikovat stejnou/jinou tabulku, mohou také spouštět externí akce (poslat email) 108
Použití Before BEFORE spouště jsou jakýmsi rozšířením systém integritních omezení. Používají se pro: Provedení validace vstupních dat, Automatické generován hodnot pro nově vkládané/modifikované záznamy Čtení záznamů z odkazovaných tabulek pro ověření referencí. BEFORE spouště nejsou používány pro další modifikace databázových objektů, protože jsou aktivovány před provedení změn vlastním dotazem a tedy jsou aktivovány před kontrolou integritních omezení 109
Použití After AFTER trigery mohou být chápány jako modul aplikační logiky který je proveden jako odezva na určitou událost v DB. AFTER trigery vždy pracují s db, která je v konzistetním stavu. Jsou spouštěny až po kontrole IO. Např: Spouštění operací jako odezvu na upravující operace v db Operace mimo databázi, např. spouštění alarmů, externích programů atd. Akce mimo db nejsou pod kontrolou db mechanismů pro rollback 110
Omezení Before Before trigery nemohou obsahovat následující operace v SQL příkazech svého těla: UPDATE DELETE INSERT 111
Příklad CREATE TABLE T4 (a INTEGER, b CHAR(10)); CREATE TABLE T5 (c CHAR(10), d INTEGER); Vytvoříme trigger, který vloží záznam do tabulky T5 pokud je vložen záznam do T4. Triger zkontroluje, zda-li nově vložený záznam má první složku 10 nebo méně a pokud ano, tak vloží reverzní záznam do T5: CREATE TRIGGER trig1 AFTER INSERT ON T4 REFERENCING NEW AS newrow FOR EACH ROW WHEN (newrow.a <= 10) BEGIN INSERT INTO T5 VALUES(newRow.b, newrow.a); END trig1; 112
MySQL mysql> delimiter // mysql> CREATE TRIGGER upd_check BEFORE UPDATE ON account FOR EACH ROW BEGIN IF NEW.amount < 0 THEN SET NEW.amount = 0; ELSEIF NEW.amount > 100 THEN SET NEW.amount = 100; END IF; END;// mysql> delimiter ; 113
CREATE TABLE test1(a1 INT); CREATE TABLE test2(a2 INT); CREATE TABLE test3(a3 INT NOT NULL AUTO_INCREMENT PRIMARY KEY); CREATE TABLE test4( a4 INT NOT NULL AUTO_INCREMENT PRIMARY KEY, b4 INT DEFAULT 0 ); DELIMITER CREATE TRIGGER testref AFTER INSERT ON test1 FOR EACH ROW BEGIN INSERT INTO test2 (a2) VALUES NEW.a1; DELETE FROM test3 WHERE a3 = NEW.a1; UPDATE test4 SET b4 = b4 + 1 WHERE a4 = NEW.a1; END; DELIMITER ; INSERT INTO test3 (a3) VALUES (NULL), (NULL), (NULL), (NULL), (NULL), (NULL), (NULL), (NULL), (NULL), (NULL); INSERT INTO test4 (a4) VALUES (0), (0), (0), (0), (0), (0), (0), (0), (0), (0); 114
CREATE TRIGGER testref AFTER INSERT ON test1 FOR EACH ROW BEGIN INSERT INTO test2 (a2) VALUES NEW.a1; DELETE FROM test3 WHERE a3 = NEW.a1; UPDATE test4 SET b4 = b4 + 1 WHERE a4 = NEW.a1; END; INSERT INTO test1 VALUES (1), (3), (1), (7), (1), (8), (4), (4); SELECT * FROM test1; +------+ a1 +------+ 1 3 1 7 1 8 4 4 +------+ 115
CREATE TRIGGER testref AFTER INSERT ON test1 FOR EACH ROW BEGIN INSERT INTO test2 (a2) VALUES NEW.a1; DELETE FROM test3 WHERE a3 = NEW.a1; UPDATE test4 SET b4 = b4 + 1 WHERE a4 = NEW.a1; END; INSERT INTO test1 VALUES (1), (3), (1), (7), (1), (8), (4), (4); SELECT * FROM test2; +------+ a2 +------+ 1 3 1 7 1 8 4 4 +------+ 116
CREATE TRIGGER testref AFTER INSERT ON test1 FOR EACH ROW BEGIN INSERT INTO test2 (a2) VALUES NEW.a1; DELETE FROM test3 WHERE a3 = NEW.a1; UPDATE test4 SET b4 = b4 + 1 WHERE a4 = NEW.a1; END; INSERT INTO test1 VALUES (1), (3), (1), (7), (1), (8), (4), (4); SELECT * FROM test3; +----+ a3 +----+ 2 5 6 9 10 +----+ 117
CREATE TRIGGER testref AFTER INSERT ON test1 FOR EACH ROW BEGIN INSERT INTO test2 (a2) VALUES NEW.a1; DELETE FROM test3 WHERE a3 = NEW.a1; UPDATE test4 SET b4 = b4 + 1 WHERE a4 = NEW.a1; END; INSERT INTO test1 VALUES (1), (3), (1), (7), (1), (8), (4), (4); SELECT * FROM test4; +----+------+ a4 b4 +----+------+ 1 3 2 0 3 1 4 2 5 0 6 0 7 1 8 1 9 0 10 0 +----+------+ 118
Uložené procedury CREATE PROCEDURE Můžeme definovat dva typy uložených procedur. Externí. Tělo procedury je napsaná v programovacím jazyce. Procedura pak během svého běhu volá externí programy, rutiny. SQL. Tělo procedury je napsané v SQL a je definované pouze pro prostředí SQL serveru. 119
MySQL CREATE [DEFINER = { user CURRENT_USER }] PROCEDURE sp_name ([proc_parameter[,...]]) [characteristic...] routine_body CREATE [DEFINER = { user CURRENT_USER }] FUNCTION sp_name ([func_parameter[,...]]) RETURNS type [characteristic...] routine_body proc_parameter: [ IN OUT INOUT ] param_name type func_parameter: param_name type type: Any valid MySQL data type characteristic: LANGUAGE SQL [NOT] DETERMINISTIC { CONTAINS SQL NO SQL READS SQL DATA MODIFIES SQL DATA } SQL SECURITY { DEFINER INVOKER } COMMENT 'string' routine_body: Valid SQL procedure statement 120
Parametry Parametry jsou defaultně jako IN. Pokud chceme specifikovat parametr jinak musíme použít klíčová slova OUT nebo INOUT před jménem parametru. 121
Return Return umožňuje definovat návratový typ procedury. 122
routine_body routine_body (tělo procedury) obsahuje validní SQL. Můžeme použít jak jednoduchý SELECT nebo INSERT, tak i složený příkaz uzavřený do BEGIN a END. 123
Příklady PROCEDURE mysql> delimiter // mysql> CREATE PROCEDURE simpleproc (OUT param1 INT) BEGIN SELECT COUNT(*) INTO param1 FROM t; END; // Query OK, 0 rows affected (0.00 sec) mysql> delimiter ; mysql> CALL simpleproc(@a); Query OK, 0 rows affected (0.00 sec) mysql> SELECT @a; +------+ @a +------+ 3 +------+ 1 row in set (0.00 sec) 124
Příklady FUNCTION mysql> CREATE FUNCTION hello (s CHAR(20)) RETURNS CHAR(50) RETURN CONCAT('Hello, ',s,'!'); Query OK, 0 rows affected (0.00 sec) mysql> SELECT hello('world'); +----------------+ hello('world') +----------------+ Hello, world! +----------------+ 1 row in set (0.00 sec) 125
Change of characteristics of a stored procedure or function. ALTER {PROCEDURE FUNCTION} sp_name [characteristic...] characteristic: { CONTAINS SQL NO SQL READS SQL DATA MODIFIES SQL DATA } SQL SECURITY { DEFINER INVOKER } COMMENT 'string' 126
DROP DROP {PROCEDURE FUNCTION} [IF EXISTS] sp_name 127
CALL CALL sp_name([parameter[,...]]) CALL spustí uloženou proceduru definovanou pomocí CREATE PROCEDURE. 128
DECLARE DECLARE var_name[,...] type [DEFAULT value] Pomocí declare definujeme lokální proměnné. Může definovat výchozí hodnotu proměnné pomocí klauzule DEFAULT. Hodnota může být samozřejmě výraz, tedy ne konstantní hodnota. Pokud neuvedeme DEFAULT, pak je výchozí hodnotu NULL. 129
SELECT INTO CREATE PROCEDURE sp1 (x VARCHAR(5)) BEGIN DECLARE xname VARCHAR(5) DEFAULT 'bob'; DECLARE newname VARCHAR(5); DECLARE xid INT; SELECT xname,id INTO newname,xid FROM table1 WHERE xname = xname; SELECT newname; END; 130
Konec. 131/53