Základy SQL a MySQL pro úplné začátečníky

Při učení PHP a databází je dobré znát několik důležitých pojmů, které vám pomohou snadněji pochopit, jak ukládat a spravovat data na webu.

Co je SQL?

SQL (Structured Query Language) je speciální jazyk, který slouží k práci s databázemi. Můžete si ho představit jako jazyk, kterým "mluvíme" s databází, abychom ji mohli požádat, aby nám data dala, změnila nebo smazala.

Co je MySQL?

MySQL je populární databázový systém, který používá právě SQL. Funguje podobně jako obří sešit plný tabulek, kam můžeme zapisovat různé informace – například jména, e-maily nebo příspěvky na webových stránkách. MySQL je oblíbený hlavně díky své rychlosti, jednoduchosti a dobrému propojení s PHP.

Proč je lepší ukládat texty v databázi než do HTML?

Když máte texty uložené přímo v HTML, každá změna znamená, že musíte ručně upravit každou stránku zvlášť. Když ale použijete databázi, můžete obsah svého webu pohodlně spravovat pomocí redakčního systému. Redakční systém (někdy označovaný jako CMS – Content Management System) je jednoduché rozhraní, které vám umožní měnit obsah webu bez nutnosti zasahovat přímo do kódu.

PDO a MeekroDB – různé způsoby práce s databází

Pro práci s databází můžete v PHP využít různé nástroje:

Procedurální vs. objektový přístup

PHP nabízí dva hlavní způsoby, jak pracovat s databází:

Příklad připojení (procedurálně)

$conn = mysqli_connect("localhost", "username", "password", "database_name");
if (!$conn) {
    die("Připojení se nezdařilo: " . mysqli_connect_error());
}
echo "Hurá, jsme připojení!";

Příklad připojení (objektově)

$conn = new mysqli("localhost", "username", "password", "database_name");
if ($conn->connect_error) {
    die("Připojení se nezdařilo: " . $conn->connect_error);
}
echo "Hurá, jsme připojení!";

Co potřebujeme k připojení?

Než začnete komunikovat s databází, potřebujete pár základních údajů:

Tento základní přehled by vám měl pomoci s prvními kroky při práci s databázemi a pochopit, proč jsou databáze skvělým způsobem správy obsahu na webu.

Jak správně vytvořit soubor config.php pro připojení k databázi

Představte si soubor config.php jako tajnou truhličku, ve které uchováváte důležité informace, jakými jsou například hesla nebo přístupové údaje k databázi. Abyste zajistili, že je vaše databáze bezpečná a správně připojená, je potřeba tento soubor dobře připravit.

Co by měl obsahovat správný config.php?

Zde je doporučený způsob, jak bezpečně vytvořit připojení pomocí objektového přístupu MySQLi v PHP:

<?php
// Zapnutí bezpečného režimu MySQLi, aby se chyby lépe kontrolovaly
mysqli_report(MYSQLI_REPORT_ERROR | MYSQLI_REPORT_STRICT);

// Údaje pro připojení
$servername = "localhost";
$username = "vas_uzivatel";
$password = "vase_heslo";
$dbname = "vase_databaze";

// Připojení k databázi s kontrolou chyb
try {
    $conn = new mysqli($servername, $username, $password, $dbname);
    // Nastavení správné znakové sady (utf8mb4 podporuje emoji a jiné speciální znaky)
    $conn->set_charset("utf8mb4");
} catch (Exception $e) {
    // Zapisujeme chyby do speciálního souboru, neukazujeme je uživatelům
    error_log($e->getMessage());
    exit('Ups! Připojení k databázi se nezdařilo. Zkuste to prosím později.');
}
?>

Proč používat tento způsob připojení?

Tímto způsobem si můžete být jistí, že vaše databáze je správně a bezpečně připojena, což vám umožní se soustředit na další zajímavé věci ve vašem projektu!

Jak se připojit k databázi pomocí PDO?

I když se v této učebnici zaměřujeme primárně na MySQLi, pojďme se podívat na základní ukázku, jak se připojit k databázi pomocí PDO. PDO podporuje více druhů databází a umožňuje snadno používat prepared statements, což zvyšuje bezpečnost vaší aplikace.

<?php
$servername = "localhost";
$username = "username";
$password = "password";
$dbname = "mydatabase";

try {
    $conn = new PDO("mysql:host=$servername;dbname=$dbname", $username, $password);
    // Nastavení PDO, aby při chybě vyhodilo výjimku
    $conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    echo "Úspěšně připojeno";
} catch(PDOException $e) {
    echo "Připojení selhalo: " . $e->getMessage();
}
?>

Základy SQL dotazů – SELECT

Předtím než se v PHP naučíte pracovat s výsledky z databáze, je důležité rozumět samotnému SQL příkazu SELECT. Ten slouží k výběru dat z tabulky.

Příkaz SELECT je základním stavebním kamenem při práci s databázemi. Umožňuje vybírat data z tabulek, filtrovat je, třídit a upravovat podle potřeby. V této kapitole si projdeme různé možnosti jeho použití.

1. Výběr všech sloupců

SELECT * FROM Osoby;

Vrátí všechna data ze všech sloupců tabulky Osoby. Vhodné pro testování nebo rychlé výpisy, ale v produkčním prostředí je lepší specifikovat konkrétní sloupce.

2. Výběr konkrétních sloupců

SELECT jmeno, vek FROM Osoby;

Vybere jen zadané sloupce, čímž šetří výkon a zjednodušuje zpracování dat.

3. Filtrování pomocí WHERE

SELECT * FROM Osoby WHERE vek > 18;

Klauzule WHERE umožňuje zobrazit jen ty řádky, které splňují určitou podmínku. Použít můžete různé operátory:

  • = (rovná se)
  • != (nerovná se)
  • >, <, >=, <=
  • BETWEEN, IN, LIKE

