Vegyünk is egy egyszerű példát. Tegyük fel azt, hogy már annyira jók vagyunk, hogy az SQL szerverrel is csak l33t nyelven vagyunk hajlandóak kommunikálni. Persze a mysqld (vagy egyéb tetszőleges daemon) nem ilyen megértő, és folyamatosan panaszkodik, hogy nem ért meg minket. A probléma elsimítása érdekében származtatunk a beépített PDO osztályból egy sajátot:

class L33tPDO extends PDO {
	private static $from = array(
		's3l3ct', 'fr0m', 'wh3r3', 's3t', '1ns3rt', '1nt0', 'upd4t3', '0rd3r', '4sc', 'd3sc', 'l3ft', 'r1ght', '1nn3r', 'j01n'
	);
	private static $to = array(
		'SELECT', 'FROM', 'WHERE', 'SET', 'INSERT', 'INTO', 'UPDATE', 'ORDER', 'ASC', 'DESC', 'LEFT', 'RIGHT', 'INNER', 'JOIN'
	);
	public function query($statement, $type = false, $param1 = false, $param2 = false) {
		$statement = $this->convertStatement($statement);
		
		if ($type && $param1 && $param2) {
			return parent::query($statement, $type, $param1, $param2);
		}
		if ($type && $param1) {
			return parent::query($statement, $type, $param1);
		}
		if ($type) {
			return parent::query($statement, $type);
		}
		
		return parent::query($statement);
	}
	public function prepare($statement, $driver_options = array()) {
		$statement = $this->convertStatement($statement);
		parent::prepare($statement, $driver_options);
	}
	private function convertStatement($statement) {
		return str_ireplace(self::$from, self::$to, $statement);
	}
}

Hogy takarékoskodjunk a hellyel, a kulcsszavak listája nem teljes. Nézzünk is egy példát a használatra:

$conn = new L33tPDO('pgsql:host=localhost port=5432 dbname=test user=test password=test');

$stmt = $conn->query("s3l3ct * fr0m users wh3r3 id > 1 0rd3r by login_name 4sc" );

var_dump($stmt->fetchAll());

Bár a felhozott példa nem igényli, a PDOStatement osztályból is származtathatunk sajátot, csak meg kell mondanunk a saját PDO osztályunknak, hogy az általunk írt PDOStatement-tet adja vissza a megfelelő függvényei. Ehhez bővítsük ki a L33tPDO osztályunkat egy konstruktorral:

function __construct($dsn, $username = null, $password = null, $driver_options = array()) {
	parent::__construct($dsn, $username, $password, $driver_options);
	
	$this->setAttribute(PDO::ATTR_STATEMENT_CLASS, array('L33tPDOStatement', array($this)));
}

És egy hozzá passzoló statement osztály:

class L33tPDOStatement extends PDOStatement {
	private $dbh;
	protected function __construct($dbh) {
		$this -> dbh = $dbh;
	}
}

Ennyit mára. További kellemes kódolást.

Először talán kezdjük az adatbázis táblával, ami roppant egyszerű lesz, mivel nem akartam a dolgot túlbonyolítani, csak egyszerűen kedvet éreztem egy ilyen kis rendszer megvalósításához:

CREATE TABLE `todo` (
	`ID` INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY,
	`description` TEXT NOT NULL,
	`status` ENUM('0', '1') NOT NULL DEFAULT '0'
) ENGINE = MYISAM;

Persze adatok se ártanak bele:

INSERT INTO `todo` (`ID`, `description`, `status`) VALUES
(NULL, 'Lorem ipsum dolor sit amet, consectetuer adipiscing elit.', '0'),
(NULL, 'Suspendisse luctus, sem at pretium interdum, dolor velit pellentesque turpis, eu volutpat velit neque vel nulla.', '0'),
(NULL, 'Praesent ligula dolor, vehicula sed, facilisis ac, gravida et, elit. Morbi id urna.', '0');

Aztán a HTML-PHP vonallal folytattam a munkát, a következő pár soros kód legenerálja nekünk a listát (aki esetleg nem mozog annyira otthonosan a PDO világában, annak tudom ajánlani egy régebbi bevezető jellegű írásomat):

print '<div id="error">&nbsp;</div>';
print '<ul id="todo">';
$db = new PDO('mysql:host=localhost;dbname=database', 'user', 'password');
foreach ($db->query("SELECT * FROM `todo`") as $row) {
	print '<li id="task-'.$row['ID'].'"'.($row['status'] === '1' ? ' class="done"' : ' class="not-done"').'>'.htmlspecialchars($row['description']).'</li>';
}
$db = NULL;
print '</ul>';

