Biblioteka PDO
Jeszcze rok temu programiści pragnący komunikować się z bazą danych poprzez PHP musieli zmagać się z wieloma problemami. Każdy serwer DB udostępniał inne API do komunikacji, które zostały na nasze nieszczęście wiernie odtworzone w interpreterze. Jeżeli ktoś chciał napisać elastyczny projekt do uruchamiania na kilku bazach, musiał pisać samodzielnie odpowiednie nakładki, które wybiorą odpowiednią funkcję w zależności od tego, czym się łączymy. Pozostawały też różne gotowe skrypty robiące to zadanie za nas.
PDO to skrót od PHP Data Objects. Jest to zupełnie nowy interfejs języka PHP przeznaczony do komunikacji z bazami danych, po raz pierwszy napisany wyłącznie w OOP. Jego najważniejszą zaletą jest to, że możemy za jego pomocą łączyć się zarówno z bazą danych MySQL, jak i z bazą danych PosgreSQL (o innych systemach DB nie wspominając), nie zmieniając ani linijki kodu. Wersji beta PDO można było używać już w PHP 5.0, natomiast stabilna wersja pojawiła się wraz z PHP 5.1. Gorąco zachęcamy do jego stosowania, gdyż nie tylko jest wygodniejszy od starych rozwiązań, ale też szybszy i bezpieczniejszy - do tego zagadnienia niedługo wrócimy.
Nawiązywanie połączenia
Aby nie być gołosłownym, przejdźmy od słów do czynów. Połączymy się z naszą bazą utworzoną podczas wcześniejszych lekcji:
<?php
try
{
$pdo = new PDO('mysql:host=localhost;dbname=produkty', 'root', 'root');
echo 'Połączenie nawiązane!';
}
catch(PDOException $e)
{
echo 'Połączenie nie mogło zostać utworzone: ' . $e->getMessage();
}
?>
Nawiązywanie połączenia polega po prostu na utworzeniu obiektu klasy PDO. Jako parametry startowe podajemy:
- DSN - specjalny ciąg znaków identyfikujący rodzaj serwera DB (np. mysql), host na jakim jest ona uruchomiona (dla nas localhost) oraz nazwę bazy, z którą chcemy się połączyć. Opcjonalnie można dodać także parametr port. Inne serwery DB mogą wymagać innych parametrów połączeń; po szczegóły odsyłamy do dokumentacji PHP.
- nazwa użytkownika
- hasło użytkownika
Host, nazwę użytkownika i hasło powinieneś dostać od swojego hostingu, kiedy będziesz chciał umieścić swoją stronę. Jeżeli podczas nawiązywania połączenia wystąpi błąd, zostanie on zgłoszony jako wyjątek PDOException, który musimy przechwycić (to ważne - jeśli wyjątek nie zostanie przechwycony, domyślny komunikat o błędzie wygenerowany przez PHP ujawni nazwę użytkownika i hasło!).
Pobieranie danych
Pobieranie danych w sterownikach baz danych realizuje się w następujący sposób: najpierw wysyłamy zapytanie i uzyskujemy od serwera zbiór wyników. Przelatując po nim pętlą, otrzymujemy kolejne rekordy w postaci tablic. W bibliotece PDO zbiorem wyniku jest obiekt klasy PDOStatement. Naraz możemy mieć otwarty tylko jeden zbiór wyników. Zabezpiecza to przed próbami tworzenia zapytań rekurencyjnych oraz wynika ze specyfiki pracy bibliotek komunikujących się z serwerem. W starszych bibliotekach ograniczenia takiego nie było dzięki emulacji, która jednak zmniejszała wydajność. Przyjrzyjmy się, jak możemy pobrać zawartość tabeli produkty:
<?php
try
{
$pdo = new PDO('mysql:host=localhost;dbname=produkty', 'root', 'root');
$pdo -> setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$stmt = $pdo -> query('SELECT id, nazwa, opis FROM produkty');
echo '<ul>';
foreach($stmt as $row)
{
echo '<li>'.$row['nazwa'].': '.$row['opis'].'</li>';
}
$stmt -> closeCursor();
echo '</ul>';
}
catch(PDOException $e)
{
echo 'Połączenie nie mogło zostać utworzone: ' . $e->getMessage();
}
?>
Metoda query() zwraca obiekt zbioru wyników odpowiadający wykonanemu zapytaniu (zauważ, że w tym przypadku nie kończymy go średnikiem!). Jedną z technik uzyskania kolejnych rekordów jest przepuszczenie tego obiektu przez pętlę foreach. Kolejne rekordy zostaną zapisane do tablicy asocjacyjnej $row, z której możemy pobrać wyniki. Po zakończeniu pobierania niezbędne jest zamknięcie zbioru wyników poleceniem closeCursor() - inaczej nie będziemy w stanie wysłać następnego zapytania.
Zauważ, że zaraz po połączeniu się z bazą danych korzystamy z metody setAttribute(). Pozwala ona skonfigurować niektóre aspekty pracy z biblioteką PDO - w tym przypadku żądamy, aby ewentualne błędy w zapytaniach raportowane były jako wyjątki.
Powyższy przykład można zapisać także w inny sposób:
<?php
try
{
$pdo = new PDO('mysql:host=localhost;dbname=produkty', 'root', 'root');
$pdo -> setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$stmt = $pdo -> query('SELECT id, nazwa, opis FROM produkty');
echo '<ul>';
while($row = $stmt -> fetch())
{
echo '<li>'.$row['nazwa'].': '.$row['opis'].'</li>';
}
$stmt -> closeCursor();
echo '</ul>';
}
catch(PDOException $e)
{
echo 'Połączenie nie mogło zostać utworzone: ' . $e->getMessage();
}
?>
W tym wypadku wykorzystaliśmy pętlę while i jawnie zażądaliśmy zwrócenia rekordu metodą fetch(). Jest ona, wbrew pozorom bardzo użyteczna - można ją wywołać wszędzie, np. w instrukcji if (sytuacja, gdy zawsze pobieramy jeden rekord), a także ustawić tryb pobierania.
Uwaga! PHP Data Objects ma czasem problemy z działaniem z MySQL 4.1. Aby uniknąć problemów na tej wersji (sporo firm hostingowych wciąż ją oferuje), musisz pamiętać o tym, aby po zamknięciu zbioru wyników metodą closeCursor() dodatkowo ręcznie skasować obiekt $stmt:
unset($stmt);
Inaczej próba przypisania do niej nowego zbioru wyników spowoduje wygenerowanie przez MySQL komunikatu General Error 2050.
Aktualizacja danych
Zapytania typu INSERT czy UPDATE służące do modyfikacji zawartości bazy lub inne, niezwracające zbioru wyników, wysyła się za pomocą metody exec(). Wynikiem jej działania jest liczba określająca ilość zmodyfikowanych rekordów. W poniższym przykładzie zakodujemy dodawanie pewnego konkretnego produktu do naszej listy produktów:
<?php
try
{
$pdo = new PDO('mysql:host=localhost;dbname=produkty;port=3305', 'root', 'root');
$pdo -> setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$ilosc = $pdo -> exec('INSERT INTO `produkty` (`nazwa`, `opis`, `ilosc`, `cena`, `jakosc`) VALUES(
\'Miotacz ognia na dezodorant\',
\'Rewelacyjny miotacz ognia dla kazdej domowej gospodyni!
Nie martw sie o paliwo - wystarczy zwykly dezodorant!\',
\'54\',
\'40.99\',
\'5\')');
if($ilosc > 0)
{
echo 'Dodano: '.$ilosc.' rekordow';
}
else
{
echo 'Wystąpił błąd podczas dodawania rekordów!';
}
}
catch(PDOException $e)
{
echo 'Wystąpił błąd biblioteki PDO: ' . $e->getMessage();
}
?>
Podpinanie
Rzadko kiedy zdarza się, aby wszystkie informacje potrzebne do zmodyfikowania bazy były na sztywno zakodowane w zapytaniu tak, jak to zrobiliśmy w powyższym przykładzie. W codziennej praktyce modyfikujemy dane za pomocą formularzy, ikonek podpowiadających, co trzeba zmienić i jak. Rozwiązanie jest pozornie banalne: składamy zapytanie z predefiniowanych części, którymi opakowujemy dane z formularza, a później wysyłamy ten miks do bazy. Ilustruje to kolejny przykład, który udostępnia prosty formularz do dodawania nowych produktów:
<?php
try
{
if($_SERVER['REQUEST_METHOD'] == 'POST')
{
$pdo = new PDO('mysql:host=localhost;dbname=produkty;port=3305', 'root', 'root');
$ilosc = $pdo -> exec('INSERT INTO `produkty` (`nazwa`, `opis`, `ilosc`, `cena`, `jakosc`) VALUES(
\''.$_POST['nazwa'].'\',
\''.$_POST['opis'].'\',
\''.$_POST['ilosc'].'\',
\''.$_POST['cena'].'\',
\''.$_POST['jakosc'].'\')');
if($ilosc > 0)
{
echo 'Dodano: '.$ilosc.' rekordow';
}
else
{
echo 'Wystąpił błąd podczas dodawania rekordów!';
}
}
else
{
?>
<form method="post" action="pdo_5.php">
<p>Nazwa: <input type="text" name="nazwa"/></p>
<p>Opis: <input type="text" name="opis"/></p>
<p>Ilosc: <input type="text" name="ilosc"/></p>
<p>Cena: <input type="text" name="cena"/></p>
<p>Jakosc: <select name="jakosc">
<option value="1">1</option>
<option value="2">2</option>
<option value="3">3</option>
<option value="4">4</option>
<option value="5">5</option>
<option value="6">6</option>
</select></p>
<p><input type="submit" value="Dodaj"/></p>
</form>
<?php
}
}
catch(PDOException $e)
{
echo 'Wystapil blad biblioteki PDO: ' . $e->getMessage();
}
?>
Kiedy został nadesłany formularz (metoda POST), nawiązywane jest połączenie z bazą. W szkielet zapytania wstawiamy wprowadzone przez użytkownika dane, wykorzystując zwyczajny operator łączenia ciągów. Później metoda exec() umieszcza nam nowy rekord w bazie. Na pierwszy rzut oka wszystko wygląda wspaniale - mamy formularz, redaktorzy mogą dodawać produkty, a internauci je oglądać. Lecz pewnego dnia jeden z redaktorów zgłasza problem: nie może wpisać do opisu produktu apostrofy, gdyż skrypt generuje wtedy jakieś tajemnicze błędy. Co jest grane? Testujemy kopię skryptu na lokalnym komputerze i działa, ale na właściwym serwerze WWW już nie. Przyczyną problemu jest złamanie dwóch podstawowych zasad obsługi formularzy:
- Nigdy nie ufaj danym zewnętrznym
- Nigdy nie ufaj magic quotes
Efekt jest taki, że stworzyliśmy aplikację podatną na włamania typu SQL Injection, które polegają na wykorzystaniu dziur w kontroli danych z formularzy. Zauważ, jak bezbronny jest nasz formularz: baza danych wymaga, aby ilość była liczbą. Gdzie to sprawdzamy w skrypcie? Nigdzie. Gdy jakiś inteligent wpisze nam zamiast ilości "miecio jest niepoważny", skrypt beztrosko umieści to w zapytaniu nie patrząc na sens tego, co robi. Co więcej, zwróć uwagę na pewną rzecz: w języku SQL znak apostrofu jest czymś więcej, niż tylko znakiem - kończy on lub zaczyna sekwencję ciągu tekstowego. Dlatego wprowadzając jakikolwiek tekst, który ma zawierać apostrofy, musimy poddać je zabiegowi escapingu, czyli mówiąc po polsku - poprzedzić znakiem backslash, aby MySQL wiedział, że są one integralną częścią tekstu i nie kończą wprowadzanej sekwencji. Kiedy PHP był jeszcze niewielkim projektem, ktoś wpadł na pomysł wspomożenia programistów i wymyślił tzw. magic quotes. Opcja ta, jeżeli jest włączona, powoduje, że we wszystkich danych z tablic $_GET, $_POST oraz $_COOKIE apostrofy są automatycznie poprzedzane backslashem, dzięki czemu nie trzeba się tym zajmować samodzielnie. Brzmi ciekawie? Niezupełnie! Zwróćmy uwagę, że nie tylko baza danych może służyć do przechowywania informacji. Niektóre z nich ktoś zechce umieścić w pliku i wtedy z kolei musi się sam tych niepotrzebnych backslashów pozbywać. Kolejną kontrowersyjną rzeczą dotyczącą magic quotes jest fakt, że nie wszystkie serwery miały tę opcję włączoną, tak samo nie wszyscy programiści wiedzieli, że coś takiego w ogóle istnieje. Czy widziałeś w sieci serwisy, gdzie apostrofy w artykułach poprzedzane były setkami backslashów? To właśnie efekt tego - programista miał u siebie w domu wyłączoną opcję magic quotes, więc ręcznie dodawał sobie backslashe przy danych umieszczanych w zapytaniach SQL. Później wrzucił skrypt na serwer, gdzie magic quotes dla odmiany było włączone, przez co backslashe doklejane były dwa razy - jeden z nich faktycznie escape'ował apostrofy, ale drugi był uznawany przez MySQL za integralną część tekstu. Z drugiej strony, jeśli ktoś miał w domu serwer lokalny z włączonymi magicznymi apostrofami, a później wrzucił swoja stronę WWW na serwer bez nich, stawał się łatwym celem dla hackerów, którzy bez trudu mogą włamać się atakiem SQL Injection. Atak ten polega na tym, że skoro apostrof nie jest escape'owany, to jego wprowadzenie tak naprawdę powoduje, że dalsza część ciągu jest uznawana za fragment zapytania! Możemy więc sobie zupełnie legalnie dopisać własne warunki. Wyobraźmy sobie teraz, że ktoś manipuluje w ten sposób zapytaniami związanymi z bezpieczeństwem za pomocą formularza logowania. To nie fikcja: do wyobraźni powinien przemówić film (j. ang).
Ostatecznie sami twórcy PHP doszli do wniosku, że magic quotes jest rozwiązaniem bezsensownym. W tworzonym właśnie PHP 6 tej opcji już nie ma i należy samodzielnie escape'ować wszystkie dane. Jednak póki co pracujemy na PHP 5.1 - choć w tym podręczniku podczas instalacji zalecaliśmy wyłączenie magic quotes, nie mamy pewności, że serwer docelowy dla naszych stron WWW posiada identyczne ustawienia. Jeśli korzystamy z PDO i mechanizmu podpinania, problem nas nie dotyczy, ponieważ biblioteka automatycznie dostosuje się wtedy do ustawień, lecz w każdym innym przypadku powinniśmy zastosować specjalny filtr, który zniweluje nam efekt niewłaściwych ustawień i nada danym pożądaną przez nasz skrypt postać.
<?php
if(version_compare(phpversion(), '6.0.0-dev', '<'))
{
// Dla PHP 5 i wcześniejszych wyłączmy magic quotes
function removeSlashes(&$value){
if(is_array($value))
{
return array_map('removeSlashes', $value);
}
else
{
return stripslashes($value);
}
} // end rmGpc();
set_magic_quotes_runtime(0);
if(get_magic_quotes_gpc())
{
$_POST = array_map('removeSlashes', $_POST);
$_GET = array_map('removeSlashes', $_GET);
$_COOKIE = array_map('removeSlashes', $_COOKIE);
}
}
?>
Przejdźmy teraz do właściwego tematu niniejszej sekcji. Skoro magic quotes jest wyłączone, rozsądek podpowiada, że dane musimy sami escape'ować. W starych rozszerzeniach do komunikacji z bazą danych służyły do tego specjalne funkcje udostępniane przez sterownik, przez które musieliśmy przepuścić wszystkie dane - nadal jednak konieczne było samodzielne spajanie tego z zapytaniem. PDO promuje filozofię przeniesienia tego zadania na bazę danych, co udostępniają najnowsze biblioteki komunikacji z serwerami DB. W języku polskim proces ten doczekał się niezbyt szczęśliwej nazwy bindowanie od angielskiego określenia data binding, jednak w tym podręczniku będziemy konsekwentnie stosować termin podpinanie, naszym zdaniem znacznie lepiej oddający jego charakter.
Podpinanie polega na przeniesieniu spajania danych z zapytaniem z języka programowania na serwer DB. Do bazy wysyłamy tutaj tak naprawdę szkielet zapytania ze specjalnymi wstawkami, do których później podpinamy interesujące nas dane za pomocą specjalnej metody, gdzie możemy dodatkowo określić ich typ (tekst, liczba itd.). Zobaczmy, jak wygląda podany na początku przykład przepisany z wykorzystaniem podpinania:
<?php
try
{
if($_SERVER['REQUEST_METHOD'] == 'POST')
{
$pdo = new PDO('mysql:host=localhost;dbname=produkty;port=3305', 'root', 'root');
$pdo -> setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$stmt = $pdo -> prepare('INSERT INTO `produkty` (`nazwa`, `opis`, `ilosc`, `cena`, `jakosc`) VALUES(
:nazwa,
:opis,
:ilosc,
:cena,
:jakosc)'); // 1
$stmt -> bindValue(':nazwa', $_POST['nazwa'], PDO::PARAM_STR); // 2
$stmt -> bindValue(':opis', $_POST['opis'], PDO::PARAM_STR);
$stmt -> bindValue(':ilosc', $_POST['ilosc'], PDO::PARAM_INT);
$stmt -> bindValue(':cena', (float)$_POST['cena'], PDO::PARAM_STR);
$stmt -> bindValue(':jakosc', $_POST['jakosc'], PDO::PARAM_INT);
$ilosc = $stmt -> execute(); // 3
if($ilosc > 0)
{
echo 'Dodano: '.$ilosc.' rekordow';
}
else
{
echo 'Wystapil blad podczas dodawania rekordow!';
}
}
else
{
?>
<form method="post" action="pdo_6.php">
<p>Nazwa: <input type="text" name="nazwa"/></p>
<p>Opis: <input type="text" name="opis"/></p>
<p>Ilosc: <input type="text" name="ilosc"/></p>
<p>Cena: <input type="text" name="cena"/></p>
<p>Jakosc: <select name="jakosc">
<option value="1">1</option>
<option value="2">2</option>
<option value="3">3</option>
<option value="4">4</option>
<option value="5">5</option>
<option value="6">6</option>
</select></p>
<p><input type="submit" value="Dodaj"/></p>
</form>
<?php
}
}
catch(PDOException $e)
{
echo 'Wystapil blad biblioteki PDO: ' . $e->getMessage();
}
?>
Opis:
- Na początek wysyłamy do bazy danych szkielet zapytania, wykorzystując metodę prepare(). Zamiast danych, umieszczamy w ich miejscu wstawki, np. :nazwa, :opis. Jako rezultat otrzymujemy obiekt klasy PDOStatement, który wykorzystamy do podpięcia danych.
- Tutaj podpinamy dane z formularza pod konkretne wstawki metodą bindValue() obiektu PDOStatement. Określamy także ich typ: stała PDO::PARAM_STR określa podpinanie danych tekstowych, PDO::PARAM_INT - liczb całkowitych.
- Właściwe wykonanie zapytania metodą execute().
Podpinanie jest odporne na ataki SQL Injection. MySQL ma jasno określone, co jest danymi, a co zapytaniem i ściśle się tego trzyma. Ponadto jest także wydajniejsze, niż samodzielne spinanie wszystkiego po stronie PHP.
Szczególnie ciekawa właściwość podpinania polega na możliwości podpięcia kilku zestawów danych do tego samego szkieletu zapytania, dzięki czemu wydajność wzrasta jeszcze bardziej. Zademonstruje to poniższy przykład, w którym rozszerzyliśmy nasz formularz tak, aby naraz można nim było wprowadzać kilka produktów. Gdy zostanie on wysłany, połączymy się z MySQL'em, przekazując szkielet naszego zapytania. Następnie będziemy podpinali do niego dane kolejnych produktów i wykonywali.
<?php
try
{
if($_SERVER['REQUEST_METHOD'] == 'POST')
{
$pdo = new PDO('mysql:host=localhost;dbname=produkty;port=3305', 'root', 'root');
$pdo -> setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$stmt = $pdo -> prepare('INSERT INTO `produkty` (`nazwa`, `opis`, `ilosc`, `cena`, `jakosc`) VALUES(
:nazwa,
:opis,
:ilosc,
:cena,
:jakosc)'); // 1
$ilosc = 0;
foreach($_POST['produkty'] as $produkt)
{
if(strlen($produkt['nazwa']) > 0)
{
$stmt -> bindValue(':nazwa', $produkt['nazwa'], PDO::PARAM_STR); // 2
$stmt -> bindValue(':opis', $produkt['opis'], PDO::PARAM_STR);
$stmt -> bindValue(':ilosc', $produkt['ilosc'], PDO::PARAM_INT);
$stmt -> bindValue(':cena', (float)$produkt['cena'], PDO::PARAM_STR);
$stmt -> bindValue(':jakosc', $produkt['jakosc'], PDO::PARAM_INT);
$ilosc += $stmt -> execute(); // 3
}
}
if($ilosc > 0)
{
echo 'Dodano: '.$ilosc.' rekordow';
}
else
{
echo 'Wystapil blad podczas dodawania rekordow!';
}
}
else
{
echo '<form method="post" action="pdo_7.php">';
for($i = 1; $i <= 4; $i++)
{
echo '<hr/>
<p>Nazwa: <input type="text" name="produkty['.$i.'][nazwa]"/></p>
<p>Opis: <input type="text" name="produkty['.$i.'][opis]"/></p>
<p>Ilosc: <input type="text" name="produkty['.$i.'][ilosc]"/></p>
<p>Cena: <input type="text" name="produkty['.$i.'][cena]"/></p>
<p>Jakosc: <select name="produkty['.$i.'][jakosc]">
<option value="1">1</option>
<option value="2">2</option>
<option value="3">3</option>
<option value="4">4</option>
<option value="5">5</option>
<option value="6">6</option>
</select></p>';
}
echo '<p><input type="submit" value="Dodaj"/></p></form>';
}
}
catch(PDOException $e)
{
echo 'Wystapil blad biblioteki PDO: ' . $e->getMessage();
}
?>
Opis:
- Szkielet zapytania wysyłany tylko raz.
- Zestawy danych ładowane są w pętli.
- W pętli wykonujemy też metodę execute().
Podpinanie nie ogranicza się tylko do zapytań typu INSERT. Z powodzeniem można stosować je także przy SELECT. Napiszemy teraz skrypt wyświetlający listę produktów oraz umożliwiający nam zobaczenie szczegółów każdego z nich. Dlatego do drugiego zapytania, pobierającego szczegółowe informacje, musimy podpiąć ID produktu, który chcemy obejrzeć.
<?phptry
{
$pdo = new PDO('mysql:host=localhost;dbname=produkty;port=3305', 'root', 'root');
$pdo -> setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$stmt = $pdo -> query('SELECT id, nazwa FROM produkty ORDER BY id');
echo '<ul>';
while($row = $stmt -> fetch())
{
echo '<li><a href=''.$row['id'].'">'.$row['nazwa'].'</a></li>';
}
$stmt -> closeCursor();
echo '</ul>';
if(isset($_GET['id'])) // 1
{
$stmt = $pdo -> prepare('SELECT `nazwa`, `opis`, `ilosc`, `cena`, `jakosc` FROM `produkty` WHERE `id` = :id'); // 2
$stmt -> bindValue(':id', $_GET['id'], PDO::PARAM_INT);
$stmt -> execute(); // 3
if($details = $stmt -> fetch()) // 4
{
echo '<hr/>
<p><b>Nazwa:</b> '.$details['nazwa'].'</p>
<p><b>Opis:</b> '.$details['opis'].'</p>
<p><b>Ilosc:</b> '.$details['ilosc'].'</p>
<p><b>Cena:</b> '.$details['cena'].'</p>
<p><b>Jakosc:</b> '.$details['jakosc'].'</p>';
}
else
{
echo '<hr/><p>Przepraszamy, podany rekord nie istnieje!</p>';
}
$stmt -> closeCursor();
}
}
catch(PDOException $e)
{
echo 'Wystapil blad biblioteki PDO: ' . $e->getMessage();
}
?>
Opis:
- Oczywiście wyświetlanie szczegółów przeprowadzamy tylko, jeśli podaliśmy ID.
- Przygotowujemy szkielet zapytania SELECT.
- Wykonujemy zapytanie metodą execute(). Zauważmy, że obiektem $stmt dysponujemy już od momentu wywołania metody prepare(), dlatego execute() nam już nic tu nie zwraca.
- Dalej postępujemy już tradycyjnie, po prostu pobierając kolejne rekordy (w tym wypadku tylko jeden) i zamykając kursor.
Jedyną wadą podpinania jest wydłużenie kodu PHP. Jeśli dotychczas wysyłaliśmy zapytanie DELETE zwyczajnie wykonując metodę exec(), teraz musimy to rozpisać na kilka linijek. Jednak jeszcze w tym rozdziale poznamy nakładkę na PDO zwaną Open Power Driver, dzięki której kod z powrotem stanie się krótki i czytelny.
Uwaga! Biblioteka PDO działa nieco inaczej na wersjach MySQL 5.0 i 4.1 także w przypadku podpinania. Wersja 5.0 jest bardziej elastyczna, jeśli chodzi o konwersję typów i nic jej nie zaszkodzi, kiedy spróbujemy wstawić do pola TINYINT(1) wartość oznaczoną w skrypcie jako PDO::PARAM_BOOL. Na MySQL 4.1 takie zapytanie nie zostanie wykonane, a ponadto serwer DB nie wygeneruje żadnego ostrzeżenia czy komunikatu.
Ćwiczenie: Zaprogramować formularz do edycji danych produktów z wykorzystaniem podpinania. Skrypt musi wczytywać do formularza dane edytowanego produktu oraz po jego wysłaniu, zmodyfikować wskazany rekord zapytaniem UPDATE. Pamiętaj: wraz z wysłanym formularzem musisz przesłać także ID rekordu, który modyfikujesz!
Obsługa relacji
Potrafimy już pobierać wyniki pojedynczego zapytania, potrafimy też wewnątrz jednego zapytania tworzyć relacje. Przejdźmy się jednak do naszej bazy danych księgarni i załóżmy, że chcemy wyświetlić listę kategorii oraz znajdujące się w każdej z nich książki. Sporo początkujących programistów podchodziło do tego zadania z marszu: wysyłali zapytanie żądające pobrania listy kategorii, a następnie w pętli kolejne, które dla aktualnej kategorii pobierało książki. Od razu przestrzegamy przed takim sposobem myślenia! Łamie on podstawową zasadę pracy z bazami danych mówiącą, że generalnie im mniej zapytań, tym lepiej. Ilość wysyłanych zapytań musi być względnie stała i poważnym błędem jest dopuszczenie do sytuacji, gdy zależy ona wprost proporcjonalnie od ilości pobieranych danych. PHP Data Objects niejako wymusza rezygnację z tej techniki, ponieważ wspominaliśmy, że nie można wysłać innego zapytania, kiedy nie skończyliśmy pobierać wyników jednego i nie zamknęliśmy jego kursora. Jak więc zatem poradzić sobie z tym zadaniem? Jest to bardzo proste - nasz skrypt będzie bez względu na ilość kategorii wykonywać dwa zapytania, których wynik będzie ładowany do tablicy. Dopiero z niej będzie wyświetlany kod HTML.
<?php
try
{
$pdo = new PDO('mysql:host=localhost;dbname=produkty;port=3305', 'root', 'root');
$pdo -> setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$stmt = $pdo -> query('SELECT id, nazwa FROM kategorie ORDER BY id');
$wynik = array();
while($row = $stmt -> fetch())
{
$wynik[$row['id']] = array( // 1
'nazwa' => $row['nazwa'],
'ksiazki' => array() // 2
);
}
$stmt -> closeCursor();
$stmt = $pdo -> query('SELECT nazwa, wydawnictwo, kategoria_id
FROM ksiazki ORDER BY kategoria_id, id'); // 3
while($row = $stmt -> fetch())
{
$wynik[$row['kategoria_id']]['ksiazki'][] = array( // 4
'nazwa' => $row['nazwa'],
'wydawnictwo' => $row['wydawnictwo']
);
}
$stmt -> closeCursor();
// 5
foreach($wynik as &$kategoria)
{
echo '<h3>'.$kategoria['nazwa'].'</h3>';
foreach($kategoria['ksiazki'] as &$ksiazka)
{
echo '<p><i>'.$ksiazka['nazwa'].'</i>
(Wyd. '.$ksiazka['wydawnictwo'].')</p>';
}
}
}
catch(PDOException $e)
{
echo 'Wystapil blad biblioteki PDO: ' . $e->getMessage();
}
?>
Sztuczka jest tu bardzo prosta - wykorzysujemy ID kategorii jako indeks tablicy (1). Ładujemy do niej nazwę kategorii oraz tworzymy pustą tablicę ksiazki (2) - tutaj będą trafiały książki należące do tej kategorii. Następnie wysyłamy zapytanie służące do pobrania wszystkich książek (3). Zauważmy, że sortujemy je najpierw według ID kategorii, a ponadto tenże ID pobieramy. Wykorzystany zostaje jako klucz dostępu, dzięki czemu jesteśmy w stanie ulokować daną książkę w odpowiedniej kategorii (4). Na końcu dwoma zagnieżdżonymi pętlami wyświetlamy wszystko.
Sposób opiera się na wcześniejszym zbuforowaniu danych. W praktyce programiści bardzo często tworzą takie bufory, ponieważ pozwalają one na dodatkową obróbkę pobranych danych, a w przypadku korzystania z systemu szablonów są nawet niezbędne.
Ćwiczenie: Zmodyfikować powyższy skrypt tak, aby przy nazwie książki wymienieni byli również wszyscy jej autorzy, tłumacze, itd. Skrypt może wysyłać najwyżej cztery zapytania.
Open Power Driver
PHP Data Objects jest tylko jednolitym interfejsem komunikacji i brak mu części funkcjonalności oferowanej przez prawdziwe kombajny zwane warstwami bazy danych (np. ADODb czy Creole). Nadaje się on jednak bardzo łatwo do rozbudowy. Zapoznamy się teraz z polską biblioteką Open Power Driver będącą nakładką na PDO. Zachowuje ona niemal w całości oryginału, dlatego wszystko, co do tej pory powiedzieliśmy sobie o PDO, będzie miało zastosowanie także do OPD. Biblioteka ta udostępnia jednak kilka dodatkowych możliwości oraz upraszcza wykonywanie niektórych czynności.
Open Power Driver napisany jest w PHP 5 i jest częścią projektu Open Power Board, w skład którego wchodzi już m.in. potężny system szablonów oraz system obsługi formularzy. Aby móc go używać, należy wejść na stronę WWW projektu: [1] i pobrać archiwum z najnowszą wersją. Archiwum zawiera, oprócz przykładów i dokumentacji opisującej różnice między biblioteką, a PDO, kod źródłowy umieszczony w katalogu lib. Kopiujemy jego zawartość do katalogu z naszymi skryptami i właściwie to wszystko.
Przyjrzyjmy się uważniej jednemu z pierwszych przykładów tego rozdziału przepisanemu z użyciem OPD:
<?php
define('OPD_DIR', './opd/');
require(OPD_DIR.'opd.class.php'); // 1
try
{
$pdo = opdClass::create(array( // 2
'dsn' => 'mysql:host=localhost;dbname=produkty;port=3305',
'user' => 'root',
'password' => 'root',
'debugConsole' => true // 2a
));
$stmt = $pdo -> query('SELECT nazwa FROM produkty ORDER BY id'); // 3
echo '<ul>';
while($row = $stmt -> fetch())
{
echo '<li>'.$row['nazwa'].'</li>';
}
$stmt -> closeCursor();
echo '</ul>';
}
catch(PDOException $e)
{
opdErrorHandler($e); // 4
}
?>
Opis:
- OPD pisany jest w PHP, dlatego najpierw musimy dołączyć kod źródłowy biblioteki. Wcześniej musimy też ustawić stałą OPD_DIR wskazującą na katalog ze źródłami.
- OPD posiada nieco więcej opcji konfiguracyjnych, dlatego też nawiązywanie połączenia wygląda nieco inaczej. Konfiguracja może być czytana z tablicy (jak w naszym przypadku) lub z pliku INI. Należy także dodać, że OPD automatycznie przełącza się w tryb raportowania błędów za pomocą wyjątków i my już nie musimy tego robić.
- Pozostała część kodu jest już taka sama, jak dla PDO.
- Open Power Driver posiada też funkcję elegancko formatującą komunikaty błędów, której możemy użyć, jeśli nie mamy ochoty pisać własnej.
Po uruchomieniu skryptu zauważymy, że nasza przeglądarka chce wyświetlić okienko pop-up. To tak zwana konsola debugowa, którą uruchomiliśmy dyrektywą debugConsole (2a). Konsola zawiera użyteczne informacje przeznaczone dla programisty. Pokazuje ona:
- Konfigurację OPD
- Łączny czas wykonywania wszystkich zapytań
- Informacje dotyczące przeprowadzanych transakcji
- Listę wszystkich wykonanych zapytań wraz z informacjami o tym, czy były one cache'owane oraz jak długo je wykonywano.
Kiedy popracujesz trochę z bazami danych, zauważysz, że niektóre zapytania pobierają w kółko te same informacje, niepotrzebnie obciążając serwer DB. Open Power Driver pozwala cache'ować wyniki zapytań, jeśli te stosunkowo rzadko ulegają zmianom. Cache'owanie polega na zrzuceniu zbioru wyników do zwykłego pliku. Jeśli przy następnym odświeżeniu strony OPD stwierdzi, że plik cache istnieje, w ogóle nie wysyła do bazy żadnego zapytania, tylko odczytuje dane z tego właśnie pliku, co jest znacznie szybsze. Napiszemy teraz skrypt wyświetlający listę produktów - ponieważ nie zmienia się ona co sekundę, możemy wyniki zapytania SELECT scache'ować. Zaczniemy od stworzenia w katalogu z naszym skryptem folderu cache/opd/, w którym OPD będzie mógł sobie trzymać pliki z wynikami zapytań. Katalog ten musimy określić podczas tworzenia obiektu dyrektywą cache - inaczej OPD zignoruje wszystkie żądania cache'owania:
<?php
define('OPD_DIR', './opd/');
require(OPD_DIR.'opd.class.php');
try
{
$pdo = opdClass::create(array(
'dsn' => 'mysql:host=localhost;dbname=produkty;port=3305',
'user' => 'root',
'password' => 'root',
'cache' => './cache/opd/', // 1
'debugConsole' => true
));
$pdo -> setCacheExpire(60, 'lista_produktow'); // 2
$stmt = $pdo -> query('SELECT nazwa FROM produkty ORDER BY id');
echo '<ul>';
while($row = $stmt -> fetch())
{
echo '<li>'.$row['nazwa'].'</li>';
}
$stmt -> closeCursor();
echo '</ul>';
echo '<p>Wykonanych zapytan: '.$pdo -> getCounter().'</p>'; // 3
}
catch(PDOException $e)
{
opdErrorHandler($e);
}
?>
Opis:
- Określamy katalog dla systemu cache.
- Aby scache'ować wynik określonego zapytania, wywołujemy tuż przed nim metodę setCacheExpire(). Określa ona, że jego zbiór wyników dostanie identyfikator lista_produktow oraz że jego ważność to 60 sekund. Po tym czasie plik cache będzie ponownie aktualizowany.
- Pokazujemy, ile zapytań SQL wykonał OPD.
Odśwież skrypt kilka razy. Zauważysz, że przy pierwszym uruchomieniu zostało wysłane jedno zapytanie, lecz przy następnych już zero. Dane są czytane z pliku cache. Po upływie 60 sekund znowu wykona się jedno zapytanie, a później żadne itd. Open Power Driver dodatkowo optymalizuje wszystko w pewien ciekawy sposób: otóż połączenie z bazą nie jest nawiązywane tak naprawdę w momencie wykonania metody opdClass::create(), lecz w momencie fizycznego wysłania pierwszego zapytania. Tak więc jeśli nasz skrypt wysyła zero zapytań, tak naprawdę nie nawiązuje też żadnego połączenia z serwerem DB (bo w sumie po co?). Open Power Driver posiada znacznie większe możliwości, jeśli chodzi o cache:
- Cache'owanie bezterminowe - w przypadku modyfikacji danych musimy samodzielnie usunąć plik cache, ale za to cache jest aktualizowany tylko wtedy, gdy faktycznie dane te ulegają zmianie. Opcja bardzo przydatna dla stron o niewielkim ruchu.
- Cache'owanie zapytań wykorzystujących podpinanie.
- Szczegółowy monitoring cache'owanych zapytań w konsoli debugowej.
Więcej szczegółów dostępnych jest w dokumentacji.
Wspomnieliśmy wcześniej, że korzystanie z podpinania wydłuża kod wielu operacji. Open Power Driver pozwala go z powrotem zredukować do normalnych rozmiarów w niektórych przypadkach dzięki istnieniu kilku metod-ułatwiaczy, automatyzujących pewne czynności. Przykładowo, metoda exec() może przyjmować drugi parametr - jeśli podamy za jego pomocą jakąś wartość, zostanie ona automatycznie podpięta do wstawki :id. Poniższy przykład służy do zwiększania o 1 ilości wybranego produktu.
<?php
define('OPD_DIR', './opd/');
require(OPD_DIR.'opd.class.php');
try
{
$pdo = opdClass::create(array(
'dsn' => 'mysql:host=localhost;dbname=produkty;port=3305',
'user' => 'root',
'password' => 'root',
'cache' => './cache/opd/',
'debugConsole' => true
));
$pdo -> setCacheExpire(60, 'lista_produktow_2');
$stmt = $pdo -> query('SELECT id, nazwa FROM produkty ORDER BY id');
echo '<ul>';
while($row = $stmt -> fetch())
{
echo '<li><a href=''.$row['id'].'">'.$row['nazwa'].'</a></li>';
}
$stmt -> closeCursor();
echo '</ul>';
if(isset($_GET['id']))
{
$pdo -> exec('UPDATE `produkty` SET `ilosc` = (`ilosc` + 1)
WHERE id = :id', $_GET['id']); // 1
echo '<p>Ilość prawidłowo zwiększona.</p>';
}
echo '<p>Wykonanych zapytan: '.$pdo -> getCounter().'</p>';
}
catch(PDOException $e)
{
echo 'Wystapil blad biblioteki PDO: ' . $e->getMessage();
}
?>
Zauważmy: gdybyśmy korzystali z oryginalnego PDO, musielibyśmy zapytanie UPDATE rozpisać na trzy linijki z wykorzystaniem metod prepare(), bindValue() oraz execute() tylko dlatego, że chcemy określić ID, którego ta operacja dotyczy. W OPD wystarczy podać tenże ID jako drugi parametr metody exec() - zostanie on automatycznie podpięty do wstawki :id, elegancko skracając kod.
Zakończenie
Nareszcie umiemy komunikować się z bazami danych z poziomu PHP, wykorzystując do tego celu bibliotekę PHP Data Objects. Nasze skrypty mogą dzięki temu w pełni czerpać z oferowanych przez bazy danych możliwości. Jednak temat baz danych nie został jeszcze zamknięty. Ponieważ PDO jest relatywnie nową biblioteką, wiele skryptów wciąż korzysta ze starych technik wywodzących się jeszcze z prehistorycznych czasów PHP 2.0/FI - dlatego też następny z rozdziałów poświęcony zostanie krótkiemu powrotowi do przeszłości.
Treść pochodzi ze strony WikiBooks i jest udostępniana na licencji GNU FDL
Autor: WikiBooks