Albi's Jogger - z pamiętnika młodego programisty

Generowanie n rekordów w Oracle

Wed, 26 Oct 2011 13:39:29 +0200

Przydatna sztuczka - generuje n rekordów z liczbami od 1 do n. Potrzebowałem tego w pracy w celu wyświetlenia nagłówków w Jasper Reports gdy nie istnieją rekordy w grupie, a jednak mimo to chcemy mieć nagłówek. SELECT rownum FROM DUAL CONNECT BY ROWNUM < 1000

Kurs PDO - podpinanie parametrów cz.2

Sun, 22 Feb 2009 15:20:39 +0100

Witam wszystkich po dłuższej przerwie spowodowanej głównie moim lenistwem ;). Inaczej nie da się wytłumaczyć tego, że przez dwa tygodnie wolnego (ferie) nie napisałem nic na blogu. Dzisiaj jednak zamierzam dodać kolejny artykuł do serii na temat PDO. Z tego wpisu dowiecie się jak za pomocą podpinania zmiennych do kolumn pobierać dane z bazy.

Wszystkie dane pobrane z bazy zawsze znajdują się w obiekcie klasy PDOStatement. Dlatego musimy przekazać mu informację o tym, do jakich zmiennych mają trafiać. Aby to osiągnąć wykorzystamy poznany przez nas już wcześniej mechanizm - FETCH_MODE. By to zrobić cel mamy dwie drogi:

Przekazanie stałej PDO::FETCH_BOUND do metody PDOStatement::fetch() (lub PDOStatement::fetchAll())
Przekazanie stałej PDO::FETCH_BOUND do metody PDOStatement::setFetchMode()

Ponadto, podobnie jak w przypadku podpinania parametrów do zapytania mamy dwa sposoby identyfikowania kolumn - za pomocą nazwy oraz przez numer porządkowy kolumny. W pierwszym przypadku podajemy nazwę kolumny zwracaną przez bazę, w drugim natomiast jej kolejność. Należy jedynie pamiętać, że kolejne kolumny liczone są od jedynki.

W przypadku wywołania PDOStatement::fetch(PDO::FETCH_BOUND) podpięcie kolumn zastosowane zostanie jedynie do aktualnego wywołania metody PDOStatement::fetch(). Czasami jednak pozwala to skrócić zapis o niepotrzebne wywołanie PDOStatement::setFetchMode() - zazwyczaj gdy rekordy wyciągane są z obiektu tylko raz.

{geshi lang=php} $players = $pdo->query('SELECT id, user, ip FROM players'); $players->bindColumn(1, $id); //indeksowanie numeryczne od jedynki $players->bindColumn(2, $user); $players->bindColumn('ip', $ip); //indeksowanie za pomocą nazy kolumny while ($players->fetch(PDO::FETCH_BOUND)) //wartość zwracana to true/false { echo $id; echo $user; } {/geshi}

W prezentowanym powyżej przypadku dane trafiają tylko i wyłącznie do podpiętych zmiennych. Metoda PDOStatement::fetch(PDO::FETCH_BOUND) zwraca jedynie wartość true/false do określenia, czy zostały pobrane wszystkie rekordy. Ponadto zastosowaliśmy dwie metody indentyfikowania kolumn.

Drugi sposób jest bardziej uniwersalny, jednak zajmuje minimalnie więcej kodu (osobiście jestem minimalistą i nie lubię jak mi się zbytnio po ekranie rozłazi ;)):

{geshi lang=php} $players = $pdo->query('SELECT id, user, ip FROM players'); $players->bindColumn(1, $id); //indeksowanie numeryczne od jedynki $players->bindColumn(2, $user); $players->bindColumn('ip', $ip); //indeksowanie za pomocą nazy kolumny $players->setFetchMode(PDO::FETCH_BOUND); while ($players->fetch()) //wartość zwracana to true/false { echo $id; echo $user; } {/geshi}

Od tej pory dla określonego obiektu klasy PDOStatement stale obowiązuje ustawienie PDO::FETCH_BOUND. Kiedy możemy to wykorzystać? Najszybciej na myśl przychodzi mi połączenie z podpinaniem parametrów:

{geshi lang=php} $players = $pdo->prepare('SELECT id, user, ip FROM players WHERE pass = ?'); $players->bindColumn(1, $id); //indeksowanie numeryczne od jedynki $players->bindColumn(2, $user); $players->bindColumn('ip', $ip); //indeksowanie za pomocą nazy kolumny $players->bindParam(1, $pass); $players->setFetchMode(PDO::FETCH_BOUND); $players->execute(array('x')); while ($players->fetch()) //wartość zwracana to true/false { echo $id; echo $user; } $players->execute(array('y')); while ($players->fetch()) //wartość zwracana to true/false { echo $id; echo $user; } $players->execute(array('z')); while ($players->fetch()) //wartość zwracana to true/false { echo $id; echo $user; } {/geshi}

Oczywiście zaprezentowany przeze mnie przykład jest nieco bezużyteczny, gdyż dałoby się to pobrać za pomocą zwykłego OR, jednak załóżmy że nie jest to bezsensowne i dobrze ilustruje to, co chcemy zrobić ;).

To już wszystko co chciałem dzisiaj pokazać. Wkrótce pojawi się na tym blogu nieco więcej - moje długoterminowe plany zmian wkrótce wejdą w życie :).

Kurs PDO - podpinanie parametrów cz.1

Fri, 26 Dec 2008 16:26:51 +0100

Dzisiejszy wpis będzie obejmował tematykę znaną już z serii na temat ADOdb. Dowiecie się w jaki sposób realizować podpinanie parametrów w PDO oraz na czym polegają różnice między obydwiema bibliotekami. Dla tych, którzy nie wiedzą co to jest, przedstawię także zasadę działania oraz powody dla których używa się tej funkcjonalności. Warto jedynie wspomnieć, że PDO obsługuje znacznie więcej możliwości związanych z podpinaniem parametrów.

Dlaczego stosować?

Podpinanie parametrów ma bardzo wiele zalet nad zwyczajnym filtrowaniem danych i podklejaniem ich do zapytań. Jedną z najważniejszych jest czytelność. Dzięki odpowiednim identyfikatorom wiemy, która zmienna pod jakie miejsce w zapytaniu trafia. Nie musimy się bawić w łączenie długich ciągów znaków, rzutowanie typów i setki filtrów, PDO zrobi to za nas samo. Osobiście znam pewną osobę która po prostu gubi się w tych wszystkich apostrofach gdy nadchodzi potrzeba dołączenia kilku zmiennych do zapytania, nawet bez filtrowania zmiennych!

