======================================================================
- zdroje:
  - Jaroslav Pokorn, Ivan Halaka: Databzov systmy, Vybran kapitoly a cvien, skript, Karolinum, Praha 1998
  - help k DB2
======================================================================
4. Jazyk SQL
======================================================================
----------------------------------------------------------------------
4.1 vod
----------------------------------------------------------------------

- histria
  - v roku 1974 vznikol dopytovac jazyk Sequel (Structured English QUEry Language) bol sasou Systmu R vyvinutho v laboratriu IBM v San Jos (zamestnvate autora relanho modelu dt E. F. Codda); po prave koncepcie a zjednoduen mena na SQL (structured query language) sa stal zkladom prvch vznamnejch databzovch produktov DB2, SQL/DS a QMF od IBM
  - s nstupom PC v 80. rokoch sa mnoho svetovch vrobcov software-u zaalo orientova na implementciu SQL, od jednopouvateskch sa postupne prechdzalo na databzov servery zaloen na SQL
  - v roku 1986 nastal zlom - tandardizcia SQL organizciou ANSI (pod nzvom SQL86), v roku 1987 bola tto tandardizcia prijat organizciou ISO; tandard bol dialekt SQL firmy IBM a bol charakterizovan ako "prienik existujcich implementci"
  - v roku 1989 sa jazyk rozril o monos definova integritn obmedzenia, tto verzia sa vol SQL89
  - al vvoj vystil v roku 1992 do tandardu SQL92, ktor ete doteraz nie je plne implementovan
  - alie tandardy
    - X/OPEN SQL svis s pouitm UNIX-u ako implementanho prostredia
    - SAA-SQL (Systems Application Architecture Database Interface) - vlastn tandard firmy IBM
  
- rysy modelovania dt pomocou SQL
  - SQL je neprocedurlny jazyk (popisuje, o poadujeme od databzy, nie to, ako to treba urobi)
  - dta s vdy prezentovan pouvateovi ako tabuky, bez ohadu na ich vntorn truktru pouit v databze
  - poloha tabuliek v databze nie je dleit, s identifikovan menom
  - poradie stpcov v tabuke nie je dleit, s identifikovan menom
  - poradie riadkov v tabuke nie je dleit, s identifikovan hodnotami v stpcoch
  
- pouitie SQL
  - dopytovac a manipulan jazyk pre relan databzy
  - zloka hostiteskho jazyka na programovanie databzovch aplikci (embedded SQL)
  - jazyk komunikcie medzi rznymi zdrojmi dt
  
- budeme sa zaobera SQL vo verzii DB2  
  
----------------------------------------------------------------------
4.2 Defincia dt - metadta
----------------------------------------------------------------------

- (niektor) dtov typy
  - presn numerick typy 
    - cel sla
      - INTEGER (alebo INT) 
        - 4 byte
      - SMALLINT 
        - 2 byte
      - BIGINT 
        - 8 byte
    - desatinn sla  
      - DECIMAL (alebo DEC) alebo NUMERIC (alebo NUM) (poet cifier [, poet desatinnch miest])
  - aproximatvne numerick typy 
    - relne sla 
      - FLOAT alebo FLOAT(presnos)
      - REAL 
        - pevn presnos (dan implementciou)
      - DOUBLE (alebo DOUBLE PRECISION) 
        - pevn presnos (dvojnsobn ne pri REAL)
  - znakov reazce
    - CHARACTER (alebo CHAR) (poet znakov) 
      - krat reazec doplnen przdnymi znakmi
      - poet znakov do 254 (preo nie 256?)
    - CHARACTER VARYING (alebo VARCHAR) (maximlny poet znakov) 
      - krat reazec nie je doplnen przdnymi znakmi
      - poet znakov do 32 672
  - vek daje (loby (z angl. large objects))
    - BLOB (vekos (v B)) alebo (vekos K alebo M alebo G) - binrne
    - CLOB (vekos (v B)) alebo (vekos K alebo M alebo G) - reazcov
  - asov daje
    - DATE - dtum
      - spravidla v tvare YYYY-MM-DD, ale povolen je aj D.M.YYYY 
        (alebo CURRENT DATE)
    - TIME - as
      - v tvare HH:MM:SS (alebo CURRENT TIME)
    - TIMESTAMP - asov peiatka (dtum a as)
      - v tvare YYYY-MM-DD HH:MM:SS alebo YYYY-MM-DD HH:MM:SS.mmmmmm (alebo CURRENT TIMESTAMP)
  - linky na dta uloen mimo databzy
    - DATALINK

