Ano, už jste asi pochopili, že v následujícím článku vás nebudu učit, jak vypsat cyklem stránkování. Raději vám představím hotové řešení: takové, které na pár řádcích zařídí vše potřebné. Vy pak nemusíte řešit malichernosti a soustředit se na důležitější věci. Například optimalizace SQL dotazů. 

Tak se jdeme podívat, jak na to. Článek byl poprvé publikován v roce 2010 a nyní, po rozsáhlé revizi stránkovací knihovny, ho znovu posouvám výš. Na PHP7 už to samozřejmě funguje. 

Základní nasazení

Samotné nasazení jsem se snažil zredukovat na nutné minimum tak, abychom nemuseli volat hromady _set funkcí, a zároveň, aby šlo stále nastavit vše potřebné. 

// SQL dotaz samozrejme upravim v souladu se svym frameworkem
$count = $mysqli->query("SELECT COUNT(*) FROM `tabulka`")->fetch_row();
$total = $count[0];

$paging_limit = 20;

// celkem | po kolika
$paging = new Paging($total, $paging_limit);
$paging->set_paging();

$paging_start = $paging->get_start();
$query = "SELECT * FROM `tabulka` LIMIT {$paging_start}, {$paging_limit}"; // -> assoc_list

// simple vypis
echo $paging->export_paging();

A to je vše. Jedním SQL dotazem spočítám záznamy, někde z nastavení vytáhnu stránkovací limit. Zbytek si knihovna zjistí sama. Výchozí proměnná pro stránkování je $_GET['page'], v případě potřeby jiné proměnné ji lze změnit v konstruktoru. Ukážu na dalším příkladu. Co se odkazů týče, vše je automatické. Ať už oddělovač ? nebo &, tak doplnění celého query stringu, pokud ho chceme předávat dál. Vstup je automaticky ošetřen: _GET parametr je přetypován na int, takže ani na tohle už myslet nemusíme. 

Na výše uvedeném příkladu dostaneme defaultní výstup. Jak ho změnit si ukážeme v rozšířeném nastavení.

Rozšířené nastavení

Kromě základních parametrů můžeme knihovně předat i spoustu dalších informací. Nejčastěji využijeme přejmenovaní GET proměnné. Nechceme-l GET['page'], stačí nastavit třetí argument. Podporu má i jednoduché pole. Umíme i vícerozměrné, nicméně takové věci už podle mého názoru nemají v URL co dělat. Ale pro jistotu. 

Další důležité metody jsou set_paging_mode(), set_output_mode() a set_around(). Ty definují, jaký typ stránkování dostaneme na výstupu. Jednotlivé příklady najdete na konci článku. 

Generování odkazů je automatické, vezme se REQUEST_URI a zkopíruje se celý GET vyjma definované proměnné. Pokud nastavím set_base_path(), automatické generování přestane. Dostanu pouze to, co jsem třídě předal, tedy například www.treba.cz/?page=2. V takovém případě pak další z metod, set_drop_vars(), nemá význam. 

Změnu generovaného HTML pomocí metody set_html_pattern() tu více rozvádět nebudu, ať mi jednoduchý návod nenakyne do obřích rozměrů. Na to se můžete podívat ve zdrojáku souboru.

A na závěr opět metoda set_paging, která si navíc umí pohlídat, jestli je volaná, kdy má. 

$paging = new Paging($total, $paging_limit, 'filter[page]');
$paging->set_paging_mode(1)               // 1|0
       ->set_output_mode(1)               // 1|0
       ->set_around(2)                    // pri paging_mode=1
       ->set_valid_links(true)            // replace [] pri slozenych odkazech

       ->set_base_path($category_url)     // nechci generovat nic, predam zaklad odkazu
       ->set_default_page(2)              // kdyz neni GET[page] zacinam na strane 2
       ->set_drop_vars(array('ajax'))     // chci zkopirovat cely get krome ?ajax=
       ->disable_translate_function(true) // mam funkci __() a dela neco jineho, nez ze akceptuje 1 string a vraci 1 string => nebudu prekladat

       ->set_title_format($dt, $mb, $mn)  // desktop title, mobile back, mobile next
       ->set_html_patterns($pattern)      // @see protected $pattern
       ->set_paging();

Funkce __ (dvě podtržítka)

Jednou z metod, které můžete či nemusíte zavolat, je také "disable_translate_function()". Protože počítám i s lokalizací titulků, testuji existenci funkce dvě podtržítka. Můžete ji najít například ve Wordpressu, používá ji i Kohana framework. Pokud ovšem takovou funkci máte k něčemu jinému, přidal jsem i možnost její volání vypnout. Stejně tak pro případ, že si chcete přeložit texty ještě před zavoláním stránkovací knihovny. Proto ani neřeším žádné callbacky. Pokud tuto funkci nemáte vůbec, neřešíte, protože volání je vždy podmíněno function_existem. 

Filosofická vsuvka

Na chvíli se ještě vrátím zpět k parsování QUERY STRINGu a celkové logice předávání parametrů. Jako správně by to knihovna vůbec neměla dělat. Měla by dostat URL, referenci na jeden klíč a podle toho se zařídit. Jenže... To bychom pak v systému neřešili nic jiného, než které proměnné předat a které ne. Takhle máme možnost buď vše anebo nic. Funkce set_drop_vars je výjimka z tohoto pravidla, ale tady jsem si prostě chtěl ušetřit práci. Raději zvolím řešení, díky kterému nemusím na nic myslet a vím, že to skript vyřeší za mě. 

Výstup do šablony

Jak je zmíněno výše, máme celkem 4 způsoby, jak stránkování vypsat. A k tomu navíc pátý pro telefon. Pokud se tedy nespokojíme se základním echo $paging; můžeme si na výstupu podmínit i alternativní výpis právě pro mobilní zařízení: namísto hromady odkazů jenom tlačítko "Následující" respektive "Předchozí". Jakoukoli další modifikaci zařídí styly, protože každý z elementů lze snadno a unikátně zacílit. 

<div class="paging">
	<div class="hide-this-on-phone">
		<?=$paging->export_paging();?>
	</div>
	<div class="hide-this-on-desktop">
		<?=$paging->export_mobile();?>
	</div>
</div>

A pokud jsme ještě náročnější a ani tohle nám nestačí, pak nám pomůže poslední funkce a my si můžeme s výstupem dělat cokoli, co se nám zlíbí. Ale jak říkám, tohle je jedna z věcí, kterou člověk opravdu nechce zaplácat jednoduchou šablonu. Když se sami podíváte na funkci export_paging(), fakt není úplně jednoduchá. Ale proti gustu... :-) 

<xmp>
<?php print_r($paging->export_data()); ?>
</xmp>

Varianty výstupu

export_paging();
1 ... 6 | 7 | 8  ... 50       (paging_mode = 1 | output_mode = 1) // vychozi
 <<  <  5  >  >>              (paging_mode = 1 | output_mode = 0 | vhodne dat set_around=1)
1 | 2 | 3 | 4 | 5             (paging_mode = 0 | output_mode = 0)
1-10 | 11-20 | 21-30 | 31-32  (paging_mode = 0 | output_mode = 1)

export_mobile();
< Predchazejici  Nasledujici >

Na zdroják se můžete podívat nebo si ho stáhnout. Člověk by si řekl - že maličkost - ale je to pěkných 600 řádků kódu. 

class.Paging.php
class.Paging.zip

Pokud jste úplný začátečník, těžko si nacpete následující kód do vlastního webu. (V takové situaci doporučuji použít čistě .htaccess.) Používáte-li komplexní redakční systém, podobný plugin už nejspíš obsahuje. A pokud ne, můžete si vzít následující kód jako inspiraci, co změnit či upravit.

Proč chceme přesměrovat

Pokud jste přesměrování jedné adresy na druhou ještě nepotřebovali, pravděpodobně se svému webu málo věnujete :-) V opačném případě jistě víte, že změna URL adresy znamená ztrátu pozice v Googlu, kterou jste složitě budovali. A právě tohle vyřešíte přesměrováním s hlavičkou 301.

Možností jak danou funkcionalitu integrovat do systému je více a já vám dnes ukážu jednu z nich. Redirecty uložené v samotné tabulce mají jednu velkou výhodu, kterou je jejich přehlednost. Pokud bychom tyto informace ukládali automaticky a řešili je například na úrovní ukládání článku (změní se url článku, uložím si automaticky redirect), museli bychom provádět obrovské množství různých kontrol napříč mnoha tabulkami. A co víc, snadno ztratíme přehled, co směruje kam. Nemluvě o automatickém čištění všech předchozích redirectů s každým uložením.

Nevýhoda odděleného řešení je pak samozřejmě ta, že na to člověk musí myslet. Ale pokud se o svůj web staráte, tak URL, která skáče na první stránce v Googlu asi neměníte každý den. A nastavit případný redirect člověk jistě nezapomene.

Kód #1: SQL

Začneme tabulkou v databázi. Ukládat chceme výchozí url, cílovou url, checkbox pro přesnou shodu, checkbox pro přesnou náhradu (vysvětlím níže) a poznámku. Ta bude sloužit ke krátkému popisu, proč redirect vlastně zakládám. Na závěr samozřejmě možnost deaktivace a čas vytvoření záznamu. original_url chceme mít jako unikátní klíč, protože více redirectů ze stejné adresy je nesmysl. 

CREATE TABLE IF NOT EXISTS `project_redirects` (
	`id` int(10) unsigned NOT NULL   AUTO_INCREMENT,
	`original_url` varchar(255) NOT NULL,
	`redirect_url` varchar(255) NOT NULL,
	`exact_match` tinyint(1) DEFAULT '1',
	`do_replace` tinyint(1)  DEFAULT '0',
	`note` varchar(255) DEFAULT NULL,
	`active` tinyint(1) DEFAULT '1',
	`timestamp` timestamp  DEFAULT CURRENT_TIMESTAMP,
	PRIMARY KEY (`id`),
	UNIQUE KEY `original_url` (`original_url`)
) ENGINE=MyISAM  DEFAULT CHARSET=utf8 ;