Pomimo tego najważniejszą zaletą takiego działania jest zabezpieczenie przed ataki typu SQL Injection. Dane które wstawiamy do zapytań zawsze są filtrowane pod względem znaków niebezpiecznych dla bazy danych której używamy, ponadto PDO bierze pod uwagę typ danych który wysyłamy (jeżeli podamy jaki to typ).

Jak tego używać?

Jak dobrze dobrze zapewne pamiętacie (a jeżeli nie, to polecam ich ponowną lekturę) z poprzednich wpisów, wysyłanie zapytania pobierającego dane w PDO składa się z dwóch etapów:

Przekazaniu zapytania do PDO::query()
Pobranie danych przy pomocy zwróconego nam obiektu klasy PDOStatement

W przypadku podpinania parametrów także użyjemy klasy PDOStatement, jednak tym razem cała operacja będzie nieco bardziej skomplikowana. Pozwala to na zwiększenie możliwości, jednak znacznie zmniejsza wygodę użytkowania. Nic nie stoi na przeszkodzie, aby napisać sobie niewielką nakładkę dla ułatwienia niektórych operacji. Zapoznajmy się w takim razie z kolejnymi krokami, jakie należy wykonać:

Przygotowanie zapytania przy pomocy PDO::prepare()
Podpięcie parametrów przy pomocy obiektu klasy PDOStatement
Wykonanie zapytania przy pomocy PDOStatement::execute()
Pobranie danych z obiektu klasy PDOStatement()

PDO pozwala na podpinanie parametrów na dwa sposoby. Przed wykonaniem zapytania, przy pomocy metody PDOStatement::bindValue(), lub podczas wykonywania zapytania metodą PDOStatement::execute(). Ponadto biblioteka obsługuje dwa sposoby identyfikacji parametrów. Przy pomocy liczb oraz nazw.

PDO::bindValue()

W przypadku podpinania danych poprzez PDO::bindValue() uzyskujemy możliwość dokładnego określenia rodzaju danych, które wysyłamy do zapytania. Dokonujemy tego podczas przypisywania kolejnych zmiennych do identyfikatorów/liczb. Kilka przykładów:

{geshi lang=php} $stmt = $db->prepare('SELECT * FROM users WHERE id = ? AND password = ?'); $stmt -> bindValue(0, $_SESSION['user_id'], PDO::PARAM_INT); //Podpinamy zmienną $_SESSION['user_id'] do pierwszego znaku zapytania jako liczbę $stmt -> bindValue(1, $_SESSION['password'], PDO::PARAM_STR, 32); //Podpinamy zmienną $_SESSION['password'] zamiast drugiego znaku zapytania jako 32 literowy ciąg znaków $stmt->execute(); {/geshi}

Przypadek z numerycznym umieszczaniem parametrów (ang. placeholders). Każdy parametr posiada swój numer według kolejności występowania znaków zapytania. Liczenie zaczynamy od jedynki (w przypadku używania metody PDOStatement::bindValue()).

{geshi lang=php} $stmt = $db->prepare('SELECT * FROM users WHERE id = :user_id AND password = :user_pass'); $stmt -> bindValue(':user_id', $_SESSION['user_id'], PDO::PARAM_INT); //Podpinamy zmienną $_SESSION['user_id'] do parametru o nazwie :user_id jako liczbę $stmt -> bindValue(':user_pass', $_SESSION['password'], PDO::PARAM_STR, 32); //Podpinamy zmienną $_SESSION['password'] zamiast identyfikatora :user_pass jako 32 literowy ciąg znaków $stmt->execute(); {/geshi}

Przypadek z nazwami jako identyfikatory parametrów (ang. named parameters). Każdy parametr posiada swoją własną nazwę według której podpinane są wartości.

Warto wspomnieć jeszcze jednej funkcji do popinania parametrów - PDOStatement::bindParam(). Jedyna różnica w stosunku do PDOStatement::bindValue() jest taka, że zmienne przekazane jako parametry podpinane są przez referencję, co umożliwia wykonanie kilki podobnych zapytań zaraz po sobie, podobnie jak robiliśmy to w przypadku ADOdb. Wystarczy, że zmienimy wartość umieszczoną w zmiennej podpiętej do zapytania i ponownie wykonamy metodę execute().

{geshi lang=php} $user = 'Klaus'; $players = $pdo -> prepare('SELECT * FROM players WHERE user = ?'); $players -> bindParam(1, $user); $players -> execute(); $player = $players -> fetch(); echo $player['email'].'
'; $players -> closeCursor(); $user = 'PQA'; $players -> execute(); $player = $players -> fetch(); echo $player['email'].'
'; $players -> closeCursor(); $user = 'sss'; $players -> execute(); $player = $players -> fetch(); echo $player['email'].'
'; $players -> closeCursor(); {/geshi}

Przekazywanie parametrów przy PDOStatement::execute()

Innym sposobem na umieszczenie wartości w zapytaniu jest podanie ich tablicy do metody PDOStatement::execute(). Jej indeksowanie zależy od wybranego przez nas sposobu identyfikowania parametrów. W przypadku parametrów z nazwami, używamy ich podobnie jak przy PDOStatement::bindValue(). Jeżeli natomiast numerujemy parametry, to ich indeks numeryczny w tablicy będzie odpowiadał kolejnym znakom zapytania.

{geshi lang=php} $stmt = $db->prepare('SELECT * FROM users WHERE id = :user_id AND password = :user_pass'); $stmt->execute(array( ':user_id' => $_SESSION['user_id'], ':user_pass' => $_SESSION['password'] )); {/geshi}

Przypadek z nazwami jako identyfikatorami. Każdej nazwie podstawiana jest odpowiednia warość z tablicy przekazanej do PDOStatement::execute() o kluczu zależnym od identyfikatora parametru.

{geshi lang=php} $stmt = $db->prepare('SELECT * FROM users WHERE id = ? AND password = ?'); $stmt->execute(array($_SESSION['user_id'], $_SESSION['password'])); {/geshi}

Przypadek ze znakami zapytania. Tym razem nie musimy podawać indeksów dla tablicy, ponieważ jest ona i tak domyślnie numerowana od zera. Osobiście używam właśnie tego sposobu ze względu na zwięzłość zapisu.