- prca s tabukou
  - vytvorenie tabuky - prkaz CREATE TABLE
    - syntax (as):
        CREATE TABLE meno_tabuky (zoznam_prvkov_tabuky)
        zoznam_prvkov_tabuky ::= prvok_tabuky [, prvok_tabuky]
        prvok_tabuky ::= defincia_stpca | defincia_IO_tabuky
        defincia_stpca ::= meno_stpca dtov_typ [IO_stpca]
    - IO (integritn obmedzenia) stpca
      - NOT NULL - stpec nesmie ma przdnu hodnotu (NULL)
      - DEFAULT - implicitn hodnota stpca
      - UNIQUE - vetky hodnoty v stpci musia by jedinen (NULL hodnota nepreka)
      - PRIMARY KEY - stpec je sasou primrneho ka tabuky
      - FOREIGN KEY - stpec je cudz k definujci referenn integritu s inou tabukou
      - CHECK - zadan logick vraz definuje integritn obmedzenie
    - vetky IO sa mu definova aj na rovni tabuky; nutn je to vtedy, ke s IO kladen na viacero stpcov
    - prklady
      - CREATE TABLE student1 
        (
          meno        VARCHAR(10),
          priezvisko  VARCHAR(20)
        );
      - CREATE TABLE student2 
        (
          id          INTEGER       NOT NULL,
          meno        VARCHAR(10)   NOT NULL,
          priezvisko  VARCHAR(20)   NOT NULL,
          datum_nar   DATE          NOT NULL,
          PRIMARY KEY (id)
        );
        - id je primrnym kom
      - CREATE TABLE student3 
        (
          id          INTEGER       NOT NULL,
          meno        VARCHAR(10)   NOT NULL,
          priezvisko  VARCHAR(20)   NOT NULL,
          datum_nar   DATE          NOT NULL,
          pohlavie    CHAR(4)       NOT NULL   CHECK (pohlavie IN ('muz', 'zena')),
          rodne_cislo CHAR(10)      NOT NULL   UNIQUE,
          id_mesto    INTEGER,
          PRIMARY KEY (id),
          CONSTRAINT FK_mesto FOREIGN KEY (id_mesto) REFERENCES mesto,
          CONSTRAINT nie_kratke CHECK ((LENGTH(meno) > 1) AND (LENGTH(priezvisko) > 1))
        );
        - pohlavie me nadobda iba hodnoty 'muz' a 'zena'
        - aj ke rodn slo nie je primrnym kom, neme nadobda dve rovnak hodnoty
        - obmedzenie FK_mesto znamen, e stpec id_mesto me nadobda iba hodnoty existujce v tabuke mesto (a t mus tie, samozrejme, existova) alebo przdnu hodnotu
        - obmedzenie nie_kratke znamen, e sa do databzy nedaj vloi zznamy, ktorch by hodnoty stpcov meno alebo priezvisko nemali aspo dva znaky 
      - CREATE TABLE osoba1 
        (
          id          INTEGER,
          priezvisko  VARCHAR(10)   DEFAULT
        );
        - po vloen zznamu iba s id sa do stpca meno ulo hodnota '' (przdny reazec)
      - CREATE TABLE osoba2 
        (
          id          INTEGER,
          priezvisko  VARCHAR(10)   DEFAULT 'Kovac'
        );
        - po vloen zznamu iba s id sa do stpca meno ulo hodnota 'Kovac'
    - tabuku mono vytvori aj pomocou prkazu SELECT (podrobnosti o om bud niie)           
      - CREATE TABLE student3_kopia AS
        (
          SELECT *
          FROM student3
        ) 
        DEFINITION ONLY;
  - prava truktry existujcej tabuky - prkaz ALTER TABLE
    - syntax (as):
        ALTER TABLE meno_tabuky zmena
    - zmeny
      - pridanie stpca - ADD defincia_stpca
        - po pridan stpca sa vetkm zznamom v tomot stpci prirad hodnota NULL (ak nie je uren inak)
      - pridanie IO tabuky - ADD CONSTRAINT defincia_IO_tabuky
      - zruenie IO tabuky - DROP CONSTRAINT meno_IO_tabuky
    - prklady
      - CREATE TABLE student 
        (
          id          INTEGER     NOT NULL,
          meno        VARCHAR(10),
          priezvisko  VARCHAR(20),
          datum_nar   DATE,
          id_mesto    INTEGER,
          PRIMARY KEY (id)
        );
        CREATE TABLE mesto 
        (
          id          INTEGER     NOT NULL,
          nazov       VARCHAR(20),
          PRIMARY KEY (id)
        );
      - vytvorenie cudzieho ka - vzby medzi dvoma existujcimi tabukami
        - 3 monosti vzhadom na delete
          - s obmedzenm delete-om (zznam, ktor je aspo raz odkazovan, potom nemono vymaza)
            - ALTER TABLE student ADD FOREIGN KEY sm (id_mesto) REFERENCES mesto; (alebo alternatvne ALTER TABLE student ADD CONSTRAINT sm FOREIGN KEY (id_mesto) REFERENCES mesto;)
            - toto je defaultn monos
          - s kaskdnym delete-om (zznam, ktor je aspo raz odkazovan, mono vymaza, ale iba vtedy, ak s nm mono vymaza aj vetky zznamy, ktor na odkazuj)  
            - ALTER TABLE student ADD FOREIGN KEY sm (id_mesto) REFERENCES mesto ON DELETE CASCADE ;
            - v prpade spechu me nasta cel kaskda delete-ov, treba by preto pri pouvan tejto monosti opatrn
          - so SET-NULL delete-om (zznam, ktor je aspo raz odkazovan, mono vymaza, ale iba vtedy, ak vetky hodnoty, ktor na odkazuj, mono nastavi na NULL (t.j. nie s NOT NULL)) 
            - ALTER TABLE student ADD FOREIGN KEY sm (id_mesto) REFERENCES mesto ON DELETE SET NULL;
        - prklad
          - ak tabuka student obsahuje zznamy (1, ..., 1), (2, ..., 2), (3, ..., 1) a tabuka mesto o.i. zznam (1, 'Koice'), pri kaskdnom delete-e sa pri vymazan Koc vyma aj zznamy (1, ..., 1) a (3, ..., 1); v prpade obmedzenho delete-u s Koice nevymazaten a v prpade SET NULL sa hodnoty stpca id_mesto v zznamoch (1, ..., 1) a (3, ..., 1) zmenia na NULL
        - cudz k me odkazova aj na stpec, ktor nie je primrnym kom, ten vak mus by jednoznan (UNIQUE)  
      - pridanie obmedzenia  
        - ALTER TABLE student ADD CONSTRAINT dk CHECK (YEAR(datum_nar)>=2000);
      - zruenie obmedzenia  
        - ALTER TABLE student DROP CONSTRAINT dk;
      - pridanie novho stpca   
        - ALTER TABLE student ADD COLUMN rocnik INTEGER;
        - ALTER TABLE student ADD COLUMN rocnik INTEGER NOT NULL; - nesprvne - nie je ho m naplni, przdnu hodnotu sme prve zakzali
        - ALTER TABLE student ADD COLUMN rocnik INTEGER NOT NULL DEFAULT 1; - vetky doterajie zznamy bud ma v tomto stpci hodnotu 1
  - zruenie tabuky - prkaz DROP TABLE
    - syntax:
        DROP TABLE meno_tabuky
    - s vymazanm tabuky sa vyma aj vetky jej integritn obmedzenia i tie cudzie ke inch tabuliek, ktor na u odkazuj
    - prklad
      - pri vymazan tabuky mesto sa automaticky vymae jej primrny k, ale aj cudz k tabuky student, ktor na u odkazoval

- indexy
  - index sli na efektvnejie vyhadvanie zznamov, neme vak by sasou dopytu - optimaliztor vyhodnocovania dopytu sm rozhodne, i a ktor index pouije
  - index mono definova pre jeden alebo kombinciu stpcov (pre tak, ktor sa asto vyskytuj v podmienkach dopytov)
  - pre jednu tabuku me by definovan ubovon poet indexov, men indexov musia by rzne  
  - indexy s spravidla implementovan pomocou B-stromov
  - vytvorenie indexu
    - syntax (as):
        CREATE [UNIQUE] INDEX meno_indexu ON meno_tabuky (meno_stpca [ASC | DESC] [, meno_stpca [ASC | DESC]]) [CLUSTER]
      - ASC resp. DESC - vzostupn resp. zostupn usporiadanie      
      - UNIQUE - vetky hodnoty v stpci musia by jedinen (NULL hodnota nepreka) 
      - CLUSTER - zznamy s v implementcii zoraden poda neho, leia na disku fyzicky za sebou 
        - iba jeden z indexov me by CLUSTER
        - s pribdajcimi riadkami sa vak sprvanie takejto truktry zhoruje
    - prklad
      - CREATE UNIQUE INDEX pm ON student (priezvisko, meno);
  - zruenie indexu
    - syntax:
        DROP INDEX meno_indexu
    - zruenm indexu sa nezruia dta    