4. Složené podmínky – AND, OR

SELECT * FROM Osoby WHERE vek > 18 AND oblibena_barva = 'modrá';

Pomocí AND a OR lze spojit více podmínek dohromady.

5. Řazení výsledků – ORDER BY

SELECT * FROM Osoby ORDER BY vek DESC;

Sloupec vek je seřazen sestupně (od nejvyššího). Použij ASC pro vzestupné řazení.

6. Omezení počtu výsledků – LIMIT

SELECT * FROM Osoby LIMIT 5;

Vrátí pouze 5 řádků. Používá se například pro stránkování nebo testování.

7. LIMIT s OFFSET

SELECT * FROM Osoby LIMIT 5 OFFSET 10;

Přeskočí prvních 10 záznamů a zobrazí dalších 5. Užívá se při stránkování např. na druhou stránku výsledků.

8. Vyhledávání pomocí LIKE

SELECT * FROM Osoby WHERE jmeno LIKE 'P%';

% je zástupný znak. Tento dotaz najde všechny osoby, jejichž jméno začíná na P.

9. Rozsah hodnot – BETWEEN

SELECT * FROM Osoby WHERE vek BETWEEN 20 AND 30;

Najde osoby, jejichž věk je v rozmezí 20 až 30 včetně.

10. Výběr z více hodnot – IN

SELECT * FROM Osoby WHERE oblibena_barva IN ('modrá', 'zelená');

Vrátí řádky, kde sloupec oblibena_barva obsahuje jednu z uvedených hodnot.

Toto jsou nejčastější možnosti příkazu SELECT. V dalších částech si ukážeme složitější dotazy, jako je spojování tabulek (JOIN) nebo agregační funkce (COUNT(), AVG(), atd.).

Souhrn nejčastěji používaných zápisů v MySQLi

Pokud se učíš pracovat s databází pomocí PHP, možná jsi narazil na spoustu nových slov a zápisů. Neboj se! Všechno si tady vysvětlíme jednoduše, krok za krokem. Představ si, že PHP je kuchař, databáze je lednice a ty chceš z lednice něco vybrat – třeba seznam jmen lidí.

1. Připojení k databázi

Nejprve musí kuchař (PHP) otevřít lednici (databázi). K tomu slouží tento kód:

$conn = new mysqli("localhost", "uzivatel", "heslo", "moje_databaze");

localhost říká, že databáze je na stejném počítači jako PHP skript. Pak zadáš uživatelské jméno, heslo a název databáze.

2. Příprava dotazu

Teď řekneme kuchaři, co má z lednice vytáhnout. Například všechny osoby, které se jmenují Tomáš:

$stmt = $conn->prepare("SELECT jmeno, vek FROM Osoby WHERE jmeno = ?");

Tento dotaz říká: „Vyber jméno a věk z tabulky Osoby, ale jen tam, kde se jméno rovná nějaké proměnné.“ Ta proměnná se doplní v dalším kroku.

3. Navázání hodnoty – bind_param()

Teď kuchaři řekneme, co má do dotazu doplnit. Například jméno z formuláře:

$stmt->bind_param("s", $_POST['jmeno']);

"s" říká, že jde o text (string). Pokud bychom doplňovali číslo, napsali bychom "i" (integer).

4. Spuštění dotazu – execute()

Kuchař má připravený dotaz a doplněné suroviny. Teď ho stačí „pustit“:

$stmt->execute();

5. Získání výsledků – get_result()

Tady se databáze zeptá: „Máš pro mě nějaké výsledky?“ A PHP je načte.

$result = $stmt->get_result();

Výsledek si můžeš načíst různými způsoby:

  • fetch_assoc() – načte jeden řádek jako pole, kde názvy sloupců jsou klíče (např. $row['jmeno'])
  • fetch_row() – načte jeden řádek jako číslované pole (např. $row[0])
  • fetch_all(MYSQLI_ASSOC) – načte všechny řádky najednou jako pole asociativních polí
  • fetch_all(MYSQLI_NUM) – načte všechny řádky najednou jako pole číselných polí
  • $stmt->get_result()->fetch_all(MYSQLI_ASSOC); – všechny řádky jako asociativní pole
  • $stmt->get_result()->fetch_all(MYSQLI_NUM); – všechny řádky jako numerické pole
  • $stmt->get_result()->fetch_assoc(); – jeden řádek jako asociativní pole

6. Alternativa – bind_result() a fetch()

Místo práce s poli můžeš také navázat proměnné a načíst rovnou hodnoty do nich. Vhodné pro načtení jednoho řádku.

$stmt->store_result();
  $stmt->bind_result($id, $jmeno, $vek);
  $stmt->fetch();
  echo "Jméno: $jmeno, Věk: $vek";

7. Zavření dotazu

Po dokončení dotazu je dobré ho uzavřít – jako když uklidíš po vaření:

$stmt->close();

8. Bonus: Rozdíl mezi objektovým a neobjektovým zápisem

// Objektově (moderní styl)
  $result = $conn->query("SELECT * FROM Osoby");
  
  // Procedurálně (starší styl)
  $result = mysqli_query($conn, "SELECT * FROM Osoby");

Objektový způsob je doporučený, protože je přehlednější a vhodnější pro větší projekty.

Tímto máš základní přehled o tom, jak vypadá komunikace mezi PHP a databází pomocí MySQLi. Ve skutečnosti je to jako rozhovor: PHP se ptá databáze, databáze odpovídá – a ty s výsledkem můžeš dělat, co potřebuješ.

CRUD Operace: Čtení (Read)

Čtení dat z databáze znamená jednoduše řečeno, že požádáme databázi o nějaké informace a ona nám je poskytne. Představte si to, jako když hledáte informace v knize: položíte dotaz a kniha (v tomto případě databáze) vám vrátí odpověď.

