From 5db93d6c3cd9759de2665d68e7289b9100c8dee8 Mon Sep 17 00:00:00 2001 From: Filip Znachor Date: Mon, 8 Jan 2024 23:05:31 +0100 Subject: [PATCH] =?UTF-8?q?P=C5=99id=C3=A1n=C3=AD=20pozn=C3=A1mek=20z=20DB?= =?UTF-8?q?1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- KIV DB1/01. SŘBD.md | 91 +++++ KIV DB1/02. Konceptuální modelování.md | 37 ++ KIV DB1/03. E-R-A modely.md | 82 ++++ KIV DB1/04. Relační model dat.md | 216 ++++++++++ KIV DB1/05. Historické datové modely.md | 36 ++ KIV DB1/06. Funkční závislost atributů.md | 40 ++ KIV DB1/07. Normální formy a dekompozice.md | 105 +++++ KIV DB1/08. Structured Query Language.md | 361 +++++++++++++++++ ...blémy s odebráním objektových oprávnění.md | 15 + KIV DB1/10. Transakce.md | 377 ++++++++++++++++++ 10 files changed, 1360 insertions(+) create mode 100644 KIV DB1/01. SŘBD.md create mode 100644 KIV DB1/02. Konceptuální modelování.md create mode 100644 KIV DB1/03. E-R-A modely.md create mode 100644 KIV DB1/04. Relační model dat.md create mode 100644 KIV DB1/05. Historické datové modely.md create mode 100644 KIV DB1/06. Funkční závislost atributů.md create mode 100644 KIV DB1/07. Normální formy a dekompozice.md create mode 100644 KIV DB1/08. Structured Query Language.md create mode 100644 KIV DB1/09. Problémy s odebráním objektových oprávnění.md create mode 100644 KIV DB1/10. Transakce.md diff --git a/KIV DB1/01. SŘBD.md b/KIV DB1/01. SŘBD.md new file mode 100644 index 0000000..2b1c914 --- /dev/null +++ b/KIV DB1/01. SŘBD.md @@ -0,0 +1,91 @@ +# SŘBD + +**Životní cyklus IS** + +- definice cílů a specifikace požadavků +- analýza + - Tvorba modelů + - Tvorba datového modelu + - Zajištění konzistence modelů +- realizace +- testování +- nasazení + +**Příklady SŘBD na trhu** + +- _Komerční SŘBD:_ + - Oracle + - MS SQL Server + - IBM DB2 + - Sybase +- _Volně šiřitelné SŘBD:_ + - MySQL (MariaDB) + - PostgreSQL + - Firebird + +**Historie: využití počítačů** + +- složité výpočty + - ladění správného postupu +- řízení technologického procesu + - jednoduché algoritmy +- ekonomické aplikace + - typická aplikace: výpočet mezd + - začátky zpracování dat + +**Souborově orientovaný způsob zpracování dat** + +- základní datový útvar + - soubor, složen ze záznamů, ty z položek +- aplikace a data jsou vzájemně závislé +- programátor více zaměřen na techniky zpracování dat než na logiku problému +- i dnes používáno, např. začátečníci preferují soubory před tabulkami + +**Systém řízení báze dat (SŘBD)** + +- rozvoj hardware umožnil odstranění neefektivní práce souborově orientovaného zpracování dat +- oddělení dat od postupů zpracování dat (aplikací) +- SŘBD je soubor programového vybavení zajišťující přístupy do databáze +- databází rozumíme množinu dat logicky související s řešenou aplikací + +**Přínosy SŘBD** + +- oddělení dat od aplikací umožňuje změnu umístění dat bez změny aplikace +- vyšší efektivita práce programátorů +- soustředění na logiku aplikace bez zbytečného řešení technik manipulace s daty + +**Požadavky na SŘBD** + +- manipulace s daty + - vkládání, vyhledávání, odstraňování, modifikace dat + - DML (Data Manipulation Language) + - procedurální - jak data nalézt (Java) + - neprocedurální - jaká data chceme nalézt (SQL) +- vícenásobný přístup k datům +- přístup oprávněným osobám +- bezpečnost dat, zálohování a obnova dat + +**Požadavky na DB** + +- implementace libovolného datového modelu + - DDL (Data Definition Language) +- ukládání dat nezávislých na aplikaci +- integrita dat, neredundantnost dat, zpřístupnění „katalogu dat“ + +**Uživatelé DBS nebo IS** + +- různé typy uživatelů, od neprogramátorů, přes analytiky po administrátory databáze +- uživatelé neprogramátoři nerozhodují o funkčnosti systému +- administrátor řeší komflikty mezi uživateli a systémem + +**Komponenty SŘBD** + +- schéma databáze, dotazy, aplikační programy +- správce databáze, překladač DDL, preprocesor DML +- správce souborů, vyrovnávací paměti, databáze a systémový katalog + +**Správce databáze** + +- zpracování dotazu, autorizace, optimalizace dotazu +- kontrola integrity, řízení transakcí, plánovač, řízení obnovy DB +- správa bufferů, správce souborů \ No newline at end of file diff --git a/KIV DB1/02. Konceptuální modelování.md b/KIV DB1/02. Konceptuální modelování.md new file mode 100644 index 0000000..9ff1a5c --- /dev/null +++ b/KIV DB1/02. Konceptuální modelování.md @@ -0,0 +1,37 @@ +# Konceptuální modelování + +**Konceptuální modelování** + +- navrhuje datový model nezávislý na implementačních detailech + - SŘBD + - aplikační program + - programovací jazyk + - fyzických omezeních (např. distribuovaná databáze) + +**ANSI – SPARC architektura (1975)** + +- rozděleno na: + - External Level (pohledy jednotlivých uživatelů) + - Conceptual Level (konceptuální model) + - Internal Level (a fyzické uložení) + +**Objektově-orientovaný model dat** + +- zahrnuje entity a vztahy mezi nimi +- entity jsou popsány atributy a chováním +- konceptuálním modelem UML diagram + +**Datový model orientovaný na záznamy** + +- **Relační model dat** + - založen na tabulkách + - logicky související záznamy jsou ve stejné tabulce +- **Síťový model dat** + - založen na souborech + - set (student a jeho známky) + - logicky související záznamy tvoří seznam zřetězených prvků + - speciální případ: hierarchický model dat (stromová struktura) + +**Konceptuální model relačního modelu** + +- založen na E-R-A modelu \ No newline at end of file diff --git a/KIV DB1/03. E-R-A modely.md b/KIV DB1/03. E-R-A modely.md new file mode 100644 index 0000000..45e0522 --- /dev/null +++ b/KIV DB1/03. E-R-A modely.md @@ -0,0 +1,82 @@ +# E-R-A modely + +**Co znamená E-R-A** + +- **E** – Entity (entita) +- **R** – Relationship (relace, vazba) +- **A** – Attribute (atribut) + +**Entita** + +- reprezentuje objekt z reálného světa +- popsána relevantními atributy +- může být v nějakém vztahu k jiné entitě +- zakresluje se jako obdélník + +**Atributy** + +- entitu popisujeme pomocí hodnot atributů +- atributy mají **datový typ**, **formát**, **povinnost výskytu** a **výchozí hodnotu** +- **klíč** + - jednoznačně určuje entitu + - měl by být podtržen nebo označen předponou PK (primary key) + - v případě nutnosti je uměle tvořený (id), nenese informaci ale je unikátní + +**Vazby (Relace)** + +- vazba vyjadřuje vztah mezi entitami +- kardinalita určuje počet entit, které se na vztahu podílejí (1:1, 1:N, M:N) +- povinnost výskytu určuje, zda se entita musí nebo nemusí na vztahu podílet + +**Realizace entit a vazeb v tabulkách** + +- entitu realizujeme tabulkou, kde každý řádek představuje entitu +- vazba **1:1** musí být oprávněná + - Proč nemůžeme spojit obě entitní množiny dohromady? +- vazba **1:N** se realizuje pomocí cizího klíče FK (Foreign Key) +- vazba **M:N** se může realizovat pomocí pomocné entitní množiny (tabulky) +- vazba může mít atribut, řešeno pomocnou tabulkou +- mezi dvěma entitami může existovat více vazeb + - zaměstnanec je vedoucím oddělení a zároveň zaměstnán na oddělení +- vazba může mít **aritu** (n-ární) + - vazby s aritou 3 a více řešit rozkladem jako u M:N + - unární vazba - vazby mezi stejnou entitní množinou + +**Datový model formulářů** + +- formuláře obsahují **hlavičku** a **položky** + - např. faktura, skladový lístek +- mezi hlavičkou a položkami je vazba 1:N +- klíč položky může být unikátní + - v rámci systému (nedoporučuje se) + - v rámci formuláře (dvojice id formuláře a id položky) + +**Fan Trap** + +- situace, kde kvůli neklíčovým vazbám dochází k chybě v modelu + - mějme: pracovníci katedra <1:N> oddělení + - není možné zjistit, na jakém oddělení pracuje pracovník +- řešením může být přidání dalších vazby nebo změna cizího klíče (u pracovníka) +- při návrhu modelu je důležité předejít "fan trap" a zajistit konzistenci dat + +**Cykly v E-R-A modelech** + +- příklad: komentář <1:N> uživatel <1:N> příspěvek <1:N> komentář + - komentář - uživatel: _napsal uživatel_ + - komentář - příspěvek - uživatel: _napsal příspěvek_ +- snaha o eliminaci cyklů a udržení konzistence + +**Chasm trap** + +- v řetězu vazeb 1:N vyskytuje se alespoň jedna vazba s nepovinným výskytem +- příklad: katedra <1:N> pracovníci <1:N(0)> majetek + - nezjistíme, jaký majetek patří které katedře + - řešení: nová vazba (1:N) mezi nedostupné entitní množiny (katedra <1:N> majetek) + +**Rozšířený E-R-A model** + +- EER - Enhanced Entity-Relationship Modeling +- zavádí prvky OOP do datového modelování + - nadtřídy, podtřídy, dědění atributů a vztahů +- dovoluje použití komplexních datových typů +- využívá agregace, kompozice, generalizace a specializace \ No newline at end of file diff --git a/KIV DB1/04. Relační model dat.md b/KIV DB1/04. Relační model dat.md new file mode 100644 index 0000000..2b2624c --- /dev/null +++ b/KIV DB1/04. Relační model dat.md @@ -0,0 +1,216 @@ +# Relační model dat + +**E-R-A vs relační model dat** + +- E-R-A model + - konceptuální + - modelujeme reálný svět +- Relační model dat + - interní model + - nahlížení na data, která jsou uložena na disku + +**Matematická definice relace** + +- Nechť je daný systém $\{D_{i}, i \in \langle 1, n \rangle\}$ neprázdných množin, tzv. domén. +- Potom podmnožinu kartézského součinu $R \subseteq D_{1} \times D_{2} \times \dots \times D_{n}$ nazveme relací stupně $n$ nad $D_{1}, D_{2}, \dots, D_{n}$. +- Prvky relace $R$ jsou uspořádané n-tice ($d_{1}, d_{2}, \dots, d_{n}$) takové, že $d_{i} \in D_{i}$ pro $i \in \langle_{1}, n\rangle$. + +**Pohled na relační model dat** + +- relační model dat zobrazuje data tabulkou +- relace je tabulka s $m$ řádky a $n$ sloupci +- každý sloupec je atribut +- v relaci $R$ neexistují dna stejné řádky +- pořadí řádků i sloupců je nevýznamné + +**Porovnání přístupů** + +| Souborově orientovaný přístup | E-R-A model | Datová struktura | Relační model | +| ----------------------------- | ----------- | ---------------- | ------------- | +| soubor | entitní množina | tabulka | relace | +| záznam | entita | řádek | uspořádaná n-tice | +| položka | atribut | sloupec (název) | doména (název) | +- doménou můžeme chápat i množinu hodnot, kterých prvek z n-tice může nabývat + +**Relační klíče** + +- superklíč (superkey) + - atribut nebo množina atributů, který/á jednoznačně identifikuje uspořádanou dvojici n-tice dané relace +- složený klíč (composite key) + - superklíč s dvěmi či více atributy +- kandidát klíče (candidate key) + - superklíč, jehož žádná podmnožina neplní funkci superklíče dané relace +- primární klíč (primary key) + - vybraný kandidát klíče, obsahující co nejmenší množinu atributů +- alternativní klíč (alternate key) + - kandidát klíče splňující vlastnost primárního klíče, který za primární klíč nebyl vybrán + +**Relační (databázové) schéma** + +- Relační schéma + - množina atributů včetně jejich domén relace $R$ + - $R(A_{1}:D_{1}, A_{2}:D_{2}, \dots, A_{n}:D_{n})$ + - obvykle se používá zápis bez domén atributů + - $R(A_{1}, A_{2}, \dots m A_{n})$ + - atributy primárního klíče jsou v relačním schématu vyznačeny podtržením +- Relační databázové schéma + - množina relačních schémat, každé s unikátním názvem relace + +**Příklady relačních schémat** + +- Student(**číslo_studenta**, jméno, příjmení, rok_narození, adresa) +- Známka(**číslo_studenta**, **zkr_předmětu**, známka, datum, pokus) + +**Důležité pojmy** + +- Databáze + - též báze dat + - konečná množina v čase proměnných konečných relací +- Relační schéma databáze + - skládá se z databáze a integritních omezení + + +## Integritní omezení + +**Definice integritních omezení** + +- **integritní omezení:** pravidla pro hodnoty objektů v databázi, které musí být splněny, aby odpovídaly reálnému světu +- příklad: učitel a student se dohodnou na známce 1, ale do systému učitel zapíše + - trojku - nejedná se o porušení integritních omezení, jen je do databáze zapsán chybný údaj + - pětku - jedná se o porušení integritních omezení, systém hodnotu nedovolí zapsat + +**Realizace integritních omezení** + ++ omezující podmínky hodnot a vztahů jsou běžné, a možnosti SQL či jiných nástrojů SŘBD na ně reagují +- **Deklarativní realizace integritních omezení** + - zadávána v rámci definice dat (např. `CREATE TABLE`) +- **Procedurální realizace integritních omezení:** + - triggery + - uložená procedura + - ošetření programem (aplikací) + +**Klasifikace integritních omezení** + +- **Entitní integrita** (Entity Integrity Constraints) + - jednoznačná identifikace entity v tabulce + - zajišťuje primární klíč + - jednoznačná hodnota `UNIQUE` + - musí být vyplněn `NOT NULL` ++ **Doménová integrita** (Domain Integrity Constraints) + - každá hodnota v databázi musí být z množiny přípustných pro daný atribut + - typem + - rozsahem + - výčtem + - speciálním odkazem +- **Referenční integrita** (Referential Integrity Constraints) + - korektnost vztahů mezi entitami + - vazba mezi nadřízenou a podřízenou tabulkou (1:N) pomocí primárního a cizího klíče + +**Příklady referenční integrity** + +- **student a jeho známky** + - existuje-li známka bez studenta, databáze je nekonzistentní +- **čtenář a jeho výpůjčky** +- **předměty zajišťované katedrou** + - výuka předmětu nemusí být nutně zajištěna katedrou, takže hodnoty atributů cizího klíče mohou být `NULL` + +**Udržení referenční integrity** + +- **Restriktivní způsob** + - výchozí nastavení + - operace vedoucí k narušení integrity nebude provedena + - typy operací + - zrušení řádku v nadřízené tabulce, pokud existuje závislý řádek v podřízené + - vložení řádku do podřízené tabulky, pokud neexistuje řádek v nadřízené + - patří sem i aktualizace cizího klíče ++ **Kaskádní způsob** + - velmi mocný (a nebezpečný) nástroj + - změny se dopraví i do podřzených tabulek, aby byla integrita zachována + - typy operací + - závislé řádky k rušenému řádku nadřazené tabulky budou zrušeny + - změna primárního klíče se provede i u cizích klíčů +- **Nastavení hodnoty `NULL`** + - lze použít jen v případech volné vazby + +## Relační algebra + +Základní operace +- selekce (selection) +- projekce (projection) +- kartézský součin (cartesian product) +- sjednocení (union) +- množinový rozdíl (set difference) +- přejmenování (rename) + +Odvozené operace +- spojení (join) +- průnik (intersection) +- dělení (division) + +Výsledkem každé operace s relacemi je opět relace. + +**Projekce** +- operace projekce relace $R$ se schématem $A, R(A)$ na množinu atributů $B$, kde $B \subseteq A$ +- vytvoří relaci se schématem $B$ a prvky, které vzniknou z původní relace ostraněním atributů $A \setminus B$ +- odstraněny jsou i případné duplicity +- značíme $\Pi_{B}(R)$ + +**Selekce** +- operace selekce relace $R$ podle podmínky $\phi$ +- vytvoří relaci se stejným schématem a ponechá ty prvky z původní relace, které splňují podmínku $\phi$ +- formule $\phi$ je Booleovský výraz s taomickými formulemi ve tvaru $t_{1} \Theta t_{2}$ + - kde $\Theta \in \{<, \leq, = \geq, >, \neq\}$ + - a $t_{i}$ je buď konstanta nebo jméno atributu +- značíme $\sigma_{\phi}(R)$ + +**Kartézský součin** +- operace kartézský součin dvou relací $R(A)$ a $S(B)$ +- vytvoří relaci se schématem zahrnující nejprve všechny atributy schématu $A$ následované všemi prvky schématu $B$ a prvky, které vzniknou spojením každého prvku relace $R$ s každým prvem relace $S$ +- schémata $A$ a $B$ by neměla mít společné atributy +- značíme $R \times S = S \times R$ + +**Sjednocení** +- operace sjednocení +- vytvoří relaci se všemi prvky obou relací $R$ a $S$ +- duplicitní prvky jsou odstraněny +- obě relace musí mít kompatibilní schémata + - stejný počet atributů + - atributy na stejných pozicích musí mít stejnou doménu +- značíme $R \cup S = S \cup R$ + +**Množinový rozdíl** +- operace množinový rozdíl dvou relací $R$ a $S$ +- vytvoří relaci se všemy prvky $R$, které nejsou v $S$ +- **pořadí** relací v zápise **je důležité** +- obě relace musí mít kompatibilní schémata +- značíme $R \setminus S \neq S \setminus R$ + +**Přejmenování** +- operace přejmenování relace $R(A)$ na relaci $S(B)$ +- vytvoří relaci se všemi prvky $R$ které může a nemusí být přejmenována na $S$ a která bude mít přejmenovaný alespoň jeden atribut svého schématu +- značení + - přejmenování všeho: $\rho_{S(B)}(R)$ + - přejmenování relace: $\rho_{S}(R)$ + - přejmenování atributů: $\rho_{a=x, b=y}(R)$ + +**Průnik** +- operace průnik $R$ a $S$ +- vytvoří relaci zahrnující jen ty prvky, které jsou současně prvky relace $R$ i $S$ +- obě relace musí mít kompatibilní schémata +- značíme $R \cap S = S \cap R$ + +**Spojení** +- operace spojení dvou relací $R(A)$ a $S(B)$ +- vytvoří novou relaci + - se schématem $(A \cup B)$ + - $\Theta$ spojení (theta join) + - přirození spojení (natural join) + - vnější spojení (outer join) + - se schématem $A$ + - polospojení (semijoin) + - antijoin + +**Dělení** +- operace dělení dvou relací $R(A)$ a $S(B)$ +- vytvoří relaci se schématem $A \setminus B$, kde $B \subseteq A$ a prvky získané projekcí nad relací $R$, kterým odpovídají všechny prvky relace $S$ +- **pořadí** relací v zápise **je důležité** diff --git a/KIV DB1/05. Historické datové modely.md b/KIV DB1/05. Historické datové modely.md new file mode 100644 index 0000000..757d436 --- /dev/null +++ b/KIV DB1/05. Historické datové modely.md @@ -0,0 +1,36 @@ +# Historické datové modely + +**CODASYL** +- v roce 1960 (1959) vzniklo seskupení CODASYL + - Conference/Committee on Data System Languages + - konference/výbor pro jazyky databázových systémů + - výsledným produktem byl jazyk COBOL +- později v šedesátých letech byla založena v rámci seskupení CODASYL samostatná DBTG + - DataBase Task Group + - publikovala základní specifikaci pro programovací jazyky určené pro práci s databázemi +- CODASYL produkt měla pochopitelně i IBM + - uvedla ho pod názvem IMS + - odvozenina od věcí vzniklých během projektu Apollo v NASA +- většina CODASYL kompatibilních databází používala síťový model dat + - IBM u své implementace použila hierarchický model +- v roce 1970 se u IBM našel nespokojený zaměstnanec Edgar Frank „Tedd“ Codd + - přišel s vlastním, relačním datovým modelem a základy jazyka SEQUEL + - jeho objevu v roce 1979 využil Larry Ellison + - zakladatel Oracle Corporation + +**Princip síťového modelu dat** +- vychází ze souborově orientovaného přístupu k datům + - soubor, záznam, položka +- **spojka** ukazuje na logicky sousedící záznam +- **výskyt setu** + - spojkami propojené záznamy, které se podílejí na vazbě 1:N + - zahrnuje vlastníka (owner) a členy (members) + - př. student (vlastník) a jeho známky (členy) +- **set type** je kolekce všech výskytů setu dané vazby 1:N + - má unikátní jméno, odpovídá názvu vazby 1:N + +**Varianty hierarchického síťového modelu** +- každý uzel v hierarchickém definičním stromu reprezentuje jeden typ záznamu +- typy záznamu jsou reprezentovány pouze listy + - ostatní uzly slouží pouze k zachování hierarchické struktury + diff --git a/KIV DB1/06. Funkční závislost atributů.md b/KIV DB1/06. Funkční závislost atributů.md new file mode 100644 index 0000000..cd17f8f --- /dev/null +++ b/KIV DB1/06. Funkční závislost atributů.md @@ -0,0 +1,40 @@ +# Funkční závislost atributů + +Příklad + +| P | U | M | H | S | Z | +| ---- | ---- | ---- | ---- | ---- | ---- | +| DB1 | Zíma | EP120 | Út 10:15 | S1 | 1 | +| DB1 | Zíma | EP120 | Út 10:15 | S2 | 2 | +| DB1 | Zíma | EP120 | Út 10:15 | S3 | 1 | +| DB1 | Zíma | EP120 | Út 10:15 | S4 | 1 | +| INS | Zíma | UC332 | Út 8:25 | S1 | 3 | +| INS | Zíma | UC332 | Út 8:25 | S265 | 1 | +| M1 | Stehlík | EP120 | Čt 9:20 | S501 | 2 | +| M1 | Stehlík | EP120 | Čt 9:20 | S504 | 3 | +| M1 | Stehlík | EP120 | Čt 9:20 | S32 | 3 | +Pro každý předmět musíme zadat tolik řádků, kolik má předmět studentů. + +Přesuneme-li předmět DB1 z EP120 do EP110, musíme hodnotuy změnit u všech zapsaných studentů. Jedna událost v reálném světě vyžaduje hodně změn v uložených datech. + +Hledáme rozklad relace na více relací: +- $D_{1} = \{PUMH, PSZ\}$ +- $D_{2} = \{PU, HMP, HUM, PSZ, HMS\}$ +- $D_{3} = \{PU, HSP, PSZ, PSZ, HMS\}$ +- $D_{4} = \{PU, HSP, PSZ, HMP\}$ + +**Funkční závislost atributů** +- popisuje vztah mezi atributy relace +- **populací relace** $R$ budeme rozumět hodnoty atributů relace v daném čase + - konkrétní naplnění tabulky hodnotami +- $A$ a $B$ jsou podmnožinami relačního schématu $R$. $B$ funkčně závisí na $A$ (značíme $A \to B$), jestliže pro všechny populace $R$ platí pro libovolné n-tice $u$ a $v$ z relace $R$: + - $\Pi_{A}(u) = \Pi_{A}(v) \implies \Pi_{B}(u) = \Pi_{B}(v)$ +- ve funkční závislosti $A \to B$ nazýváme množinu atributů $A$ **determinantem** + +Příklad +- Přednáška(Předmět, Učitel, Místnost, Hodina, Student, Známka) +- $P \to U$ (jestliže předmět učí jen jeden učitel) +- $HM \to P$ +- $HU \to P$ +- $PS \to Z$ +- $HS \to M$ diff --git a/KIV DB1/07. Normální formy a dekompozice.md b/KIV DB1/07. Normální formy a dekompozice.md new file mode 100644 index 0000000..c70e1df --- /dev/null +++ b/KIV DB1/07. Normální formy a dekompozice.md @@ -0,0 +1,105 @@ +# Normální formy a dekompozice + +**Úvod** +- normální formy se vztahují jen k jedné relaci $R$ +- označují se pořadovými čísly, 1NF až 5NF +- NF s vyšším pořadovým číslem předpokládá, že se relace $R$ nachází v NF s nižším číslem včetně umístění BCNF (meni 3NF a 4NF) +- platí úmluva, že v návrzích by relace měly splňovat 3NF + - každá NF odhaluje (popisuje) nějakou diplicitu + +**První normální forma** (1NF) +- relace $R$ se nachází v 1NF, pokud všechny komponenty n-tice jsou atomické (řetězce znaků), tj. komponentou nesmí být opět relace +- poznámka + - pokud v relačním SŘBD vytvoříme tabulku, je v 1NF, jinak to nejde +- příklad + - Přednáška(Předmět, Učitel, Místnost, Hodina, **Zkoušení**) + - **Zkoušení**(Student, Známka) + +**Druhá normální forma** (2NF) +- relace $R$ se nachází v 2NF + - jestliže je v 1NF + - každý atribut, který není součástí primárního klíče relace $R$, silně funkčně závisí na primárním klíči relace $R$ +- poznámka + - hledáme, zda některý neklíčový atribut nezávisí na některém atributu, který tvoří primární klíč + - pokud je primární klíč tvořen jediným atributem, je 2NF splněna triviálně +- příklad + - Dodávka(**č_Dodavatele**, č_Součástky, **Adresa**, Množství) + - v reálném světě platí funkční závislost č_dodavatele $\to$ adresa + - adresu převést do samostatné tabulky s dodavatelem + +**Třetí normální forma** (3NF) +- relace $R$ se nachází v 3NF + - jestliže je v 2NF + - každý atribut, který není součástí primárního klíče relace $R$, není tranzitivně závislý na primárním klíči relace $R$ +- poznámka + - hledáme, nezávisí některý nmeklíčový atribut na jiném neklíčovém atributu + - pokud relace obsahuje maximálně jeden neklíčový atribut, 3NF je splněna triviálně + - pokud tabulka obsahuje pouze dva sloupce, splňuje 3NF (PK tvořen 1-2 sloupci) +- příklad + - Zaměstnanci(č_Zaměstnance, Oddělení, Budova) + - předpokládejme, že oddělení se nachází jen v jedné budově, poté platí funkční závislost oddělení $\to$ budova + - budovu převést do samostatné tabulky s oddělením + +**V jaké NF se nachází relace R?** + +| A | B | C | D | +| --- | --- | --- | -------- | +| a | 1 | A | $\alpha$ | +| b | 1 | A | $\beta$ | +| c | 2 | B | $\gamma$ | +| a | 1 | C | $\delta$ | +| b | 3 | D | $\alpha$ | +- primární klíč: **A, C** + - relace je v 1NF + - relace není ve 2NF + - $A \to B$, $A \to D$ - neplatí + - $C \to B$ - **platí** + - $C \to D$ - nezkoumáno + - relace není ve 3NF (není ve 2NF) ++ primární klíč: **A, D** + - relace je v 1NF + - relace je ve 2NF + - $A \to B$, $A \to C$, $D \to B$, $D \to C$ - neplatí + - relace není ve 3NF + - $B \to C$ - neplatí + - $C \to B$ - platí +- primární klíč: **B, D** + - relace je v 1NF + - relace je ve 2NF + - $B \to A$, $B \to C$, $D \to A$, $D \to C$ - neplatí + - relace je ve 3NF + - $A \to C$, $C \to A$ - neplatí + +## Dekompozice + +Převedení relace do 2NF nebo 3NF se provede rozkladem původní relace. + +**Věta o dekompozici:** Mějme relaci $R$ a tři disjunktní množiny atributů $A, B, C$, které zahrnují všechny atributy relačního schématu relace $R$ a funkční závislosti $B \to C$. Rozložíme-li relaci $R$ na relace $R_{1}(B, C)$ a $R_{2}(A, B)$, potom řekneme, že takto provedená dekompozice je **bezeztrátová**. + +**Syntéza** +- Je dána relace $R(A, B, C)$ a její projekce $\Pi_{B,C}(R)$ a $\Pi_{A,B}(R)$. Pak přirozeným spojením těchto projekcí získáme zpět původní relaci $R$. +- Syntéza chybně provedené dekompozice (tzv. **ztrátové**) vede k situaci, že obvykle získáme nějakou n-tici navíc, ale říkáme tomu **ztrátovost**. + +## Pokročilé NF + +**Boyce-Coddova normální forma** (BCNF) +- relace $R$ se nachází v BCNF + - jestliže je v 3NF + - každý determinant je kandidátem klíče +- poznámka + - existují různé definice BCNF + - nalezneme všechny funkční závislosti a u každé určíme, zda jejich determinant může být primárním klíčem a pokud některá nemůže být primárním klíčem, potom relace $R$ není v BCNF +- příklad + - Adresář(město, ulice, PSČ) + - závislosti + - {město, ulice} $\to$ PSČ + - PSČ $\to$ město + - relace je v 3NF, ale druhá funkční závislost brání být v BCNF + - dekompozice + - Město(město, PSČ) + - Ulice(PSČ, ulice) + +**Multizávislost** +- z definice funkční závislosti vyplývá, že pokud $A \to B$, pak každá hodnota atributu $A$ určuje (nejvýše) jednu hodnotu atributu $B$ +- **Multizávislost (vícehodnotová závislost)** vyžaduje závislost mezi množinami atributů $A$ a $B$ relačního schématu $X$ relace $R, R(X)$ takovou, že pro každou n-tici hodnot množiny atributů $A$ existuje nějaká množina n-tic hodnot množiny atributů $B$ a tato množina přitom nezávisí na hodnotě ostatních atributů relace $R$ +- značíme $A \to\to B$ \ No newline at end of file diff --git a/KIV DB1/08. Structured Query Language.md b/KIV DB1/08. Structured Query Language.md new file mode 100644 index 0000000..95217de --- /dev/null +++ b/KIV DB1/08. Structured Query Language.md @@ -0,0 +1,361 @@ +# Structured Query Language + +- dotazovací jazyk pro relační SŘBD +- ISO standard jazyka SQL + - ISO/EIC 9075 + - 1986, 1989, **1992**, 1999, 2003, 2006, 2008, 2011, 2016, 2019, 2023 +- komponenty: + - DDL - Data Definition Language + - DML - Data Manipulation Language + - DCL - Data Control Language + - TCL - Transaction Control Language + +**Vlastnosti a použití SQL** +- neprocedurální deklarativní jazyk +- vychází z jazyka SEQEL +- slouží k vytvoření databáze a struktury relací (tabulek) +- uživatelé jazyka + - administrátor (DBA) + - management + - vývojář aplikace + - koncový uživatel + +**Základní příkazy** +- DDL + - `CREATE TABLE`, `ALTER TABLE`, `DROP TABLE` + - `CREATE VIEW`, `DROP VIEW` + - `CREATE INDEX`, `DROP INDEX` +- DML + - `SELECT` + - `INSERT`, `UPDATE`, `DELETE` +- DCL a TCL + - `GRANT`, `REVOKE` + - `COMMIT`, `ROLLBACK` + +**Jak psát příkazy** +- každý příkaz musí začínat na nové řádce + - může být zapsán na více řádek +- SQL rozlišuje + - rezervovaná slova - nejsou case-sensitive + - názvy objektů - mohou být case-sensitive +- rezervovaná slova nesmí být dělená do více řádků +- každý příkaz SQL musí být zakončen středníkem +- řetězce v příkazu musí být uzavřeny v apostrofech + +## DML + +**Příkaz SELECT** +- příkaz `SELECT` nebo jeho části jsou součástí jiných příkazů +- zjednodušená syntaxe + +```sql +SELECT [DISTINCT] {* | [sloupec_vyraz [[AS] +alias] [,...]} +FROM tabulka [alias] [,...] +[WHERE podmínka] +[GROUP BY seznam_neagregovaných_sloupců_výrazů] +[HAVING podmínka] +[ORDER BY seznam_řazených_sloupců_výrazů]; +``` + +**Agregované funkce** +- `COUNT(sloupec)` + - počet neprázdných hodnot sloupce +- `SUM(sloupec)` + - součet neprázdných hodnot sloupce +- `AVG(sloupec)` + - aritmetický průměr neprázdných hodnot sloupce +- `MIN(sloupec)` + - minimální hodnota sloupce +- `MAX(sloupec)` + - maximální hodnota sloupce + +**Vložení záznamu do tabulky** +- jedním příkazem `INSERT` lze vložit jen jeden záznam do jedné tabulky +- registrace čtenáře Jana Nováka + +```sql +INSERT INTO Čtenář (Č_čt, Jméno) VALUES (123, 'Jan Novák'); +``` + +**Změna záznamů tabulky** +- jedním příkazem `UPDATE` lze modifikovat hodnoty několika záznamů jedné tabulky +- uložení adresy čtenáři č. 123 + +```sql +UPDATE Čtenář SET Adresa = 'Univerzitní 8, Plzeň' +WHERE Č_čt = 123; +``` + +**Zrušení záznamu tabulky** +- jedním příkazem `DELETE` lze zrušit více záznamů jedné tabulky +- zrušení (smazání) všech rezervací čtenáře č. 123 + +```sql +DELETE FROM Rezervace WHERE Č_čt = 123; +``` + +## DDL + +**Identifikátory** +- názvy tabulek, pohledů, sloupců a dalších databázových objektů +- názvy objektů jsou u mnoha SŘBD case-sensitive +- max. velikost 128 znaků +- povoleny malá a velká písmena, cifry a podtržítko + - musí začít písmenem +- nesmí obsahovat diakritická znaménka a bílé znaky + +**Vybrané datové typy** ++ textové znaky a řetězce + - `CHARACTER`, `CHARACTER VARYING` +- přesné matematické výpočty + - `NUMERIC`, `DECIMAL`, `INTEGER` +- přibližné matematické výpočty + - `FLOAT`, `REAL`, `DOUBLE PRECISION` ++ datum a čas + + `DATE`, `TIME`, `TIMESTAMP` ++ rozsáhlé objekty + + `BINARY LARGE OBJECT`, `CHARACTER LARGE OBJECT` + +**Definice tabulky** +- příkazem `CREATE TABLE` vytváříme tabulku, ve které + - definujeme její jméno + - zavedeme alespoň jeden sloupec (a jeho datový typ) + - můžeme a nemusíme definovat + - výchozí hodnotu, nepojmenovaná integritní omezení + - můžeme zavést pojmenovaná integritní omezení vázané s tabulkou + - seznam sloupců a integritních omezení je oddělován čárkou a uzavřen v závorce + +```sql +CREATE TABLE Kluby ( + Id_klubu NUMERIC PRIMARY KEY, + Název CHARACTER VARYING(30) NOT NULL, + Založen DATE +); +``` + +**Logické vs. fyzické datové typy** + +| logický | SŘBD Oracle | SŘBD MariaDB | +| ---- | ---- | ---- | +| CHARACTER | CHAR | CHAR | +| CHARACTER VARYING | VARCHAR2 | VARCHAR | +| NUMERIC | NUMBER | NUMBER | +| DECIMAL | NUMBER | DECIMAL | +| INTEGER | NUMBER | INT | +| FLOAT | NUMBER | FLOAT | +| REAL, DOUBLE PRECISION | NUMBER | DOUBLE | +| DATE, TIME | DATE | DATE, TIME, TIMESTAMP | +| TIMESTAMP | DATE | TIMESTAMP | +| BINARY LARGE OBJECT | BLOB | BLOB | +| CHARACTER LARGE OBJECT | CLOB | TEXT | + +**Nepojmenovaná integritní omezení** +- každý sloupec může zahrnout tato integritní omezení +- `NOT NULL` - vyžadovaná hodnota +- `UNIQUE` - unikátní +- `PRIMARY KEY` - primární klíč +- `CHECK` - omezení podmínkou + +**Pojmenovaná integritní omezení** +- začínají klíčovým slovem `CONSTRAINT` následovaného názvem omezení +- poté jedna z uvedených možností nahoře (kromě `NOT NULL`) +- zápis pokračuje seznamem sloupců tabulky, pro které je omezení definováno +- některá omezení mají další konstrukce v zápise + +**Primární klíč** +- maximálně jeden pro tabulku +- nepojmenovaná varianta + - `id_klubu NUMBER PRIMARY KEY` +- pojmenovaná varianta + - `CONSTRAINT kluby_pk PRIMARY KEY (id_klubu)` + - umožňuje složený PK + +**Alternativní klíč** +- nepojmenovaná varianta + - `nazev VARCHAR2(30) NOT NULL UNIQUE` +- pojmenovaná varianta + - `CONSTRAINT nazev_un UNIQUE (nazev)` + +**Cizí klíč** +- pouze pojmenovaná varianta + +```sql +CONSTRAINT exemplar_fk1 +FOREIGN KEY (isbn) +REFERENCES kniha (isbn) +``` + +- možno doplnit o reakci na rušení/aktualizaci prvku v nadřízené tabulce + +```sql +ON DELETE NO ACTION +ON DELETE RESTRICT +ON DELETE SET NULL +ON DELETE CASCADE +ON UPDATE NO ACTION +ON UPDATE RESTRICT +ON UPDATE SET NULL +ON UPDATE CASCADE +``` + +- příklad + +```sql +CONSTRAINT exemplar_fk1 +FOREIGN KEY (isbn) +REFERENCES kniha (isbn) +ON DELETE NO ACTION +ON UPDATE NO ACTION +``` + +**Výběrová podmínka** (`CHECK`) +- stanovení hodnot sloupce výčtem nebo podmínkou +- nepojmenovaná varianta + +```sql +... +semestr CHAR(2) NOT NULL +CHECK (semestr IN ('ZS', 'LS')) +... +kladne_cislo NUMBER +CHECK (kladne_cislo > 0) +... +``` + +- pojmenovaná varianta + +```sql +CONSTRAINT ruzne_tymy +CHECK (id_domaci <> id_hoste) +``` + +**Kompletní vytvoření tabulky** + +```sql +CREATE TABLE zapas ( + id_zapasu NUMBER PRIMARY KEY, + misto VARCHAR2(100) NOT NULL, + datum_cas DATE, + id_domaci NUMBER, + id_hoste NUMBER, + goly_domaci NUMBER DEFAULT 0, + goly_hoste NUMBER DEFAULT 0, + CONSTRAINT zapas_fk1 FOREIGN KEY (id_domaci) + REFERENCES kluby(id_klubu), + CONSTRAINT zapas_fk2 FOREIGN KEY (id_hoste) + REFERENCES kluby(id_klubu), + CONSTRAINT ruzne_tymy CHECK (id_domaci <> id_hoste) +); +``` + +**Modifikace tabulky** +- provádí se příkazem `ALTER TABLE` +- lze měnit + - název, sloupec, integritní omezení +- lze přidat/zrušit sloupce + - ideálně u prázdné tabulky + - lze přidat nebo zrušit více sloupců jedním příkazem +- lze přidat/zrušit pojmenovaná integritní omezení + - jen jedno jedním příkazem + +**Indexy** +- datová struktura + - logické uspořádání prvků relace podle hodnot vybraných sloupců + - má za úkol zrychlit operaci `SELECT` nad danou tabulkou + - zpomaluje operace `INSERT`, `UPDATE` a `DELETE` +- index je tvořen pro jeden nebo skupinu sloupců +- index může být + - unikátní (automaticky pro integritní omezení) + - dovoluje opakování hodnot (ručně tvořené, např. pro cizí klíče) + +```sql +-- Unikátní index +CREATE UNIQUE INDEX kluby_pk_idx +ON kluby (id_klubu); +-- Index dovolující opakovat hodnoty +CREATE INDEX zapas_fk1_idx +ON zapas (id_domaci); +-- Zrušení indexu +DROP INDEX kluby_pk_idx; +DROP INDEX zapas_fk1_idx; +-- zruší je i DROP TABLE +``` + +**Databázový pohled** +- virtuální relace, která fyzicky neexistuje +- poskytuje výsledek jedné nebo více relačních operací + - definice spojena s příkazem `SELECT` + - přiděluje příkazu `SELECT` jméno, pod kterým je uložen v databázi +- datová struktura výhradně ke čtení + - výjimkou jsou aktualizovatelné pohledy +- čtenáři a jejich výpůjčky + +```sql +CREATE VIEW vypujcky_ctenare AS +SELECT c.jmeno, v.inv_c +FROM ctenar c, vypujcka v +WHERE c.id_ctenar = v.id_ctenar; +``` + +- statistika tabulky exemplář + +```sql +CREATE VIEW statistika (zeme, pocet, soucet) +SELECT zeme_vydani, +COUNT(inv_c), +SUM(cena) +FROM exemplar +GROUP BY zeme_vydani; +``` + +- zrušení: `DROP VIEW vypujcky_ctenare;` +- pohled se může stát nevalidním, pokud bude smazána tabulka či pohled, který je jím používán + +## DCL + +**Role a oprávnění** +- DB administrátor může uživateli udělit + - systémovou roli, např. `CONNECT`, `RESOURCE` + - systémové oprávnění, např. `UNLIMITED TABLESPACE` +- uživatel databáze může jinému uživateli udělit + - uživatelskou roli + - oprávnění k přístupu k jeho databázovému objektu + - oprávnění předávat přidělený přístup dalším +- role je množinou systémových nebo objektových oprávnění ++ vybraná objektová oprávnění + - `ALL PRIVILEGES` + - `CREATE`, `ALTER`, `DROP` + - `INSERT`, `UPDATE`, `DELETE`, `SELECT` + +**Přidělení přístupu k objektům** +- příkazem `GRANT` je možné přidělit jednomu či více uživatelům + - jednu či více rolí + - jedno nebo více systémových oprávnění + - jedno nebo více oprávnění k jednomu DB objektu +- konstrukcí `IDENTIFIED BY` je možné nastavit heslo k přístupu +- konstrukcí `WITH ADMIN OPTION` možnost předávat přidělené systémové oprávnění dalším uživatelům +- konstrukcí `WITH GRANT OPTION` možnost předávat přidělené objektové oprávnění dalším uživatelům + +```sql +GRANT UNLIMITED TABLESPACE TO zima; +GRANT SELECT ON osoby TO PUBLIC; +GRANT INSERT, UPDATE, DELETE ON osoby +TO rychlik WITH GRANT OPTION; +``` + +**Odebrání přístupu** +- příkazem `REVOKE` lze odebrat jednomu nebo více uživatelům + - jednu či více rolí + - jedno nebo více systémových oprávnění + - jedno nebo více oprávnění k jednomu DB objektu +- vždy možné odebrat + - ty role a oprávnění, která byla přidělena + - těm uživatelům, kterým byla přidělena + +```sql +REVOKE UNLIMITED TABLESPACE FROM zima; +REVOKE SELECT ON osoby FROM PUBLIC; +REVOKE INSERT, UPDATE, DELETE ON osoby +FROM rychlik; +``` \ No newline at end of file diff --git a/KIV DB1/09. Problémy s odebráním objektových oprávnění.md b/KIV DB1/09. Problémy s odebráním objektových oprávnění.md new file mode 100644 index 0000000..52f79e2 --- /dev/null +++ b/KIV DB1/09. Problémy s odebráním objektových oprávnění.md @@ -0,0 +1,15 @@ +# Problémy s odebráním objektových oprávnění + +**Řešení přístupových práv v SŘBD** +- uživatel A vlastní tabulku OSOBY a nabídne různá oprávnění k této tabulce uživatelům B, X a Y +- uživatel B využije možnosti šířit přidělené oprávnění dále a poskytne rozšířené oprávnění k tabulce OSOBY (uživatele A) uživateli X +- uživatel A se rozhodne, že uživateli B přidělená práva odebere + - to odebere jistá práva i uživateli X +- tento příklad je jednoduchý, ale může to být složitější + +**Správné fungování řízení práv** +- ke každému příkazu `GRANT G_i` existuje odpovídající příkaz `REVOKE R_i` + - příkazy volají stejní uživatelé + - zahrnují stejnou množinu oprávnění nad shodným objektem +- vykonání příkazu `REVOKE R_i` musí způsobit to, jako by žádný příkaz `GRANT G_i` nebyl proveden + - a to i se svými důsledky diff --git a/KIV DB1/10. Transakce.md b/KIV DB1/10. Transakce.md new file mode 100644 index 0000000..cecc9f5 --- /dev/null +++ b/KIV DB1/10. Transakce.md @@ -0,0 +1,377 @@ +# Transakce + +## Transakční zpracování + +**Ochrana integrity dat** +- stav databáze + - dán hodnotami objektů databáze v daném okamžiku + - objektem se rozumí + - tabulka, záznam, položka a spojení + +**Konzistentní stav databáze** +- podmínky definující konzistentní stav databáze jsou definovány integritními omezeními + - jednoduché deklarativní formou + - složitější procedurální formou + +**Porušení integrity DB** +- porušení integrity DB = porušení konzistentního stavu DB +- příčiny + - selhání technického/hw zařízení (disk) + - selhání operačního systému + - chyba v aplikačním programu + - chybný zásah obsluhy + - chybná data +- příčin porušení integrity je tolik, že je těžké jim zabránit + - SŘBD je tedy vybaven + - mechanismem detekce nekonzistentního stavu + - mechanismem zotavení + +**Ochrana integrity** +- prostředky poskytnuté OS + - kopie souboru (zpravidla na různá média) + - kontrolní bod (záloha všech souborů a případné obnovení) +- speciálně vyvinuté pro databázové systémy + - transakce + +**Transakce** +- posloupnost operací nad objekty databáze + - z pohledu uživatele ucelená operace +- je + - logickou jednotkou práce + - jednotkou zotavení z chyb +- po dobu provádění transakce není databáze v konzistentním stavu +- příklad: změna čísla čtenáře + - u čtenáře ale i všech jeho výpůjček + +**Stavy transakce** +- aktivní (A) + - stav od začátku provádění +- chybný (F) + - v pokračování transakce nelze pokračovat +- částečně potvrzený (PC) + - po provedení poslední elementární operace + - transakce nebyla dosud potvrzena +- zrušený (AB) + - po příkazu `ROLLBACK`, vrácení do původního stavu +- potvrzený (C) + - úspěšné doknčení a potvrzení příkazem `COMMIT` + +**Vlastnosti transakce** +- atomicita (**A**tomicity) + - buď všechny operace nebo žádná +- konzistence (**C**onsistency) + - DB v konzistentním stavu před i po transakci +- izolovanost (**I**solation) + - paralelně probíhající transakce se nijak neovlivňují +- trvalost (**D**urability) + - po úspěšném potvrzení transakce všechny změny v databázi nemohou být ztraceny (ani při havárii systému) + +**Žurnál** +- základní nástroj pro ochranu transakcí +- znám též jako logovací protokol +- zapisují se do něj změny od posledního kontrolního bodu +- obecně obsahuje + - identifikaci transakce + - kdo změnu provádí + - kdy je změna provedena + - kterého objektu se týká + - novou hodnotu objektu + - někdy i starou/původní hodnotu objektu + +**Metody používání žurnálu** +- dopředné procházení (`REDO`) + - po chybě se vychází z kopie uložené v kontrolním bodě + - postupně se provádí změny uložené v žurnálu až do chybového okamžiku + - potřebujeme jen nové hodnoty objektů +- zpětné použití žurnálu (`UNDO`, `ROLLBACK`) + - po chybě se vychází ze současného (nekonzistentního) stavu DB + - využíváme starých hodnot v žurnálu do začátku chybné transakce + - postupným zpětným odvíjením žurnálu se dojde k začátku chybné transakce + +**Metody ochrany transakce** +- odložený zápis do databáze + - tvorba žurnálu s odloženými realizacemi změn + - v minulosti též dvoufázové potvrzování +- přímý zápis do databáze + - tvorba žurnálu s bezprostřední realizací změn + +**Odložený zápis do databáze* +- transakce nesmí měnit hodnoty objektů v databázi dříve, než je částečně potvrzena +- transakce nemůže být částečně potvrzená, pokud není vytvořen příslušný záznam o změnách v žurnálu +- žurnál nevyžaduje staré hodnoty objektů +- nevýhoda: pomalé ++ pokud došlo k chybě + + před uložením do žurnálu + + přechod ze stavu _aktivní_ do _částečně porvrzený_ + + nedošlo ke změnám v databázi (zůstala v konzistentním stavu) + + po částečném potvrzení transakce + + přechod ze stavu _částečně potvrzený_ do stavu _potvrzený_ + + všechny změny jsou uloženy v žurnálu + + na žurnál bude použita metoda `REDO` + +**Strategie obnovení odloženého zápisu do DB** + +- vytvoříme seznam `REDO` +- žurnál procházíme od kontrolního bodu do předu + - narazíme-li na konec transakce, vložíme ji do `REDO` +- transakce v seznamu `REDO` zpracujeme metodou `REDO` +- nedokončené transakce řešit nemusíme, protože neprovedly žádný zápis do databáze + +**Přímý zápis do databáze** +- změny v DB se provedou okamžitě v době potřeby před potvrzením transakce +- v žurnálu je nutné uchovat staré hodnoty objektů + - v případě chyby se provádí _vycouvání_ transakce použitím metody `UNDO` +- výhoda: rychlé ++ při chybě disku, kde mám uložený žurnál, nelze použít ++ do žurnálu nutno zapisovat i operace čtení + + novou hodnotu objektu zapsanou dosud nepotvrzenou transakcí může číst jiná transakce + + při vycouvání aktuální transakce proto musí vycouvat i ty transakce, které četly nové hodnoty objektů + + to může vést až k tzv. kaskádovému rušení transakcí + - známý také jako dominový efekt + - nejedná se o nějak častý jev + +**Strategie obnovení přímého zápisu do DB** +- vytvoříme dva seznamy: `REDO` a `UNDO` + - do seznamu `UNDO` vložíme všechny transakce z kontrolního bodu + - seznam `REDO` zůstane prázdný +- žurnál p +# T1 +A := read(X) +A := A + 5 +write(X, A)rocházíme do kontrolního bodu do předu + - narazíme-li na začátek transakce, vložíme ji do `UNDO` + - narazíme-li na konec transakce, převedeme ji z `UNDO` do `REDO` +- transakce zpracujeme metodou odpovídající názvu seznamu, ve kterém se nachází + +## Paralelní zpracování transakcí + +**Moduly SŘBD pro zpracování transakcí** +- z pohledu synchronizace nás ze SŘBD zajímají tyto moduly +- modul řízení transakcí (RT) + - transakce se na něj obracejí se žádostí o vykonání operace +- modul řízení obnovy databáze (RD) + - v databázi vykoná (realizuje) čtení/zápis podle požadavků plánovače +- plánovač + - zabezpečuje synchronizaci požadavků více transakcí v RT + - požadavky zařazuje do tzv. plánů (rozvrhů) + +**Zadání příkladu** +- ve všech příkladech budeme označovat + - objekty (na disku) písmeny z konce abecedy + - interní proměnné ze začátku abecedy +- mějme + - počáteční hodnotu `X := 10` + - dvě transakce `T1` a `T2` mající shodnou činnost + +| T1 | T2 | +| ---- | ---- | +| `A := read(X)` | | +| `A := A + 5` | | +| `write(X, A)` | | +| | `B := read(X)` | +| | `B := A + 5` | +| | `write(X, B)` | +- je několik možných plánů, kdy někde se může čtení z disku spustit dříve, než se zapíše předchozí výsledek + +**Uspořádatelnost** +- serializovatelnost +- efekt paralelního zpracování transakcí musí být stejný, jako by byly transakce uspořádány v nějakém sériovém plánu + +Příklad: původní hodnota `X := 10` + +```python +# T1 +A := read(X) +A := A + 5 +write(X, A) +# T2 +B := read(X) +B := B * 3 +write(X, B) +``` + +- plán 1 (T1, T2), X = 45 +- plán 2 (T2, T1), X = 35 ++ paralelní běh transakcí může skončit jedním nebo druhým výsledkem + +### Uzamykací protokoly + +**Operace `LOCK(X)`** +- uzamknutí objektu X vyvolá transakce, aby ho ochránila před přístupem jiných transakcí +- objekt smí být uzamčen pouze jednou transakcí +- pokud chce objekt uzamknout ještě jiná transakce, je systémem pozastavena + +**Operace `UNLOCK(X)`** +- odemknutí objektu X +- objekt může odemknout jen ta transakce, která jej uzamkla +- pokud na odemčení tohoto objetu čeká jiná transakce, může být opětovně spuštěna + +**Dvoufázový (zamykací) protokol** +- lze dokázat, že uspořádatelnost plánu je zaručena, jestliže + - objekt může být v každém okamžiku uzamčen pouze pro jednu transakci + - jakmile transakce odemkne alespoň jeden objekt, nesmí už žádný objekt uzamknout +- poznámka + - nesmí uzamknout ani ten samý objekt, co odemkla (prostě nesmí žádný objekt uzamknout) + - porušení dvoufázového protokolu hrozí v případě, že si sami definujete a řídíte transakce ++ Two-phase locking (2PL) ++ fáze 1: růst (expanding) + + transakce smějí pouze zamykat objekty, nesmí je odemykat ++ fáze 2: smršťování (shrinking) + + transakce smějí pouze objekty odemykat, nesmí žádný objekt uzamknout + +**Zamykání objektů** +- databázové objekty lze zamykat ve dvou režimech + - výlučný, též exklusivní režim + - sdílený režim +- výlučný režim + - objekt je uzamčen pro operace čtení i zápis + - nemůže být současně uzamčen jinou transakcí +- sdílený režim + - objekt je uzamčen jen pro operaci čtení + - daný objekt může být současně uzamčen v režimu čtení další transakcí + +**Uváznutí** (deadlock) +- dodržení dvoufázového protokolu ještě neznamená odstranění všech potíží +- zásadní výhoda DB: transakce umí `ROLLBACK` + +| T1 | T2 | +| --------- | --------- | +| `LOCK(X)` | | +| | `LOCK(Y)` | +| `LOCK(Y)` | | +| | `LOCK(X)` | +## Další protokoly + +Musíme znát nějakou další informaci o objektech databáze, např. způsob jejich uložení + +**Stromový uzamykací protokol** (Tree protocol) +- používá zámky +- pro hierarchické databáze +- reprezentace tzv. grafového protokolu +1. první výlučný zámek transakce T lze použít na jakýkoliv objekt X +2. další objekt může být uzamčen transakcí T pouze když byl v T uzamčen jeho předchůdce +3. objekty mohou být odemknuty kdykoliv +4. objekt, který byl v transakci T uzamknut a odemknut nesmí být už v T následovně znovu uzamknut +- všechny plány jsou uspořádatelné a nemůže dojít k uváznutí + +**Protokol časových značek** +- místo zámků používá tzv. časové značky ČZ + - předává ji systém, tvoří rostoucí posloupnost +- plánovač transakcí vykonává konfliktní transakce (pracují nad stejným objektem X) v pořadí jejich ČZ + - takto navržené plány jsou uspořádatelné +- u každého objektu X jsou zaznamenávány největší značky + - pro čtení R_ČZ(X) + - pro zápis W_ČZ(X) + +## Transakce v praxi + +**Zajištění konzistence v SŘBD Oracle** +- konzistentní čtení (Multiversion Read consistency) + - na úrovni příkazu (Statement-Level Read Consistency) + - data získaná dotazem jsou vždy potvrzená + - na úrovni transakce (Transaction-Level Read Consistency) + - každý příkaz transakce vidí data nová, která byla transakcí zapsána + - ostatní transakce vidí data, která byla dostupná před začátkem transakce +- ke správě konzistentního čtení se využívají tzv. návratové segmenty + - uloženy v tzv. návratovém tabulkovém prostoru + +**Nežádoucí jevy při čtení dat v transakcích** + +- **Špinavé čtení** (Dirty read) + - též nepotvrzené čtení (Uncommited read) + - příklad + - transakce T1 aktualizuje vybraný záznam + - transakce T2 následně přečte tuto aktualizovanou hodnotu dříve, než proběhne její potvrzení + - problém nastane, když transakce T1 bude zrušena, tj. zavolá `ROLLBACK` + - potom transakce T2 přečetla hodnotu, která neměla existovat + ++ **Neopakovatelné čtení** (Non-repeatable read) + - nastane, pokud čteme opakovaně stejnou hodnotu, ale v různých časech obdržíme různé hodnoty + - příklad + - transakce T1 přečte vybraný záznam + - transakce T2 následně daný záznam aktualizuje a bude potvrzena + - opětovné čtení stejného záznamu transakce T1 poskytne jiná data nebo také žádná + +- **Fantomové čtení** (Phantom read) + - nastane, pokud při opakovaném čtení získáme nová data, která nebyla dostupná při prvním čtení + - příklad + - transakce T1 přečte záznamy, které vyhovují dotazu + - transakce T2 generuje nový záznam, která změní výsledek dotazu transakce T1 + - opětovné vyhodnocení stejného dotazu transakce T1 poskytuje data navíc + +**Úrovně izolace transakce dle normy** + +- **Serializovatelná** (serializable) + - nejvyšší stupeň izolace + - dovoleno vykonávat pouze uspořádatelné plány + - transakce čeká, dokud záznamy uzamčené pro zápis ostatními transakcemi budou odemčeny + - transakce drží zámky buď pro čtení anebo pro zápis pro rozsah záznamů, které chce buď číst anebo ovlivnit zápisem + - rozsahem záznamů se rozumí výsledek selekce transakce + - pokud jiná transakce vloží/aktualizuje/smaže záznam, který do daného rozsahu zapadá, nebude jí zápis povolen + - transakce uvolňuje všechny zámky po jejím potvrzení nebo odvolání + ++ **Opakovatelné čtení** (repeatable read) + - transakce čeká, dokud záznamy uzamčené pro zápis ostatními transakcemi budou odemčeny + - transakce drží + - zámky pro čtení pro záznamy, které chce číst + - zámky pro zápis pro záznamy, které chce vkládat/aktualizovat/mazat + - jiná transakce může vložit/aktualizovat ty záznamy, které spadají do rozsahu záznamů uzamčených pro čtení + - transakce uvolňuje všechny zámky po jejím potvrzení nebo odvolání + +- **Potvrzené čtení** (read commited) + - transakce čeká, dokud záznamy uzamčené pro zápis ostatními transakcemi budou odemčeny + - transakce drží + - zámek pro čtení pro aktuálně čtený záznam + - zámek pro zápis záznamu, který chce aktualizovat/mazat + - transakce uvolňuje + - zámek pro čtení po přečtení aktuálního záznamu + - zámky pro zápis po potvrzení nebo odvolání transakce + ++ **Nepotvrzené čtení** (read uncommited) + - nejnižší stupeň izolace + - transakce není izolovaná od ostatních transakcí + - obvykle je tato úroveň použita u transakcí v režimu čtení + - čte i nepotvrzené záznamy jiných transakcí + +| | špinavé čtení | neopakovatelné čtení | fantomové čtení | +| ----------------------- | -------------- | -------------------- | --------------- | +| serializovatelná úroúveň | nevyskytuje se | nevyskytuje se | nevyskytuje se | +| opakované čtení | nevyskytuje se | nevyskytuje se | VYSKYTUJE SE | +| potvrzené čtení | nevyskytuje se | VYSKYTUJE SE | VYSKYTUJE SE | +| nepotvrzené čtení | VYSKYTUJE SE | VYSKYTUJE SE | VYSKYTUJE SE | +**Izolace transakce v SŘBD Oracle** +- Read Commited Isolation Level + - výchozí úroveň + - transakce vidí data dostupná před začátkem transakce + - dovoluje jevy neopakovatelné a fantomové čtení + - trpí efektem ztráty aktualizace dat (lost update) +- Serializable Isolation Level + - transakce vidí potvrzené změny v čase začátku transakce a změny provedené v transakci + - brání všem nežádoucím jevům čtení, netrpí efektem ztráty aktualizace dat +- Read-Only Isolation Level + - podobné jako předchozí úroveň + - transakce nemají přístup k datům, které modifikují jiné transakce + +**Ztráta aktualizace** +- nastane, pokud souběžné transakce modifikují hodnotu stejného záznamu + - zůstane zapsaná až poslední změna, předchozí se ztratí +- příklad + - transakce T1 modifikuje hodnotu konkrétního záznamu + - transakce T2 také později chce modifikovat hodnotu stejného záznamu, ale je pozastavena + - transakce T1 bude poté potvrzena, následně dojde k modifikaci dat transakce T2 + - transakce T2 bude potvrzena + +**Nastavení úrovně izolace** +- na úrovni transakce + ```sql + SET TRANSACTION ISOLATION LEVEL READ COMMITTED; + SET TRANSACTION ISOLATION LEVEL SERIALIZABLE; + SET TRANSACTION ISOLATION LEVEL READONLY; + ``` + +- na úrovni aktuálního spojení + ```sql + ALTER SESSION SET ISOLATION_LEVEL READ COMMITTED; + ALTER SESSION SET ISOLATION_LEVEL SERIALIZABLE; + ALTER SESSION SET ISOLATION_LEVEL READONLY; + ``` \ No newline at end of file