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í

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.

Naším cílem bude již zmiňované omezení otravných operací spolu s maximálním zjednodušení zápisů konkrétních typů dotazů. Nepodstatný výčet členských proměnných přeskočím a přejdu rovnou ke konstruktoru třídy.

Obecné nastavení

Než se vůbec dostaneme k samotné práci s daty, je potřeba nastavit potřebné parametry a provést spojení. U jednotlivých knihoven s oblibou využívám kombinaci nastavení přes globální proměnné a metody typu set. Princip je takový, že nastavení, které je společné pro všechny potencionální instance dané třídy nechám v globální proměnných, naproti tomu specifická nastavení uložím do členských proměnných až po vytvoření instance. V našem případě ale zůstanu pouze u globálních proměnných, a to z důvodu bezpečnosti, jelikož chceme používat výjimky v PHP5 a nechceme riskovat nechtěný výpis hesla k databázi.

Parametrem v tomto případě bude klíč ke globálnímu poli, kde bude veškeré nastavení uloženo. Nastavím všechny 4 potřebné údaje, kódování, prefix tabulek a znění SQL dotazu pro porovnávání.

public function __construct($key = 'db'){
	global $config;
	
	try {
		if(!empty($config[$key]['connected'])){
			throw new DbException('Connection from $config['.$key.'] already exists.');
		}
		
		if(!isset($config[$key]['host'], $config[$key]['user'], $config[$key]['pass'], $config[$key]['name'])){
			throw new DbException('One of global vars $config['.$key.'][host] // user | pass | name is undefined.');
		}
		
		$this->database = $config[$key]['name'];
		
		$this->connection = @mysql_connect($config[$key]['host'], $config[$key]['user'], $config[$key]['pass']);
		if(!$this->connection){
			throw new DbException();
		}
		
		$this->selectedDb = @mysql_select_db($this->database, $this->connection);
		if(!$this->selectedDb){
			throw new DbException();
		}
		
		$this->magicQuotes = (get_magic_quotes_gpc() ? true : false);
		$this->setNames = (!empty($config[$key]['charset']) ? $config[$key]['charset'] : 'SET NAMES utf8');
		$this->prefix = (!empty($config[$key]['prefix']) ? $config[$key]['prefix'] : '');
		
		// pokud tabulka obsahuje jak klic [name] tak klic [title]
		// pokud je title prazdny, priradi se hodnota sloupce name
		// kvuli SEO : name pro <h1> title pro <title> aby mohly byt odlisne
		if(isset($config[$key]['title_replace'])){
			Query::$titleReplace = (bool)$config[$key]['title_replace'];
		}
		
		$this->query($this->setNames);
		
	}catch(Exception $e){
		$e->show();
	}
	
	// reset aby se v nejakem dumpu nahodou neobjevilo heslo k databazi
	$config[$key]['host'] = 'true';
	$config[$key]['user'] = 'true';
	$config[$key]['pass'] = 'true';
	$config[$key]['name'] = 'true';
	$config[$key]['connected'] = true;
}

Od pohledu je asi jasné, co všechno konstruktor řeší. O některých funkcích zde ale vůbec mluvit nebudu, a ušetřený čas raději věnuji podrobnějšímu popisu, proč tohle všechno děláme: automatizace, ušetření práce. Jen ještě připomenu, že řádek, ve kterém se zjišťuje aktuální nastavení magických uvozovek si bere za úkol kompletně se postarat o tuto problematiku. Nás už následně nebude zajímat žádné slashování či escapování.

Dotazy typu SELECT

Právě metoda Db::query() bude zajišťovat veškeré dotazy na databázi. Provede náhradu prefixu tabulek, ošetří veškerý vstup proti MySQL Injection a čistá data pošle třídě Query. Mimo to i změří kolik času SQL dotaz sebral. Automatické ošetření vstupu provedeme pomocí takzvaných placeholderů, které budou ve funkci nahrazeny.

public function query($query, $pholders = null, $replacePrefix = true){
	$time = $this->startTime();
	if($replacePrefix){
		$query = $this->replacePrefix($query);
	}
	
	if(!empty($pholders)){
		$q = explode('?', $query);
		$count = count($pholders);
		$query = '';
		for ($i = 0; $i < $count; $i++){
			$query .= $q[$i].$this->escape($pholders[$i]);
		} 
		$query .= $q[$i];
	}

	$result = new Query($this, $query);
	$this->queries[] = $result.'; '.$this->stopTime($time);
	return $result;
}

Díky tomu dosáhneme naprosto jednoduchého zápisu:

$q = $db->query("SELECT * FROM ?_tabulka WHERE id = '?' AND category_id = '?'", array($id, $category_id));