- pohady (views)
  - pohad mono povaova za virtulnu tabuku, ktor nem vlastn dta, sli iba ako filter na dta v inch tabukch; so zmenou dt v pvodnch tabukch sa tak automaticky men aj vsledok pohadu
  - pvodn tabuka, mono obsahujca citliv dta, me by benmu pouvateovi ako celok neprstupn, pohadom mu vak mono sprstupni aspo jej zverejniten as 
  - vytvorenie pohadu
    - syntax (as):
        CREATE VIEW meno_pohadu [(meno_stpca [, meno_stpca]])] AS prkaz_SELECT
      - prkaz SELECT bude popsan v alej kapitole
      - zoznam mien stpcov a ich dtovch typov je uren prkazom SELECT; ak sa men stpcov z definujceho prkazu SELECT nedaj odvodi, zoznam mien stpcov pohadu je povinn
    - prklady (vyuvame tabuky student a mesto definovan v predolom odseku)
      - CREATE VIEW meno_studenta AS SELECT meno, priezvisko FROM student;
      - CREATE VIEW student_mesto (meno, priezvisko, mesto) AS 
          SELECT s.meno, s.priezvisko, m.nazov 
          FROM student s, mesto m
          WHERE s.id_mesto = m.id;
  - zruenie pohadu
    - syntax:
        DROP VIEW meno_pohadu
    - so zruenm pohadu sa neruia tabuky, na ktorch bol vybudovan    
    - prklad
      - DROP VIEW meno_studenta;
  - pohady mu by v istch prpadoch aj aktualizovaten

- systmov katalg
  - podva informcie o metadtach 
    - tabuky: meno, tvorca, dtum vytvorenia, poet stpcov, ..., komentr
    - stpce: z ktorej tabuky, meno, dtov typ, ..., komentr
    - alie informcie o systme, kad typ je v osobitnej tabuke - pohady, indexy, integritn obmedzenia, ..., 
  - je zloen op z databzovch tabuliek (presnejie z pohadov) a je prstupn pomocou SQL dopytov
  - katalg by sa nemal da aktualizova benmi aktualizanmi prostriedkami SQL, rob sa to automaticky
  - aktualizova vak mono komentre k tabukm a stpcom
    - syntax:
      - pre tabuky: COMMENT ON TABLE meno_tabuky IS komentr_v_apostrofoch
      - pre stpce: COMMENT ON COLUMN meno_tabuky.meno_stpca IS komentr_v_apostrofoch
    - prklady  
      - COMMENT ON TABLE student IS 'Info o (po)riadnych studentoch';
      - COMMENT ON COLUMN student.id IS 'Identifikator';
  
----------------------------------------------------------------------
4.3 Prkaz SELECT
----------------------------------------------------------------------