Jak to bude fungovat 

Ze struktury tabulky už nejspíš pochopíte i chování. Uložíme původní a cílovou url a při každém načtení stránky zjistíme, jestli má aktuální URL kam přesměrovat. Porovnáme vždy relativní i absolutní variantu cesty.

Pole exact_match nám řekne, jestli budeme testovat přesnou shodu nebo nasadíme funkci strpos. Pole do_replace následně definuje, jestli provádíme klasický str_replace nebo chceme směrovat vše na novou url. 

Jaké případy tedy umíme podchytit?

• Jedna konkrétní adresa na novou adresu: /kategorie/ => /nova-kategorie/
• Zahodíme celou větev a přesměrujeme na novou adresu: /kategorie/vše/ => /nova-kategorie/
• Celá větev změní jen část své adresy: /kategorie/cokoli/ => /nova-kategorie/cokoli/

Porovnání přes strpos === 0 zaručí, že se podmínka chytí jenom na adresy, které daným stringem začínají. Takže když bude stejný string zanořený někde hlouběji, nic se nestane. Vše je navíc navrženo tak, abych tu root_url nemusel nikam ukládat, ať u případné změny domény neřeším absolutní cesty bůhví kde v databázi. 

Kód #2: .htaccess

Abychom mohli provádět efektivnější redirecty, jsou potřeba i nějaké ty "hezké url". Následující zápis nasměruje vše, co není existující soubor nebo složka na index. Pro spuštění v podadresáři je pak potřeba přidat i RewriteBase. 

RewriteEngineOn
#RewriteBase /redir/
RewriteCond %{REQUEST_FILENAME} !-d 
RewriteCond %{REQUEST_FILENAME} !-f
RewriteRule ^(.*)$ index.php?path=$1 [L,QSA]

Kód #3: základní proměnné, funkce a připojení k databázi

Zpracujeme primární GET proměnnou, nastavíme ROOT a připojíme se k databázi. Databázi si jistě vyřeší každý po svém, tady jsem uvedl jen minimum kódu tak, aby ukázka fungovala. (Pro sešny platí to samé.) Funkce get_url nám pak vrátí celou absolutní URL, na které se zrovna nacházíme. 

$_root_url = 'http://localhost/redir/';
$_path = (!empty($_GET['path']) ? (string)$_GET['path'] : '');

$config['db_host'] = 'localhost'; 
$config['db_user'] = 'root';
$config['db_pass'] = ''; 
$config['db_name'] = 'evil';

$sqli = new mysqli($config['db_host'], $config['db_user'], $config['db_pass'], $config['db_name']);
$sqli->set_charset('utf8');
if(!empty($sqli->connect_error)){
 	exit($sqli->connect_error);
}

session_start();

function get_url($header = false){
	$pure_url = null;
	$html_url = null;
	
	if(!$pure_url){
		$url = (isset($_SERVER['HTTPS']) ? 'https://' : 'http://');
		$url .= $_SERVER['SERVER_NAME'];
		$port = explode(':', $_SERVER['HTTP_HOST']);
		if(!empty($port[1])){
			$url .= ':'.$port[1];
		}
		$url .= $_SERVER['REQUEST_URI'];
		$pure_url = $url;
		$html_url = str_replace('&', '&', $pure_url);
	}
	
	return $header ? $pure_url : $html_url;
}

Kód #4: Samotná funkce

Hned první blok kódu vznikl po analýze adres, kterou často navštěvují spamboti. Jakože fakt často. Takže mezera (respektive plus) hranatá závorka se automaticky přesměruje na root. 

Pak už jen vytáhneme všechny existující redirecty z databáze a pustíme se do kontroly. SQL dotaz by šel určitě lépe vydefinovat tak, aby se netahaly úplně všechny řádky, ale na druhou stranu počítám s nějakou lidsky rozumnou správou. Fakt tam nechceme mít stovky řádků. Což bychom ani mít neměli, když je možnost vypnout exact_match a obsáhnout i větší množství záznamů jedním řádkem. 

V cyklu podle exact_match zvolíme způsob porovnání. No a následuje samotné ošetření smyčky. Redirect loop totiž není příliš fajn věc, protože vám to zpravidla zahlásí až prohlížeč. Žádnou chybovku od serveru nedostaneme, což se opravdu špatně ladí. Třeba Chrome už se v poslední době umoudřil a stránku zabije poměrně rychle, ovšem na to se nedá vždy spolehnout. Raději si tam podstrčím hlášku vlastní, abych hned viděl, kde je problém. Stejné ošetření pak můžeme provádět během jakéhokoli systémového redirectu. 

// redirekty z tabulky
// plus nejake natvrdo
function redirect_check($_path, $_root_url, $sqli){
	
	// tohle delaji spamboti
	if(strpos($_path,' [') !== false){
		header('Location: ' . $_root_url);
		return false;
	}
	
	$redir_query = $sqli->query("SELECT original_url, redirect_url, exact_match, do_replace FROM project_redirects WHERE `active` = 1 ORDER BY id DESC");
	$redirects = array();
	while($row = $redir_query->fetch_assoc()){
		$redirects[] = $row;
	}
	
	// podminka vzdy pro relativni i absolutni URL
	// vse bud relativni nebo absolutni
	// neni-li exact_match, testujeme jestli url danym retezcem zacina, at to nereplacuje kdekoli
	// neni-li replace (default 0), pak to redirektuje vse co danym stringem zacina na cilovou url
	foreach($redirects as $item){
		if(!empty($item['exact_match'])){
			
			if(($_path == $item['original_url']) || (get_url(true) == $item['original_url'])){
				$redirect_target = $item['redirect_url'];
			}
			
		}else{
			
			if((strpos(get_url(true), $item['original_url']) === 0) || (strpos($_path, $item['original_url']) === 0)){
				if(!empty($item['do_replace'])){
					$redirect_target = str_replace($item['original_url'], $item['redirect_url'], $_path);
				}else{
					$redirect_target = $item['redirect_url'];
				}
			}	
			
		}
	}

	
	if(!empty($redirect_target)){
	
		// zastupny znak pro redirekt na homepage
		if($redirect_target == '/'){ 
			$redirect_target = $_root_url;
		}
		
		if((strpos($redirect_target, 'http://') === false) && (strpos($redirect_target, 'https://') === false)){
			$redirect_target = $_root_url . $redirect_target;
		}
		
		// redirect_happened bude vzdy prazdny, pokud nedojde k zacykleni
		if(!empty($_SESSION['redirect_happened']) && $_SESSION['redirect_target_url'] == get_url(true)){		
			
			// potreba vynulovat
			// aby to zase nechciplo, kdyz to v administraci opravim
			// cela konstrukce musi byt obalena v try catch
			// musi se porovnavat URL, nestaci 1/0, kvuli requestovym spam botum
			$exception_message = 'Redirect linking to another.'; 
			$exception_message.= '<br>Previous URL: ' . $_SESSION['redirect_prev_url'];
			$exception_message.= '<br>Next URL: ' . $_SESSION['redirect_target_url'];

			$_SESSION['redirect_happened']   = false;
			$_SESSION['redirect_target_url'] = null;
			$_SESSION['redirect_prev_url']   = null;
			
			exit($exception_message);
		}
		
		$_SESSION['redirect_happened']   = true;
		$_SESSION['redirect_target_url'] = $redirect_target;
		$_SESSION['redirect_prev_url']   = get_url(true);
		
		header('Location: ' . $redirect_target, true, 301);
		return;
	}
	
	$_SESSION['redirect_happened']   = false;
	$_SESSION['redirect_target_url'] = null;
	$_SESSION['redirect_prev_url']   = null;

		
	// doplneni lomitka
	// lze vyresit komplexeni : ale pro ukazku staci
	if(!empty($_path) && substr($_path, -1) != '/'){
		if((strpos($_SERVER['REQUEST_URI'], '?') === false) && (strpos($_SERVER['REQUEST_URI'], '&') === false)){
			
			// u nekterych url treba lomitko nechceme
			if($_path != 'sitemap.xml'){
				header('Location: ' . get_url() . '/', false);
				return;
			}
		}
	}
	
	return $redirects;
}

$_redirects = redirect_check($_path, $_root_url, $sqli);

Ošetříme zacyklení

Funkce běží a zjistí, jestli má proběhnout redirect. V tu chvíli se zeptá: neproběhl už naposled nějaký?

Nastavíme do _SESSION potřebné hodnoty a zabijeme skript. 

Pokud podmínka splněna není, tedy je vše v pořádku, proměnné v _SESSION zase vynulujeme. Protože kdybychom to neudělali, hodnoty zůstanou uložené a bude se to cyklit i v případě, že chybné přesměrování v administraci opravíme.

A protože vynulování proměnných nastane jen tehdy, je-li vše v naprostém pořádku, máme automaticky ošetřené i víceúrovňové zacyklení: tedy když odkaz 1 směruje na odkaz 2, ten na odkaz 3 a ten zase zpátky na 1. Jednoduše se testuje, jestli jeden redirect nesměřuje na jiný. Je jedno, jestli to po dvou / třech přesměrováních skončí na normální adrese nebo ve smyčce. Nechceme ani jedno. 

Na řádek s exitem samozřejmě doporučuji nějaké pokročilé odchytávání výjimek: např. logovací soubor nebo odeslání mailu.

Závěrem ještě doplníme lomítko, protože je s tím méně ladění, než to řešit v .htaccessu. 

Kód #5: Testovací data