Nyní k vysvětlení otazníků: ?_ znamená prefix tabulek. Význam začíná mít právě ve chvíli, kdy nemáme možnost vytvoření nové databáze pro projekt na stejném systému. A samotný otazník už je placeholder, obdobně jako například v PDO. Metody startTime(), stopTime() a replacePrefix() doufám popisovat nemusím.

Trojice funkcí pro dotazy typu INSERT, UPDATE a DELETE

Jak napoví nadpis, funkce si budou něčím podobné. V tomto případě totiž už nebudeme psát celé znění dotazu, ale pouze předáme jméno tabulky, pole s daty a případnou podmínku.

Vložení nového řádku

Jak jsem slíbil, tak učiním. Nejjednodušší z nadepsaných funkcí, metoda Db::insert() bere 2 parametry: jméno tabulky + pole s hodnotami a vrací ID vloženého záznamu. Je samozřejmě nutné, aby seděly klíče a jména sloupců vůči tabulce.

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)." )";
		
		$insertId = $this->query($final_query, array(), false)->insertId();
		
		return $insertId;
	}catch(Exception $e){
		$e->show();
	}
}

UPDATE

Nejčastěji prováděná aktualizace záznamu je jeden řádek podmíněný jedním ID. Právě tuto akci si automatizujeme. Výsledek bude obdobná funkce akorát s odlišně vygenerovaným řetězcem.

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}'";
		
		return $this->query($final_query, array(), false)->affectedRows();
	}catch(Exception $e){
		$e->show();
	}
}

DELETE

Mazání přecijen provádíme méně často než vkládání nových řádků a jejich editace, a tak by nám do základu měla stačit metoda, která bude mazat řádek / řádky pouze s porovnáním v podmínce. Metoda vezme dva argumenty: jméno tabulky a pole s podmínkou.

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}";

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

Přínos

Ač se výše uvedené metody mohou zdát na první pohled zbytečně složité, splňují na 100% vše, co od nich očekáváme a navíc zcela správně implementují princip knihovny: složité vnitřní operace s vlastním reportem chyb a jejich jednoduchá aplikace. Po vyladění těchto metod (což už samozřejmě vyladěné mám) nás tělo funkce přestane zajímat a budeme se starat pouze o vstup a návratové hodnoty. A pokud si honem nevzpomeneme, jaké že to argumenty musíme předat, mrkneme na interface.

Pro náročnější dotazy už je samozřejmě třeba volat klasickou metodu Db::query(), ale existují věci, které prostě zobecnit nelze.

Ukázka

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

$db->update('?_categories', $_GET['id'], array(
	'name' => $_POST['name'],
	'text' => $_POST['text'],
));

$deleted = $db->delete('?_articles', array(
	'parent_id' => 1,
));

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.

Sám jsem začínal zprvu jednoduchým podnětem: potřebou monitorovat a sčítat provedené SQL dotazy. Skutečný život se ale následně ukázal mnohem složitější, a tak bylo potřeba napsat pokročilou knihovnu, která toho co nejvíce udělá za mě. Proto nyní otevírám miniseriál tak trochu o objektech a tak trochu o návrhových vzorech.

Zadání

Každý úkol by měl mít své zadání, takže nejdříve si specifikujeme body, které se pokusíme splnit. Úkolem třídy bude komunikace s MySQL databází, podchycení nejčastěji prováděných akcí za pomocí metod, které mám kompletně nahradí mysql_ funkce v jazyce PHP. To vše samozřejmě za využití výhod, které nám objektově orientované programování v PHP5 nabízí.

Jaké jsou tedy cíle?

• Automatizovat otravných, přesto nutných operací.
• Docílení sympatičtějšího zápisu opakovaně volaných funkcí.
• Příprava platformy pro snadné připojení k více databázím. Jedna instance bude rovna jednomu otevřenému spojení.
• Tvorba prostředí pro ladění SQL dotazů.
• A v neposlední řadě se také něco naučit a zlepšit si abstraktní myšlení :o)

Prvotní návrh

Rozhraní, které je vlastně takový to do list, nám definuje všechny veřejné metody, které má výsledná třída obsahovat. Většinu těch soukromých zatím vůbec zmiňovat nebudu, jelikož po jejich implementaci nás stejně přestanou zajímat. V prvním kroku tedy definujeme tři rozhraní, jedno pro každou třídu, která bude ve výsledku existovat.

Rozhraní pro class Db

Kostra databázové třídy napoví, co od ní budeme očekáváme. Jejím úkolem bude mimo jiné uchovávat spojení s databází, ošetřovat veškerý vstup před předáním další třídě a zautomatizovat zdlouhavé psaní dotazů typu INSERT, UPDATE a DELETE. Nakonec ji také rozšíříme o export tabulek.