- SELECT-FROM-WHERE-blok (kratie SELECT)
  - zkladn kontrukt SQL na dopytovanie (t.j. vber dt)
  - SELECT - klauzula obsahujca zoznam stpcov vslednej tabuky (v prpade jednoduchch men, v prpade zloitejch ich kontrukciu), implicitne s zahrnut aj ich dtov typy
  - FROM - klauzula obsahujca zoznam tabuliek, nad ktormi je dopyt definovan
  - WHERE - klauzula obsahujca podmienku, ktor musia vybrat dta spa
    - v prpade, e tto klauzula chba, povauje sa podmienka za tautolgiu
  - vzah k relanej algebre
    - dopyt tvaru 
        SELECT A_1, ..., A_j
        FROM R_1, ..., R_k
        WHERE \phi
      zodpoved v relanej algebre vrazu (R_1 x ... x R_k)(\phi)[A_1, ..., A_j] 
    - prklady
      - odpove dopyt SELECT * FROM tabuka je kpia tabuky 
      - dopyt 
          SELECT priezvisko, nazov 
          FROM student, mesto 
          WHERE student.id_mesto = mesto.id 
        zodpoved vrazu 
          STUDENT x MESTO (STUDENT.id_mesto = MESTO.id) [priezvisko, nazov] 
    - v skutonosti dopyt nemus by vyhodnocovan takmto asto neefektvnym spsobom
    - na rozdiel od relanej algebry SELECT neeliminuje (automaticky) z vsledku duplicitn riadky
  - syntax (zjednoduen):
      SELECT [DISTINCT] {* | kontrukcia_stpca [AS alias_stpca] [, kontrukcia_stpca [AS alias_stpca]] | meno_tabuky.* [, meno_tabuky.*]}
      FROM meno_tabuky [AS alias_tabuky] [, meno_tabuky [AS alias_tabuky]]
      [WHERE podmienka]
      [ORDER BY pecifikcia_usporiadania_poda_stpca [, pecifikcia_usporiadania_poda_stpca]]
    - prklad
      - SELECT student.priezvisko, nazov AS mesto, mesto.* 
        FROM student, mesto 
        WHERE student.id_mesto = mesto.id 
        ORDER BY 1 ASC, 2 DESC
    - kontrukcia stpca vslednej tabuky je v najjednoduchom a najastejom prpade meno niektorho stpca niektorej tabuky z FROM klauzuly, a to v tvare meno_stpca alebo meno_tabuky.meno_stpca resp. alias_tabuky.meno_stpca 
    - DISTINCT - eliminuje z vsledku duplicitn riadky  
    - * znamen, e vyberme vetky stpce zo vetkch tabuliek, meno_tabuky.* znamen, e vyberme vetky stpce z tabuky meno_tabuky
    - alias_stpca a alias_tabuky s loklne premenovania (v rmci SELECTu)
    - men tabuliek sa mu opakova, musia vak potom by odlen pomocou aliasov
    - klauzula ORDER BY presahuje rmec relanch truktr (tam na porad riadkov nezle)
      - pecifikcia_usporiadania_poda_stpca := [alias_stpca | kontrukcia_stpca | poradie_stpca] [ASC | DESC]
        - ASC resp. DESC - vzostupn resp. zostupn usporiadanie, implicitn hodnota je ASC   
    - v podmienke vo WHERE mono zada ubovon booleovsk vraz pouvajci:
      - logick opertory AND (a), OR (alebo), NOT (nie)
        - NOT m viu prioritu ne AND a AND m viu prioritu ne OR
      - porovnvania (=, <> alebo !=, <, >, <=, >=)
      - porovnanie LIKE
        - umouje pracova s podreazcami hodnt stpcov typu CHAR alebo VARCHAR
        - obvykle vo forme meno_stpca LIKE maska, priom maska me obsahova znaky '%' (nhrada za reazec ubovonej dky (aj nulovej)) a '_' (nhrada za prve jeden znak)
        - v maske mono poui aj znak '%' alebo '_' - treba poui formu meno_stpca LIKE maska ESCAPE in_znak, priom pred znakom '%' alebo '_' je v maske napsan in_znak
          - napr. vyhodnoteniu reazca LIKE '%10@%' ESCAPE '@' vyhovuje reazec '10%' alebo '2310%'
      - BETWEEN 
        - vraz (a BETWEEN b AND c) znamen ((a >= b) AND (a <= c))
          - a, b, c musia ma kompatibiln typy
      - IN
        - vraz (a IN (b_1, ..., b_n)) znamen ((a = b_1) OR ... OR (a = b_n))
          - a, b_1, ..., b_n musia ma komptibiln typy
      - NULL (przdnu hodnotu)
        - od dvojhodnotovej logiky (TRUE, FALSE) potom musme prejs k trojhodnotovej (naviac hodnota UNKNOWN); pre ubovon porovnanie @ plat:
          x@y m hodnotu UNKNOWN prve vtedy, ke aspo jedno z x a y je NULL
          - pecilne aj porovnanie NULL=NULL m hodnotu UNKNOWN
        - pravidl:
          - pre NOT:
            FALSE  | TRUE
            TRUE   | FALSE
            UNKNOWN| UNKNOWN
          - pre AND:
                   | FALSE   UNKNOWN TRUE
            --------------------------------        
            FALSE  | FALSE   FALSE   FALSE
            UNKNOWN| FALSE   UNKNOWN UNKNOWN
            TRUE   | FALSE   UNKNOWN TRUE
          - pre OR:
                   | FALSE   UNKNOWN TRUE
            --------------------------------        
            FALSE  | FALSE   UNKNOWN TRUE
            UNKNOWN| UNKNOWN UNKNOWN TRUE
            TRUE   | TRUE    TRUE    TRUE
        - na porovnvanie s przdnou hodnotou teda nemono poui x @ NULL; poslia na to porovnania x IS NULL, ktor nadobda hodnotu TRUE prve vtedyt, ke x je przdna hodnota, resp. x IS NOT NULL, s ktorm je to presne naopak
          - prklad
            SELECT * FROM student WHERE cislo_izby IS NULL
              - tudenti, ktor nebvaj na internte (slo ich interntnej izby m teda przdnu hodnotu)
      - vnoren SELECT
        - dosad sa za mnoina, ktor vznikne ako jeho vsledok
        - predikty pre prcu s mnoinami
          - IN
            - prklad
              - SELECT * FROM student 
                WHERE priezvisko IN (SELECT priezvisko FROM ucitel)
                - njde vetkch tudentov, ktor maj menovcov medzi uitemi
          - BETWEEN
            - ak je pouit vnoren SELECT, jeho vsledok tu mus by jednoznan
            - prklad
              - SELECT * FROM student 
                WHERE datum_nar between 
	          (SELECT MIN(datum_nar) FROM ucitel)
	          AND
	          (SELECT MAX(datum_nar) FROM ucitel)
                - njde vetkch tudentov, ktor "s vo veku uiteov"
          - porovnvania (=, <> alebo !=, <, >, <=, >=)
            - ak je pouit vnoren SELECT, jeho vsledok tu mus by jednoznan
            - prklady
              - SELECT * FROM student 
                WHERE datum_nar = (SELECT MAX(datum_nar) FROM student)
                - njde vetkch najstarch tudentov
              - SELECT * FROM student 
                WHERE priezvisko = (SELECT priezvisko FROM ucitel)
                - njde vetkch tudentov, ktor maj menovcov medzi uitemi
                - zafunguje iba vtedy, ak je uite jedin, inak vyhod chybu
          - ALL
            - prklad
              - SELECT * FROM student 
                WHERE priezvisko <> ALL(SELECT priezvisko FROM ucitel)
                - njde vetkch tudentov, ktor nemaj menovcov medzi uitemi
            - porovnanie s ALL aplikovanm na przdnu mnoinu dva TRUE     
          - SOME (alebo aj ANY)
            - prklad
              - SELECT * FROM student 
                WHERE priezvisko = SOME(SELECT priezvisko FROM ucitel)
                - njde vetkch tudentov, ktor maj menovcov medzi uitemi
            - porovnanie so SOME aplikovanm na przdnu mnoinu dva FALSE     
          - EXISTS, NOT EXISTS 
            - vraz EXISTS (SELECT ...) sa vyhodnot ako pravdiv, ak je vsledok SELECT-u v ztvorkch neprzdna mnoina, inak je nepravdiv 
            - prklady
              - SELECT * FROM mesto 
		WHERE EXISTS resp. NOT EXISTS
		(
		  SELECT * 
		  FROM student
		  WHERE student.id_mesto = mesto.id
		)
                - mest, v ktorch bva aspo jeden resp. nebva iaden tudent 
        - SELECTy mu by vnoren aj do viacerch rovn
          - prklad
            - SELECT MAX(datum_nar)
	      FROM student
	      WHERE datum_nar < 
	      (
	        SELECT MAX(datum_nar)
	        FROM student
	        WHERE datum_nar <
	        (
	          SELECT MAX(datum_nar) 
	          FROM student
	        )
	      )
	      - dtum narodenia tretieho najstarieho tudenta
  - pri kontrukcii stpca vslednej tabuky, ale i v termoch podmienok mono pouva:
    - aritmetick opercie +, -, *, /
      - ak @ \in {+, -, *, /}, x@y m hodnotu NULL prve vtedy, ke aspo jedno z x a y je NULL
    - hodnotov vrazy
      - hodnotov vraz vznikne kombinciou aritmetickch vrazov, mien stpcov, agregci, hodnt skalrnych poddopytov (t.j. poddopytu, ktorho vsledkom je tabuka s jednm riadkom a jednm stpcom) a alch pecilnych funkci, najastejie je to vak iba meno stpca
        - prklady
          - SELECT (SELECT COUNT(*) FROM mesto m WHERE m.nazov <= mesto.nazov), nazov 
            FROM mesto
            ORDER BY 1
            - usporiadanie a oslovanie miest poda abecedy
          - SELECT MAX(datum_nar)
            FROM student
            WHERE datum_nar < 
            (
              SELECT MAX(datum_nar)
              FROM student
            )  
            - dtum narodenia druhho najmladieho tudenta   
      - niektor pecilne funkcie
        - funkcie na reazce (typu CHAR alebo VARCHAR)
          - LENGTH - dka reazca 
            - prklad 
              - LENGTH('Slovensko') = 9
            - ak je prv reazec typu CHAR(n), funkcia LENGTH vrti n besz ohadu na jeho (ozajstn) dku, v prpade VARCHAR s medzery ignorovan
          - LTRIM, RTRIM - osekva medzery zava, sprava 
            - prklady 
              - LTRIM('  Slovensko  ') = 'Slovensko  '
              - RTRIM('  Slovensko  ') = '  Slovensko'
              - LTRIM(RTRIM('  Slovensko  ')) = 'Slovensko'
          - SUBSTR - vyber z reazca podreazec (substring)
            - syntax:
                SUBSTR(reazec, zaiaton_index_podreazca, dka_podreazca)
              - zaiaton index reazca je slo znaku reazca, to sa pota od 1
              - set zaiatonho indexu a dky podreazca zmenen o 1 nesmie presiahnu dku vymedzenho  miesta pre reazec
            - prklad 
              - SUBSTR('Slovensko', 2, 4) = 'love'
          - CONCAT alebo || - konkatenuje (lep) dva reazce  na seba    
            - syntax:
                CONCAT(reazec1, reazec2) 
                alebo 
                reazec1 || reazec2
            - prklad 
              - CONCAT('my', 'lienka') = 'mylienka'
            - ak je prv reazec typu CHAR(n), ale jeho (ozajstn) dka je m < n, pri lepen sa medzi reazce vlo n-m medzier; v prpade VARCHAR sa iadne medzery nevkladaj
          - UCASE, LCASE - vetky psmen zmen na vek resp. mal  
            - prklady 
              - UCASE('Slovensko') = 'SLOVENSKO'
              - LCASE('Slovensko') = 'slovensko'
        - funkcie na dtumy a/alebo asov peiatku
          - YEAR - slo roka z danho dtumu
          - MONTH - slo mesiaca z danho dtumu
          - DAY - slo da z danho dtumu
          - HOUR - poet hodn z danej asovej peiatky
          - MINUTE - poet mint z danej asovej peiatky
          - SECOND - poet seknd z danej asovej peiatky
          - MICROSECOND - poet mikroseknd z danej asovej peiatky
          - DAYOFWEEK - poradie da v tdni (nedea -> 1, pondelok -> 2, ...)
          - DAYOFYEAR - poradie da v roku (napr. 29.2. -> 60)
          - DAYS - poet dn od 1.1.1 
        - alie uiton funkcie
          - CAST - konverzia medzi typmi
            - syntax:
                CAST (vraz AS dtov_typ)
              - prklady
                - CAST (2002 AS CHAR(4)) = '2002'
                - CAST ('2002' AS INTEGER) = 2002
                - CAST (NULL AS dtov_typ) - "veobecn" NULL bude ma navrhnut dtov typ
          - CASE - umouje zada hodnotu v zvislosti na hodnote nejakho stpca 
            - syntax:
                CASE 
                  WHEN podmienka THEN vraz
                  ...
                  WHEN podmienka THEN vraz
                  [ELSE vraz]
                END
                alebo
                CASE vraz
                  WHEN hodnota THEN vraz
                  ...
                  WHEN hodnota THEN vraz
                  [ELSE vraz]
                END
              - v prpade, e ELSE chba, pod prslunm vrazom sa implicitne rozumie NULL
            - podmienky za WHEN sa nemusia vyluova - ak ich plat viac, vezme sa prv v porad
            - ak je splnen podmienka za WHEN, vrti hodnotu vrazu za THEN; ak nie je splnen iadna, vrti  hodnotu vrazu po ELSE
            - prklady
              - SELECT 
                  priezvisko, 
                  CASE 
                    WHEN SUBSTR(rodne_cislo,3,1) IN ('0','1') THEN 'muz'
                    WHEN SUBSTR(rodne_cislo,3,1) IN ('5','6') THEN 'zena'
                    ELSE '???'
                  END
                FROM student3;
              - SELECT 
                  priezvisko, 
                  CASE SUBSTR(rodne_cislo,3,1)
                    WHEN '0' THEN 'muz'
                    WHEN '1' THEN 'muz'
                    WHEN '5' THEN 'zena'
                    WHEN '6' THEN 'zena'
                    ELSE '???'
                  END
                FROM student3;
          - COALESCE alebo VALUE- umouje nahradi NULL neprzdnym vrazom
            - syntax: COALESCE(V_1, ..., V_n) alebo VALUE(V_1, ..., V_n)
            - vrti prv hodnotu V_i zo zoznamu, ktor nie je NULL
            - prklad
              - COALESCE(priezvisko, meno, 'no name') dva pre zznam ((meno, priezvisko) =) ('Albert', 'Einstein') hodnotu 'Einstein', pre ('', 'Madonna') hodnotu 'Madonna' a pre ('','') hodnotu 'no name'
          - NULLIF - umouje vrti przdnu hodnotu
            - zpis NULLIF(V_1, V_2) je ekvivalentn zpisu CASE WHEN V_1=V_2 THEN NULL ELSE V_1
            - prklad
              - NULLIF(tento, iny) dva pre zznam ((tento, iny) =) (1,1) hodnotu NULL, pre zznam (1,2) hodnotu 1
  - prkazy s agreganmi funkciami COUNT, SUM, MAX, MIN, AVG
    - agregan funkcie sa aplikuj na asti tabuky, ktor vznikn skupinovanm poda hodnt stpcov resp. z nich vytvorenho vrazu uvedenho v klauzule GROUP BY - kad skupina tak prispeje do vslednej tabuky jednm riadkom (ak tam klauzula GROUP BY nie je, agregan funkcia sa aplikuje na jedin skupinu - cel tabuku - a vsledok m jedin riadok)
    - vznamy
      - COUNT - poet hodnt
      - SUM - suma hodnt
      - MAX - maximum hodnt
      - MIN - minimum hodnt
      - AVG - (aritmetick) priemer hodnt
    - syntax: 
        agregan_funkcia ([DISTINCT] hodnotov_vraz [, hodnotov_vraz]); 
        COUNT(*)
      - COUNT(*) pota vetky riadky vtane duplict a riadkov obsahujcich len hodnoty NULL; v inch prpadoch s hodnoty NULL ignorovan
      - COUNT(\empty) = 0, ale SUM(\empty) = NULL, AVG(\empty) = NULL, MIN(\empty) = NULL, MAX(\empty) = NULL
      - SUM a AVG mono poui len na seln typy
      - DISTINCT nezapotava do vsledku duplicitn riadky
      - prklady
        - SELECT COUNT(*) FROM student - poet tudentov
        - SELECT COUNT(*) FROM student WHERE (priezvisko LIKE 'P%') - poet tudentov s priezviskom zanajcim na 'P' 
        - SELECT COUNT(DISTINCT priezvisko) FROM student - poet rznych priezvisk tudentov
        - SELECT MAX(datum_nar) FROM student - dtum narodenia najstarieho tudenta
    - klauzuly GROUP BY a HAVING
      - ak sa v klauzule SELECT vyskytuje aj vraz bez agregci, musia by uveden v klauzule GROUP BY vetky men stpcov, ktor sa vyskytuj pri jeho kontrukcii, alebo on sm
      - pri pouit klauzuly HAVING, ktor je nasledovan logickou podmienkou (ako pri WHERE), sa z tabuky vzniknutej apolikciou na jednotliv skupiny vyber len tie riadky, ktor podmienke vyhovuj
      - prklad
        - vpis miest, z ktorch s aspo dvaja tudenti:
          SELECT nazov, COUNT(*)
          FROM student, mesto
          WHERE mesto.id = student.id_mesto
          GROUP BY nazov
          HAVING COUNT(*) > 1
    - poda defincie s SUM(\empty), AVG(\empty), MAX(\empty) a MIN(\empty) rovn NULL, nie 0; v takom prpade mono namiesto vrazu agregan_funkcia(stpec) poui vraz COALESCE(agregan_funkcia(stpec), 0)
      - pri potan AVG je vsledok rovnakho typu ako hodnoty, z ktorch sa priemer pota, o me by v prpade celoselnch typov zavdzajce; v takom prpade treba celoseln hodnoty konvertova na desatinn sla 
        - prklad
          - v tabuke so schmou hodnotenie(meno: INTEGER, znamka: INTEGER) nech s hodnoty ('Jano',1), ('Mio',2), ('Fero',3), ('uro',4); dopyt SELECT AVG(znamka) FROM hodnotenie dva celoseln hodnotu 2, ale sprvna hodnota je 2.5; dosiahneme ju dopytom SELECT AVG(CAST (znamka AS DECIMAL(5,2))) FROM hodnotenie