INSERT INTO `project_redirects` (`id`, `original_url`, `redirect_url`, `exact_match`, `do_replace`, `note`, `active`, `timestamp`) VALUES
(1, 'test-url-1/', 'test-url-2/', 1, 0, 'test', 1, '2020-02-02 13:37:33'),
(2, 'test-url-2/', 'test-url-1/', 1, 0, 'test zacykleni', 1, '2020-02-02 13:37:33'),
(3, 'kategorie/', 'nova-kategorie/', 0, 0, 'vse na jednu jedinou url', 1, '2020-02-02 13:37:33'),
(4, 'kategorie-x/', 'nova-kategorie-x/', 0, 1, 'vcetne deti', 1, '2020-02-02 13:37:33'),
(5, 'nesmysl/', '/', 1, 0, 'test redirectu na root', 1, '2020-02-02 13:37:33');

A na úplný závěr ještě jeden tip: při testování redirectů doporučuji vždy smazat historii prohlížeče, protože si ty redirecty cachují. Což má jít vyřešit zasláním no-cache v headeru a exitem, nicméně to není bohužel stoprocentní. 

index.php
.htaccess
redirect.sql

ZIP archív ke stažení

Než jsem našel tu správnou knihovnu, strávil jsem nějaký čas na Googlu. Nakonec se ukázalo, že žádná jiná pořádně ani neexistuje. Tedy pokud chceme kvalitní produkt, jehož vývoj stále pokračuje. Autor knihovnu průběžně aktualizuje, což je v případě detekce zařízení nejdůležitější aspekt. Dovolte mi, abych vám představil Mobile Detect Library.

Mobile Detect Library
mobiledetect.net

Nasazení si můžete nastudovat na uvedeném odkazu, pro snazší porozumění uvedu příklad i zde.

include_once('libs/detect/detect.php');
if (Detect::isTablet()) {
	$device = 'tablet';
} elseif (Detect::isMobile()) {
	$device = 'mobile';
} else {
	$device = 'desktop';
}

<body class="<?=$device;?>">

Je to opravdu takhle jednoduché. Jenom na jeden malý zádrhel si musíme dávat pozor: metoda Detect::isMobile vrací true i v případě tabletu, proto je nutné dodržet dané pořadí, chceme-li tato dvě zařízení odlišit. Je to vlastně uvedené i na hlavní stránce projektu.

Pak už stačí jen vytisknout proměnnou do třídy <html> nebo <body> a ve stylech můžeme krásně cílit zařízení. Stejně tak v JavaScriptu, kde stačí otestovat element na přítomnost třídy "mobile" respektive "tablet".

if ($('body.mobile').length) {
	// tento blok proběhne pouze na telefonu
}

Třída funguje krásně, nedostatkem může být nejpspíš jen špatná rychlost jednotlivých metod. Pořád je to regulár za regulárem, což chvíli trvá a urychlit to příliš nelze. U mě na webu detekce vezme nějakých 0,02 sekundy, což se nemusí zdát až tak moc, ale pro srovnání - stejně dlouho mi trvá hlavní SQL dotaz na články, ve kterém spojuji víc jak 4 tabulky dohromady...

Každopádně nic lepšího asi neexistuje, a tak si musíme vystačit s tím, co máme zadarmo. A bez práce. Mně detekce slouží dobře: k čemu přesně ji využívám, si řekneme v dalším dílu seriálu "Co jsem dnes udělal pro svůj web".

Knížku jsem totiž psal v době, kdy PHP5 rozhodně nebylo samozřejmostí. Bylo potřeba dodržovat nějakou zpětnou kompatibilitu, která už je ale v tuto chvíli bezpředmětná. Celou miniaplikaci jsem tedy aktualizoval a stejně jako naposledy si i dnes ukážeme, jak ji rozběhnout na vlastním webu. Také si projdeme některé nové funkce a vychytávky, které jsem zachoval, přidal či zrušil.

Prosím berte v potaz, že původní článek je z roku 2007. Hodně se za tu dobu změnilo, a tak návod nemusí odpovídat dnešním standardům. Ukázka ale funguje na PHP5 a můžete ji využít jako první krok k lepšímu porozumnění PHP.

1. Co všechno návštěvní kniha umí

Než si ukážeme, jak knížku nainstalovat, projdeme si, co všechno vlastně umí. Aplikace se skládá ze dvou skriptů (frontend a backend), instalačního souboru, configu, souboru s funkcemi a tří knihoven. Části kódu jsem se snažil okomentovat tak, aby bylo jasné, k čemu přesně slouží. Co vás tedy zajímá, jsou souboru "guestbook.php", "guestbook-admin.php", "config.php" a případně i "functions.php".

Funkce:

• jednoúrovňová reakce na příspěvky: žádná složitá strukturovaná diskuse, pouze první úroveň odpovědí
• základní formátování písma, smajlíci
• několik vrstev antispamu
• administrace
• notifikace na e-mail
• ošetření dlouhých řetězců

2. Přístup do databáze

Tímto začneme. Po rozbalení zipky, ještě před samotnou instalací musíme nastavit přístupové údaje do databáze. Otevřeme soubor "config.php" a hned na začátku upravíme:

$config['db']['host'] = 'localhost';	// db server
$config['db']['user'] = 'root';		// uzivatel
$config['db']['pass'] = '';		// heslo
$config['db']['name'] = 'mysql';	// jmeno databaze

3. Instalace: vytvoření tabulky v databázi

Tabulku můžeme vytvořit buď manuálně nebo spuštěním skriptu "guestbook-install.php". Na první pohled se možná zarazíte, proč se datum ukládá do varcharu namísto jiného, přijatelnějšího formátu: je to pouze kvůli zpětné kompatibilitě. Tak, aby to stále fungovalo, když si vezmete čistě skripty a přepíšete ty původní.

