[COURS] Introduction à PDO (PHP Data Object)

[alton]

PDO, ou PHP Data Object est une extension apparue dans php 5.1 servant de socle commun pour les SGBD (serveurs de gestion de bases de données). Il ne s'agit pas totalement d'un système d'abstraction, certaines requètes devront être réécrites si l'on change de SGBD.

Toutefois, la plupart des requètes resteront valables, et surtout les méthodes et les objets manipulés restent les mêmes (pas de mysql_query mais plutot $pdo->query...). Il sera donc beaucoup plus rapide de porter des scripts d'un SGBD à l'autre qu'en les ayant écrits pour un en particulier.

Autres avantages, les requêtes préparées qui permettent un gain de temps dans l'execution de requêtes répétitives, et la gestion des transactions, ensemble de requêtes qui ne seront executées que si toutes sont valables.

PDO supporte MySQL, PostgreSQL, SQLite, Oracle et ODBC !


Les classes PDO et PDOStatment


Voici les classes et leurs méthodes telles que présentées dans le manuel de php. Nous ne les détaillerons pas toutes, donc aller y faire un tour si vous le désirez.

[php]PDO
{
PDO::__construct ( string $dsn [, string $username [, string $password [, array $driver_options ]]] )
bool PDO::beginTransaction ( void )
bool PDO::commit ( void )
string PDO::errorCode ( void )
array PDO::errorInfo ( void )
int PDO::exec ( string $statement )
mixed PDO::getAttribute ( int $attribute )
array PDO::getAvailableDrivers ( void )
string PDO::lastInsertId ([ string $name ] )
PDOStatement PDO::prepare ( string $statement [, array $driver_options ] )
PDOStatement PDO::query ( string $statement )
string PDO::quote ( string $string [, int $parameter_type ] )
bool PDO::rollBack ( void )
bool PDO::setAttribute ( int $attribute , mixed $value )
}[/php]

• PDO::beginTransaction — Démarre une transaction
• PDO::commit — Valide une transaction
• PDO::__construct — Creates a PDO instance representing a connection to a database
• PDO::errorCode — Retourne le SQLSTATE associé avec la dernière opération sur la base de données
• PDO::errorInfo — Retourne les informations associées à l'erreur lors de la dernière opération sur la base de données
• PDO::exec — Exécute une requête SQL et retourne le nombre de lignes affectées
• PDO::getAttribute — Récupère un attribut d'une connexion à une base de données
• PDO::getAvailableDrivers — Return an array of available PDO drivers
• PDO::lastInsertId — Retourne l'identifiant de la dernière ligne insérée ou la valeur d'une séquence
• PDO:: prepare — Prépare une requête à l'exécution et retourne un objet
• PDO::query — Exécute une requête SQL, retourne un jeu de résultats en tant qu'objet PDOStatement
• PDO::quote — Protège une chaîne pour l'utiliser dans une requête SQL PDO
• PDO::rollBack — Annule une transaction
• PDO::setAttribute — Set an attribute

[php]PDOStatement implements Traversable
{
bool PDOStatement::bindColumn ( mixed $column , mixed &$param [, int $type [, int $maxlen [, mixed $driverdata ]]] )
bool PDOStatement::bindParam ( mixed $parameter , mixed &$variable [, int $data_type [, int $length [, mixed $driver_options ]]] )
bool PDOStatement::bindValue ( mixed $parameter , mixed $value [, int $data_type ] )
bool PDOStatement::closeCursor ( void )
int PDOStatement::columnCount ( void )
string PDOStatement::errorCode ( void )
array PDOStatement::errorInfo ( void )
bool PDOStatement::execute ([ array $input_parameters ] )
mixed PDOStatement::fetch ([ int $fetch_style [, int $cursor_orientation [, int $cursor_offset ]]] )
array PDOStatement::fetchAll ([ int $fetch_style [, int $column_index [, array $ctor_args ]]] )
string PDOStatement::fetchColumn ([ int $column_number ] )
mixed PDOStatement::fetchObject ([ string $class_name [, array $ctor_args ]] )
mixed PDOStatement::getAttribute ( int $attribute )
array PDOStatement::getColumnMeta ( int $column )
bool PDOStatement::nextRowset ( void )
int PDOStatement::rowCount ( void )
bool PDOStatement::setAttribute ( int $attribute , mixed $value )
bool PDOStatement::setFetchMode ( int $mode )
}[/php]