- spojenia tabuliek
  - v klasickom SELECT prkaze 
      SELECT A_1, ..., A_j 
      FROM R_1, ..., R_k 
      WHERE \phi 
    je \phi spravidla konjunkciou podmienok dvoch typov - jednak s tu vzobn podmienky medzi zastnenmi tabukami R_1, ..., R_k a jednak porovnania s kontantami; SQL umouje tieto dva typy podmienok oddeli tm, e vzobn podmienky sa definuj u v klauzule FROM, a to (naprklad) v takejto forme ekvivalentnej s predolou:
      SELECT A_1, ..., A_j 
      FROM R_1 
        JOIN R_2 ON vzobn_podmienky_medzi_R_1_A_R_2
        ...
        JOIN R_k ON vzobn_podmienky_medzi_R_i_A_R_k
      WHERE ostatn podmienky 
    - prklad
      - dopyt na vetky informcie o vetkch tudentoch s menom Jozef  
          SELECT *
          FROM student s, mesto m, skupina g, izba i, typ_izby t
          WHERE s.id_mesto = m.id
            AND s.id_skupina = g.id
            AND s.id_izba = i.id
            AND i.id_typ = t.id
            AND s.meno = 'Jozef'
        mono ekvivalentne nahradi dopyotm
          SELECT *
          FROM 
            student s
              JOIN mesto m ON s.id_mesto = m.id
              JOIN skupina g ON s.id_skupina = g.id
              JOIN izba i ON s.id_izba = i.id
                JOIN typ_izby t ON i.id_typ = t.id
          WHERE s.meno = 'Jozef'
  - mon s aj kombincie tchto prstupov - as vzobnch podmienok je v kluzule FROM pod JOIN-mi, zvyok je vo WHERE klauzule
    - prklad
      - alm ekvivalentnm zpisom k predolm dvom je napr. dopyt
          SELECT *
          FROM 
            student s
              JOIN mesto m ON s.id_mesto = m.id
              JOIN skupina g ON s.id_skupina = g.id
              JOIN izba i ON s.id_izba = i.id,
            typ_izby t
          WHERE i.id_typ = t.id
            AND s.meno = 'Jozef'
  - spojenia tabuliek a przdne hodnoty
    - pri pouit obyajnho spojenia sa (poda defincie) eliminuj riadky, v ktorch je hodnota niektorho prepjacieho stpca przdna; niekedy je vak vhodn ma vo vsledku aj riadky s przdnymi hodnotami ako zdraznen signl toho, e na nich nemono ni naviaza; v takomto prpade namiesto obyajnho spojenia pouijeme tzv. vonkajie spojenie
    - typy vonkajieho spojenia
      - av vonkajie spojenie - R_1 LEFT OUTER JOIN R_2
        - do vsledku sa okrem zznamov, za ktor "me" obyajn JOIN, pridaj aj tie zznamy pochdzajce z R_1, ktor nemaj partnerov v R_2, priom miesta stpcov z R_2 s doplnen przdnymi hodnotami
      - prav vonkajie spojenie - R_1 RIGHT OUTER JOIN R_2
        - lohy R_1 a R_2 sa vymenia
      - pln vonkajie spojenie - R_1 FULL OUTER JOIN R_2
        - vsledkom je zjednotenie avho a pravho vonkajieho spojenia
    - na zdraznenie odlinosti od vonkajch spojen sa obyajnmu spojeniu hovor aj vntorn spojenie (a namiesto JOIN mono poui INNER JOIN)
    - syntax:
      - na mieste, kde by sa vo vntornom spojen napsalo JOIN, tu sa nape LEFT OUTER JOIN resp. RIGHT OUTER JOIN resp. FULL OUTER JOIN
    - prklad
      - predpokladajme, e tabuka student(id:INTEGER, meno:VARCHAR(20), id_mesto INTEGER) obsahuje zznamy (1, 'Jn Hrako', 1), (2, 'Ali Baba', NULL) a tabuka mesto(id:INTEGER, nazov:VARCHAR(20)) zznamy (1, 'Hraovk'), (2, 'algovk')
      - vsledkom dopytu 
          SELECT * FROM student s JOIN mesto m ON s.id_mesto = m.id 
          (alebo ekvivalentne SELECT * FROM student s INNER JOIN mesto m ON s.id_mesto = m.id)
        je tabuka s jedinm zznamom (1, 'Jn Hrako', 1, 'Hraovk')
      - vsledkom dopytu 
          SELECT * FROM student s LEFT OUTER JOIN mesto m ON s.id_mesto = m.id 
        je tabuka so zznamami (1, 'Jn Hrako', 1, 'Hraovk') a (2, 'Ali Baba', NULL, NULL) 
      - vsledkom dopytu 
          SELECT * FROM student s RIGHT OUTER JOIN mesto m ON s.id_mesto = m.id 
        je tabuka so zznamami (1, 'Jn Hrako', 1, 'Hraovk') a (NULL, NULL, 2, 'algovk') 
      - vsledkom dopytu 
          SELECT * FROM student s FULL OUTER JOIN mesto m ON s.id_mesto = m.id 
        je tabuka so zznamami (1, 'Jn Hrako', 1, 'Hraovk'), (2, 'Ali Baba', NULL, NULL) a (NULL, NULL, 2, 'algovk') 