CREATE TABLE `knizka_2` (
	`id` int(10) unsigned NOT NULL   auto_increment,
	`jmeno` varchar(255),
	`text` text,
	`datum` varchar(255),
	`email` varchar(255),
	`web` varchar(255),
	`addr` varchar(255),
	`r` int(11) DEFAULT '0',
	PRIMARY KEY  (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8;

4. Nastavení

Tabulka byla úspěšně vytvořena, nyní se můžeme pustit do rozšířeného nastavení guestbooku a podívat se, co všechno umí. Vrátíme se do souboru "config.php", kde je uvedeno další nastavení.

// vase IP adresa, pro odliseni komentaru (jmeno bude jinou barvou)
$config['guestbook']['myip'] = '127.0.0.1'; 

// po kolika budeme strankovat (reakce nejsou zapocitany)
$config['guestbook']['per_page'] = 10; 

// po kolika budeme strankovat v administraci
$config['guestbook']['per_page_admin'] = 20; 

// heslo do administrace - NEZAPOMENTE ZMENIT
$config['guestbook']['admin_password'] = '123'; 

// IP adresy, z nichz nebude povoleno zanechavat vzkazy
$config['guestbook']['blacklist'] = array(
    '127.0.0.2',
    '127.0.0.3',
);

// dalsi ochrana proti spamu - pokud bude v poli zprava nektere ze zadanych slov, 
// prispevek se neodesle. (piste malymi pismeny)
$config['guestbook']['spamwords'] = 'anatrim website [url] [/url]';

Takto jsou jednotlivé direktivy okomentovány přímo v souboru. Pokud máte pevnou IP adresu, můžete odlišit vlastní příspěvky jinou barvou. Následuje limit stránkování pro frontend i administraci spolu s heslem do administrace. Poslední 2 proměnné jsou pro vlastní ochranu knížky: můžeme zabanovat otravné spammery a definovat seznam slov, které zamezí uložení příspěvku.

Notifikace na e-mail

// budou chodit notifikace na email
$config['notif']['enable'] = true;

// kam budou chodit notifikace, mozno vice oddeleno strednikem
$config['notif']['to'] = 'vas@email.cz';

// odesilatel
$config['notif']['from_name'] = 'Guestbook - nový komentář';

// vzor predmetu
$config['notif']['subject'] = 'Nový komentář od %s';

// vzor pro telo emailu
$config['notif']['body'] = "
	Od: %s
	
	Zpráva: %s 
	
	Odkaz: %s
";

Nová verze knížky vám nyní pošle e-mail s každou novou zprávou. Nastavení je poměrně intuitivní, jediné, co stačí nastavit, je vaše e-mailová adresa. Pokud notifikace nechcete, stačí řádky zakomentovat. Nebo nastavit první proměnnou na false. Nebo prázdný řetězec do adresy. Testování probíhá přes konstrukt !empty, takže blok kódu se pak prostě přeskočí. Pro posílání e-mailu používám vlastní jednoduchou knihovnu, její náhradu za PHPMailera by měl zvládnout každý začátečník.

5. Změny oproti předchozí verzi

Celou knížku jsem dost překopal. Tabulka ale zůstala nezměněna, takže když starý guestbook smažete a nahradíte novým, o uloženou diskusi nepřijdete. Jak už jsem zmiňoval na začátku, hlavní důvod k nové verzi byla zpětná kompatibilita, která v nových verzích PHP už vyhazuje chyby. Co se tedy změnilo dále?

• Třídy ve stylech jsou trochu rozumněji pojmenované, aby to případně nic nepřebíjelo.
• Nasazena databázová třída a stránkovací knihovna - přesně ty, o kterých už jsem psal. Odkazy na články najdete znovu níže jako "Související". Až totiž soudruzi z NDR jednoho dne zakážou mysql_ funkce, změna bude pohodlnější.
• Změnilo se ukládání data, nyní už ve formátu datetime: 2016-01-12. Kvůli zpětné kompatibilitě se ale stále ukládá do sloupce varchar. Každopádně není problém sloupec přetypovat.
• Diskuse už nepřevádí odkazy, protože toto chování považuji za nevyžádané. Stejně tak už se nezobrazuje email - ten uvidíme pouze v administraci.
• Chybové hlášky jsou méně "nasí*ací"
• Systém reakcí je trochu upraven: už nesměruje na novou url, při reakci na reakci se akorát do příspěvku vloží jméno.
• JavaScriptové funkce jsou psány na frameworku jQuery.
• Formátovací značky už se vkládají na pozici vybraného textu (není-li vybraný, pak nakonec).

6. Ukázka a link ke stažení

Ukázka v tuto chvíli není k dispozici. Skript je psaný pro PHP5 a na webu mám nasazené PHP7. Ale ZIPku si stáhnout můžete. 

ZIP archív ke stažení: guestbook.zip

Dnes uživatelé vyžadují větší pohodlí a intuitivnější chování webových aplikací, a tak zobrazujeme chybová hlášení většinou hned vedle daného políčka. Jak jsem už ale zmínil, princip kontrol není třeba měnit. Článek "Je čas udělat Wordpressu pápá" se datuje na 1. 10. 2007, tehdy jsem přešel na vlastní redakční systém, kde používám úplně stejné kontroly v komentářích. A od té doby jsem nezaznamenal jediný spam - tedy spam od neživého návštěvníka. Základní prvky ochrany tedy fungují stále dobře a je na čase si je připomenout.

Prosím berte v potaz, že původní článek je z roku 2007. Hodně se za tu dobu změnilo, a tak návod nemusí odpovídat dnešním standardům. Ukázka ale funguje na PHP5 a můžete ji využít jako první krok k lepšímu porozumnění PHP.

Ukázkový formulář

<? if(!empty($_GET['sent'])){ ?>
	<p class="success">Formulář byl úspěšně odeslán</p>
<? } ?>

<form action="<?=$_SERVER['REQUEST_URI'];?>" method="post">
	<fieldset>
		<legend>Přidej komentář</legend>
		
		<label>Jméno <b>*</b></label><br />
		<input type="text" name="jmeno" value="<?=(isset($_jmeno) ? $_jmeno : '');?>" /><br />
		<?=(!empty($error_messages['jmeno']) ? '<div class="error">'.$error_messages['jmeno'].'</div>' : ''); ?>
		
		<label>E-mail <b>*</b></label><br />
		<input type="text" name="web" value="<?=(isset($_email) ? $_email : '');?>" /><br />
		<?=(!empty($error_messages['email']) ? '<div class="error">'.$error_messages['email'].'</div>' : ''); ?>
		
		<label>Web</label><br />
		<input type="text" name="email" value="<?=(isset($_web) ? $_web : '');?>" /><br />
		<?=(!empty($error_messages['web']) ? '<div class="error">'.$error_messages['web'].'</div>' : ''); ?>
		
		<label>Vaše zpráva <b>*</b></label><br />
		<textarea name="text" rows="4" cols="10"><?=(isset($_text) ? $_text : '');?></textarea><br />
		<?=(!empty($error_messages['text']) ? '<div class="error">'.$error_messages['text'].'</div>' : ''); ?>
		
		<span class="schovany">
			<label>Tohle políčko ponechte prázdné</label><br />
			<input type="text" name="city" /><br />
			<?=(!empty($error_messages['check1']) ? '<div class="error">'.$error_messages['check1'].'</div>' : ''); ?>
		</span>
		
		<label>Kontrola: Opište číslici pět <b>*</b></label><br />
		<input type="text" name="skype" /><br />
		<?=(!empty($error_messages['check2']) ? '<div class="error">'.$error_messages['check2'].'</div>' : ''); ?>
		
		<button name="submit" type="submit">Odeslat</button><br />
	</fieldset>
</form>

Takhle nějak by mohla vypadat základní kostra formuláře. Doporučuji samozřejmě i atributy FOR a ID pro labely a inputy (popřípadě obalit input labelem). Třídu "schovany" nastylujte na display:none. Pokud se na kód podíváte blíže, můžete si všimnout hned tří úrovní ochrany proti spamu, které za chvíli rozeberu. Další dvě úrovně ochrany pak budou schované už v obsluze odesílacího skriptu.

Zpracování dat po odeslání, krok 1: Základní ošetření

Formulář budeme posílat na stejnou url, na které je, takže zpracování odeslaných dat musí proběhnout ještě před zobrazením jakéhokoli HTML kódu. V případě jednoduchého formuláře, na kterém kontrolu předvádím můžeme začít například takto:

<?php
if(isset($_POST['submit'])){
	$_jmeno = htmlspecialchars(trim($_POST['jmeno']));
	$_email = htmlspecialchars(trim($_POST['web']));
	$_web   = htmlspecialchars(trim($_POST['email']));
	$_text  = htmlspecialchars(trim($_POST['text']));
	
	$_check1 = $_POST['city'];
	$_check2 = htmlspecialchars(trim($_POST['skype']));

htmlspecialchars() a trim() je vše, co k ošetření vstupu potřebujete. Při ukládání do databáze je samozřejmě potřeba myslet na escape uvozovek, ale o databázi se v dnešním článku bavit nebudeme. U větších formulářů pak tato kontrola bude napsaná úplně jinak, ale pro začátek je tato ukázka víc než dostatečná. Ukončující závorku záměrně neuvádím, protože v bloku kódu budeme pokračovat.

Zpracování dat po odeslání, krok 2: Antispam

Na pořadí kroku 2 a 3 samozřejmě nezáleží, já zvolil jako první antispam. Jak nahoře ve formuláři, tak zde v prvních pár řádcích PHP jste si mohli všimnout, že jména pole e-mail a web jsou prohozená. To je první past na roboty. Pokud v poli email bude zavináč, vypíšeme chybu a formulář nezpracujeme. Dále zkontrolujeme odpověď na kontrolní otázku a hodnotu skrytého pole: pokud je vyplněno, opět se jedná o robota. Roboti totiž zpravidla vyplní každé pole formuláře nějakými bláboly - a my si proto řekneme, že právě jedno z polí musí být prázdné. Robot ho vyplní a skončil.

Skrytému poli je také dobré dát nějaký výstižný název, na který se roboti nachytají. V mém případě "city", můžete ale uvést i názvy "email_here" nebo cokoli jiného. I kontrolní pole samo o sobě má název, který láká na vyplnění všeho jiného jen ne jednomístného čísla.

Prohození názvů polí samozřejmě můžeme vynechat. V případě, kdy generujeme celý formulář z databáze a atribut name má hodnoty ve tvaru "input_25", "input_26" a podobně, budou nám bohatě stačit dvě antispamová pole pojmenovaná "email", "skype" či v podobném duchu.

Dále provedeme kontrolu zakázaných slov a počet hypertextových odkazů v těle zprávy. Zakázaná slova můžeme mít uložená v databázi nebo jenom staticky v proměnné, na tom nezáleží. Na čem ale záleží je uvedení těch správných frází, které se často vyskytují ve spamu. Pokud takové slovo vloží sám uživatel, dostane chybové hlášení, slovo smaže a příspěvek může odeslat. Robot ale bude ztracen.

	// antispam
	$evil_words = array('[url', 'viagra', 'website');
	foreach($evil_words as $word){
		if(strpos($_text, $word) !== false){
			$error_messages['text'] = 'Zpráva obsahuje některé ze zakázaných slov: '.implode(', ', $evil_words);
		}
	}
	
	if(substr_count($_text, 'http://') > 5 ){
  		$error_messages['text'] = 'Více než pět hypertextových odkazů není povoleno.';
  	}
  	
  	if(strpos($_web, '@') !== false){
		$error_messages['web'] = 'Jste spam, prosím nebuďte spam.';
	}
	
	if(!empty($_check1)){
		$error_messages['check1'] = 'První kontrolní pole ponechte prázdné.';
	}
	
	if($_check2 != 5){
		$error_messages['check2'] = 'Chybně opsaný kontrolní kód.';
	}

Zpracování dat po odeslání, krok 2: Kontrola uživatelských dat

Po prvním bloku kontrol následuje druhý, kde už jenom zkontrolujeme, zda-li jsou vyplněna všechna pole a jestli mají správný formát. Abychom ošetřili samotné tělo zprávy proti dlouhým řetězcům bez mezer, přidáme poslední blok kódu, které rozdělí slova delší než 50 znaků. Pokud je vše v pořádku (proměnná $error_messages nebyla ani jednou naplněna), můžeme provést uložení formuláře a redirect.

	// kontrola uzivatelskych dat
	if(empty($_jmeno)){
		$error_messages['jmeno'] = 'Pole Jméno je povinné.';
	}
	
	if(!preg_match('/^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$/', $_email)){
		$error_messages['email'] = 'Pole E-mail má chybný formát.';
	}

	if(empty($_email)){
		$error_messages['email'] = 'Pole E-mail je povinné.';
	}
	
	if(empty($_text)){
		$error_messages['text'] = 'Pole Vaše zpráva je povinné.';
	}else{
		$text_array  = explode(' ', $_text);
		$text_count  = count($text_array);
		$text_return = NULL;
		
		for($i = 0; $i <= $text_count-1; $i++){
		    $text_array[$i] = wordwrap($text_array[$i], 50, ' ', 1); 
		    $text_return .= $text_array[$i].' '; 
		}
		
		$_text = $text_return;
	}
	
	// uložení dat do DB, odeslání na email + přesměrování
	if(empty($error_messages)){
		$current_url = $_SERVER['REQUEST_URI'];
		$current_url.= (strpos($current_url, '?') === false ? '?sent=1' : '&sent=1');
		
		header('Location: '.$current_url);
		echo '<meta http-equiv="refresh" content="1;url='.$current_url.'" />';
		exit;
	}
} // konec if(isset($_POST['submit']))

Vypsání chyb zpět do formuláře

Jak jste si mohli všimnout v ukázce výchozího HTML, formulář už je na chystaný na zpětný výpis chyb. Pokud bude naplněn některý z klíčů proměnné k tomu určené, na daném místě se vypíše. Pokud bude u některého pole zaznamenáno více chyb, vypíše se vždy jen poslední zaznamenaná: není nutné vypisovat všechny, uživatel formulář odešle a dostane nové chybová hlášení. Když například zapomenu vyplnit e-mail, stačí napsat, že e-mail není vyplněn. Nemusím ještě číst další řádek o tom, že pole neodpovídá regulárnímu výrazu.

Bonus: GEO IP ochrana

Ochrana před přístupy z některých vyjmenovaných zemí je sice věc, která by měla být řešená na úrovni PHP (abychom mohli návštěvníkovi vypsat alespoň hlášení, že je ve špatné lokalitě a celé to mohlo být administrovatelné), ovšem pro malé weby cílené na menší region je tohle vcelku zbytečné. IP adresy některé exotických zemí bývají často využíváné spammery, takže zákazem přístupu z dané země můžeme velice jednoduše přidat další úroveň ochrany. Stačí do souboru .htaccess vložit následující řádky, popřípadě je rozšířit o další domény.

# soubor .htaccess
Deny from .ru # rusko
Deny from .ua # ukrajina
Deny from .cn # cina
Deny from .in # indie
Deny from .sa # saudska arabie

Ukázka

Formulář
Zdrojový kód

Na první pohled se může zdát o složité termíny, ale jejich samotné použití nijak náročné není. Mnohem složitější je správné použití. Nepřidávat dědičnost jen proto, abychom ukázali, že ji umíme, nenaplácat všechna klíčová slova do jedné třídy jenom aby tam byly. To je také hlavní důvod, proč píšu samostatný text, důvod, proč nemohu vše demonstrovat na své databázové třídě.

Skládání objektů

Objekty skládáme ve chvíli, kdy třída A uloží do členské proměnné instanci třídy B a do jejího konstruktoru předá sama sebe. Tímto způsobem to může jít pořád dál, takže v každé třídě aplikace budeme mít přístup k veřejným metodám všech ostatních tříd. Předání objektu neprobíhá přes kopii jako u proměnných, nýbrž přes referenci. Nevzniká X kopií databázové třídy, ale pouze jedna, a jakákoli změna nastavení se projeví ve všech referencích na daný objekt.

Tato definice ale zní strašně krkolomně, takže si ukažme příklad ze života.

Mějme třídu Environment, která vytváří základní prostředí aplikace. V členských proměnných má uložené instance některých tříd, které budou volány napříč celou aplikací. V našem příkladu to bude třída Db (databáze) a třída Debug (s nějakým uživatelským výstupem pro ladění). Třída Env pak vytvoří instanci samotného modulu, který už se bude starat o obsluhu konkrétní části webu. V ukázce je kontroler pro administraci. Ten vytvoří instanci další třídy, která už bude zpracovávat jednotlivé části administračního prostředí: kategorie, články, produkty, formuláře... Třída Db je prázdná, aby nám ukázka neházela fatal error, Debug obsahuje akorát metodu s funkcí print_r() pro ukázku rekurzivního předávání objektů.

Takže pokaždé, kdy postoupíme hlouběji do aplikace, daná třída předá sama sebe dál.

Je samozřejmě důležité, aby všechny parametry obsahující referenci na jiný objekt měly viditelnost public - pokud tedy nechceme přístup explicitně zakázat. Kostra by mohla vypadat například takto:

class Db { }

class Debug {

	public $env;
	
	public function __construct(Environment $env){
		$this->env = $env;
	}
	
	public function printDebug(){
		print_r($this);
	}
}

class Environment {

	public $db;
	public $debug;
	public $module;
	
	public function __construct(){
		$this->db = new Db();
		$this->debug = new Debug($this);
		$this->module = new MasterAdminController($this);
	}
}

class MasterAdminController {

	public $env;
	public $localModule;
	
	public function __construct(Environment $env){
		$this->env = $env;
		
		$this->localModule = new ArticleAdminController($this);
	}
}

class ArticleAdminController {

	public $parentModule;
	
	public function __construct($parent_controller){
		$this->parentModule = $parent_controller;
		
		// pristup k tride DB
		$db = $this->parentModule->env->db; // ->metoda();
	}
}

Nyní si ukážeme, co se stane, když zavoláme následující kód:

$env = new Environment;

echo "<pre>";
print_r($env);
echo "</pre>";

echo "<pre>";
print_r($env->debug->printDebug());
echo "</pre>";

Oba bloky vypíšou skoro to stejné. Klíčové slovíčko *RECURSION* nám potvrdí, že objekty jsou vázány opravdu přes referenci.

Environment Object
(
    [db] => Db Object
        (
        )

    [debug] => Debug Object
        (
            [env] => Environment Object
 *RECURSION*
        )

    [module] => MasterAdminController Object
        (
            [env] => Environment Object
 *RECURSION*
            [localModule] => ArticleAdminController Object
                (
                    [parentModule] => MasterAdminController Object
 *RECURSION*
                )
        )
)

Debug Object
(
    [env] => Environment Object
        (
            [db] => Db Object
                (
                )

            [debug] => Debug Object
 *RECURSION*
            [module] => MasterAdminController Object
                (
                    [env] => Environment Object
 *RECURSION*
                    [localModule] => ArticleAdminController Object
                        (
                            [parentModule] => MasterAdminController Object
 *RECURSION*
                        )
                )
        )
)

Dědičnost

Abychom pochopili, jak správně využít dědičnost, budeme si muset vysvětlit některé pojmy a stejně tak si povědět o základním smyslu dědění tříd. Příklad bych opět demonstroval na kostře projektu, na které jsme si popsali skládání. Přeskočíme třídu prostředí a začneme rovnou moduly. Mějme tedy instanci modulu pro administraci, která pak načítá už konkrétní obsluhy jednotlivých funkčních celků.

Chceme-li spravovat například již zmíněné články, kategorie a produkty, jistá část skriptů bude vždy podobná až stejná. Jiné části se budou lišit, a to konkrétními bloky kódu, které v jiných modulech obsaženy nebudou. A tak si navrhneme jakousi centrální třídu, kterou dané moduly zdědí.

Tím vlastně docílíme stejné logiky každého skriptu. Rodičovská třída bude obsahovat metody a parametry společné pro každý modul, její potomci ji pak vždy rozšíří o metody sobě specifické. Tím nejen ušetříme spoustu řádků kódu, ale také donutíme sami sebe psát ten kód tak říkajíc "slušně". Budeme muset dodržovat předem stanovenou logiku.

Druhý případ využití dědičnosti je už mnohem jednodušší. Máme knihovnu, do které potřebujeme přidat funkčnost. A jelikož knihovny nejsou určeny k tomu, aby se do nich hrabalo, založíme třídu novou, která knihovnu rozšíří. Můžeme vzít databázovou třídu a přidáme funkce pro zasílání chyb na e-mail. Tento způsob se často využívá v situacích, kdy jsou knihovny umístěné v nějakém centrálním úložišti, my je známe, můžeme je includovat ale nemůžeme tyto soubory měnit.

Na následujícím příkladě si ukážeme stav první. Ale zpět k důležitým pojmům. Než se dostanu ke kódu, je potřeba si tyto pojmy vysvětlit.

Viditelnost

PHP nabízí tři úrovně viditelnosti: public, protected a private. Public (veřejný) znamená, že k metodám či atributům třídy můžeme přistupovat z venčí. Protected (chráněný) toto omezí pouze na potomky: k funkci nepůjde přistupovat z venčí, ale pokud třídu zdědíme, ke všemu se dostaneme. Často se říká, že pokud chceme metody respektive atributy využít jen interně, dáme všechno protected. Nejvyšší stupeň utajení, private (soukromý), pak omezí přístup pouze na danou třídu. I když ji zdědíme, k metodám se nedostaneme.

Abstrakce

Klíčové slovo abstract definuje, že třída musí být zděděná. Nelze vytvořit její instance, jakýkoli pokus selže chybou. Pakliže je třída definovaná jako abstraktní, může obsahovat i abstrakní metody. Abstraktní metoda má pouze definici, nemá vlastní tělo funkce. Tím řekneme, že potomek musí danou funkci obsahovat. Jaké bude její tělo už ale neurčujeme. Asi by bylo dobré v daném kontextu i vysvětlit rozdíl mezi rozhraním (interface) a abstraktní třídou.

Rozhraní je šablona vzoru, osnova. Abstraktní třída už může být knihovna nebo modul, musí se ale "dokončit" jejím zděděním a dopsáním prázdných metod.

Klíčové slovo "final"

Naopak klíčové slovíčko final jakoukoli dědičnost zakazuje. Třída už je kompletní a nechce být žádným způsobem rozšiřována.

abstract class AdminController {

	public $parentModule;
	
	protected $path = array();
	
	private $someParam;
	
	final public function __construct($parent_module = null){
		$this->parentModule = $parent_module;
	}
	
	public function loadData($param){
		echo 'load some data';
	}
		
	abstract public function __init();
}

class CategoryAdminController extends AdminController {
	public function __init(){
		// samotne spusteni
	}
	
	public function loadData($param = null){
		parent::loadData($param);
		echo ' and do something';
	}
	
	public function loadAnotherData($param){
		echo 'load another data';
	}
}

$cont = new CategoryAdminController();
$cont->loadData();

Na výše uvedeném příkladu je ukázaná možnost redefinovat metody rodiče v potomkovi, což je přesně ten typ rozšíření, kvůli kterému vůbec chceme něco dědit. Ukázka vypíše přesně toto:

load some data and do something

Na závěr přikládám použitý kód ke stažení, i když si myslím, že zde to ani tolik nutné není.

Odkaz:

dedeni_skladani_sample.zip

Kromě naprosto základních funkcí jako ošetření SQL dotazů proti SQL injection umí i jednoduché logování, export databáze buď do souboru nebo přímo do force downloadu i vlastní obsluhu chyb. Posílání chyb na e-mail zde ale obsažené není: na notifikační e-maily mám třídu další, o které si můžeme povědět v jiném článku. Nesmím také vynechat možnost připojení k více databázím v rámci jednoho projektu: i to class Db zvládne. Tak hurá na rekapitulaci.

Vytvoření instance

Přihlašovací údaje k databázi nastavíme v globálních proměnných. Klíč proměnné config, ve kterém bude třída hledat potřebná data můžeme změnit přímo v parametru konstruktoru; tímto pak můžeme vytvořit připojení k více databázím.

$config['db']['host'] // db server
$config['db']['user'] // uzivatel
$config['db']['pass'] // heslo
$config['db']['name'] // jmeno databaze

$db = new Db;

Nastavení ještě umožňuje zadání tří dalších nepovinných hodnot, které ale najdete až v komentářích ve zdrojové kódu.

Základní metody pro SQL dotazy

// asociativni pole z tabulky, zakladni (pokrocile nastaveni @227)
$query = $db->query("SELECT * FROM ?_tabulka WHERE id = '?' AND category_id = '?'", array($id, $category_id))->assocList();

// insert, vraci mysql_insert_id()
$insert_id = $db->insert('?_categories', array( 
    'name' => $_POST['name'], 
    'text' => $_POST['text'], 
));

// update, zakladni (pokrocile nastaveni @499)
$affected_rows = $db->update('?_categories', $_GET['id'], array( 
    'name' => $_POST['name'], 
    'text' => $_POST['text'], 
)); 
 
// delete, vraci opet mysql_affected_rows();
$deleted_rows = $db->delete('?_articles', array( 
    'parent_id' => 1, 
));

Debug

Jak jsem zmínil v úvodu, knihovna má obsažený i pár debugovacích funkcí pro případné ladění rychlosti SQL dotazů. Umí vypsat počet provedených dotazů + pole s jejich kompletním zněním i časem, jak dlouho který dotaz trval.

// debug
echo "<pre>";
echo "pocet provedenych dotazu: ".$db->numQueries();
print_r($db->getQueries());
echo "</pre>";

Export databáze

V neposlední řadě můžeme provést i export databáze. Buď celé nebo jen konkrétních tabulek či konkrétních částí daných tabulek. Tuto funkci nedoporučuji přidávat dynamicky do aplikace: sám ji používám vždy v podobě samostatného souboru kam kód i podmínky napíšu ručně, takže i vám doporučuji stejnou logiku použití.

// export databaze
$db = new Db; 
//$db->addExportCondition('shop_categories', ''); 
//$db->addExportCondition('shop_products', 'WHERE category_id IN (1,2,3)'); 
$db->dumpAndSave();
//$db->dumpAndDownload();

Odkazy:

Zdrojové kód: class.Db2.phps
ZIP ke stažení: class.Db2.zip

Edit 4. 5. 2020: 
Text se týká PHP 5. Pod PHP 7 už třída fungovat nebude, protože všechny mysql_ funkce skončí chybou.

Nejdřív ale krátká rekapitulace. Soubor článků o objektech v PHP jsem začal psát už poměrně dávno, ještě před pauzou v blogování. Jelikož jsem měl ale na články vcelku pozitivní ohlasy, byla by asi škoda seriál nedokončit, byť opožděně.

V prvním dílu jsme si stanovili cíle a řekli si něco o rozhraní nad třídou. V dílu druhém jsme si ukázali základní metody na dotazy typu select, insert, update a delete, které si dnes připomeneme a upravíme. Třetí díl byl vlastně o skládání objektů, a to ukázka třídy Query, jejíž instanci vracely metody mateřské třídy Db. Poslední, čtvrtý díl byl spíš takový návod jak jednoduše exportovat databázi bez přístupu do PHPMyAdmina; hodně kódu a méně povídání.

Dnešní článek bude podobně stavěný jako ten předchozí. Ukážeme si, jak logovat SQL dotazy, povíme si proč spolu s vysvětlením, u kterých metod má rozšíření o logování smysl a u kterých ne. V seriálu budou následovat ještě 2 další články: slovo závěrem s odkazem na celý zdrojový kód ke stažení a navíc ještě jeden krátký text o dědičnosti. Té jsem se zatím nevěnoval a jelikož se jedná o poměrně důležitou kapitolu v objektově orientovaném programování, zaslouží si článek navíc.

Princip logování a kdy má smysl

Základní princip je poměrně triviální: u každého provedeného dotazu zkopírujeme celé jeho znění do další tabulky. Metoda insert poskládá SQL dotaz dle zadaných parametrů a provede ho vlastně na 2 tabulkách. Metody update a delete pak upraví respektive smažou záznam z databáze spolu se zavoláním dalšího insertu na pozadí do logovací tabulky. U žádných dalších metod pak logování samozřejmě nemá význam.

Samotné logování má smysl v jednom jediném případě, a to v administraci či na jiných místech aplikace, kde mají uživatelé přístup k úpravě dat. Ve výsledku totiž dostaneme takovou jednoduchou historii provedených změn. Chtěl bych zdůraznit, že v žádném případě nepůjde o nějaké revize článků či kategorií, to je samo o sobě neskutečně komplexní funkcionalita, kterou rozhodně neobslouží pár metod v databázové třídě.

Využití v praxi

Pokud si spravujeme vlastní malé stránky jako například nyní já a stane se nám nehoda, kdy si například omylem umažeme kus napsaného textu, v databázi pak snadno dohledáme předchozí provedený update ainformace zachráníme. Pakliže má do administrace přístup více uživatelů, můžeme velice snadno zjistit, kdo kde co rozbil :-) Tento případ se může na první pohled zdát poněkud úsměvný, ale z praxe vím, že k takovýmto situacím dochází dnes a denně... Jako jeden z příkladů mohu uvést editaci uživatelského profilu na e-shopu. Může se stát, že zákazník odešle objednávku, další den si v profilu upraví adresu a pak se bude hádat, že mu objednávka byla odeslána na adresu špatnou. A člověk je pak zbytečně za blbce. Bohužel, i tak to chodí. Takže je fajn mít tyto stavy podchycené.

Struktura tabulek

Dost bylo teorie, přejdeme k samotnému kódu. V databázi bude potřeba založit 2 nové tabulky.

CREATE TABLE `project_log` (
  `id` bigint(20) unsigned  auto_increment,
  `user_id` int(10) default '0',
  `table_name` varchar(64) NOT NULL,
  `method` varchar(16) NOT NULL,
  `insert_id` bigint(20) DEFAULT NULL,
  `whole_query` longtext,
  `timestamp` timestamp  default CURRENT_TIMESTAMP,
  PRIMARY KEY  (`id`),
  KEY (`user_id`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8 ;

CREATE TABLE `project_log_items` (
  `id` bigint(20) unsigned  auto_increment,
  `parent_id` bigint(20) unsigned NOT NULL,
  `col_name` text,
  `col_value` text,
  PRIMARY KEY  (`id`),
  KEY (`parent_id`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8 ; 

První bude obsahovat základní informace o provedeném dotazu: ID uživatele referující na interní tabulku v daném systému, jméno tabulky, kde úprava proběhla, název fukce, která logování zavolala, ID záznamu pro dotazy typu insert, celé znění SQL dotazu a informaci o čase. Do druhé tabulky s referencí na první pak budeme ukládat veškeré údaje sloupec po sloupci. Díky tomu pak budeme mít zpětný přístup k naprosto všem změnám včetně smazaných řádků. Opět bych ale zdůraznil, že se rozhodně nejdená o nějaký archív smazaných položek nebo koš; logovací tabulky jsou primárně určeny pro vkládání a nic jiného. Předpokládáme zde obrovský objem dat, takže jakýkoli výpis záznamů s případným filtrováním by nám docela zavařil dráty.

Rozšíření třídy Db

private $log = false;
private $user = 0;
private $logTable;
private $tableItems;

Ve čtyřech nových proměnných s viditelností private bude uloženo vše potřebné pro logování: ID uživatele, jména tabulek a stav zapnuto / vypnuto.

public function enableLog($user = 0){
	$this->log = true;
	if($user){
		$this->user = $user;
	}
}

public function setLogTable($logTable = null){
	if($logTable){
		$this->logTable = $logTable;
	}
}

public function setLogItemsTable($tableItems = null){
	if($tableItems){
		$this->tableItems = $tableItems;
	}
}

public function disableLog(){
	$this->log = false;
}

Další 4 nové metody typu set budou tyto proměnné nastavovat. Metoda enableLog() bude volána přímo s parametrem ID uživatele, jelikož předpokládáme její zavolání někde uvnitř administračního modulu po přihlášení. Další dvě metody umožní přenastavení výchozích jmen tabulek a nakonec zbývá už jen poslední funkce pro vypnutí. Vypínač bude mít i velice důležitou interní funkci, k tomu ale až za chvíli.

Metoda insert

Základní znění metody insert jsme si ukázali hned v druhém dílu, nyní si ji rozšíříme.

public function insert($table, array $items){
	try {
		if(empty($items)){
			throw new DbException('No values to insert.', var_export($items, true));
		}
		
		$keys = array();
		$vals = array();
		
		foreach ($items as $key => $t){
			if($t === 0 || $t === '0'){
				$vals[$key] = "'0'";
				$keys[]     = "`{$key}`";
			} elseif(!empty($t)){				
				$vals[$key] = "'".$this->escape($t)."'";
				$keys[]     = "`{$key}`";
			}
		}

		$qtable  = $this->replacePrefix($table);
		$final_query     = "INSERT INTO {$qtable} ( ".implode("\n,", $keys)." ) VALUES ( ".implode(",\n ", $vals)." )";
		$final_query_log = "INSERT INTO {$qtable} ( ".implode(",",   $keys)." ) VALUES ( ".implode(", ",   $vals)." ) ;";

		$insertId = $this->query($final_query, array(), false)->insertId();
		
		if($this->log){
			$this->log = false;
			$this->insert($this->logTable, array(
				'user_id'     => $this->user, 
				'table_name'  => $this->replacePrefix($table), 
				'method'      => __FUNCTION__, 
				'insert_id'   => $insertId,
				'whole_query' => $final_query_log,
			));
			$this->log = true;
		}
		
		return $insertId;
	}catch(Exception $e){
		$e->show();
	}
}

Úprava spočívá v bloku začínajícím podmínkou if($this->log). Pokud je tedy logovaní aktivní, nejdříve ho vypneme, uložíme data a pak ho znovu zapneme. Proč to? Funkce totiž volá sama sebe, takže kdybychom tak neučinili, celé by se to zacyklilo a metoda by volala sama sebe pořád dokola do nekonečna. A logovat logování fakt nechceme. Ve funkci insert logujeme až na závěr, abychom už znali mysql_insert_id a mohli uložit referenci na právě vytvořený záznam.

Metoda update

Update bude o jednu úroveň náročnější, protože zde už využijeme i druhé tabulky. Tady naopak zálohujeme záznam v jeho podobě před úpravou. Nejdříve tedy proběhne select na řádek / řádky, jenž cílíme v podmínce updatu, získané údaje uložíme a nakonec až přepíšeme.

public function update($table, $id, array $items, $col = 'id'){
	try {
		if(empty($items)){
			throw new DbException('No values to update.', var_export($items, true));
		}
		if(empty($id)){
			throw new DbException('No id.', var_export($id, true));
		}
		
		$update = array();
		foreach ($items as $key => $item){
			$update[$key] = "`{$key}` = '".$this->escape($item)."'";
		}
		
		$qtable = $this->replacePrefix($table);
		$final_query     = "UPDATE {$qtable} SET ".implode(",\n ", $update)." WHERE `{$col}` = '{$id}'";
		$final_query_log = "UPDATE {$qtable} SET ".implode(" ",    $update)." WHERE `{$col}` = '{$id}' ;";
		
		if($this->log){
			$this->log = false;	
			$_entry = $this->query("SELECT * FROM {$table} WHERE `{$col}` = '{$id}'")->assocList();
			foreach ($_entry as $_row){
				$_log_id = $this->insert($this->logTable, array(
					'user_id'     => $this->user, 
					'table_name'  => $this->replacePrefix($table), 
					'method'      => __FUNCTION__,
					'whole_query' => $final_query_log,
				));
				foreach ($_row as $_key => $_col){
					$this->insert($this->tableItems, array(
						'parent_id' => $_log_id, 
						'col_name'  => $_key, 
						'col_value' => $_col
					));
				}
			}
			$this->log = true;
		}
		
		return $this->query($final_query, array(), false)->affectedRows();
	}catch(Exception $e){
		$e->show();
	}
}

Logování opět nejdříve vypneme před zavoláním patřičných insertů.

Metoda delete

Jak jsem naznačil výše, i při mazání řádků z databáze vlastně provedeme nejdřív jejich zálohu. Chování bude úplně stejné jako u metody insert.

public function delete($table, array $cond){
	try {
		if(empty($cond)){
			throw new DbException('No condition.', var_export($cond, true));
		}
		
		$c = array();
		foreach ($cond as $key => $t){
			$c[] = "`{$key}` = '".$this->escape($t)."'";
		}
		
		$qtable = $this->replacePrefix($table);
		$string = implode(' AND ', $c);
		$final_query     = "DELETE FROM {$qtable} WHERE {$string}";
		$final_query_log = "DELETE FROM {$qtable} WHERE {$string} ;";
		
		if($this->log){
			$this->log = false;
			$_entry = $this->query("SELECT * FROM {$table} WHERE {$string}")->assocList();
			foreach ($_entry as $_row){
				$_log_id = $this->insert($this->logTable, array(
					'user_id'    => $this->user, 
					'table_name' => $this->replacePrefix($table), 
					'method'     => __FUNCTION__,
					'whole_query' => $final_query,
				));
				foreach ($_row as $_key => $_col){
					$this->insert($this->tableItems, array(
						'parent_id' => $_log_id, 
						'col_name'  => $_key, 
						'col_value' => $_col
					));
				}
			}
			$this->log = true;
		}

		return $this->query($final_query, array(), false)->affectedRows();
	}catch(Exception $e){
		$e->show();
	}
}

Závěrem

To by bylo v kostce asi vše. V příštím dílu bych seriál o databázové třídě uzavřel, abych mohl navázat slíbeným článkem o dědičnosti.

Edit 4. 5. 2020: 
Text se týká PHP 5. Pod PHP 7 už třída fungovat nebude, protože všechny mysql_ funkce skončí chybou.

Kostra řešení bude poměrně jednoduchá:

SHOW TABLES

foreach ($tables) {
	SHOW CREATE TABLE
	SELECT * FROM $table
	while (FETCH_ROW) {
		foreach ($row) {
			mysql_real_escape_string($row);					
		}
		$export .= "INSERT INTO $table VALUES implode(, $row)"
	}
}

Nejdříve zjistíme, jaké tabulky exportujeme, následně od každé z nich získáme strukturu přes SHOW CREATE TABLE, vybereme hvězdičku, provedeme escapování a uložíme znění SQL dotazu na insert.

Metody na export databáze budou 2. Budou si podobné, protože v rámci zachování čitelnosti kódu není dobry nápad cpát do už tak velké funkce hromadu podmínek. První metoda uloží celý export do proměnné a nabídne soubor k uložení, druhá bude data postupně ukládat do souboru, který si pak můžeme stáhnout přes FTP klienta.

Před uvedením výsledné funkce si ale nejprve ukážeme pár podpůrných metod, jenž se nám budou hodit. O prováděném exportu chceme samozřejmě mít nějaké zběžné informace, které nám poskytnou následující funkce.

private function prepareBackupInfo(){
	$this->backupInfo['date_pattern'] =  @date('Y-m-d_H.i.s');
	$this->backupInfo['timestamp'] = strtr($this->backupInfo['date_pattern'], array('_' => ' ', '.' => ':'));
	$this->backupInfo['start_time'] = $this->startTime();
	$this->backupInfo['queries'] = 0;
	$this->backupInfo['written'] = 0;
}

private function appendBackupInfo(){
	$output = "";
	$output .= "\n";
	$output .= "--\n";
	$output .= "-- Queries contained: ".$this->backupInfo['queries']."\n";
	$output .= "-- Shots to file: ".$this->backupInfo['written']."\n";
	$output .= "-- Total time: ".$this->stopTime($this->backupInfo['start_time'])."\n";
	$output .= "-- Timestamp start: ".$this->backupInfo['timestamp']."\n";
	$output .= "--\n";
	return $output;
}

Metoda DB::downloadHeaders() zašle potřebné hlavičky pro force download, naproti tomu Db::writeToFile() bude obsluhovat průběžný zápis do souboru. Nakonec uvedu ještě funkci Db::addExportCondition(), kterou využijeme v případě, když budeme chtít exportovat pouze některé tabulky nebo jejich části.

private function downloadHeaders($file_size, $file_type, $file_name){
	header("Pragma: public");
	header("Expires: 0");
	header("Cache-Control: must-revalidate, post-check=0, pre-check=0");
	header("Cache-Control: private", false);
	header("Content-Transfer-Encoding: binary");
	header("Content-Type: ".$file_type);
	header("Content-Length: ".$file_size);
	header("Content-Disposition: attachment; filename=".$file_name);
}

// pouzivano na nekolika mistech v zaloze
// zapis do souboru
// @param string $file_name
// @param string $content
// @return null abych si automaticky vynulloval promennou
public function writeToFile($file_name, $content){
	$file = fopen($file_name, 'a');
	fwrite($file, $content);
	fclose($file);
	return null;
}

public function addExportCondition($table, $where = null){
	$this->exportConditions[$table] = $where; 
}

Nyní už se můžeme pustit do exportu. Funkci uvedu pouze jednu, metodu Db::dumpAndSave() - tu složitější. Tělo pouze kopíruje úvodní vzor, přidaná je podmínka na kontrolu nastavení exportu (konkrétní tabulky a vnitřní podmínky).

public function dumpAndSave(){
	$limit = 5000000;
	
	$this->prepareBackupInfo();
	$file_name = $this->backupFolder.$this->database.'_'.$this->backupInfo['date_pattern'].'.sql';
	
	if($this->backupFolder && !is_dir($this->backupFolder)){
		mkdir($this->backupFolder, '0777');
	}
	
	$_tables = array();
	$_select = $this->query('SHOW TABLES');
	
	while($t = $_select->fetch(FETCH_ROW)){
		$_tables[] = $t[0];
	}
	
	unset($_select);

	$_output = null;
	$_output = "--\n-- Database: `".$this->database."`\n--\n\n-- --------------------------------------------------------\n\n";
	$_output = $this->writeToFile($file_name, $_output);
	
	// zaloha po jedne tabulce
	foreach ($_tables as $value){
		if(!count($this->exportConditions) || (count($this->exportConditions) && isset($this->exportConditions[$value]))){
		
			// show create table
			$_select_ct = $this->query("SHOW CREATE TABLE `{$value}`");
			$_row = $_select_ct->fetch(FETCH_ROW);
			
			// ukladame do souboru show create table
			$_output = null;
			$_output .= "--\n";
			$_output .= "-- `".$_row[0]."`\n";
			$_output .= "--\n\n";
			$_output .= $_row[1]." ;\n\n";
			$_output = $this->writeToFile($file_name, $_output);
			
			unset($_select_ct);
			
			++$this->backupInfo['queries'];

			if(isset($this->exportConditions[$value])){
				$_select = $this->query("SELECT// FROM `{$value}` {$this->exportConditions[$value]}");
			}else{
				$_select = $this->query("SELECT// FROM `{$value}`");
			}
			
			while($t = $_select->fetch(FETCH_ROW)){
				foreach ($t as $k => $i){
					$t[$k] = "'".$this->escape($i)."'";
				}
				
				$_output .= "INSERT INTO `{$value}` VALUES (".implode(',', $t).");\n";
				++$this->backupInfo['queries'];
				
				// co 5 mega, to zapis do souboru a vynulovani promenne. abych neshazoval server
				if(strlen($_output) > $limit){
					$_output = $this->writeToFile($file_name, $_output);
					++$this->backupInfo['written'];
				}
			}
			
			unset($_select);
			
			// pokud tu jsou nejake resty. zbavime se jich. tady uz tech 5 mega fakt testovat nebudu a rovnou to zapisu
			if($_output){
				$_output = $this->writeToFile($file_name, $_output);
				++$this->backupInfo['written'];
			}
		}
	}
	
	$_output .= $this->appendBackupInfo();
	$_output = $this->writeToFile($file_name, $_output);
}

Aplikace metod bude opět naprosto triviální. Zakomentované řádky nastaví, že se exportuje celá tabulka s kategoriemi a tabulka s produkty zařazenými do kategorie 1, 2 nebo 3.

$db = new Db;
// $db->addExportCondition('shop_categories', '');
// $db->addExportCondition('shop_products', 'WHERE category_id IN (1,2,3)');
$db->dumpAndSave();

Znění druhé funkce si většina z vás jistě domyslí. Ostatní si budou muset počkat na zveřejnění zdrojového kódu, které je naplánováno na šestý díl. Příště si povíme něco o logování změn.

Edit 4. 5. 2020: 
Text se týká PHP 5. Pod PHP 7 už třída fungovat nebude, protože všechny mysql_ funkce skončí chybou.

Krátce ještě zopakuji, co vše už máme: jsou to základní metody třídy Db pro volání SQL dotazů: SELECT, UPDATE, INSERT, DELETE. Hodnoty, které nás zajímají při změně či odstranění řádků tabulky už máme přímo v návratových hodnotách jednotlivých metod. Co ale ještě hotové nemáme, je zpracování klasického výběru dat z databáze.

Cíle

Cílem třídy Query bude kompletní obsluha SQL dotazů. Ty, jak už jsem se zmiňoval, se provedou přímo v konstruktoru. Jednotlivé metody pak už budou vracet zpracovaná data: celé řádky i sloupce, jednotlivé řádky či jediný sloupec v jediném řádku. Pokud se jí něco nebude líbit, vyhodí výjimku a dále už se o nic nestará: to bude v pravomoci třídy DbException, které se budu věnovat v pokračování. Seznam členských proměnných napoví základní vlastnosti:

final class Query implements QueryModel {

	// reference na db objekt
	// @var object	 
	private $db;
	
	// obecne nastaveni vsech instanci
	// nahrada titulku	 
	public static $titleReplace = false;

	// nyni uz info o danem SQL dotazu
	// query : string | resource | assocList | num_rows | affected_rows | insert_id
	private $stringQuery;
	private $query;
	private $assocList;
	private $numRows;
	private $affectedRows;
	private $insertId;
}

V konstruktoru pak proběhne funkce mysql_query, která při nezdaru skončí výjimkou. Mějte ovšem na paměti, že návrh nepočítá s vytvářením instancí z jiného zdroje než jsou metody třídy Db. PHP bohužel neumí nadefinovat třídu ve třídě a tím zúžit její viditelnost, čímž pádem je potřeba tato pravidla uvést v dokumentaci.

Konstruktor je opravdu triviální, tam snad nic popisovat nemusím.

public function __construct(Db $db, $query){
	$this->db = $db;
	try {
		$conn = $this->db->getConnection();
		$this->query = @mysql_query($query, $conn);
		$this->stringQuery = $query;
		if(!$this->query){
			throw new DbException(null, $query);
		}
	}catch(Exception $e){
		$e->show();	
	}
}

mysql_num_rows, affected_rows, insert_id

Metody, jenž jsem referoval v předchozím článku zajistí základní operace nad výsledkem dotazu. mysql_affected_rows a insert_id je automaticky vráceno patřičnými metodami třídy Db, pro num_rows ale musíme šáhnout na jednu z metod. Pro úplnost je zde uvedu všechny 3. Každá z nich je ošetřená proti vícenásobnému volání, abychom zbytečně neprováděli již provedené operace. Na testování používám isset ku nullovým parametrům. Míchat sem například boolean hodnoty by bylo špatně.

public function numRows(){
	if(isset($this->numRows)){
		return $this->numRows;
	}else{
		return $this->countNumRows();
	}
}

public function insertId(){
	if(!isset($this->insertId)){
		$this->insertId = mysql_insert_id();
	}
	return $this->insertId;
}

public function affectedRows(){
	if(!isset($this->affectedRows)){
		$this->affectedRows = mysql_affected_rows();
	}
	return $this->affectedRows;
}

Získání řádku, celé tabulky a jedné položky

Abych i zde splnil cíl, který jsem si na začátku nadefinoval, přidám knihovně metody, které mi budou vracet data v přesně takovém formátu, v jakém je požaduji.

mysql_result

mysql_result jakožto výchozí funkce není moc šikovná, protože vrací errory, pokud SQL dotaz nevrátí žádný řádek. To ošetříme:

public function result($col = 0, $field = null) {
	if ($this->numRows()) {
		return mysql_result($this->query, $col, $field);
	} else {
		return false;
	}
}

Jediný řádek

Často prováděná operace, proto ji zakonzervujeme do další metody. Bude vracet buď pole nebo false. Metoda fetch zastoupí všechny čtyři mysql_fetch funkce, s výchozím nastavením na assoc.

public function result($col = 0, $field = null){
	if($this->numRows()){
		return mysql_result($this->query, $col, $field);
	}else{
		return false;
	}
}

public function row($type = FETCH_ASSOC){
	$return = $this->fetch($type);
	return !empty($return) ? $return : false;
}

Asociativní pole z SQL dotazu

Přichází na řadu nejsilnější a nejvyužívanější metoda: selectAssocList. Jejím účelem je jak jinak než převod výsledku dotazu do nějaké slušné podoby. Jednotlivé argumenty pak nahrazují další často prováděné operace, které bychom museli dělat mimo třídu během projíždění pole dalším cyklem.

Mám zde dvě ukázková chování: generování odkazu a přiřazení výchozí hodnoty do prázdného sloupce. V případě, že výsledek obsahuje jak sloupec name tak sloupec title (a je zapnuté nahrazování), doplní se do každé prázdné hodnoty title obsah sloupečku name.

V prvním parametru předáme jméno sloupce, jenž bude sloužit jako klíč. V dalších dvou pak parametry pro generování odkazů. Pokud zavoláme i s posledním parametrem, můžeme slepit více polí dohromady.

// navrat asociativniho pole
// @param string [$key] - sloupec, kt. bude klic
// @param string [$col] - sloupec, kt. bude odkaz
// @param string [$pattern] - pro generovani odkazu, ve tvaru http://www.treba.cz/kategorie/%s/	 	 	 
// @return array
public function assocList($key = null, $col = null, $pattern = null, $array = array()){
	static $checked = null;

	if(isset($this->assocList)){
		return $this->assocList;
	}else{
		$this->assocList = (array)$array;
	}

	while($t = $this->fetch()){
		if(isset($col, $pattern, $t[$col])){
			if(!isset($checked)){
				$checked = (mb_substr_count($pattern, '%s', 'utf-8') == 1);
			}
			if($checked){
				$t['href'] = sprintf($pattern, $t[$col]);
			}
		}

		// je nastaveno automaticke doplnovani titulku ze jmena
		if(self::$titleReplace && array_key_exists('name', $t) && array_key_exists('title', $t)){
			$t['title'] = $t['title'] ? $t['title'] : $t['name'];
		}
		
		if(isset($key, $t[$key])){
			$this->assocList[$t[$key]] = $t;
		}else{
			$this->assocList[] = $t;
		}
	}

	return $this->assocList;
}

Automatizace mysql_free_resultu

V úvodním dílu jsem psal něco o tom, že volání funkce mysql_free_result patří k těm otravným činnostem, kterých bychom se rádi zbavili. Celou věc vyřešíme efektivně: funkci zavoláme prostě z destruktoru, takže kdykoli zanikne proměnná s objektem aktuálního SQL dotazu, provede se automaticky i mysql_free_result.

public function __unset($value = null){
	if($this->query !== false && is_resource($this->query)){
		mysql_free_result($this->query);
	}
	$this->query = false;
}
	 
public function __destruct(){
	$this->__unset();
}

Použití

Nyní už k použití. Jak jsem sliboval, zápis jednotlivých metod bude jednodušší, intuitivnější:

// vygenerování asociativního pole včetně odkazů na kategorie
$query = "SELECT * FROM ?_tabulka WHERE parent_id = '?'";
$array = $db->query($query, array($_GET['id']))->assocList('id', 'seo_url', './kategorie/%s/');

// vygenerování asociativního pole, klíče klasicky od nuly
$array = $db->query("SELECT * FROM ?_tabulka")->assocList();

// mysql_result
$result = $db->query("SELECT id FROM ?_tabulka LIMIT 1")->result();

// vytvoření zdroje + projetí cyklem
$q = $db->query("SELECT * FROM ?_tabulka");
while ($item = $q->fetch()) {
	
}

// získání jediného řádku
$query = "SELECT * FROM ?_categories WHERE seo_url = '?'";
$category = $db->query($query, array($_GET['path']))->row();

Edit 4. 5. 2020: 
Text se týká PHP 5. Pod PHP 7 už třída fungovat nebude, protože všechny mysql_ funkce skončí chybou.