Dalej dane pobieramy już tak jak zwykle, przy pomocy metod PDOStatement::fetch(), PDOStatement::fetchAll() lub PDOStatement::fetchColumn(). Warto jedynie pamiętać, że PDOStatement zwraca jedynie wartość typu bool, która zawiera informację o powodzeniu wykonania zapytania. Wszelkie dane pobrane z bazy znajdują się nadal w obiekcie klasy PDOStatement na którym wykonaliśmy metodę execute().

{geshi lang=php} $stmt = $db->prepare('SELECT * FROM users WHERE id = ? AND password = ?'); $stmt->execute(array($_SESSION['user_id'], $_SESSION['password'])); foreach($stmt as $user) { echo $user['login'].'
'; } {/geshi}

Zakończenie

To już wszystko co chciałem przedstawić w dzisiejszym wpisie. Następnym razem dowiemy się, w jaki sposób przy pomocy podpinania kolumn do zmiennych pobierać dane z bazy. Jeszcze tylko pytanie do czytelników: czy wpisy z serii na temat PDO są dla was przydatne? Jeżeli czegoś im brakuje, bardzo proszę o jakiś komentarz, chciałbym aby były one możliwie najlepszym źródłem wiedzy dla początkujących.

Zwracanie wartości przy include()?

Fri, 28 Nov 2008 19:38:57 +0100

Dzisiaj spotkałem się z bardzo ciekawym rozwiązaniem o którym wcześniej nie wiedziałem, dlatego postanowiłem podzielić się nim z innymi czytelnikami. Jednocześnie przepraszam za moją dość długą nieobecność i obiecuję poprawę w najbliższym czasie.

Wracając do tematu, czy wiecie że możliwe jest zwracanie wartości podczas wykonywania pliku PHP załadowanego przy include/require? Ciekaw jestem, ilu z was to wiedziało... Przykładowe kody wyglądają tak:

Przykład 1

file.php

{geshi lang=php} {/geshi}

file2.php

{geshi lang=php} {/geshi}

Przykład 2

configuration.php

{geshi lang=php} {/geshi}

index.php

{geshi lang=php} {/geshi}

Ciekaw jestem ilu z was wiedziało o takiej możliwości. Czy tylko ja czytam niedokładnie manual? Warto czytać to wszystko od deski do deski? Może więcej takich ciekawych funkcji udałoby się wyłapać... Jak sądzicie? Czekam na komentarze.

Źródło: Kurt Urdalen's Blog

FETCH_ASSOC vs FETCH_NUM

Mon, 06 Oct 2008 19:54:18 +0200

Jak zapewne część z was wie (albo i nie) pracuję obecnie nad projektem zwanym Orodlin. W tymże właśnie zespole, ktoś niesamowicie genialny wpadł na pomysł używania numerycznego pobierania pól przy pomocy ADOdb (wszystko co w tym poście zostanie napisane, odnosi się także do PDO oraz mysql_fetch_num()). Istnieje pogląd, że numeryczne pobieranie pól jest szybsze...

W porządku. Mogę zrozumieć pewne względy wydajności przy pisaniu skryptów. Jednak nie potrafię znieść przedkładania wydajności kodu całkowicie ponad jego czytelność oraz elastyczność. Całą sytuację postaram się zobrazować na przykładzie jednego prostego kawałka kodu (przepisany na PDO dla lepszej czytelności):

{geshi lang=php} $players = $pdo -> query('SELECT id, user, email, pass, tribe, tribe_rank, class, race FROM players'); $players -> setFetchMode(PDO::FETCH_NUM); foreach($players as $player) { echo 'ID:'.$player[0].' Imię: '.$player[1].' Rasa: '.$player[7].' Klasa: '.$player[6]; } {/geshi}

Kod oczywiście działa i ma się świetnie... Moim zadaniem w tym miejscu była prosta zmiana - wyrzucenie pól odnośnie klanów z zapytania (tribe, tribe_rank) ponieważ pola te nie znajdowały się już w bazie (całkowite przepisanie systemu klanowego). Niestety, pola pobrane numerycznie z tego zapytania wykorzystywane były w kilku miejscach poniżej. Zmiana indeksów w każdym z tych miejsc całkowicie nie wchodziła w grę. W tym momencie wszedł brzydki-hack-tm, czyli pobieranie zer na miejsce usuniętych pól.

Do czego doprowadza taki styl kodowania? Jako ciekawostkę zobaczcie sobie skrypt poniżej ;)

{geshi lang=php} if ($arrPlayers[$i][2] == 'Member') { if ($arrPlayers[$i][6] == 'F') { $arrRankImages['Member'] = 'f_member'; } if ($arrPlayers[$i][6] == 'M') { $arrRankImages['Member'] = 'm_member'; } } $playerName = Player::getTaggedPlayerName($arrPlayers[$i][0]); //id $arrPlayers2[$i]['id'] = $arrPlayers[$i][0]; //name $arrPlayers2[$i]['name'] = $playerName; //opis $arrPlayers2[$i]['opis'] = $arrPlayers[$i][5]; //rankIcon $arrPlayers2[$i]['rankIcon'] = $rankIcon; //rankName $arrPlayers2[$i]['rankName'] = $rankName; //reputation $arrPlayers2[$i]['reputation'] = (empty($arrPlayers[$i][7])) ? 0 : $arrPlayers[$i][7]; //place $arrPlayers2[$i]['place'] = $arrPlayers[$i][9]; //rasa $arrPlayers2[$i]['rasa'] = $arrPlayers[$i][10]; //hp $arrPlayers2[$i]['hp'] = ($arrPlayers[$i][11] > 0)? 1 : 0; //gender $arrPlayers2[$i]['gender'] = $arrPlayers[$i][6]; //avatar $arrPlayers2[$i]['avatar'] = $arrPlayers[$i][12]; {/geshi}

No przepraszam, za takie kwiatki to ja dziękuję... Totalnie nieczytelny kod, gdyby nie komentarze, pozostałoby mi się jedynie pochlastać.

EDIT:

Jeszcze jedna sytuacja, która przypomniała mi się dopiero po publikacji wpisu - nasz kod obecnie używa mieszanych typów. Dlatego praktycznie w każdym miejscu dochodzi taki kwiatek:

{geshi lang=php} $oldFetchMode = $db -> SetFetchMode(ADODB_FETCH_NUM); // TUTAJ KOD KORZYSTAJACY Z FETCHA KTOREGO TY LUBISZ $db -> SetFetchMode($oldFetchMode); {/geshi}

No i gdzie tu sens?

Jak jest z wami? Spotkaliście się kiedyś z podobnym wykorzystaniem tej opcji w skryptach? Do czego używanie mysql_fetch_num/PDO::FETCH_NUM? A może ta opcja jest całkowicie bezużyteczna? Czekam na wasze opinie.

Kurs PDO - CRUD (Create, Retrieve, Update, Delete)

Mon, 29 Sep 2008 16:19:30 +0200

W dzisiejszym wpisie zamierzam kontynuować rozpoczęty ostatnio kurs PDO. Tym razem nauczymy się podstaw wstawiania, usuwania, pobierania i aktualizacji rekordów w bazie danych. Razem wszystkie te operacje nazywane są często CRUD (z angielskiego Create-Retrive-Update-Delete).

W przypadku dawnego sposobu wykonywania zapytań używanego w PHP, jedna funkcja (mysql_query) służyła do obsłużenia wszystkich ich rodzajów. W przypadku PDO pobieranie jest potraktowane w sposób szczególny, natomiast pozostałe zapytania wykonujemy przy pomocy jednej funkcji.

Pobieranie danych

W poprzedniej części nauczyliśmy się pobierać dane z bazy danych przy pomocy metody PDO::query() oraz klasy PDOStatement. Dzisiaj dowiemy się w jaki sposób decydować o sposobie ich umieszczania w wynikowym obiekcie. Służą do tego metody PDOStatement::setFetchMode(). Przy jej pomocy możemy ustawić jeden z poniższych atrybów:

PDO::FETCH_NUM - pobieranie numeryczne. Kluczami dla kolejnów pól w rekordach są liczby naturalne. Tak więc pole pobrane jako 1 będzie miało indeks 0 a każde następne o jeden większy.

{geshi lang=php} $players = $pdo->query('SELECT * FROM players'); $players->setFetchMode(PDO::FETCH_NUM); print_r($players->fetch()); {/geshi}

Array
(
    [0] => 7399
    [1] => Klaus Korner
    [2] => albi@jabster.pl
)

PDO::FETCH_ASSOC - pobieranie asocjacyjne. Kluczami są nazwy pobranych kolumn. Tak więc pole `username` znajdzie się pod kluczem `username`. Jeżeli w wyniku zapytania znajdą się dwa pola o tej samej nazwie to zwrócone zostanie tylko pierwsze. Bardzo wygodne, jednak nieco wolniejsze (podobno) od numerycznego. Osobiście nagminnie z niego korzystam.

{geshi lang=php} $players = $pdo->query('SELECT * FROM players'); $players->setFetchMode(PDO::FETCH_ASSOC); print_r($players->fetch()); {/geshi}

Array
(
    [id] => 7399
    [user] => Klaus Korner
    [email] => albi@jabster.pl
)

PDO::FETCH_NAMED - podobnie jak w przypadku FETCH_ASSOC dane umieszczane są na podstawie nazwy kolumny. Jedyna różnica polega na tym, że w razie wystąpienia wielu wartości o tej samej nazwie pola zwrócona zostanie tablica wszystkich pól o tym indeksie zamiast pierwszego wystąpienia.

{geshi lang=php} $players = $pdo -> query('SELECT id,user,email,pass as email FROM players'); $players->setFetchMode(PDO::FETCH_NAMED); print_r($players->fetch()); {/geshi}

Array
(
    [id] => 7399
    [user] => Klaus Korner
    [email] => Array
        (
            [0] => albi@jabster.pl
            [1] => 7815696ecbf1c96e6897b779456d330e
        )

)

W powyższym przykładzie specjalnie zastosowałem małą sztuczkę w zapytaniu, aby zwróciło dwie kolumny o tej samej nazwie. To powinno lepiej zobrazować działanie powyższej opcji.

PDO::FETCH_BOTH - połączenie pobierania numerycznego oraz asocjacyjnego. Możliwe jest używanie obydwu typów indeksów, jednak powoduje to podwojenie ilości danych i spowolnienie skryptu. Ponadto podczas iteracji w pętli foreach wszystkie kolumny w rekordach wyświetlane są dwukrotnie. Czasem może być to jednak przydatne.

{geshi lang=php} $players = $pdo -> query('SELECT id,user,email FROM players'); $players->setFetchMode(PDO::FETCH_BOTH); print_r($players->fetch()); {/geshi}

Array
(
    [id] => 7399
    [0] => 7399
    [user] => Klaus Korner
    [1] => Klaus Korner
    [email] => albi@jabster.pl
    [2] => albi@jabster.pl
)

PDO::FETCH_OBJ - pobiera dane do obiektu. Właściwości takiego obiektu są nazwami pól w bazie.

{geshi lang=php} $players = $pdo -> query('SELECT id,user,email FROM players'); $players->setFetchMode(PDO::FETCH_OBJ); print_r($players->fetch()); {/geshi}

stdClass Object
(
    [id] => 7399
    [user] => Klaus Korner
    [email] => albi@jabster.pl
)

PDO::FETCH_BOUND - umieszcza dane w odpowiednich zmiennych które poprzednio zostały podpięte poprzez metody PDOStatement::bindParam() oraz PDOStatement::bindColumn(). Dokładniej zostanie omówiony przy wpisie na temat podpinania parametrów.
PDO::FETCH_COLUMN
PDO::FETCH_CLASS
PDO::FETCH_INTO
PDO::FETCH_FUNC
PDO::FETCH_GROUP
PDO::FETCH_UNIQUE
PDO::FETCH_KEY_PAIR
PDO::FETCH_CLASSTYPE
PDO::FETCH_SERIALIZE
PDO::FETCH_PROPS_LATE
PDO::FETCH_LAZY

Tak więc przykładowe zapytanie oraz pobranie danych we wcześniej ustalony sposób powinno wyglądać tak:

{geshi lang=php} $players = $pdo -> query('SELECT id,user,email FROM players'); $players -> setFetchMode(PDO::FETCH_ASSOC); foreach($players->fetch() as $key => $value) { echo $key.' ma wartość '.$value."\n"; } $players -> closeCursor(); //nie zapominamy zamknąć kursora {/geshi}

