🗄️ Databáze a SQL

První kroky (30 minut)

Co je databáze a k čemu slouží

Databáze = strukturované úložiště dat (tabulky s řádky a sloupci). Jako Excel, ale s pravidly a rychlé i pro miliony řádků.

Proč ne prostý soubor (txt, JSON)?

• Rychlost: Databáze má indexy - najde 1 záznam z milionu za milisekundy. V textovém souboru = musíte číst celý soubor.
• Konzistence: Nemůžete uložit text do sloupce pro čísla (databáze odmítne). V JSON/txt = uložíte cokoliv, pak aplikace spadne.
• Současný přístup: Více uživatelů může zapisovat najednou bez kolizí. V souboru = data se přepíšou chaoticky.

Typy databází

Relační databáze (SQL): Data v tabulkách, vztahy mezi tabulkami. Příklady: MySQL, PostgreSQL, SQLite, Microsoft SQL Server.

NoSQL databáze: Data bez pevné struktury (dokumenty, klíč-hodnota). Příklady: MongoDB, Redis. Pro pokročilé - začněte SQL.

Základní pojmy

• Tabulka: Místo, kde ukládáte data (např. tabulka "users", "products").
• Sloupec (column): Typ informace (jméno, email, věk).
• Řádek (row): Jeden záznam (jeden uživatel, jeden produkt).
• Primární klíč (primary key): Unikátní ID každého záznamu (např. user_id = 1, 2, 3...).
• Cizí klíč (foreign key): Odkaz na záznam v jiné tabulce (např. objednávka má user_id → propojuje objednávku s uživatelem).

Základní SQL příkazy (CRUD)

CRUD = Create (vytvořit), Read (číst), Update (upravit), Delete (smazat). 90 % práce s databází je CRUD.

1. CREATE TABLE (vytvoření tabulky)

Co dělá: Vytvoří novou tabulku s definovanými sloupci a datovými typy.

CREATE TABLE users (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    email TEXT UNIQUE NOT NULL,
    age INTEGER,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
);

Vysvětlení:

• id INTEGER PRIMARY KEY AUTOINCREMENT - unikátní ID, automaticky se zvyšuje (1, 2, 3...)
• name TEXT NOT NULL - sloupec pro jméno, textový typ, povinné (nelze nechat prázdné)
• email TEXT UNIQUE NOT NULL - email musí být unikátní (nemůžete mít 2 stejné emaily)
• age INTEGER - věk, číslo, nepovinné (může být NULL)
• created_at DATETIME DEFAULT CURRENT_TIMESTAMP - datum vytvoření, automaticky se vyplní aktuálním časem

2. INSERT (vložení dat)

Co dělá: Přidá nový řádek (záznam) do tabulky.

INSERT INTO users (name, email, age)
VALUES ('Jan Novák', 'jan@example.com', 25);

INSERT INTO users (name, email, age)
VALUES ('Petra Svobodová', 'petra@example.com', 30);

Vysvětlení: Do tabulky users přidáme 2 záznamy. id a created_at se vyplní automaticky.

3. SELECT (čtení dat)

Co dělá: Načte data z tabulky. Nejpoužívanější příkaz.

-- Všechny záznamy, všechny sloupce
SELECT * FROM users;

-- Jen konkrétní sloupce
SELECT name, email FROM users;

-- S podmínkou (WHERE)
SELECT * FROM users WHERE age > 25;

-- Řazení (ORDER BY)
SELECT * FROM users ORDER BY age DESC;

-- Limit (prvních 10 záznamů)
SELECT * FROM users LIMIT 10;

Vysvětlení:

• SELECT * FROM users - všechny sloupce (*) z tabulky users
• WHERE age > 25 - filtr (jen záznamy, kde věk > 25)
• ORDER BY age DESC - seřadit podle věku, sestupně (DESC = descending, ASC = vzestupně)
• LIMIT 10 - jen prvních 10 záznamů

4. UPDATE (úprava dat)

Co dělá: Změní existující záznamy.

-- Změna jednoho sloupce
UPDATE users SET age = 26 WHERE id = 1;

-- Změna více sloupců
UPDATE users SET name = 'Jana Nováková', age = 27 WHERE id = 1;

POZOR: Vždycky použijte WHERE! Bez WHERE se upraví VŠECHNY řádky.