Ez után már tényleg nincs is más hátra, mint a Prototype segítségével megírni a szükséges JavaScript kódot. Először is az oldal betöltődése után az összes listatagnak elkezdjük figyelni a click eseményét:

Event.observe(window, 'load', function(e) {
	var todos = $('todo').getElementsByTagName('li');

	for (var i = 0; i < todos.length; ++i) {
		Event.observe(todos[i], 'click', listElementClick);
	}
});

Miután ez megvan, már nincs más dolgunk, mint a listElementClick nevezetű függvény, ami annyit tesz, hogy az adott ID-jű feladat státuszát az adatbázisban megváltoztatja, majd siker esetén a listaelem stílusát az új státuszhoz igazítja (ha 'done' volt akkor 'not-done' lesz, ha 'not-done' volt, akkor pedig 'done').

function listElementClick(e) {
	$('error').innerHTML = ' ';

	var t;
	if (e.srcElement) t = e.srcElement;
	else t = e.target;

	var tmp = t.id.split('-');
	var ID = tmp[1];
	var status = 0;

	if (t.className == 'not-done') status = 1;
	else status = 0;

	/* ... */
}

Nos, ezzel így még nem sok mindent csináltunk, csak előkészítettük a terepet a /* ... */ helyére kerülő Ajax kérésnek, ami pedig a következő lesz:

var req = new Ajax.Request(
	'process.php',
	{
		method     : 'post',
		parameters : 'ID='+ID+'&status='+status,
		onComplete : function(req) {
			var response_status = req.responseText.split(',');

			if (response_status[0] == '1') {
				$('task-'+response_status[1]).className = response_status[2];
			}
			else {
				$('error').innerHTML = 'Nem sikerült módosítani a tennivaló státuszát!';
			}
		}
	}
);

Már csak a process.php tartalma van hátra, ami tulajdonképpen elvégzi a szükséges adatbázis műveleteket és visszatér egy [módosítás státusza],[feladat ID-je],[új css osztály neve] formátumú listával.

header('Content-Type: text/plain');

if (isset($_POST['ID']) && isset($_POST['status'])) {
	try {
		$db = new PDO('mysql:host=localhost;dbname=database', 'user', 'password');
		$db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

		$db->query("UPDATE `todo` SET `status`='".(int)$_POST['status']."' WHERE `ID`='".(int)$_POST['ID']."'");

		echo '1,'.$_POST['ID'].','.($_POST['status'] === '1' ? 'done' : 'not-done');
	}
	catch (PDOException $e) {
		echo '0';
	}
}
else {
	echo '0';
}

És ha minden kis darabkát sikerült a megfelelő helyre illesztenünk, akkor az oldalt betöltve kattintgathatjuk is a feladatokat, ami nagyszerűen látszik is, ha megfelelő CSS-t is csatolunk a dokumentumunkhoz. Valami ilyesmi egyszerű meg is teszi:

#todo li {
	cursor: pointer;
}
.done {
	color: gray;
	text-decoration: line-through;
}
.not-done {
	color: black;
	text-decoration: none;
}
#error {
	font-size: 14px;
	color: red;
	font-weight: bold;
}

Ezzel meg is volnánk. Mint azt az elején is említettem, nem bonyolítottam túl a dolgokat semmiféle extrával. A működő példa megtekinthető itt.

A PDO nem más mint egy objektum az adatbázis kapcsolatok, lekérdezések, stb. kényelmes, hatékony, átlátható kezelésére. No de lássunk egy "ilyen volt, ilyen lett" példát, csak a mondani valóm nyomatékosítása érdekében (aztán majd rátérünk a PDO mélyrehatóbb elemzésére):

$conn = mysql_connect('localhost', 'user', 'password');
mysql_select_db('database', $conn);

$query = mysql_query(" SELECT * FROM `table` ", $conn);
while ($row = mysql_fetch_assoc($query)) {
    print_r($row);
}
mysql_close($conn);

Nézzük csak, mi lett belőle:

$db = new PDO('mysql:host=localhost;dbname=database', 'user', 'password');
foreach ($db->query(" SELECT * FROM `table` ") as $row) {
    print_r($row);
}
$db = NULL;

Ízlés kérdése, de nekem az utóbbi jobban tetszik. Talán érdemes lenne az osztályok szerkezetének a vizsgálatával folytatni a dolgokat. A rendszer három osztályból áll, amik a PDO, PDOStatement és a PDOException. Az első fontosabb függvényei a query, prepare, exec, beginTransaction, commit. Míg a másodiké (természetesen mindkét esetben a teljesség igénye nélkül) a fetch, fetchAll, rowCount, bindParam, execute. A harmadik osztály (a nevéből talán nem nehéz rájönni) a kivételkezelést hivatott elősegíteni. Amint az sejthető, a dolog például úgy működik, hogy a PDO osztály query függvénye visszaad egy PDOStatement típusú érétket, aminek függvényeivel megkaphatjuk a kívánt sorokat vagy dob egy PDOException típusú kivételt.