Jak získáváme data z databáze?

Pro získání dat z databáze používáme SQL dotaz SELECT. Tento dotaz říká databázi, jaká data chceme získat. Data se nám pak vrátí v podobě výsledku, se kterým v PHP můžeme dále pracovat.

Ukážeme si základní příklad načtení dat z databáze pomocí MySQLi a objektového přístupu, který je dnes nejvíce používaný.

// SQL dotaz pro výběr dat
$sql = "SELECT id, jmeno, prijmeni FROM Osoby";

// Spuštění dotazu
$result = $conn->query($sql);

// Zkontrolujeme, zda dotaz vrátil nějaké výsledky
if ($result->num_rows > 0) {
    // Data projdeme a vypíšeme
    while($row = $result->fetch_assoc()) {
        echo "ID: " . $row["id"] . " - Jméno: " . $row["jmeno"] . " " . $row["prijmeni"] . "<br>";
    }
} else {
    echo "Žádné výsledky nenalezeny.";
}

// Uzavření spojení s databází
$conn->close();

Vysvětlení příkladu:

Tato metoda čtení dat je nejčastější a nejjednodušší způsob, jak začít pracovat s daty v databázi pomocí PHP a MySQLi.

V příštích částech se podíváme na další způsoby čtení dat a vysvětlíme si rozdíly mezi nimi.

Další možnosti čtení dat: get_result() vs. bind_result()

Kromě základního způsobu načítání dat existují v MySQLi další metody, jak získávat výsledky dotazů. Dvě nejčastější metody jsou get_result() a bind_result(). Podívejme se na ně podrobněji.

Metoda get_result()

Metoda get_result() vrací celý výsledek dotazu najednou, což vám dává možnost načítat výsledky různými způsoby – jako asociativní pole, numerické pole nebo objekty. Tato metoda je velmi flexibilní a doporučuje se pro většinu scénářů.

// Ukázka použití get_result()
$stmt = $conn->prepare("SELECT id, jmeno, prijmeni FROM Osoby WHERE jmeno = ?");
$stmt->bind_param("s", $jmeno);
$stmt->execute();
$result = $stmt->get_result();

while ($row = $result->fetch_assoc()) {
    echo "ID: " . $row['id'] . " Jméno: " . $row['jmeno'] . " " . $row['prijmeni'] . "<br>";
}
$stmt->close();

Metoda bind_result() – proč ji používat?

I když je metoda bind_result() méně flexibilní než get_result(), stále existuje kvůli své jednoduchosti při načítání menšího množství dat nebo jediného řádku. S touto metodou přistupujete přímo k jednotlivým sloupcům pomocí jasně definovaných proměnných, což může být čistší a přehlednější v situacích, kdy víte, že vracíte omezený počet výsledků.

Ukázka použití metody bind_result() pro jeden řádek:
// Připravíme dotaz
$stmt = $conn->prepare("SELECT id, jmeno, prijmeni FROM Osoby WHERE jmeno = ?");
$stmt->bind_param("s", $jmeno);
$stmt->execute();
$stmt->store_result();

// Ověříme, že máme nějaký výsledek
if ($stmt->num_rows === 0) exit('Žádné výsledky');

// Výsledky uložíme přímo do proměnných
$stmt->bind_result($id, $jmeno, $prijmeni);
$stmt->fetch();

// Použijeme data z proměnných
 echo "ID: $id, Jméno: $jmeno $prijmeni";

$stmt->close();
Srovnání s metodou get_result() pro jeden řádek:

Zde je ukázka načtení jednoho řádku pomocí get_result():

$stmt = $conn->prepare("SELECT id, jmeno, prijmeni FROM Osoby WHERE jmeno = ?");
$stmt->bind_param("s", $jmeno);
$stmt->execute();

$result = $stmt->get_result()->fetch_assoc();

if (!$result) exit('Žádné výsledky');

// Použijeme data z asociativního pole
echo "ID: " . $result['id'] . ", Jméno: " . $result['jmeno'] . " " . $result['prijmeni'];
$stmt->close();
Kdy tedy použít bind_result()?

Metodu bind_result() využijte, když:

Výhody metody bind_result():
Nevýhody metody bind_result():

Obecně platí, že pro většinu situací doporučujeme používat metodu get_result(), avšak bind_result() je stále užitečná v určitých specifických případech.

Souhrn možností čtení dat metodou get_result() a bind_result()

Při používání parametrizovaných dotazů v MySQLi je začátek vždy velmi podobný, ale liší se způsob, jakým výsledky získáváte a zpracováváte. Zde si shrneme dvě hlavní metody a způsoby načítání výsledků:

Metoda get_result()

Metoda get_result() je univerzálnější a umožňuje vám flexibilně pracovat s výsledky dotazu různými způsoby. Používá se standardní rozhraní mysqli_result, které můžete používat stejně jako při běžném použití $conn->query().

Způsoby načítání jednoho řádku:
Způsoby načítání všech řádků najednou:

Metoda bind_result()

Metoda bind_result() váže výsledky přímo na proměnné, které si musíte předem definovat. Tato metoda je méně flexibilní, ale může být přehlednější při práci s menším počtem přesně definovaných sloupců.

V dalších částech budeme podrobně procházet a ukazovat jednotlivé postupy těchto metod.

Příklady použití metod get_result() a bind_result()

Načtení asociativního pole

Nejčastější způsob načítání výsledků dotazů je pomocí asociativních polí, která umožňují přístup k datům podle názvu sloupců.

// Načtení všech řádků najednou
$stmt = $conn->prepare("SELECT id, jmeno, vek FROM Osoby WHERE jmeno = ?");
$stmt->bind_param("s", $_POST['jmeno']);
$stmt->execute();
$result = $stmt->get_result()->fetch_all(MYSQLI_ASSOC);