-- NEBEZPEČNÉ - změní všechny záznamy!
UPDATE users SET age = 99;  -- Všichni uživatelé budou mít věk 99

5. DELETE (mazání dat)

Co dělá: Smaže záznamy.

-- Smazat konkrétní záznam
DELETE FROM users WHERE id = 1;

-- Smazat podle podmínky
DELETE FROM users WHERE age < 18;

POZOR: DELETE bez WHERE smaže VŠECHNY řádky! Neexistuje UNDO.

Návrh tabulek (database design)

Špatný návrh databáze = aplikace je pomalá, data jsou duplikovaná, obtížné se s tím pracuje. Dobrý návrh = rychlá aplikace, data konzistentní.

Normalizace (základy)

Princip: Každá informace by měla být uložena pouze na jednom místě.

Špatný design (duplikace dat):

-- Tabulka orders (objednávky)
| order_id | customer_name | customer_email | product_name | price |
|----------|---------------|----------------|--------------|-------|
| 1        | Jan Novák     | jan@example.com| iPhone       | 20000 |
| 2        | Jan Novák     | jan@example.com| iPad         | 15000 |

Problém: Jméno a email Jana Nováka je 2x (duplikace). Pokud změní email → musíte změnit ve všech objednávkách.

Dobrý design (normalizace):

-- Tabulka customers
| customer_id | name      | email           |
|-------------|-----------|-----------------|
| 1           | Jan Novák | jan@example.com |

-- Tabulka products
| product_id | name   | price |
|------------|--------|-------|
| 1          | iPhone | 20000 |
| 2          | iPad   | 15000 |

-- Tabulka orders (propojení)
| order_id | customer_id | product_id |
|----------|-------------|------------|
| 1        | 1           | 1          |
| 2        | 1           | 2          |

Výhoda: Jméno a email Jana jsou jen 1x. Změna emailu = update v jedné tabulce, všechny objednávky automaticky ukazují na správný email.

Datové typy (nejpoužívanější)

• INTEGER: Celá čísla (věk, ID, počet). Rozsah: -2 miliardy až +2 miliardy.
• TEXT: Libovolný text (jméno, email, popis). Délka: až 1 GB (prakticky neomezená).
• REAL: Desetinná čísla (cena, hmotnost). Příklad: 19.99, 3.14.
• BOOLEAN: True/False (aktivní/neaktivní). V SQLite: 0 nebo 1.
• DATETIME: Datum a čas. Formát: 2025-01-15 14:30:00.

Pokročilejší dotazy

1. JOIN (propojení tabulek)

Co dělá: Spojí data z více tabulek dohromady.

Příklad: Máme tabulku orders (objednávky) a customers (zákazníci). Chceme zobrazit objednávky včetně jména zákazníka.

SELECT orders.order_id, customers.name, orders.product_id
FROM orders
INNER JOIN customers ON orders.customer_id = customers.customer_id;

Výsledek:

| order_id | name      | product_id |
|----------|-----------|------------|
| 1        | Jan Novák | 1          |
| 2        | Jan Novák | 2          |

2. Agregační funkce (COUNT, SUM, AVG)

Co dělá: Vypočítá statistiky (počet, součet, průměr).

-- Počet uživatelů
SELECT COUNT(*) FROM users;

-- Průměrný věk
SELECT AVG(age) FROM users;

-- Nejstarší uživatel
SELECT MAX(age) FROM users;

-- Nejmladší uživatel
SELECT MIN(age) FROM users;

3. GROUP BY (seskupení)

Co dělá: Seskupí záznamy podle hodnoty a spočítá agregace.

Příklad: Kolik objednávek má každý zákazník?

SELECT customer_id, COUNT(*) as order_count
FROM orders
GROUP BY customer_id;

Praktické cvičení

Úkol: Vytvořte databázi pro správu knih (knihovna).

Požadavky:

• Kniha má: název, autor, rok vydání, ISBN
• Můžete půjčovat knihy uživatelům
• Evidujete, kdo má jakou knihu půjčenou a kdy

Řešení:

-- Tabulka books
CREATE TABLE books (
    book_id INTEGER PRIMARY KEY AUTOINCREMENT,
    title TEXT NOT NULL,
    author TEXT NOT NULL,
    year INTEGER,
    isbn TEXT UNIQUE
);

-- Tabulka users
CREATE TABLE users (
    user_id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    email TEXT UNIQUE NOT NULL
);