Tranzakciók

Aki annak idejé olvasta Polaa PostgreSQL bejegyzés-sorozatát, annak nem lehet annyira ismeretlen ez a fogalom. A dolog lényege dióhéjban annyi, hogy egy blokkban vagy mindegyik SQL utasítás végrehajtódik, vagy pedig egyik sem. Eléggé szemléletes a mindenhol felhozott banki átutalásos példa, ahol az egyik lekérdezés leveszi "A" ügyfél számlájáról a pénzt, a második pedig rárakja "B" számlájára. Ez esetben azt szeretnénk, hogy ha nem sikerül az első lépés, akkor a második se hajtódjon végre. Nézzünk kódot, mert az érdekesebb:

try {
    $db = new PDO('mysql:host=localhost;dbname=database', 'user', 'password');
    $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

    $db->beginTransaction();
    $db->exec(" UPDATE `accounts` SET `account_value`=`account_value`-100 WHERE `account_id`='1' ");
    $db->exec(" UPDATE `accounts` SET `account_value`=`account_value`+100 WHERE `account_id`='2' ");
    $db->commit();
} catch (PDOException $e) {
    $db->rollBack();
}

setAttribute

Az adatbázis kezelő objektum tulajdonságait tudjuk vele beállítani különböző, a PDO objektumban tárolt konstansokkal. Ez esetben az lett beállítva, hogy - az alapértelmezettől eltérően - kivételt dobjon hiba esetén.

beginTransaction

Jelzi, a tranzakció kezdetét.

commit

A tranzakció lefuttatása.

rollBack

A tranzakció visszavonása.

Előkészített lekérdezések

Ez egy tipikusan olyan dolog volt, amit annak idején hiányoltam MySQL-ben és, ami miatt sikerült elég gyorsan megkedvelnem a PostgreSQL-t. A dolog már a neve alapján is teljesen egyértelmű, de a kód is önmagáért fog beszélni, tehát csapjunk is a lecsóba:

$db = new PDO('pgsql:host=localhost;dbname=database;user=user;password=password');
$pre = $db->prepare(' INSERT INTO "attrs" ("id", "name") VALUES (:id, :name) ');
$pre->execute(array(':id' => '1', ':name' => '12'));
$pre->execute(array(':id' => '2', ':name' => '43'));

A PDO prepare részének az is a nagy előnye, hogy elég sokféleképpen használható. Itt van például egy másik megoldás is, ahol a kérdőjelek sorrendben cserélődnek le a tömb egyes elemeire, ugyanazt elérve mint az előző kódblokkban (az adatbázis kapcsolatot elhagytam):

$pre = $db->prepare(' INSERT INTO "attrs" ("id", "name") VALUES (?, ?) ');
$pre->execute(array('1', '12'));
$pre->execute(array('2', '43'));

Jöjjön még egy megoldás két variációja, ami mégjobban leegyszerüsíti az előkészített lekérdezések használatát (a végeredmény ugyanaz, mint az előző esetekben).

$pre = $db->prepare(' INSERT INTO "attrs" ("id", "name") VALUES (:id, :value) ');
$pre->bindParam(':id', $id);
$pre->bindParam(':value', $value);

$id = '1';
$value= '12';
$pre->execute();
$id = '2';
$value= '43';
$pre->execute();

Vagy a másik megoldás (ismét kérdőjeleket használva a beillesztések helyeinek meghatározására):

$pre = $db->prepare(' INSERT INTO "attrs" ("id", "name") VALUES (?, ?) ');
$pre->bindParam(1, $id);
$pre->bindParam(2, $value);

$id = '1';
$value = '12';
$pre->execute();
$id = '2';
$value = '43';
$pre->execute();

Azt hiszem ennyi lenne a kis ismertető a PDO kiterjesztéssel kapcsolatban. Kedvcsinálásnak talán megteszi, mindenesetre mégegyszer megjegyezném, hogy az igazi ereje a dolognak abban rejlik (azon felül, hogy a kódot átláthatóbbá teszi, aminek az erejét sosem szabad lebecsülni), hogy akár egy sor átírása elég lehet ahhoz, hogy egy rendszert például MySQL alapúról PostgreSQL alapúvá tegyünk.