----------------------------------------------------------------------
4.4 Zloitejie nadstavby nad prkazom SELECT
----------------------------------------------------------------------

- mnoinov opercie (INTERSECT, UNION, EXCEPT)
  - aby bolo mon mnoinov upercie urobi, musia by obe tabuky kompatibiln - musia ma rovnak poet riadkov a rovnak datov typy 
  - vznam
    - INTERSECT - prienik
    - UNION - zjednotenie
    - EXCEPT - rozdiel
  - syntax (zjednoduen):
      select_prkaz_1 
      mnoinov_opercia [ALL] 
      select_prkaz_1 
      [ORDER BY pecifikcia_triedenia]
    - pri pouit ALL sa neodstrnia duplicity (zato je vak opercia UNION ALL rchlejia ne UNION)
    - v prpade, e nesedia nzvy stpcov v oboch SELECT-och, v ORDER BY mono poui len poradie stpcov
  - prklady
    - SELECT meno, priezvisko FROM student 
      UNION ALL
      SELECT meno, priezvisko FROM ucitel 
      ORDER BY priezvisko
      - zoznam vetkch tudentov i uiteov
    - SELECT meno FROM student 
      INTERSECT
      SELECT priezvisko FROM student 
      ORDER BY 1
      - zoznam prievisk tudentov, ktor sa zhoduj s krstnm menom niektorho tudenta, ale kad iba raz
      - v ORDER BY klauzule me by iba slo