-- Tabulka loans (půjčky)
CREATE TABLE loans (
    loan_id INTEGER PRIMARY KEY AUTOINCREMENT,
    book_id INTEGER NOT NULL,
    user_id INTEGER NOT NULL,
    borrowed_date DATE NOT NULL,
    return_date DATE,
    FOREIGN KEY (book_id) REFERENCES books(book_id),
    FOREIGN KEY (user_id) REFERENCES users(user_id)
);

-- Vložit testovací data
INSERT INTO books (title, author, year, isbn)
VALUES ('1984', 'George Orwell', 1949, '978-0451524935');

INSERT INTO users (name, email)
VALUES ('Jan Novák', 'jan@example.com');

-- Půjčit knihu
INSERT INTO loans (book_id, user_id, borrowed_date)
VALUES (1, 1, '2025-01-15');

-- Zobrazit půjčky s jmény knih a uživatelů
SELECT users.name, books.title, loans.borrowed_date
FROM loans
INNER JOIN users ON loans.user_id = users.user_id
INNER JOIN books ON loans.book_id = books.book_id
WHERE loans.return_date IS NULL;  -- Jen nevrácené knihy

Časté chyby začátečníků

1. UPDATE/DELETE bez WHERE

Chyba: DELETE FROM users; smaže VŠECHNY uživatele, ne jednoho.
Řešení: Vždy použijte WHERE: DELETE FROM users WHERE id = 5;

2. SELECT * v produkci

Chyba: SELECT * FROM users; načte všechny sloupce, i když potřebujete jen 2.
Problém: Pomalé, plýtvání přenosem dat.
Řešení: SELECT name, email FROM users; - jen sloupce, co potřebujete.

3. Žádné indexy

Chyba: Tabulka má milion řádků, dotaz trvá 10 sekund.
Příčina: Databáze musí projít všechny řádky (full table scan).
Řešení: Vytvořte index na sloupce, které často používáte ve WHERE:

CREATE INDEX idx_email ON users(email);

Index = jako rejstřík v knize. Místo procházení celé knihy najdete stránku okamžitě.

4. SQL injection (bezpečnostní riziko)

Chyba: Skládat SQL dotaz jako string s uživatelským vstupem:

// NEBEZPEČNÉ (PHP příklad)
$email = $_POST['email'];
$query = "SELECT * FROM users WHERE email = '$email'";  // SQL injection!

Útok: Uživatel zadá: ' OR '1'='1 → dotaz se stane: SELECT * FROM users WHERE email = '' OR '1'='1' → načte VŠECHNY uživatele.

Řešení: Prepared statements (parametrizované dotazy):

// BEZPEČNÉ (PHP příklad)
$stmt = $pdo->prepare("SELECT * FROM users WHERE email = ?");
$stmt->execute([$email]);

Závěr

SQL je dotazovací jazyk pro práci s relačními databázemi. 90 % práce = CRUD (Create, Read, Update, Delete). Dobrý návrh databáze = normalizace (žádná duplikace dat).

Co vzít z článku:

• Stáhněte SQLite Browser, vytvořte databázi, napište první SELECT dotaz (30 minut).
• Základní příkazy: CREATE TABLE, INSERT, SELECT, UPDATE, DELETE - naučte se nazpaměť.
• Návrh tabulek: každá informace jen jednou (normalizace), primární klíče (ID), cizí klíče (odkazy mezi tabulkami).
• JOIN = propojení tabulek, GROUP BY = seskupení, agregační funkce (COUNT, SUM, AVG).
• Vždy používejte WHERE u UPDATE/DELETE, indexy pro rychlost, prepared statements proti SQL injection.

První akce (30 minut): Stáhněte SQLite Browser, vytvořte databázi "test.db", vytvořte tabulku "users" s 3 sloupci (id, name, email), vložte 3 záznamy, zkuste SELECT s WHERE podmínkou. Hotovo - máte první databázi.

Kam dál:

• SQLBolt: sqlbolt.com - interaktivní tutoriál SQL (15 lekcí, zvládnete za víkend)
• W3Schools SQL: w3schools.com/sql - reference všech SQL příkazů s příklady
• PostgreSQL: Až ovládnete SQLite, přejděte na PostgreSQL (výkonnější, používá se v produkci)
• Projekt: Vytvořte databázi pro svůj projekt (to-do list, blog, e-shop) - nejlepší způsob učení