interface DbModel 
{
	public function __construct($key = 'db');
	
	public function query($query, $pholders = null);
	public function select($query, $pholders = null, $replacePrefix = true);
	public function insert($table, array $items);
	public function update($table, $id, array $items, $col = 'id');
	public function delete($table, array $cond);
	
	public function replacePrefix($string); 
	public function escape($string);
	public function getUniqueColumns($table);
	public function columnExists($table, $col);
	public function tableExists($table);
	
	public function startTime();
	public function stopTime($start, $format = 6);
	
	public function dumpAndSave();
	public function dumpAndDownload();
	public function writeToFile($file_name, $content);
	public function addExportCondition($table, $where = null);
	
	public function getConnection();
	public function getQueries();
	public function numQueries();
	public function getMagicQuotes();
	
	public function setPrefixChar($char = null);
	public function setBackupFolder($folder); 
	
// 	public function enableLog($user_id = 0);
// 	public function setLogTable($logTable = null);
// 	public function setLogItemsTable($tableItems = null);
// 	public function disableLog();
	
	public function __destruct();
}

class Query

Syrové informace, které dostane třída Db budou po zpracování odeslány konstruktoru třídy Query. Půjde o znění SQL dotazu plus samozřejmě referenci instanci Db. Jediný konstruktor bude tedy data vkládat, všechny ostatní metody je budou vracet. Rozhraní opět napoví, jaké chování od objektu vyžadujeme.

interface QueryModel 
{
	public function __construct(Db $db, $query);
	public function assocList($key = null, $col = null, $pattern = null, $array = array());
	public function result($col = 0, $field = null);
	public function row();
	public function numRows();
	public function insertId();
	public function affectedRows();
	public function countNumRows();
	public function fetch($type = FETCH_ASSOC);
	public function __toString();
	public function __unset($value = null);
	public function __destruct();
}

class DbException

Class DbException bude pouze rozšíření třídy Exception o jednu metodu, které se postará o smysluplný výpis informací o vzniklé chybě. Do konstruktoru budeme předávat vlastní chybové hlášení plus znění ztroskotaného SQL dotazu.

interface DbExceptionModel 
{
	public function __construct($msg = null, $errString = null);
	public function show();
}

To by pro úvod zatím stačilo, v pokračování začneme rovnou spojením s databází v metodě Db::__construct a hlavními funkcemi, které využijeme pro výběr, vkládání a mazání dat.

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. 

Jelikož už se se standardními zprávami typu "Fatal error: Call to undefined function..." nespokojíme, je potřeba si rozšířit znalosti o některé funkce a předdefinované třídy, jenž nám ulehčí vývoj aplikací.

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

Chyby, které mohou v aplikaci nastat bych rád rozdělil na 4 skupiny: podrobně se budu věnovat prvním dvěma z nich, o těch dalších dvou třeba v pokračování. Půjde o následující skupiny:

1. Warning, notice, strict
2. Fatal a parse error
3. Database error
4. Exceptions: uměle vyvolané výjimky

Warning, notice, strict

Návod jak si "vytunit" chybová hlášení typu warning a notice je přímo uvedené i v oficiálním manuálu. Co už se ale nedočtete, je, že na fatální a syntaktické chyby je toto řešení krátké. Pokud totiž taková chyba vznikne, běh skriptu se okamžitě ukončí a server rozhodně nemá náladu na volání nějakých námi definovaných funkci.

Zpracování těchto chyb totiž spočívá v deklaraci vlastní funkce, kterou pomocí set_error_handler nastavíme jako primární ovladač chyb. Na co je dále nutné myslet je, že při použití set_error_handler přestane bez výjimky fungovat zavináčový hack. Ač od toho bývá spousta začátečníků odrazována, jedná se o výbornou věc... Tomu se ale dnes věnovat nebudu.

V následující ukázce kódu zpracujeme všechny chyby typu warning, notice, strict a jim podobné. Ukázka předpokládá, že všechna chybová hlášení jsou zapnutá jak přes display_errors, tak přes error_reporting.