• PDOStatement->bindColumn — Lie une colonne à une variable PHP
• PDOStatement->bindParam — Lie un paramètre à un nom de variable spécifique
• PDOStatement->bindValue — Associe une valeur à un paramètre
• PDOStatement->closeCursor — Ferme le curseur, permettant à la requête d'être de nouveau exécutée
• PDOStatement->columnCount — Retourne le nombre de colonnes dans le jeu de résultats
• PDOStatement->errorCode — Récupère le SQLSTATE associé lors de la dernière opération sur la requête
• PDOStatement->errorInfo — Récupère les informations sur l'erreur associée lors dernière opération sur la requête
• PDOStatement->execute — Exécute une requête préparée
• PDOStatement->fetch — Récupère la ligne suivante d'un jeu de résultat PDO
• PDOStatement->fetchAll — Retourne un tableau contenant toutes les lignes du jeu d'enregistrements
• PDOStatement->fetchColumn — Retourne une colonne depuis la ligne suivante d'un jeu de résultats
• PDOStatement->fetchObject — Récupère la prochaine ligne et la retourne en tant qu'objet
• PDOStatement->getAttribute — Récupère un attribut de requête
• PDOStatement->getColumnMeta — Retourne les métadonnées pour une colonne d'un jeu de résultats
• PDOStatement->nextRowset — Avance à la prochaine ligne de résultats d'un gestionnaire de lignes de résultats multiples
• PDOStatement->rowCount — Retourne le nombre de lignes affectées par le dernier appel à la fonction PDOStatement::execute()
• PDOStatement->setAttribute — Définie un attribut de requête
• PDOStatement->setFetchMode — Définit le mode de récupération par défaut pour cette requête

Première connexion


PDO::__construct ( string $dsn [, string $username [, string $password [, array $driver_options ]]] )

Le premier argument du constructeur est le DSN. C'est avec cette chaîne que nous allons définir le SGBD à utiliser, le domaine, le port et la base.

Pour mySQL la syntaxe est la suivante :
[php]mysql:host=$host;port:$port;dbname=$dbname[/php]Je vous laisse vous documenter pour les autres SGBD.

C'est partit, on se connecte :

[php]<?php
$hote='localhost'; // le chemin vers le serveur
$port='3306';
$nom_bd='maBase'; // le nom de votre base de données
$utilisateur='moi'; // nom d'utilisateur pour se connecter
$mot_passe=''; // mot de passe de l'utilisateur pour se connecter
try
{
$connexion = new PDO('mysql:host='.$hote.';port='.$port.';dbname='.$nom_bd, $utilisateur, $mot_passe);
}
catch (PDOException $e)
{
print "Erreur PDO : ".$e->getMessage() ;
}
$connexion = null; // fermeture de la connection
?>[/php]Pour ceux qui n'ont pas l'habitude de gérer les exceptions de cette manière, avec try et catch, je vous renvois à la documentation PHP disponible ici : www.php.net.


Les requêtes


Et maintenant, intéressons nous aux requêtes. Concernant les requêtes les plus utilisées, PDO distingue deux types de requêtes : les requêtes renvoyant un résultat (SELECT...) et les requêtes ne renvoyant pas de résultat (INSERT...). Cette distinction n'était pas présente dans les versions antérieures de PHP (mysql_query était utilisé pour tout type de requête). Voyons comment PDO gère ceci :

[php]
<?php
$login = 'login';
$mdp = 'mdp';
$bdd = 'mysql:host=localhost;dbname=mabase';
try {
$cnx = new PDO($bdd, $login, $mdp);
}
catch (PDOException $error) {
die("Erreur de connexion : " . $error->getMessage() );
}
// Requête sans renvoi de résultat
$req = "INSERT INTO clients (pseudo, mail) VALUES ('client', 'client@mail.com')";
$cnx->exec($req);
// Requête avec renvoi de résultat(s)
$req = "SELECT * FROM clients";
$res = $cnx->query($req);
$cnx = null; // Fermeture de la connexion
?>
[/php]Il est bon de noter qu'en cas d'erreur, les fonctions exec() et query() renvoient FALSE.

Maintenant que nous avons sélectionné nos enregistrements, il faut les récupérer. Nous avions l'habitude des mysql_fetch_array, mysql_fetch_object... Avec PDO, nous ne sommes pas dépaysés, mais la syntaxe est différente. Là voici :

[php]<?php
$login = 'login';
$mdp = 'mdp';
$bdd = 'mysql:host=localhost;dbname=mabase';
try {
$cnx = new PDO($bdd, $login, $mdp);
}
catch (PDOException $error) {
die("Erreur de connexion : " . $error->getMessage() );
}
// Requête sans renvoi de résultat
$req = "INSERT INTO clients (pseudo, mail) VALUES ('client', 'client@mail.com')";
$cnx->exec($req);
// Requête avec renvoi de résultat(s)
$req = "SELECT * FROM clients";
$res = $cnx->query($req);
while ($row = $res->fetch(PDO::FETCH_NUM)){}
// PDO::FETCH_NUM renvoie un tableau avec des clefs numériques.
// PDO::FETCH_ASSOC renvoie un tableau associatif.
// PDO::FETCH_BOTH renvoie un tableau associatif avec des clefs numériques.
// PDO::FETCH_OBJ renvoie une instance de stdClass.
$cnx = null; // Fermeture de la connexion
?>[/php]J'ai mentionné dans l'exemple les constantes les plus utilisées, il y a en tout 17 méthodes permettant de "récolter" les enregistrements d'une base de données.

Voilà, pour de plus amples informations à propos de PDO, je vous renvois à la documentation PHP, qui comme a son habitude, est très bien expliquée.