- pomocn tabuky - klauzula WITH
  - ak na zskanie vslednej tabuky nestaia doterajie prostriedky, mono pomocou klauzuly WITH vytvori pomocn tabuky a tie potom poui pri kontrukcii vsledku
  - syntax:
      WITH defincia_pomocnej_tabuky [, defincia_pomocnej_tabuky] select_prkaz,
    kde 
      defincia_pomocnej_tabuky := 
        nzov_pomocnej_tabuky (nzov_stpca_pomocnej_tabuky [, nzov_stpca_pomocnej_tabuky]) AS (select_prkaz)
  - prklad
    - WITH
        mozne (id, kredit) AS
        (
          SELECT s.id, SUM(kredit)
          FROM student s, zapisane z, predmet p
          WHERE s.id = z.id_student AND p.id = z.id_predmet
          GROUP BY s.id
        ),
        ziskane (id, kredit) AS
        (
          SELECT s.id, SUM(kredit)
          FROM student s, zapisane z, predmet p
          WHERE s.id = z.id_student AND p.id = z.id_predmet AND znamka IS NOT NULL
          GROUP BY s.id
        )
      SELECT s.id, s.meno, s.priezvisko, m.kredit, z.kredit
      FROM sk.student s, mozne m, ziskane z
      WHERE m.id = s.id AND z.id = s.id
      ORDER BY 3, 2;
      - najprv sme si vo WITH klauzule vytvorili pomocn tabuku mozne, kde s id tudentov so sumami kreditov, ktor mohli zska, a pomocn tabuku ziskane, kde s id tudentov so sumami nimi naozaj zskanch kreditov; tieto pomocn tabuky sme potom zaangaovali do vslednho SELECT-u
  - slabou alternatvou je definovanie tabuky priamo vo FROM klauzule
    - syntax (as):
      - SELECT ... FROM (select_prkaz) AS meno_pomocnej_tabuky(meno_stpca_pomocnej_tabuky, [meno_stpca_pomocnej_tabuky])
    - prklad
      - SELECT AVG(suma)
        FROM 
        (  
          SELECT t.kod, SUM(t.poplatok)
          FROM 
            student s
              JOIN izba i ON s.id_izba = i.id
              JOIN typ_izby t ON i.id_typ = t.id
          GROUP BY t.kod
        ) 
        AS zaplatene(kod, suma)
        - v tabuke zaplatene sa vypota, koko bvajci tudenti zaplatili za ten-ktor typ izby, vo vonkajom prkaze sa zist priemern hodnota tchto sel

