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.
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.
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.
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.
Pro práci s databází můžete v PHP využít různé nástroje:
PHP nabízí dva hlavní způsoby, jak pracovat s databází:
$conn = mysqli_connect("localhost", "username", "password", "database_name");
if (!$conn) {
die("Připojení se nezdařilo: " . mysqli_connect_error());
}
echo "Hurá, jsme připojení!";
$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í!";
Než začnete komunikovat s databází, potřebujete pár základních údajů:
localhost,
což znamená, že databáze běží na stejném serveru.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.
config.php pro
připojení k databáziPř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.
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.');
}
?>
utf8mb4 zabráníte problémům se speciálními
znaky jako jsou emoji.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!
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();
}
?>
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í.
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.
SELECT jmeno, vek FROM Osoby;
Vybere jen zadané sloupce, čímž šetří výkon a zjednodušuje zpracování dat.
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:
SELECT * FROM Osoby WHERE vek > 18 AND oblibena_barva = 'modrá';
Pomocí AND a OR lze spojit
více podmínek dohromady.
SELECT * FROM Osoby ORDER BY vek DESC;
Sloupec vek je seřazen sestupně (od
nejvyššího). Použij ASC pro vzestupné
řazení.
SELECT * FROM Osoby LIMIT 5;
Vrátí pouze 5 řádků. Používá se například pro stránkování nebo testování.
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ů.
SELECT * FROM Osoby WHERE jmeno LIKE 'P%';
% je zástupný znak. Tento dotaz najde
všechny osoby, jejichž jméno začíná na
P.
SELECT * FROM Osoby WHERE vek BETWEEN 20 AND 30;
Najde osoby, jejichž věk je v rozmezí 20 až 30 včetně.
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.).
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í.
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.
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.
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).
execute()Kuchař má připravený dotaz a doplněné suroviny. Teď ho stačí „pustit“:
$stmt->execute();
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í polebind_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";
Po dokončení dotazu je dobré ho uzavřít – jako když uklidíš po vaření:
$stmt->close();
// 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š.
Č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ěď.
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();
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.
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.
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();
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ů.
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();
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();
bind_result()?
Metodu bind_result() využijte, když:
bind_result():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.
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ů:
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().
fetch_assoc() – načte data
jako asociativní pole (klíče jsou názvy sloupců).fetch_row() – načte data
jako numerické pole (indexy odpovídají pořadí
sloupců).fetch_object() – načte
data jako objekt (vlastnosti odpovídají názvům
sloupců).fetch_all(MYSQLI_ASSOC) –
načte všechny výsledky jako pole asociativních
polí.fetch_all(MYSQLI_NUM) –
načte všechny výsledky jako pole numerických polí.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.
get_result() a
bind_result()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();
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();
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í.
fetch_array()
Metoda fetch_array() vám umožňuje načítat data
jako:
MYSQLI_ASSOC – asociativní poleMYSQLI_NUM – číselné poleMYSQLI_BOTH – obojí zároveň
(výchozí)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í.
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í
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.
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;
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;
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.
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.
$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();
$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();
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 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 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;
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.
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
);
AUTO_INCREMENT znamená, že se
hodnota automaticky zvyšuje s každým novým
řádkem.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);
V další části se budeme věnovat čtení dat z databáze
pomocí příkazu SELECT.
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().
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é.
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.
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');
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.
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!
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();
$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();
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.
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();
}
Pokud používáš prepared statements, je
důležité vědět, jak správně zapisovat dotazy:
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);
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.
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ů:
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.
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.
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é.
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ší.
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.
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é.
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ě.
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ářů.
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! ⚠️
UPDATE Osoby SET vek = 31 WHERE jmeno = 'Petr';
$stmt = $conn->prepare("UPDATE Osoby SET vek = ? WHERE jmeno = ?");
$stmt->bind_param("is", $vek, $jmeno);
$stmt->execute();
$stmt->close();
prepare() – připraví SQL dotaz s otazníky místo hodnotbind_param("is", ...) – "i" je integer, "s" je stringexecute() – vykoná dotazclose() – uzavře dotaz$stmt = $conn->prepare("UPDATE Osoby SET jmeno = ?, prijmeni = ?, vek = ? WHERE id = ?");
$stmt->bind_param("ssii", $jmeno, $prijmeni, $vek, $id);
$stmt->execute();
$stmt->close();
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.
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!
UPDATE Osoby SET oblibena_barva = 'modrá'
WHERE vek > 18 AND mesto = 'Brno';
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();
INSERT INTO tabulka (sloupce...) VALUES (?, ?, ?)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.
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 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 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 Produkty
SET cena = cena * 1.10
WHERE kategorie = 'elektro';
Navýší cenu všech produktů v kategorii "elektro" o 10 %.
UPDATE Zamestnanci
SET bonus = plat * 0.15
WHERE oddeleni = 'marketing';
Vypočítá bonus jako 15 % z platu pro všechny zaměstnance v marketingu.
Použití ORDER BY a LIMIT v UPDATE není součástí oficiálního SQL standardu, ale MySQL je podporuje.
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).
$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();
$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();
$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();
$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();
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í.
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.
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. ⚠️
$stmt = $conn->prepare("DELETE FROM Osoby WHERE id = ?");
$stmt->bind_param("i", $id);
$id = 5;
$stmt->execute();
$stmt->close();
Pokud nezadáš WHERE podmínku:
DELETE FROM Osoby;
Tento dotaz smaže všechny záznamy v tabulce Osoby. Vždy používej WHERE!
$stmt = $conn->prepare("DELETE FROM Osoby WHERE vek < ? AND mesto = ?");
$stmt->bind_param("is", $vek, $mesto);
$vek = 18;
$mesto = "Brno";
$stmt->execute();
$stmt->close();
DELETE slouží k odstranění záznamů z tabulky.WHERE, abys neodstranil všechna data.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.