if (!$result) exit('Žádné výsledky');
foreach ($result as $row) {
    echo "ID: " . $row['id'] . ", Jméno: " . $row['jmeno'] . ", Věk: " . $row['vek'] . "
"; } $stmt->close();

Pokud potřebujete výsledky dále upravovat, například seřadit nebo filtrovat, můžete si data nejprve uložit do pole a poté s nimi pracovat:

$arr = [];
$stmt = $conn->prepare("SELECT id, jmeno, vek FROM Osoby WHERE vek > ?");
$stmt->bind_param("i", $_POST['minimalni_vek']);
$stmt->execute();
$result = $stmt->get_result();

while($row = $result->fetch_assoc()) {
    $arr[] = $row;
}

// Seřadíme pole podle věku sestupně
usort($arr, fn($a, $b) => $b['vek'] <=> $a['vek']);

foreach ($arr as $row) {
    echo "ID: " . $row['id'] . ", Jméno: " . $row['jmeno'] . ", Věk: " . $row['vek'] . "
"; } $stmt->close();

Načtení numerického pole

Použití numerických polí může být výhodné například při práci s tabulkami, kde názvy sloupců neznáte, nebo když potřebujete rychle zpracovat hodnoty podle jejich pořadí.

// Výpočet průměrného věku osob z vybraných měst
$stmt = $conn->prepare("SELECT vek FROM Osoby WHERE mesto IN (?, ?, ?)");
$stmt->bind_param("sss", $_POST['m1'], $_POST['m2'], $_POST['m3']);
$stmt->execute();
$arr = $stmt->get_result()->fetch_all(MYSQLI_NUM);

if (!$arr) exit('Žádné výsledky');

$celkem = 0;
foreach ($arr as $row) {
    $celkem += $row[0]; // věk
}
$prumer = $celkem / count($arr);
echo "Průměrný věk: " . round($prumer);

$stmt->close();

Načtení jediného řádku – použití bind_result()

Pokud načítáte pouze jediný řádek, metoda bind_result() nabízí velmi čistý přístup k jednotlivým sloupcům přímo přes proměnné.

$stmt = $conn->prepare("SELECT id, jmeno, vek FROM Osoby WHERE jmeno = ?");
$stmt->bind_param("s", $_POST['jmeno']);
$stmt->execute();
$stmt->store_result();

if ($stmt->num_rows === 0) exit('Žádné výsledky');

$stmt->bind_result($id, $jmeno, $vek);
$stmt->fetch();

echo "ID: $id, Jméno: $jmeno, Věk: $vek";
$stmt->close();

Alternativně můžete použít get_result() pro načtení jednoho řádku:

$stmt = $conn->prepare("SELECT id, jmeno, vek FROM Osoby WHERE jmeno = ?");
$stmt->bind_param("s", $_POST['jmeno']);
$stmt->execute();
$result = $stmt->get_result()->fetch_assoc();

if (!$result) exit('Žádné výsledky');
echo "ID: " . $result['id'] . ", Jméno: " . $result['jmeno'] . ", Věk: " . $result['vek'];
$stmt->close();

V dalších lekcích se detailněji zaměříme na tyto metody a ukážeme si více scénářů jejich použití.

Načtení kombinovaného pole – fetch_array()

Metoda fetch_array() vám umožňuje načítat data jako:

Pokud použijete MYSQLI_BOTH, můžete přistupovat ke stejnému sloupci buď pomocí názvu, nebo indexu.

$stmt = $conn->prepare("SELECT id, jmeno FROM Osoby WHERE vek > ?");
$stmt->bind_param("i", $_POST['vek']);
$stmt->execute();
$result = $stmt->get_result();

while ($row = $result->fetch_array(MYSQLI_BOTH)) {
    echo "Jméno: " . $row['jmeno'] . " (" . $row[1] . ") - ID: " . $row[0] . "
"; } $stmt->close();

Kdy použít:
Pokud nevíte, jaké pole se vám bude hodit, nebo potřebujete přistupovat k datům jak podle názvu, tak indexu – například při výpisu do HTML tabulek, kde může být číselný index pohodlnější.

V dalších lekcích se detailněji zaměříme na tyto metody a ukážeme si více scénářů jejich použití.

JOIN – spojování tabulek

V reálném světě jsou data často rozdělená do více tabulek. Například jedna tabulka obsahuje informace o objednávkách a druhá o zákaznících. Když chceš zobrazit objednávku spolu se jménem zákazníka, musíš data spojit. K tomu slouží příkaz JOIN.

Pro lepší pochopení rozdílů mezi jednotlivými JOINy doporučujeme interaktivní nástroj:

joins.spathon.com – vizuální porovnání JOIN operací

1. INNER JOIN – pouze odpovídající záznamy

Tento příkaz vrátí pouze ty řádky, které mají odpovídající hodnoty v obou tabulkách.

SELECT objednavky.id, zakaznici.jmeno
  FROM objednavky
  INNER JOIN zakaznici ON objednavky.zakaznik_id = zakaznici.id;

Tímto získáš seznam objednávek i se jménem zákazníka, který je vytvořil.

2. LEFT JOIN – všechno zleva, i když nenajdeme pár

Tento příkaz vrátí všechny záznamy z první tabulky a pokud k nim najde odpovídající záznam ve druhé, připojí ho. Když ne, tak doplní NULL.

SELECT objednavky.id, zakaznici.jmeno
  FROM objednavky
  LEFT JOIN zakaznici ON objednavky.zakaznik_id = zakaznici.id;

3. RIGHT JOIN – všechno zprava

Opačně než LEFT JOIN. Vrátí všechny zákazníky, i když nic neobjednali.

SELECT objednavky.id, zakaznici.jmeno
  FROM objednavky
  RIGHT JOIN zakaznici ON objednavky.zakaznik_id = zakaznici.id;

4. CROSS JOIN – všechny kombinace

Tvoří kombinaci každého řádku z jedné tabulky se všemi řádky druhé. Většinou se moc nepoužívá.

SELECT *
  FROM zakaznici
  CROSS JOIN produkty;

Výsledkem budou všechny možné kombinace zákazníků a produktů – pozor na množství dat!

V dalších kapitolách si ukážeme, jak tyto JOINy použít v PHP, například jak spojit tabulky pomocí MySQLi nebo prepared statements.

Použití JOIN v PHP (MySQLi)

V této části si ukážeme, jak zapisovat dotazy s JOIN v PHP pomocí prepare(), bind_param() a execute(). Ukážeme si příklady pro INNER JOIN, LEFT JOIN, RIGHT JOIN a CROSS JOIN.

INNER JOIN – seznam uživatelů s objednávkami

$stmt = $conn->prepare("SELECT Uzivatele.jmeno, Objednavky.produkt
                          FROM Uzivatele
                          INNER JOIN Objednavky ON Uzivatele.id = Objednavky.uzivatel_id
                          WHERE Uzivatele.jmeno = ?");
  $stmt->bind_param("s", $_POST['jmeno']);
  $stmt->execute();
  $result = $stmt->get_result();
  
  while ($row = $result->fetch_assoc()) {
      echo "Jméno: " . $row['jmeno'] . ", Produkt: " . $row['produkt'] . "
"; } $stmt->close();

LEFT JOIN – seznam všech uživatelů (i těch bez objednávky)

$stmt = $conn->prepare("SELECT Uzivatele.jmeno, Objednavky.produkt
                          FROM Uzivatele
                          LEFT JOIN Objednavky ON Uzivatele.id = Objednavky.uzivatel_id");
  $stmt->execute();
  $result = $stmt->get_result();
  
  while ($row = $result->fetch_assoc()) {
      echo "Jméno: " . $row['jmeno'] . ", Produkt: " . ($row['produkt'] ?? 'Žádný') . "
"; } $stmt->close();

RIGHT JOIN – seznam všech objednávek (i bez uživatele)

MySQL podporuje RIGHT JOIN, ale bývá méně častý. Zde je příklad:

$stmt = $conn->prepare("SELECT Uzivatele.jmeno, Objednavky.produkt
                          FROM Uzivatele
                          RIGHT JOIN Objednavky ON Uzivatele.id = Objednavky.uzivatel_id");
  $stmt->execute();
  $result = $stmt->get_result();
  
  while ($row = $result->fetch_assoc()) {
      echo "Produkt: " . $row['produkt'] . ", Uživatel: " . ($row['jmeno'] ?? 'Neznámý') . "
"; } $stmt->close();

CROSS JOIN – všechny kombinace

CROSS JOIN vytvoří každou možnou kombinaci řádků mezi dvěma tabulkami. Většinou se používá velmi opatrně.

$stmt = $conn->prepare("SELECT Uzivatele.jmeno, Produkty.nazev
                          FROM Uzivatele
                          CROSS JOIN Produkty");
  $stmt->execute();
  $result = $stmt->get_result();
  
  while ($row = $result->fetch_assoc()) {
      echo "Uživatel: " . $row['jmeno'] . ", Produkt: " . $row['nazev'] . "
"; } $stmt->close();

UNION – spojení dvou tabulek

UNION slouží ke spojení výsledků ze dvou nebo více SELECT dotazů. Počet a typ sloupců musí být ve všech dotazech stejný.

SELECT jmeno FROM Uzivatele
    UNION
    SELECT jmeno FROM Administratori;

Tento dotaz vrátí jeden sloupec jmeno, ve kterém budou jména ze dvou různých tabulek. Výsledky budou bez duplicit.

Pokud chceš zachovat i duplicitní záznamy, použij UNION ALL:

SELECT jmeno FROM Uzivatele
    UNION ALL
    SELECT jmeno FROM Administratori;

Vytváření dat v databázi CREATE + INSERT

Vytvoření dat v databázi je základní krok pro práci s databázemi. To zahrnuje vytvoření nových tabulek a vkládání dat do těchto tabulek.

Jak vytvořit tabulku v SQL

Pro vytvoření tabulky v MySQL databázi použijeme příkaz CREATE TABLE. Tento příkaz definuje strukturu tabulky – tedy názvy sloupců, jejich datové typy a další omezení:

CREATE TABLE Osoby (
          id INT AUTO_INCREMENT PRIMARY KEY,
          jmeno VARCHAR(50),
          prijmeni VARCHAR(50),
          vek INT
      );
  • id: Primární klíč tabulky. AUTO_INCREMENT znamená, že se hodnota automaticky zvyšuje s každým novým řádkem.
  • VARCHAR(50): Datový typ pro text s maximální délkou 50 znaků.
  • INT: Datový typ pro celá čísla.

Jak vložit data do tabulky

Jakmile máme tabulku, můžeme do ní vložit data pomocí příkazu INSERT INTO:

INSERT INTO Osoby (jmeno, prijmeni, vek) VALUES ('Petr', 'Novák', 30);

Důležité aspekty

  • Primární klíč: Zajišťuje, že každý záznam má unikátní identifikátor.
  • AUTO_INCREMENT: Usnadňuje přidávání nových řádků bez nutnosti zadávat ID ručně.

V další části se budeme věnovat čtení dat z databáze pomocí příkazu SELECT.

Bezpečné vkládání dat v PHP (MySQLi)

Když vkládáš data z formuláře do databáze, je důležité chránit svou aplikaci proti tzv. SQL injection útokům. To znamená, že nikdy nepíšeme hodnoty přímo do SQL dotazu, ale používáme tzv. prepared statements a funkci bind_param().

Bezpečné vložení dat pomocí MySQLi – krok za krokem

1. Připojení k databázi:

$conn = new mysqli('localhost', 'username', 'password', 'databasename');
      if ($conn->connect_error) {
          die("Nepodařilo se připojit k databázi: " . $conn->connect_error);
      }

2. Příprava SQL příkazu:

$stmt = $conn->prepare("INSERT INTO Osoby (jmeno, prijmeni, vek) VALUES (?, ?, ?)");
      if (!$stmt) {
          die("Chyba při přípravě příkazu: " . $conn->error);
      }

3. Vázání parametrů k příkazu:

$jmeno = 'Petr';
      $prijmeni = 'Novák';
      $vek = 30;
      $stmt->bind_param('ssi', $jmeno, $prijmeni, $vek);

4. Vykonání příkazu:

if ($stmt->execute()) {
          echo "Nový záznam byl úspěšně vytvořen.";
      } else {
          echo "Chyba při vkládání dat: " . $stmt->error;
      }

5. Uzavření dotazu a spojení:

$stmt->close();
      $conn->close();

Tímto způsobem je vložení dat nejen bezpečné, ale i přehledné a snadno rozšiřitelné.

Vkládání dat do databáze (INSERT)

Zápis nových údajů do databáze je jedním ze základních kroků každé webové aplikace. V této lekci si ukážeme, jak do databáze bezpečně přidávat data pomocí PHP a MySQLi. Budeme postupovat krok za krokem – od jednoduchého SQL příkazu až po bezpečné použití v reálné aplikaci.

1. Základní SQL příkaz INSERT

Příkaz INSERT slouží k vložení nového řádku do tabulky:

INSERT INTO tabulka (sloupec1, sloupec2) VALUES ('hodnota1', 'hodnota2');

Např. do tabulky Uzivatele můžeme vložit jméno a e-mail takto:

INSERT INTO Uzivatele (jmeno, email) VALUES ('Tomáš', 'tomas@example.com');

2. Proč nepoužívat hodnoty přímo

V PHP ale nikdy nezapisujeme hodnoty přímo do SQL dotazu. Místo toho používáme prepared statements (připravené dotazy), které zvyšují bezpečnost a zabraňují útokům typu SQL injection.

Chybný způsob – přímé vložení hodnot

Tento způsob je velmi nebezpečný, protože vkládá uživatelská data přímo do SQL dotazu. Pokud útočník vloží škodlivý kód, může upravit nebo dokonce smazat data v databázi.

INSERT INTO Osoby (jmeno, prijmeni, vek) VALUES ('$jmeno', '$prijmeni', $vek)
$jmeno = $_POST['jmeno'];
$prijmeni = $_POST['prijmeni'];
$vek = $_POST['vek'];
          
$sql = "INSERT INTO Osoby (jmeno, prijmeni, vek) VALUES ('$jmeno', '$prijmeni', $vek)";
$conn->query($sql);

🔒 Pokud by uživatel do pole „jméno“ zadal Petr'); DROP TABLE Osoby; --, mohl by vyvolat destruktivní příkaz, který by smazal celou tabulku. Proto vždy používej prepared statements!

3. Bezpečný INSERT v PHP – krok za krokem

Krok 1: Připravíme SQL příkaz s otazníky místo hodnot:

$stmt = $conn->prepare("INSERT INTO Uzivatele (jmeno, email) VALUES (?, ?)");

Krok 2: Přiřadíme hodnoty z formuláře:

$stmt->bind_param("ss", $_POST['jmeno'], $_POST['email']);

Krok 3: Spustíme dotaz a zkontrolujeme úspěšnost:

if ($stmt->execute()) {
          echo "Úspěšně vloženo.";
      } else {
          echo "Chyba při vkládání: " . $stmt->error;
      }

Krok 4: Uzavřeme dotaz:

$stmt->close();

4. Kompletní příklad

$stmt = $conn->prepare("INSERT INTO Uzivatele (jmeno, email) VALUES (?, ?)");
      $stmt->bind_param("ss", $_POST['jmeno'], $_POST['email']);
      
      if ($stmt->execute()) {
          echo "Úspěšně vloženo.";
      } else {
          echo "Chyba při vkládání: " . $stmt->error;
      }
      
      $stmt->close();

5. Získání ID posledního vloženého záznamu

Pokud má tvoje tabulka sloupec s AUTO_INCREMENT, můžeš po vložení zjistit nové ID:

$posledni_id = $conn->insert_id;
      echo "ID nového záznamu: $posledni_id";

Tuto hodnotu můžeš použít například pro navazující vložení do jiné tabulky.

Kontrola před vložením – e-mail už existuje?

Než vložíš nového uživatele, je dobré zkontrolovat, zda daný e-mail už v databázi není:

$check = $conn->prepare("SELECT id FROM Uzivatele WHERE email = ?");
      $check->bind_param("s", $_POST['email']);
      $check->execute();
      $result = $check->get_result();
      
      if ($result->num_rows > 0) {
          echo "Tento e-mail již existuje.";
      } else {
          $stmt = $conn->prepare("INSERT INTO Uzivatele (jmeno, email) VALUES (?, ?)");
          $stmt->bind_param("ss", $_POST['jmeno'], $_POST['email']);
          $stmt->execute();
          $stmt->close();
      }

Rozdíl mezi INSERT a UPDATE při používání otazníků (?)

Pokud používáš prepared statements, je důležité vědět, jak správně zapisovat dotazy:

INSERT – používá se VALUES (?, ?, ?)

Pro vkládání nových dat do tabulky použijeme seznam sloupců a VALUES s otazníky v přesném pořadí:

$stmt = $conn->prepare("INSERT INTO Osoby (jmeno, prijmeni, vek) VALUES (?, ?, ?)");
$stmt->bind_param("ssi", $jmeno, $prijmeni, $vek);
UPDATE – používá se SET sloupec = ?

U úpravy existujícího záznamu zapisujeme každý sloupec zvlášť pomocí SET sloupec = ?:

$stmt = $conn->prepare("UPDATE Osoby SET jmeno = ?, prijmeni = ?, vek = ? WHERE id = ?");
$stmt->bind_param("ssii", $jmeno, $prijmeni, $vek, $id);

❗ Mnoho začátečníků si plete tyto dva zápisy a snaží se napsat jmeno = ? už v příkazu INSERT, což je chyba.
Zápis sloupec = ? se používá výhradně u UPDATE.

Srovnání zápisu – SELECT, INSERT, UPDATE

Když pracujeme s databází v PHP pomocí prepared statements, používáme místo skutečných hodnot tzv. ? zástupce (placeholders). Níže jsou tři ukázky, které ti ukážou rozdíly v zápisu dotazů a použití otazníků:

1. Výběr dat – SELECT

$stmt = $conn->prepare("SELECT jmeno, prijmeni FROM Osoby WHERE id = ?");
$stmt->bind_param("i", $id);

Používáme ? v podmínce WHERE. Tento otazník bude nahrazen proměnnou $id.

2. Vkládání dat – INSERT

$stmt = $conn->prepare("INSERT INTO Osoby (jmeno, prijmeni, vek) VALUES (?, ?, ?)");
$stmt->bind_param("ssi", $jmeno, $prijmeni, $vek);

Zde ? zastupují hodnoty pro jednotlivé sloupce ve správném pořadí. Typy v bind_param(): s je string, i je integer.

3. Úprava dat – UPDATE

$stmt = $conn->prepare("UPDATE Osoby SET jmeno = ?, vek = ? WHERE id = ?");
$stmt->bind_param("sii", $jmeno, $vek, $id);

V příkazu UPDATE se ? používají u každého sloupce, který měníme, a také v podmínce WHERE.

➤ Tato srovnání ti pomohou pochopit, kolik otazníků má být v SQL dotazu a v jakém pořadí vázat proměnné.

Srovnání zápisu SQL příkazů pomocí MeekroDB – SELECT, INSERT, UPDATE

MeekroDB je jednoduchá PHP knihovna, která výrazně zjednodušuje práci s databází. Nepotřebuješ psát prepare() ani bind_param() – místo toho používáš pole a zápis je přehlednější.

1. Výběr dat – SELECT

$id = 5;
$osoba = DB::queryFirstRow("SELECT jmeno, prijmeni FROM Osoby WHERE id = %i", $id);

%i znamená, že proměnná je celé číslo (integer). Pokud by šlo o text, použiješ %s.

2. Vkládání dat – INSERT

$jmeno = "Petr";
$prijmeni = "Novák";
$vek = 30;
                      
DB::insert("Osoby", [
"jmeno" => $jmeno,
"prijmeni" => $prijmeni,
"vek" => $vek
]);

Zápis je velmi čitelný – používá se asociativní pole, kde klíče jsou názvy sloupců a hodnoty jsou proměnné.

3. Úprava dat – UPDATE

$id = 5;
$jmeno = "Pavel";
$vek = 35;
                      
DB::update("Osoby", [
"jmeno" => $jmeno,
"vek" => $vek
], "id = %i", $id);

Nejprve je opět asociativní pole s novými daty, a pak podmínka WHERE s parametrem %i.

S MeekroDB je práce rychlá a přehledná, bez nutnosti připravovat a vázat dotazy ručně.

Úprava dat v databázi (UPDATE)

V této kapitole se naučíš, jak upravit existující data v databázi pomocí SQL příkazu UPDATE. Tento příkaz je nezbytný pro všechny redakční systémy nebo administrátorské rozhraní, kde se pracuje s úpravou údajů z formulářů.

Základní struktura SQL příkazu UPDATE

UPDATE tabulka
SET sloupec1 = nová_hodnota1, sloupec2 = nová_hodnota2
WHERE podmínka;

Příkaz UPDATE změní data v jednom nebo více sloupcích. Klauzule WHERE určuje, kterých řádků se změna týká. Pokud WHERE vynecháš, změna se provede u všech řádků v tabulce! ⚠️

Příklad: Změna věku osoby podle jména

UPDATE Osoby SET vek = 31 WHERE jmeno = 'Petr';

Příklad použití v PHP – objektově (MySQLi)

$stmt = $conn->prepare("UPDATE Osoby SET vek = ? WHERE jmeno = ?");
$stmt->bind_param("is", $vek, $jmeno);
$stmt->execute();
$stmt->close();

Vysvětlení

  • prepare() – připraví SQL dotaz s otazníky místo hodnot
  • bind_param("is", ...) – "i" je integer, "s" je string
  • execute() – vykoná dotaz
  • close() – uzavře dotaz

Ukázka: Úprava více sloupců zároveň

$stmt = $conn->prepare("UPDATE Osoby SET jmeno = ?, prijmeni = ?, vek = ? WHERE id = ?");
$stmt->bind_param("ssii", $jmeno, $prijmeni, $vek, $id);
$stmt->execute();
$stmt->close();

Častá chyba: zápis jako INSERT

Začátečníci často zkusí napsat UPDATE podobně jako INSERT:

UPDATE Osoby (jmeno, vek) VALUES ('Petr', 30);

❌ Tento zápis je neplatný. UPDATE vždy vyžaduje SET sloupec = hodnota.

Vhodné použití podmínky WHERE

Bez podmínky WHERE se změní všechny záznamy:

UPDATE Osoby SET vek = 0;

Tento dotaz vynuluje všem osobám věk. Vždy používej WHERE pro konkrétní řádky!

Podmínky v UPDATE – více možností

UPDATE Osoby SET oblibena_barva = 'modrá'
WHERE vek > 18 AND mesto = 'Brno';

Využití s formulářem

Pokud data pochází z formuláře, bude vypadat zápis takto:

$stmt = $conn->prepare("UPDATE Osoby SET jmeno = ?, prijmeni = ?, vek = ? WHERE id = ?");
$stmt->bind_param("ssii",
$_POST['jmeno'],
$_POST['prijmeni'],
$_POST['vek'],
$_POST['id']
);
$stmt->execute();
$stmt->close();

Shrnutí – jak vypadá UPDATE oproti INSERT

  • INSERT: INSERT INTO tabulka (sloupce...) VALUES (?, ?, ?)
  • UPDATE: UPDATE tabulka SET sloupec1 = ?, sloupec2 = ? WHERE ...

UPDATE se hodí pro úpravy článků, profilů, změnu hesel, nastavení a obecně jakékoli úpravy existujících dat v aplikaci.

Rozšířené použití příkazu UPDATE – LIMIT, ORDER BY a další

SQL příkaz UPDATE lze rozšířit o další klauzule jako LIMIT nebo ORDER BY. To se může hodit při specifickém hromadném upravování dat.

UPDATE s LIMIT – úprava jen určitého počtu řádků

UPDATE Osoby
SET oblibena_barva = 'červená'
WHERE vek > 18
LIMIT 3;

Tento příkaz upraví pouze 3 záznamy, které odpovídají podmínce vek > 18. Které 3? To můžeme určit pomocí ORDER BY.

UPDATE s ORDER BY – určení pořadí úpravy

UPDATE Osoby
SET status = 'aktivní'
WHERE status = 'neaktivní'
ORDER BY vek DESC
LIMIT 1;

Tento příkaz najde nejstarší neaktivní osobu a označí ji jako aktivní.

UPDATE s výpočtem

UPDATE Produkty
SET cena = cena * 1.10
WHERE kategorie = 'elektro';

Navýší cenu všech produktů v kategorii "elektro" o 10 %.

UPDATE podle jiného sloupce

UPDATE Zamestnanci
SET bonus = plat * 0.15
WHERE oddeleni = 'marketing';

Vypočítá bonus jako 15 % z platu pro všechny zaměstnance v marketingu.

Poznámka

Použití ORDER BY a LIMIT v UPDATE není součástí oficiálního SQL standardu, ale MySQL je podporuje.

UPDATE – LIMIT, ORDER BY a další

SQL příkaz UPDATE lze rozšířit o další klauzule jako LIMIT nebo ORDER BY. To se může hodit při specifickém hromadném upravování dat. V následujících příkladech ukazujeme také použití v PHP pomocí MySQLi (objektový způsob).

UPDATE s LIMIT – úprava jen určitého počtu řádků

$stmt = $conn->prepare("UPDATE Osoby SET oblibena_barva = ? WHERE vek > ? LIMIT 3");
  $stmt->bind_param("si", $barva, $vek);
  $barva = "červená";
  $vek = 18;
  $stmt->execute();
  $stmt->close();

UPDATE s ORDER BY – určení pořadí úpravy

$stmt = $conn->prepare("UPDATE Osoby SET status = ? WHERE status = ? ORDER BY vek DESC LIMIT 1");
  $stmt->bind_param("ss", $novyStatus, $staryStatus);
  $novyStatus = "aktivní";
  $staryStatus = "neaktivní";
  $stmt->execute();
  $stmt->close();

UPDATE s výpočtem

$stmt = $conn->prepare("UPDATE Produkty SET cena = cena * ? WHERE kategorie = ?");
  $stmt->bind_param("ds", $koef, $kategorie);
  $koef = 1.10; // navýšení o 10 %
  $kategorie = "elektro";
  $stmt->execute();
  $stmt->close();

UPDATE podle jiného sloupce

$stmt = $conn->prepare("UPDATE Zamestnanci SET bonus = plat * ? WHERE oddeleni = ?");
  $stmt->bind_param("ds", $bonusKoef, $oddeleni);
  $bonusKoef = 0.15;
  $oddeleni = "marketing";
  $stmt->execute();
  $stmt->close();

Poznámka

Použití ORDER BY a LIMIT v UPDATE není součástí oficiálního SQL standardu, ale MySQL je podporuje. Ne všechny databázové systémy tyto rozšíření umožňují.

Odstraňování dat z databáze (DELETE)

Poslední základní operací v databázích je DELETE, která slouží k odstranění dat z tabulky. Používá se opatrně, protože odstraněná data už většinou nelze obnovit.

Základní struktura SQL příkazu DELETE

DELETE FROM tabulka WHERE podmínka;

Příkaz odstraní všechny řádky, které splňují podmínku WHERE. Pokud podmínku vynecháš, smažou se všechna data z tabulky. ⚠️

Příklad: Odstranění osoby podle ID

$stmt = $conn->prepare("DELETE FROM Osoby WHERE id = ?");
  $stmt->bind_param("i", $id);
  $id = 5;
  $stmt->execute();
  $stmt->close();

Bezpečnostní upozornění

Pokud nezadáš WHERE podmínku:

DELETE FROM Osoby;

Tento dotaz smaže všechny záznamy v tabulce Osoby. Vždy používej WHERE!

Příklad s více podmínkami

$stmt = $conn->prepare("DELETE FROM Osoby WHERE vek < ? AND mesto = ?");
  $stmt->bind_param("is", $vek, $mesto);
  $vek = 18;
  $mesto = "Brno";
  $stmt->execute();
  $stmt->close();

Shrnutí

  • DELETE slouží k odstranění záznamů z tabulky.
  • Vždy používej WHERE, abys neodstranil všechna data.
  • Pomocí PHP a prepare() lze mazat bezpečně a jednoduše.

Pokud potřebuješ záznamy pouze "skrýt", můžeš místo mazání použít příznak (např. deleted = 1) a později je případně obnovit.