function user_error_handler($errno, $errstr, $errfile, $errline, $errcontext) {
	static $type = array(
		E_ERROR => 'Fatal Error',
		E_PARSE => 'Parse Error',
		E_RECOVERABLE_ERROR => 'Recoverable Error',
		E_WARNING => 'Warning',
		E_NOTICE => 'Notice',
		E_CORE_ERROR => 'Core Error',
		E_CORE_WARNING => 'Core Warning',
		E_COMPILE_ERROR => 'Compile Error',
		E_COMPILE_WARNING => 'Compile Warning',
		E_USER_ERROR => 'User Error',
		E_USER_WARNING => 'User Warning',
		E_USER_NOTICE => 'User Notice',
		E_STRICT => 'Runtime Notice',
		E_ALL => 'All',
	);

	/**
	 * ošetření zavináčového hacku
	 * když ho použijeme, ani email nedojde
	 **/
	if (!ini_get('error_reporting')) {
		return true;
	}

	$e = new Exception();
	
	$msg_begin = '<b>' . $type[$errno] . '</b>: <i>' . $errstr . '</i> in ' . $errfile . ':' . $errline . "\n";
	
	$msg_email = $msg_begin . "\nTrace:\n" . $e->getTraceAsString();
	$msg_print = $msg_begin . $e->getTraceAsString();
	
	$notif = user_error_notification(strip_tags($msg_email), $type[$errno]);

	if (!empty($GLOBALS['config']['error']['enable'])) {
		echo '<pre style="background:#fff;color:red;padding:5px;">';
		echo $msg_print . '<br />' . $notif;
		echo '</pre>';
	}
}

set_error_handler('user_error_handler'); 

Všimněte si podmínky uprostřed, která testuje ini_get('error_reporting'). Jedná o ošetření již zmiňovaného zavináčového hacku, aby se  choval stejně jako před tím. Dále je vytvořena instance třídy Exception. Ta se postará o naši kompletní informovanost, co všechno chybě předcházelo.

Před vytištěním znění chyby ještě zavoláme ukázkovou funkci (kterou jsem pro příklad pojmenoval user_error_notification. Ta pošle e-mail, kde a kdy k chybě došlo. Vrátit může například zprávu, zda-li se e-mail povedlo či nepovedlo odeslat.

Ve finále podmiňuji globální proměnnou  $config['error']['enable']. V té je nastavena boolean hodnota, díky které se chyba zobrazí či nezobrazí. To kvůli přechodu z vývojového na ostré prostředí, abychom návštěvníkům zbytečně nezobrazovali nesrozumitelná hlášení. Žádné vypínání error_reporting, ale efektivní řešení, kdy my jakožto vývojáři jsme informovaní o chybě, ale návštěvník nikoli.

Fatal & parse error

Jak jsem již zmiňoval, na tyto chyby je potřeba úplně jiným metrem. Existují dvě krásné direktivy, které pro náš účel použijeme. Půjde o parametry error_prepend_string a error_append_string, které jsou argumenty jak jinak než funkce ini_set. Do každé z nich vložíme část HTML kódu, který vytvoří pěkně nastylovanou stránku. Pomocí JavaScriptu skryjeme skutečné hlášení a uživateli zobrazíme pouze omluvnou zprávu.

E-mailové notifikace také nebudou obtížné: stačí přidat Ajaxový request na skript, který z GET proměnné vytáhne znění chyby a z HTTP_REFERERA url, kde se chyba stala. Použití třídy Exception zde samozřejmě odpadá.

$err_begin_pattern = <<<HTML
<!DOCTYPE html SYSTEM>
<html>
<head>
	<meta http-equiv="content-type" content="text/html; charset=utf8">
	<style type="text/css">
		/* CSS definice */
	</style>
	<title>FATAL ERROR</title>
</head>
<body><div style="clear:both;font-size:0;"></div>
	<h1>FATAL ERROR</h1>
	%MSG%
	<span id="fatal_error">
HTML;

$fatal_error_begin = strtr($err_begin_pattern, array(
	'%MSG%' => $GLOBALS['config']['error']['alt_message']
));

$err_end_pattern = <<<HTML
	</span>
	<span id="request"></span>
	<script type="text/javascript">
	// <![CDATA[
		var httpRequest = null;
		var sendRequest = %SEND%;
		var sendUrl = '%AJAX%';
		/**
		 * zde zavoláme Ajaxem externí skript
		 * znění chyby vytáhneme ze span#fatal_error		 
		 **/
	// ]]>
	</script>
</body>
</html>
HTML;

$fatal_error_end = strtr($err_end_pattern, array(
	'%SEND%' => $GLOBALS['config']['error']['email_send'],
	'%AJAX%' => $GLOBALS['config']['error']['ajax_url'],
));

ini_set('error_prepend_string', $fatal_error_begin);
ini_set('error_append_string', $fatal_error_end);

Jak je vidět ve výše uvedené ukázce, opět využijeme nastavení v globálních proměnných. Tam nastavíme alternativní chybovou hlášku, url, kam se bude posílat request a samotné zapnutí / vypnutí notifikačních e-mailů.

Nakonec to zase tak složité nebylo. Na co je ovšem opravdu nutné myslet, je, ošetření samotného error handleru. V daném skriptů totiž nesmí dojít k sebemenší chybičce. Pokud totiž nastane chyba ve funkci, která se o chyby má starat, dojde k zacyklení a nekonečnému volání sebe sama.