- tranzitvny uzver
  - pecilnou monosou SQL vo verzii DB2 je vyjadrenie rekurzvneho uzveru pomocou rekurzie
  - prklad
    - predpokladajme, e mme rodokme reprezentovan tabukou 
        clen (id: INTEGER, id_otec: INTEGER, meno: VARCHAR(10)
      (s primrnym kom id), v ktorej id_otec je cudzm kom do tej istej tabuky a znamen id otca - priameho predchodcu cez prve jednu generciu; "praotec" v naej databze bude ma v stpci id:otca przdnu hodnotu
    - na to, aby sme zskali tabuku s dvojicami predkov a potomkov cez ubovon poet generci, vyrobme pomocn tabuku potomkovia, ktor bude zloen z dvoch ast spojench UNION-om; v prvej asti (prv krok rekurzie)vlastne len skoprujeme tabuku clen (a na riadok praotca), ktor bude znamena rozdiel jednej genercie, v druhej asti, kde je skryt samotn rekurzia, na tabuku potomkovia opakovane navzujeme tabuku clen - kad al medzivsledok bude ma o jednu generciu viac (napodobujeme tak proces spomnan v asti 3.2)
    - WITH 
        potomkovia (id, id_potomok) AS
        (
          SELECT koren.id_otec, koren.id
          FROM clen koren
          WHERE koren.id_otec IS NOT NULL
          UNION ALL
          SELECT otec.id, dieta.id
          FROM potomkovia otec, clen dieta
          WHERE otec.id_potomok = dieta.id_otec
        )
      SELECT predok.id, predok.meno, potomok.id, potomok.meno
      FROM potomkovia p, clen predok, clen potomok
      WHERE predok.id = p.id AND potomok.id = p.id_potomok
      ORDER BY 1, 2

----------------------------------------------------------------------
4.4 Aktualizcia dt
----------------------------------------------------------------------

- aktualizan prkazy v SQL
  - INSERT - vkladanie novch zznamov
    - syntax:
        INSERT INTO meno_tabuky [(meno_stpca [, meno_stpca])] VALUES hodnota_zznamu [, hodnota_zznamu],
        kde hodnota_zznamu := (hodnota_stpca [, hodnota_stpca])
        alebo
        INSERT INTO meno_tabuky [(meno_stpca [, meno_stpca])] select_prkaz
      - poet, poradie a dtov typy stpcov musia korepondova s prslunmi hodnotami stpcov resp. so stpcami prkazu SELECT
      - v prpade, e men stpcov nie s uveden, predpoklad sa, e s vetky a v takom porad, v akom boli definovan pri vytvran tabuky
      - stpce, ktor nie s uveden, s vyplnen automaticky, a to poda defincie tabuky (spravidla przdnou hodnotou, tu sa vak vyaduje, aby prslun stpec przdne hodnoty pripal (t.j aby nebol NOT NULL)) 
    - prklady    
      - majme alsiu tabuku - osoba(_id_: INTEGER, meno: VARCHAR(30))
      - prkaz
          INSERT INTO osoba 
          VALUES (1, 'Jn Hrako') 
        vlo do tabuky osoba zznam (1, 'Jn Hrako') (ak tam ete zznam s takou hodnotou primrneho ka nie je)
      - prkaz
          INSERT INTO osoba 
          VALUES 
            (1, 'Jn Hrako'), 
            (2, 'Jn Polienko') 
        vlo do tabuky osoba zznamy (1, 'Jn Hrako') a (2, 'Jn Polienko') (ak tam ete zznamy s takmi hodnotami primrneho ka nie s)
      - prkaz
          INSERT INTO osoba (id)
          VALUES (1) 
        vlo do tabuky osoba zznam (1, NULL') (ak tam ete zznam s takou hodnotou primrneho ka nie je)
      - prkaz
          INSERT INTO osoba 
            SELECT id, meno || ' ' || priezvisko 
            FROM student
        vlo do tabuky osoba zznamy odvoden zo zznamov z tabuky student (ak tam ete zznamy s takmi hodnotami primrneho ka nie s)
  - DELETE - mazanie existujcich zznamov
    - syntax:
        DELETE FROM meno_tabuky [WHERE podmienka]
      - vyma sa vetky zznamy, ktor spaj uveden podmienku (ktor me by aj zloen)   
      - ak klauzula WHERE nie je uveden, chpe sa ako pravdiv , t.j. vyma sa vetky zznamy - cel obsah tabuky 
    - prklady
      - DELETE FROM osoba WHERE id=1
        - vymae sa jeden zznam
      - DELETE FROM osoba WHERE meno LIKE 'Jn %'
        - vyma sa vetky zznamy, ktorch hodnota atribtu meno zana na 'Jn'
      - DELETE FROM osoba WHERE id IN (SELECT id FROM student)
        - vyma sa vetci tudenti
  - UPDATE - zmena hodnt existujcich zznamov
    - syntax:
        UPDATE meno_tabuky SET nastavenie_hodnoty_stpca [, nastavenie_hodnoty_stpca] [WHERE podmienka],
        kde nastavenie_hodnoty_stpca := meno_stpca = hodnota
      - prepu sa vetky zznamy, ktor spaj uveden podmienku (ktor me by aj zloen)   
      - ak klauzula WHERE nie je uveden, chpe sa ako pravdiv , t.j. vyma sa vetky zznamy - cel obsah       tabuky 
      - hodnota nemus by len kontanta, mu v nej figurova aj on stpce tabuky, ba aj ten ist
    - prklady
      - UPDATE student SET meno='Jozef' WHERE id=1
        - uprav sa meno tudenta s id 1
      - UPDATE student SET meno='Jozef', priezvisko='Mrkvika' WHERE id=1
        - uprav sa meno a priezvisko tudenta s id 1
      - UPDATE student SET meno='Jozef' WHERE meno='Joo'
        - uprav sa meno vetkch Joov na Jozef
      - UPDATE osoba SET meno='tudent '|| meno WHERE id IN (SELECT id FROM student)
        - upravia sa men vetkch osb, ktor s tudentmi, tak, e sa pred nich predpe slovo 'tudent'
  - pri vhodnej defincii mono upravova aj hodnoty v "pohade", uprav sa tm pvodn tabuka

----------------------------------------------------------------------
4.5 Triggery
----------------------------------------------------------------------
- triggery
  - pri zmene nejakch hodnt v niektorej tabuke me by vhodn i nutn meni aj stav alch hodnt v inej alebo aj v tej istej tabuke; je preto vhodn vytvori trigger - prostriedok, ktor tto sslednos zabezpe
  - syntax (as):
      CREATE TRIGGER meno_triggeru 
      {AFTER | ON CASCADE BEFORE}
      {INSERT | DELETE | UPDATE[(zoznam_stpcov)} ON meno_tabuky
      [REFERENCING 
        [OLD AS zvolen_meno_starho_zznamu] 
        [NEW AS zvolen_meno_novho_zznamu] 
      ]  
      FOR EACH {ROW | STATEMENT} MODE DB2SQL
      [WHEN (podmienka)]
      akcia
      - trigger sa me spusti pred (ON CASCADE BEFORE) alebo po (AFTER) zmene a vyvol ho iba prslun opercia
      - ak zoznam stpcov pri UPDATE przdny, trigger sa tka zmien vetkch stpcov tabuky
      - pri nastavovan hodnt mono poui aj nov alebo star (prepisovan) hodnoty, o sa uvedie v sekcii REFERENCING OLD resp. NEW
      - pod akciou sa najastejie rozumie nastavenie nejakej hodnoty
      - akcia sa vykon iba po splnen podmienky; ak podmienka nie je uveden, akcia sa vykon vdy
  - prklady
     - CREATE TRIGGER student_plus resp. student_minus
       AFTER INSERT resp. DELETE ON student
       FOR EACH ROW MODE DB2SQL
       UPDATE statistika SET hodnota = hodnota + resp. - 1 WHERE parameter='pocet studentov'
       - po pridan novho/zmazan ubovonho existujceho zznamu sa v tabuke statistika(parameter, hodnota) automaticky o 1 zv/zmen hodnota x v zzname ('pocet studentov', x)
     - CREATE TRIGGER student_zmena
       AFTER UPDATE ON student
       REFERENCING OLD AS o
       FOR EACH ROW MODE DB2SQL
       INSERT INTO student_historia (id, meno, priezvisko, datum_do) VALUES (o.id, o.meno, o.priezvisko, CURRENT TIME)
       - po zmene dajov o tudentovi sa do tabuky histrie zmien vlo nov zznam so starmi hodnotami tudenta a aktulnou peiatkou
     - CREATE TRIGGER t0 
       NO CASCADE BEFORE INSERT ON zapas 
       REFERENCING NEW AS NOVY 
       FOR EACH ROW MODE DB2SQL 
       WHEN (NOVY.goly1<NOVY.goly2) 
       SET NOVY.body2=0, NOVY.body1=3
         - pred vloenm vsledku zpasu sa automaticky vypotaj body

----------------------------------------------------------------------
4.6 Ochrana dt
----------------------------------------------------------------------

- ochrana dt - prkaz GRANT
  - kee s databzou spravidla pracuje viacero osb rznej kategrie, sprvca databzy by mal uri, kto z nich m ma ak prva na tanie alebo modifikciu tabuliek i pohadov
  - syntax (as):
      GRANT {ALL | zoznam_privilgi}
      ON objekt
      TO {PUBLIC | zoznam_pouvateov},
      WITH GRANT OPTION,
    kde
      zoznam_privilgi := privilgium [, privilgium],
      privilgium := SELECT | DELETE | UPDATE[zoznam_atribtov] | ...
    a
      zoznam_pouvateov := pouvate [, pouvate],
      pouvate := GROUP meno_skupiny | USER meno_pouvatea
    - objekt je meno tabuky alebo pohadu
    - klauzula WITH GRANT OPTION umouje pouvateom zo zoznamu udeova prvo alej; prvm udeovateom je pouvate, ktor objekt vyrobil
  - prklady
    - GRANT SELECT ON pohlad_osoba TO PUBLIC
      - ta pohad pohlad_osoba me kad
    - GRANT UPDATE (izba) ON student TO USER riaditel_internatu
      - riadite interntu m prvo meni slo izby kadho tudenta
    - GRANT DELETE ON osoba TO GROUP mafia
      - lenovia skupiny mafia mu z tabuky odstraova jednotliv osoby
    - GRANT ALL ON osoba TO USER Fero WITH GRANT OPTION
      - Fero m pln moc nad tabukou osoba, me ju poda aj alej

----------------------------------------------------------------------
4.7 Integrcia SQL do programovacieho jazyka
----------------------------------------------------------------------

- integrcia SQL do programovacieho jazyka
  - SQL prkazy mu by sasou inho programovacieho jazyka (asto C), hovor sa o tzv. embedded SQL
  - do zdrojovho kdu programu sa vloia prkazy SQL s predtextom EXEC SQL a vo fze predkompilcie sa automaticky nahradia sriou prkazov v prslunom jazyku; samotn kompilcia u potom pouva nahraden riadky
  - pre SELECT mono deklarova tzv. kurzor, po jeho otvoren potom mono v cykle pracova s jednotlivmi zznamami - vklada ich do premennch pomocou prkazu FETCH, ktor umiestni kurzor na aliu odpove zznamu; v novch verzich SQL mono kurzor presun aj na in miesta
  - pred premenn pouit v EXEC SQL riadkoch potom treba psa dvojbodku
  - prklad
    - EXEC SQL DECLARE CURSOR studentiNaPismeno 
        FOR SELECT meno, priezvisko FROM student WHERE SUBSTR(priezvisko,1,1)=:pismeno ORDER BY 2, 1
      EXEC SQL OPEN studentiNaPismeno
      (a v cykle) EXEC SQL FETCH studentiNaPismeno INTO (:menoStudenta, :priezviskoStudenta)
      - po deklarcii a otvoren kurzoru sa postupne pretaj usporiadan men a priezvisk tudentov zanajcich na dan psmeno a vsledky sa ukladaj do prslunch premennch
  - sptn vzba sa po vyvolan SQL prkazu rob pomocou premennej SQLCODE; po spenom vykonan prkazu je v tejto premennej 0, hodnota 100 indikuje spenos opercie s upozornenm, e neexistuj dta, zporn sla znamenaj vskyt chyby
      
======================================================================

= transakcie
= ako riesit problem zo strany 37...
- funkn zvislosti = 2. semester