Powyższy skrypt wyświetli rezultat z listingu poniżej. Dzięki zastosowaniu metody PDOStatement::fetch() uzyskaliśmy dostęp do pojedyńczego wiersza zwróconego przez bazę danych. Moglibyśmy także pobrać wszystkie wiersze, jednak wtedy musielibyśmy użyć dwóch pętli aby wyświetlic po kolei każdy wiersz oraz wszystkie pola. Możnaby to zrobić za pomocą PDOStatement::fetchAll() lub używając wbudowanego w PHP mechanizmu iteracji (to coś dla bardziej zaawansowanych, ogółem chodzi o to, że obiekt klasy PDOStatement można "potraktować" pętlą foreach).

id ma wartość 7399
user ma wartość Klaus Korner
email ma wartość albi@jabster.pl

Usuwanie danych

Usuwanie oraz edycja danych przy pomocy PDO nie różni się niczym od wykonania zwykłego zapytania do bazy danych. Ponieważ jednak zapytania pracujące na danych nic nie zwracają, używamy do tego celu metody PDO::exec(). Dzięki temu nie jest tworzony obiekt klasy PDOStatement, co przyspiesza działanie skryptu (po co tworzyć fabrykę, która niczego nie będzie produkować?). Przykładowy kod może wyglądać tak:

{geshi lang=php} $count = $pdo->exec('DELETE FROM players'); echo 'Usunięto '.$count.' graczy'; {/geshi}

Jak widać w naszym kodzie, metoda ta zwraca ilość zmodyfikowanych/usuniętych/dodanych pól.

To już wszystko co musicie wiedzieć na temat podstawowych operacji przy pomocy PDO. W dalszej części tego kursu omówię technikę, ktorą poznaliście przy okazji kursu ADOdb - param binding. Oprócz tego będzie nieco na temat innych użytecznych metod.

Kurs PDO - wprowadzenie

Mon, 22 Sep 2008 21:57:16 +0200

Tak jak zapowiadałem, w dzisiejszym wpisie zajmiemy się biblioteką PDO. Przy jej pomocy można w bardzo szybki i wygodny sposób pobrać dane z wielu popularnych baz danych (MSSQL, Firebird, MySQL, Informix, Oracle, ODBC, DB2, SQLite, PostgreSQL). Większość operacji poznanych przez nas wcześniej przy ADOdb możliwe jest do wykonania wzykorzystując jej możliwości, przy jednoczesnym znacznym przyspieszeniu i większej wygodzie użytkowania.

Dlaczego PDO?

PDO (PHP Data Objects) jest biblioteką która ma za zadanie wprowadzić jednolity sposób dostępu do baz danych. Poprzednie rozwiązanie było bardzo niedoskonałe. Nazwy funkcji dla każdej bazy były inne (mysq_connect, pg_connect), a możliwości dość mocno ograniczone (brak bindowania parametrów, zwracania całej tablicy czy obsługi wyjątków).

Obecnie problem ten rozwiązuje PDO, które jest dostępne domyślnie od PHP 5.1. Dostęp do każdej bazy danych jest realizowany przy pomocy tych samych funkcji i klas (typ bazy pobierany jest jedynie z konfiguracji), SQL Injection przestaje być problemem, a czas wykonywania jest znacznie mniejszy niż u konkurencyjnego ADOdb czy Creole.

Zaczynamy pracę - połączenie z bazą

Największą różnicą w tym miejscu w stosunku do ADOdb będzie wykorzystanie bloku try-catch do obsługi wyjątków. Dzięki temu uzyskamy dokładne informacje odnośnie błędu w razie niepowodzenia i będziemy mogli odpowiednio go obsłużyć (na przykład wyświetlić stronę z przeprosinami).

Parametry bazy danych podajemy do PDO podczas tworzenia obiektu klasy PDO służącego do obsługi połączenia. Aby to zrobić musimy przekazać do konstruktora specjalny ciąg znaków zwany DSN. Za jego pomocą określamy rodzaj sterownika bazy, jej nazwę oraz host wraz z portem. Nazwę użytkownika oraz hasło podajemy kolejno w drugim i trzecim parametrze. Możliwe jest także podanie pliku w którym znajduje się ciąg znaków DSN. Ostatnia opcja to zdefiniowanie tych danych w pliku php.ini i podanie nazwy dyrektywy konfiguracyjnej zamiast DSN.

{geshi lang=php} try { $pdo = new PDO('mysql:host=localhost;dbname=jakasnazwa', 'root', 'root'); echo 'Nawiązałem połączenie'; } catch(PDOException $e) { echo 'Błąd:'.$e->getMessage(); } {/geshi}

Użyty zostanie DSN z parametru.

{geshi lang=php} try { $pdo = new PDO('uri:file:///www/account/path/to/dsn', 'root', 'root'); echo 'Nawiązałem połączenie'; } catch(PDOException $e) { echo 'Błąd:'.$e->getMessage(); } {/geshi}

DSN zostanie pobrany z pliku do którego podaliśmy ścieżkę.

