|
Onze verbinding is gerealiseerd! laten we er nu iets mee gaan doen!
We beginnen met een simpele select query, nu ga ik er vanuit dat jullie de basis van SQL wel begrijpen, ik ga dit dus ook niet uitleggen.
De Prepare (voorbereiden) methode van PDO, is een query klaar leggen voor gebruik, dit is handig zodat je diezelfde query meerdere keren kan uitvoeren op basis van verschillende waardes.
Je kunt het zien als in mini template voor querys, je vertelt van te voren hoe het eruit moet zien, en daarna gooi je de juiste waardes erin.
Klein voorbeeldje:
$dbs = $pdo->prepare('SELECT bar FROM tabel WHERE foo = :foo LIMIT 1');
Zoals je kunt zien in de query vraag ik de waarde "bar" op waar de waarde "foo" is ":foo", ":foo" representeert de variable waarde die ik ga gebruiken om mijn select query verder te definiëren.
De methode prepare geeft een ander object als waarde terug, het zogeheten PDOStatement, met dit object ga je de gecreëerde query uitvoeren.
Om het PDOStatement uit te voeren heeft het de methode genoemd execute.
PDOStatement::execute (
[ array $input_parameters ]
)
Deze methode is te gebruiken met een variable aantal parameters, in het geval van mijn voorbeeld query heb ik maar 1 waarde.
De execute verwacht de waardes op deze manier:
$params = array(
':key' => 'value',
':key' => 'value',
':key' => 'value'
)
In de voorbeeld query zal het dus alsvolgt zijn:
$params = array(
':foo' => 'wms'
)
Ik vraag dus eigenlijk om de waarde :foo te vervangen met wms, in zijn geheel ziet het er zo uit:
$dbs = $pdo->prepare('SELECT bar FROM tabel WHERE foo = :foo LIMIT 1');
$params = array(
':foo' => 'webmasterstart.nl'
)
$dbs->execute($params);
Als alles goed is gegaan heeft PDOStatement de query uitgevoerd en heeft zijn resultaten in zijn buffer.
Net als bij mysql_fetch_array kun je deze gegevens ophalen via de fetch methode van de PDOStatement.
PDOStatement::fetch(
[ int $fetch_style ],
[ int $cursor_orientation ],
[ int $cursor_offset ]
);
Het meest interessante op dit punt is de eerste parameter van de methode fetch, hiermee kun je aangeven of je bijvoorbeeld een associative array wilt, of misschien toch een numerieke array.
Standaard staat deze op beide, dus zowel numeriek als associative array word terug gegeven.
Op PDOStatement::fetch() is terug te vinden welke fetch modes er precies zijn.
Hieronder de werking van de fetch methode:
while($row = $dbs->fetch()) {
print_r($row);
}
De uitkomst zal er bijvoorbeeld er dan zo uitzien:
array(
0 => 'Webmaster Start!',
'bar' => 'Webmaster Start!'
)
Nu kun je in eerste opzicht niet direct zien wat de voordelen zijn ten opzichte van normaal query gebruik.
Nou het handige voordeel is dat de execute meerdere keren uitgevoerd kan worden.
Dus de waarde ":foo" kan meerdere waardes krijgen, dit is te doen om nog een execute uit te voeren op de PDOStatement, alleen dit keer met andere parameters.
$dbs = $pdo->prepare('SELECT bar FROM tabel WHERE foo = :foo LIMIT 1');
$params = array(
':foo' => 'webmasterstart.nl'
)
$dbs->execute($params);
while($row = $dbs->fetch()) {
print_r($row);
}
$params = array(
':foo' => 'van-rossum.com'
)
$dbs->execute($params);
while($row = $dbs->fetch()) {
print_r($row);
}
De uitkomst zal hetvolgende zijn:
array(
0 => 'Webmaster Start!',
'bar' => 'Webmaster Start!'
)
array(
0 => 'Van Rossum.com!',
'bar' => 'Van Rossum.com!'
)
Via de prepare en execute is het dus mogelijk om de query welke 1 keer geschreven is meerdere keren uit te voeren.
Nu zal dit niet heel vaak voorkomen bij een SELECT query, maar je kan je voorstellen dat je dit wel veel vaker wilt gebruiken bij bijvoorbeeld een INSERT of UPDATE query.
Dit klinkt allemaal leuk en aardig, maar niet echt als een spannend voordeel.
PDO is de Fetch Mode PDO::FETCH_CLASS, hierover zal ik het hebben in de volgende paragraaf.
Fetch Mode PDO::FETCH_CLASS
In de vorige paragraaf werd al uitgelegd hoe de fetch mode werkt, gebaseerd op arrays.
Nu ga ik laten zien hoe het werkt om directe objecten uit de database te trekken.
Hoe vaak is het immers niet voorgekomen dat je een select query uitvoerd, en de waardes hiervan in een object zet en deze verder gaat gebruiken.
PDO is met een uiterst handige oplossing gekomen, namelijk Fetch mode PDO::FETCH_CLASS. Ik geef hieronder een voorbeeld hoe dit te gebruiken met de class Foo.
class Foo {
public $bar;
public $foo;
}
$dbs = $pdo->prepare('SELECT bar, foo FROM tabel');
$dbs->execute();
$dbs->setFetchMode(PDO::FETCH_CLASS, 'Foo');
$foos = array();
while($foo = $dbs->fetch()) {
$foos[] = $foo;
}
print_r($foos);
Zoals te zien is in het voorbeeld vertel ik na de execute dat de fetch mode PDO::FETCH_CLASS zal zijn met als waarde "Foo",
dit betekend niet meer dan dat ik zeg dat pdo de class "Foo" moet gaan gebruiken voor zijn data uit de database.
PDO zal de selectie waarde van bar en foo( SELECT bar, foo FROM tabel ) automatisch in de variable "bar" en "foo" gooien van de class "Foo".
De benaming van de variablen in de class, en de kolomen van de tabellen zijn dus hetzelfde.
Het resultaat van het bovenstaande voorbeeld:
Array
(
[0] => Foo Object
(
[bar:public] => Webmaster Start!
[foo:public] => webmasterstart.nl
)
[1] => Foo Object
(
[bar:public] => Van Rossum.com!
[foo:public] => van-rossum.com
)
)
Lees verder over PDO in deel drie van het artikel Error afhandeling
Auteur : Arno
|
Ontwerp je site