{geshi lang=php} try { $pdo = new PDO('database1', 'root', 'root'); //dyrektywa php.ini - pdo.dsn.database1 echo 'Nawiązałem połączenie'; } catch(PDOException $e) { echo 'Błąd:'.$e->getMessage(); } {/geshi}

Dane zostaną pobrane z php.ini - dyrektywa pdo.dsn.database1.

Jako ostatni parametr możemy także ustawić nieco innych opcji sterownika bazy danych opisanych w manualu. Przykład ustawienia kodowania dla połączenia z bazą:

{geshi lang=php} $pdo = new PDO('mysql:host=localhost;dbname=jakasnazwa', 'root', 'root', array(PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES utf8")); {/geshi}

Wykonywanie zapytań

Wykonywanie zapytań do bazy danych z PDO jest o wiele ławiejsze niż w przypadku ADOdb. Biblioteka ta posiada całą masę funkcji z których każda pobiera i zwraca dane w inny sposób. W przypadku PDO istnieją trzy funkcje służące do wywoływania zapytań:

PDO::query() - funkcja używana w przypadku pobierania danych z bazy
PDO::exec() - funkcja używana, gdy chcemy wywołać zapytanie które nie zwraca żadnego rezultatu
PDO::prepare() - funkcja wywoływana gdy używamy prepared statements (więcej na ten temat w następnych wpisach o PDO)

Zasadnicza reguła między ADOdb a PDO jest taka, że w przypadku ADOdb sposób dostępu do danych z zapytania określany był przy pomocy użytej funkcji. W przypadku obecnie omawianej biblioteki wszystko jest dużo bardziej przejrzyste. Każda metoda klasy PDO zwraca obiekt klasy PDOStatement, za pomocą którego uzyskujemy dostęp do danych.

Jak zatem uzyskać efekty podobne do tych z ADOdb? Wszystko jest tutaj możliwe dzięki potędze PHP5 oraz SPL'a. Implementacja odpowiednich interfejsów pozwala na ietrację zwracanego przez metodę PDO::query() obiektu PDOStatement w pętli foreach. Ponadto posiada on wiele użytecznych funkcji, które pozwalają na manipulowanie nim oraz pobieranie danych.

PDOStatement::fetch() - pobiera pojedynczy rekord z wyniku. Może być używana wiele razy - każde wywołanie pobierze nowy rekord.
PDOStatement::fetchAll() - pobiera wszystkie rekordy z wyniku
PDOStatement::fetchColumn() - pobiera wartość kolumny z wyniku. Może być używana wiele razy - każde wywołanie pobierze nowy rekord.

Przykłady użycia:

{geshi lang=php} $db = new PDO($dsn, $user, $password); $players = $db -> query('SELECT * FROM players'); while($row = $players->fetch()) { echo $row['login']; } foreach($players->fetchAll() as $row) { echo $row['login']; } echo $players->fetchColumn(); //zakladamy, ze zadane pole zostalo pobrane jako pierwsze {/geshi}

Wykonywanie zapytania które nie zwraca żadnej wartości jest dużo szybsze i prostsze:

{geshi lang=php} $db->exec('DELETE FROM players'); {/geshi}

Na zakończenie warto zobaczyć potęgę SPL'a w akcji. Podobne możliwości dawało ADOdb, jednak tam musieliśmy wykonywać zapytanie przy pomocy funkcji Execute(), co uniemożliwiało nam dostęp do danych na inne sposoby. Warto zwrócić uwagę na to, że poniższy kod nie używa metody fetchAll(). Dzięki temu ilość wykonanych pętli zmiejszy się (nie musimy wykonywać pętli aby pobrać wszystkie rekordy do tablicy, zamiast tego pobieramy je po jednym).

{geshi lang=php} $players = $db -> query('SELECT * FROM players'); foreach($players as $row) { echo $row['login']; } {/geshi}

EDIT: Kiri przypomniała mi, że aby wszystko działało prawidłowo konieczne jest zamknięcie kursora do obiektu klasy PDOStatement. Wykonuje się to za pomocą metody PDOStatement::closeCursor().

{geshi lang=php} $players = $db -> query('SELECT * FROM players'); foreach($players as $row) { echo $row['login']; } $player -> closeCursor(); {/geshi}

Jeżeli jej nie użyjemy, mogą pojawić się problemy z wykonaniem kolejnego zapytania. Nie pytajcie dlaczego tak jest ;).

Zakończenie

To już koniec dzisiejszego wpisu. Chciałbym was zapytać, które API wy preferujecie? Osobiście uważam, że droga obrana przez PDO jest słuszna i bardzo intuicyjna. W przypadku ADOdb ciężko było połapać się w niezliczonej ilości metod. Ponadto obsługa wyjątków sprawia, że mogę dokładnie zdecydować, co zrobić z błędem związanym z bazą danych. Dlaczego reszta całego PHP nie zdąża w tym kierunku?

ADOdb vs PDO

Fri, 19 Sep 2008 17:23:50 +0200

PDO jest kolejną biblioteką dostępu do bazy danych którą będę omawiał na łamach mojego bloga. W dzisiejszym wpisie chciałbym dość pokrótce omówić różnice w stosunku do ADOdb na temat którego pisałem we wcześniejszych postach.

Najważniejszą sprawą dla wszystkich będzie fakt, że PDO jest biblioteką wbudowaną w PHP i dostępną jako rozszerzenie PECL. Ponadto jest stale rozwijana w przeciwieństwie do ADOdb, które stanęło w miejscu kilka lat temu. Następstwem tego jest bardzo ważne dla twórców stron skrócenie czasu wykonywania skryptów wykorzystujących PDO.

Olbrzymią różnicą pomiędzy ADOdb a PDO jest podejście do obsługi wielu baz danych. Pierwsza z nich udostępnia specjalne funkcje, które pozwalają zamaskować niektóre różnice w implementacji standardu SQL w różnych systemach baz danych. PDO natomiast takiej funkcjonalności nie posiada, co przyspiesza jej działanie.

Kolejna kwestia warta poruszenia to obsługa cache, sesji w bazie danych oraz innych "bajerów" które posiada ADOdb. Niestety w PDO ich nie doświadczymy. Czy to źle? Zdania z całą pewnością będą podzielone dlatego decyzję pozostawię czytelnikowi.

Na koniec warto zaznaczyć, że o ile ADOdb była biblioteką bardzo bałaganiarską (konfiguracja w zmiennych globalnych, wiele aliasów metod, duplikacja funkcjonalności) o tyle PDO radzi sobie z tym o wiele lepiej. Wszystkie stałe związane z klasą znajdują się w niej samej zamiast w przestrzeni globalnej. Ponadto wszystkie nazwy funkcji są w jednym standardzie kodowania (camel case).

Wpis ten jest jedynie krótkim wprowadzeniem do PDO mającym wskazać zalety tej biblioteki. Mam nadzieję, że przyda się on wszystkim, którzy chcieliby ją poznać lepiej. Już wkrótce pojawi się więcej wpisów na temat jej używania w swoich skryptach wraz z przykładami. Czy waszym zdaniem PDO prezentuje się lepiej? A może już z niego korzystacie i chcielibyście podzielić się wrażeniami? Zachęcam do dyskusji.

Funkcje ADOdb i wykonywanie zapytań cz.3

Fri, 12 Sep 2008 15:14:03 +0200

W dzisiejszym wpisie omówię wykorzystanie cache w bibliotece ADOdb oraz moduł ADOdb C. Dowiecie się jak zapisać wynik zapytania przy pomocy ADOdb tak, aby ponowne pobieranie niezmienionych danych zajmowało jak najmniej czasu.

Cache - co to jest?

Cache jest to mechanizm, który umożliwia szybszy dostęp do danych przy pomocy zapisywania ich kopii w miejscu o szybszym czasie odczytu. Dzięki temu gdy dane się nie zmieniły, lub nie zależy nam na ich aktualności, nie musimy pobierać ich z bazy danych, nawiązując połączenie i wysyłając zapytanie. Wystarczy odczytać je ze zwykłego pliku zapisanego na dysku, który jest znacznie szybciej odczytywany, niż baza danych.

ADOdb i cache zapytań

Na samym początku chciałbym wypisać funckje obsługujące cache w ADOdb. Są to:

$db -> cacheExecute()
$db -> cacheGetAll()
$db -> cacheGetRow()
$db -> cacheGetOne()
$db -> cacheSelectLimit()

Jak łatwo się domyślić, działanie wszystkich wyżej wymienionych metod jest bardzo podobne do tych z poprzednich części, za jednym wyjątkiem - jako pierwszy parametr podajemy czas w sekundach, przez jaki wykonane zapytanie SQL ma być zapisane i pobierane z cache. Jeżeli funkcja wywoływana jest po raz pierwszy, lub czas cache dla danego zapytania minął, wtedy jest ono wykonywane. Inaczej dane zostaną pobrane ze specjalnego pliku cache zapisanego w odpowiednym katalogu przez ADOdb. Katalog ten określany jest przez globalną zmienną $ADODB_CACHE_DIR. Tak, też uważam to za dziwne rozwiązanie, jednak tak już po prostu jest.

{geshi lang=php} $ADODB_CACHE_DIR = '/tmp'; $sql = 'SELECT * FROM players WHERE id=?' $db -> cacheExecute(3600, $sql, array($_GET['id'])); $db -> cacheGetAll(3600, $sql, array($_GET['id'])); $db -> cacheGetRow(3600, $sql, array($_GET['id'])); $db -> cacheGetOne(3600, $sql, array($_GET['id'])); $db -> cacheSelectLimit(3600, $sql, 1, 1, array($_GET['id'])); {/geshi}

Możemy także nie podawać pierwszego parametru. Wtedy wykorzystana zostanie wartość $db -> cacheSecs (domyślnie ustawiona na 3600 sekund).

{geshi lang=php} $db -> cacheSecs = 1200; $sql = 'SELECT * FROM players WHERE id=?' $db -> cacheExecute($sql, array($_GET['id'])); $db -> cacheGetAll($sql, array($_GET['id'])); $db -> cacheGetRow($sql, array($_GET['id'])); $db -> cacheGetOne($sql, array($_GET['id'])); $db -> cacheSelectLimit($sql, 1, 1, array($_GET['id'])); {/geshi}

Czyszczenie cache polega na wywołaniu funkcji $db -> cacheFlush(). Jeżeli chcemy usunąć cache tylko dla jednego zapytania, podajemy je jako parametr naszej funkcji. Taki sposób nie jest możliwy w przypadku $db -> cacheSelectLimit(), ponieważ funkcja ta generuje swoje własne zapytanie zależnie od bazy danych. Wtedy należy tę funkcję wywołać z pierwszym parametrem jako zero.

{geshi lang=php} $db -> cacheSelectLimit(3600, $sql, 1,1); //Pobranie danych i zapisanie do cache $db -> cacheSelectLimit(3600, $sql, 1,1); //Pobranie danych z cache $db -> cacheSelectLimit(0, $sql, 1,1); //Skasowanie cache {/geshi}

ADOdb extension

ADOdb extension powstało, aby przyspieszyć działanie biblioteki. Napisane jest w C i zgodne z PHP 4.3.*, 4.4.*, 5.0.* oraz 5.1.* (oficjalnie). Osobiście używamy wersji PHP 5.2 i wszystko działa jak do tej pory bezproblemowo. Rozszerzenie to jest modułem który nadpisuje niektóre funkcje zwykłego ADOdb w celu zwiększenia ich wydajności. Warto nim się zainteresować, jeżeli nasz projekt używa już ADOdb. W innym wypadku polecam PDO, które w całości napisane jest w C. To już koniec serii poświęconej ADOdb. Mam nadzieję, że opisane przeze mnie funkcje pomogły wam zrozumieć zasadę działania tej nierozwijanej już biblioteki. Była to pierwsza biblioteka DAO (wtedy jeszcze nie wiedziałem co to jest), z której korzystałem. W dalszej części przeglądu tego typu bibliotek będzie PDO.

Funkcje ADOdb i wykonywanie zapytań cz.2

Wed, 10 Sep 2008 16:53:32 +0200

W dzisiejszej części artykułu na temat ADOdb poznamy funkcje, które są nieco rzadziej używane oraz nauczymy się korzystać z tak zwanych "prepared statements" - specjalnego sposobu przekazywania parametrów do zapytań SQL który ma za zadania zapobiec atakom typu SQL Injection. Oto lista funkcji, które dzisiaj poznamy:

$db -> AutoExecute()
$db -> Replace()

Tym razem będzie ich nieco mniej, ponieważ dużą część wpisu chciałbym poświęcić podpinaniu zmiennych pod zapytania SQL. Jest to bardzo ciekawa opcja, gdyż pozwala na zabezpieczenie się przed atakami typu SQL Injection w bardzo prosty sposób oraz poprawia czytelność zapytań. Poniżej kod wykorzystujący variable binding:

{geshi lang=php} $db->Execute("SELECT * FROM players WHERE id=?", array($_GET['id'])); {/geshi}

Kod taki spowoduje, że do zapytania zamiast znaku zapytania podstawiona zostanie wartość zmiennej $_GET['id']. Dodatkowo według manuala ADOdb, taki sposób podawania zmiennych do zapytania przyspiesza czas jego wykonywania i korzystania z cache. Teraz pora na nieco bardziej skomplikowany przykład:

{geshi lang=php} $db->Execute("SELECT * FROM players WHERE id=? AND ip=? AND user=?", array($_GET['id'], $_GET['ip'], $sUserName)); {/geshi}

lub

{geshi lang=php} $arrValues = array($_GET['id'], $_GET['ip'], $sUserName); $db->Execute("SELECT * FROM players WHERE id=? AND ip=? AND user=?", $arrValues); {/geshi}

W ten sposób do zapytania zostaną podstawione kolejno wartości z tablicy przekazanej jako parametr. A teraz zobaczmy kod który nie wykorzystuje tej techniki:

{geshi lang=php} $db->Execute('SELECT * FROM players WHERE id='.(int)$_GET['id'].' AND ip='.$db->qstr($_GET['id']).' AND user='.$db->qstr($sUserName)); {/geshi}

I teraz czytelniku, który sposób jest czytelniejszy i bardziej zwięzły? Jest jeszcze jedna rzecz, którą musisz wiedzieć używając tego sposobu. Otóż działa on we wszystkich funkcjach, jakie do tej pory poznaliśmy i poznamy! Ale to nie koniec dobrej zabawy. Teraz dodamy kilka rekordów i to za jednym zamachem!

{geshi lang=php} $arrValues = array( array($_GET['ip'], $_GET['user'], 'Człowiek'), array($_GET['ip2'], $_GET['user2'], 'Człowiek'), array($_GET['ip3'], $_GET['user3'], 'Człowiek'), ); $db->Execute('INSERT INTO players(ip, user, rasa) VALUES(?,?,?)', $arrValues); {/geshi}

Tak więc kiedy do funkcji przekazujemy tablicę dwuwymiarową, wtedy dla każdego jej elementu ADOdb generuje oddzielne zapytanie i podpina wartości z drugiego wymiaru tablicy. Warto jeszcze na końcu zaznaczyć, że podpinać parametry do zapytań można nie tylko w metodzie $db -> Execute(), lecz także w innych które do tej pory poznaliśmy. Kilka przykładów:

{geshi lang=php} $db -> getAll('SELECT * FROM players WHERE level > ?', array($_GET['level'])); $db -> getRow('SELECT * FROM players WHERE id = ?', array($_GET['id'])); $db -> getRow('SELECT name FROM players WHERE id = ?', array($_GET['id'])); {/geshi}

To wszystko, jeżeli chodzi o nasz nowy sposób dodawania zmiennych do zapytań. Teraz zajmijmy się nowymi funkcjami.

Funkcja ADOConnection::AutoExecute()

To bardzo ciekawa funkcja, która ma wiele zastosowań. Potrafi całkiem sporo, dlatego naprawdę warto zapoznać się z jej działaniem. Funkcja ta na podstawie podesłanej tablicy asocjacyjnej generuje odpowiednie zapytanie dodające lub aktualizujące rekord w zależności od kolejnego parametru. Przykładowe wywołania:

{geshi lang=php} $arrData = array('user' => 'Klaus Korner', 'ip' => '127.0.0.1', 'rasa' => 'Krasnolud'); $db -> AutoExecute('players', $arrData, 'INSERT'); //1 $db -> AutoExecute('players', $arrData, 'UPDATE', "user='Klaus Korner'"); //2 {/geshi}

W pierwszym przykładzie dodajemy nowy rekord do tabeli players, zaś w drugim aktualizujemy go. Jako pierwszy parametr funkcji przekazujemy nazwę tabeli którą modyfikujemy. Następnie tablicę z danymi, gdzie klucze są nazwami kolumn. Potem rodzaj zapytania i na końcu ewentualny warunek, jeżeli aktualizujemy rekord(y). Podobna do tej jest funkcja $db -> getUpdateSQL(), jednak ta zamiast wykonywać zapytanie, jedynie zwraca jego treść. Warto też zapamiętać, że aby dane wysyłane do bazy były poprawne, ADOdb sprawdza poprzednio czy klucze w tablicy z polami są prawidłowe i kasuje te złe. Niestety, trzeba za to zapłacić zapytaniem które musi zostać wykonane, dlatego należy z rozsądkiem używać tej funkcji.

Funkcja ADOConnection::Replace()

Jeszcze ciekawsza od poprzedniej funkcja służy do zastępowania/dodawania rekordów. Takie potwory są plagą skryptu na którym mam dość często nieprzyjemność pracować:

{geshi lang=php} $test = $db->Execute("SELECT `id` FROM `potions` WHERE `name`='".$strName."' AND `owner`=".$player -> id." AND `status`='K' AND `power`=".$intPower) or die("błąd"); if (!$test->fields['id']) { $db->Execute("INSERT INTO potions (`owner`, `name`, `efect`, `power`, `amount`, `status`, `type`) VALUES(".$player->id.", '".$strName."', '".$objItem->fields['efect']."', ".$intPower.", ".$intTmpamount.", 'K', '".$objItem->fields['type']."')"); } else { $db->Execute("UPDATE `potions` SET `amount`=`amount`+".$intTmpamount." WHERE `id`=".$test -> fields['id']); } {/geshi}

Coś takiego możemy zastąpić jednym, prostym wywołaniem funkcji $db->Replace(). Poniżej mały przykład:

{geshi lang=php} $arrData = array( 'name' => $strName, 'owner' => $player -> id, 'status' => 'K', 'power' => $intPower, 'amount' => 'amount + '.$intTmpamount ); $arrKeys = array('name', 'owner', 'status', 'power'); $db->Replace('potions', $arrData, $arrKeys, true); {/geshi}

W ten sposób zawiły i skomplikowany kod zamieniliśmy w zwięzłe wywołanie jednej funkcji. Jak widać, przydatność jest wysoka. Omówmy teraz dokładniej jej działanie. Funkcja ta na podstawie tablicy z drugiego parametru dodaje lub aktualizuje rekord z tabeli podanej jako pierwszy parametr. Sprawdzanie czy istnieje rekord do aktualizacji odbywa się za pomocą kluczy z trzeciego parametru (dane te trafiają do warunku WHERE, a pozostałe elementy tablicy z drugiego parametru służą do aktualizacji). Ostatni, czwarty parametr określa, czy funkcja ma dodawać apostrofy i domyślnie ustawiony jest na false. To już wszystko co dzisiaj chciałem wam pokazać. Mam nadzieję, że rozwiałem wszelkie wątpliwości, dlaczego uważam zastępowanie ADOdb jego biedniejszymi zamiennikami za niezbyt dobry pomysł. Jeżeli nie, to zapraszam na kolejny wpis z serii, który opisze wykorzystywanie cache w zapytaniach oraz kilka słów na temat modułu ADOdb napisanego w C. Powiem szczerze, że podczas pisania dwóch poprzednich wpisów zostałem mile zaskoczony ilością ciekawych funkcji w ADOdb. A może już ich używacie? Jakie są wasze doświadczenia z tą biblioteką i jak wiele dowiedzieliście się z tego wpisu? Czekam na komentarze.