PDO fournit une interface d’abstraction à l’accès de données, ce qui signifie que vous utilisez les mêmes fonctions pour exécuter des requêtes ou récupérer les données quelque soit la base de données utilisée. PDO ne fournit pas une abstraction de base de données : il ne réécrit pas le SQL, n’émule pas des fonctionnalités manquantes. Vous devriez utiliser une interface d’abstraction complète si vous avez besoin de cela.

PDO est fournit avec PHP 5.1 et est disponible en tant qu’extension PECL pour PHP 5.0 ; PDO requiert les nouvelles fonctionnalités OO fournies par PHP 5 et donc, ne fonctionne pas avec les versions antérieures de PHP.

PHP 5.1 et supérieur sur les systèmes Unix
| ./configure –with-zlib –enable-pdo=shared –with-pdo-sqlite=shared –with-sqlite=shared |

1. Après avoir installé PDO en tant que module partagé, vous devez éditer votre fichier “php.ini” afin que l’extension PDO soit chargée automatiquement lorsque PHP est lancé. Vous devez y activer également le driver spécifique à votre base de données ; assurez-vous qu’ils sont listés après la ligne pdo.so, car PDO doit être initialisé avant le chargement des extensions spécifiques à la base de données. Si vous avez compilé PDO et les extensions spécifiques à la base de données statiquement, vous pouvez sauter cette étape.
   | extension=pdo.so |
2. Le fait d’avoir PDO en tant que module partagé vous permet d’exécuter la commande pecl upgrade pdo pour mettre à jour votre version de PDO sans pour autant avoir besoin de recompiler complètement PHP. Notez que si vous faites cela, vous devez également mettre à jour votre driver PDO spécifique à votre base de données en même temps.

PHP 5.0 et supérieur sur les systèmes Unix

1. PDO est disponible en tant qu’extension PECL depuis http://pecl.php.net/package/pdo. L’installation peut être faite via la commande pecl ; ceci est activé par défaut lorsque vous configurez PHP. Vous devriez vous assurer que PHP a été configuré avec –with-zlib pour pouvoir utiliser la commande pecl afin de gérer les paquets compressés.
2. Exécutez la commande suivante pour télécharger, compiler et installer la dernière version stable de PDO :
   | pecl install pdo |
3. La commande pecl installe automatiquement le module PDO dans votre dossier d’extensions PHP. Pour activer l’extension PDO sous les systèmes Linux ou Unix, vous devez ajouter la ligne suivante dans votre fichier “php.ini” :
   | extension=pdo.so |
   Pour plus d’informations sur la compilation de paquets PECL, consultez la section sur l’installation de PECL du manuel.

Utilisateurs de Windows avec PHP 5.1 et supérieur

1. PDO ainsi que tous les drivers principaux interagissent avec PHP en tant qu’extensions partagées, et ont tout simplement besoin d’être activés en éditant le fichier “php.ini” :
   | extension=php_pdo.dll |
2. Ensuite, choisissez les autres fichiers DLL spécifiques à votre base de données et utilisez soit la fonction dl() pour les charger au moment de l’exécution ou activer-les dans le fichier “php.ini” en dessous de la ligne “php_pdo.dll”. Par exemple :

| extension=php_pdo.dll extension=php_pdo_firebird.dll extension=php_pdo_informix.dll extension=php_pdo_mssql.dll extension=php_pdo_mysql.dll extension=php_pdo_oci.dll extension=php_pdo_oci8.dll extension=php_pdo_odbc.dll extension=php_pdo_pgsql.dll extension=php_pdo_sqlite.dll |

Le comportement de ces fonctions est affecté par la configuration dans le fichier “php.ini”.

Tableau 1. Options de Configuration PDO

Pour plus de détails sur les constantes PHP_INI_*, reportez-vous à Annexe G.

Voici un éclaircissement sur l’utilisation des directives de configuration.

“pdo.dsn.*” string

Définit un alias DSN. Voyez PDO::__construct pour une explication complète.

Les drivers suivants sont actuellement implémentés dans l’interface PDO :

Les connexions sont établies en créant des instances de la classe de base de PDO. Peut importe quel driver vous voulez utiliser ; vous utilisez toujours le nom de la classe PDO. Le constructeur accepte des paramètres pour spécifier la source de la base de données (connue en tant que DSN) et optionnellement, le nom d’utilisateur et le mot de passe (s’il y en a un).

<?php
$dbh = new PDO('mysql:host=localhost;dbname=test', $user, $pass);
?>

S’il y a des erreurs de connexion, un objet “PDOException” est lancé. Vous pouvez attraper cette exception si vous voulez gérer cette erreur, ou laisser le gestionnaire global d’exception défini via la fonction set_exception_handler() la traiter.

<?php
try {
   $dbh = new PDO('mysql:host=localhost;dbname=test', $user, $pass);
   foreach ($dbh->query('SELECT * from FOO') as $row) {
      print_r($row);
   }
   $dbh = null;
} catch (PDOException $e) {
print "Erreur ! : " . $e->getMessage() . "<br/>";
die();
}
?>

Lorsque la connexion à la base de données a réussi, une instance de la classe PDO est retournée à votre script. La connexion est active tant que l’objet PDO l’est. Pour clore la connexion, vous devez détruire l’objet en vous assurant que toutes ses références sont effacées. Vous pouvez faire cela en assignant “NULL” à la variable gérant l’objet. Si vous ne le faites pas explicitement, PHP fermera automatiquement la connexion lorsque le script arrivera à la fin.

<?php
$dbh = new PDO('mysql:host=localhost;dbname=test', $user, $pass);
// utiliser la connexion ici
 
 
// et maintenant, fermez-la !
$dbh = null;
?>

Beaucoup d’applications web utilisent des connexions persistantes aux serveurs de base de données. Les connexions persistantes ne sont pas fermées à la fin du script, mais sont mises en cache et réutilisées lorsqu’un autre script demande une connexion en utilisant les mêmes paramètres. Le cache des connexions persistantes vous permet d’éviter d’établir une nouvelle connexion à chaque fois qu’un script doit accéder à une base de données, rendant l’application web plus rapide.

<?php
$dbh = new PDO('mysql:host=localhost;dbname=test', $user, $pass, array(
   PDO::ATTR_PERSISTENT => true
));
?>

Note : Si vous utilisez le driver PDO ODBC et que votre bibliothèque ODBC supporte le pool de connexion ODBC (unixODBC et Windows le supportent tous les deux ; peut être plus), alors il est recommandé de ne pas utiliser les connexions persistantes PDO mais plutôt laisser le pool de connexion ODBC mettre en cache les connexions. Le pool de connexion ODBC est partagé avec les autres modules dans le processus ; si PDO met en cache la connexion, alors cette connexion ne sera jamais retournée par le pool de connexion ODBC, faisant que plusieurs connexions sont créées pour les autres modules.

Maintenant que vous êtes connecté via PDO, vous devez comprendre comment PDO gère les transactions avant d’exécuter des requêtes. Si vous n’avez jamais utilisé les transactions, elles offrent 4 fonctionnalités majeures : Atomicité, Consistance, Isolation et Durabilité (ACID). En d’autres termes, n’importe quel travail mené à bien dans une transaction, même s’il est effectué par étapes, est garanti d’être appliqué à la base de données sans risque, et sans interférence pour les autres connexions, quand il est validé. Le travail des transactions peut également être automatiquement annulé à votre demande (en supposant que vous n’avez encore rien validé), ce qui rend la gestion des erreurs bien plus simple dans vos scripts.

Les transactions sont typiquement implémentées pour appliquer toutes vos modifications en une seule fois ; ceci a le bel effet d’éprouver drastiquement l’efficacité de vos mises à jour. Dans d’autres termes, les transactions rendent vos scripts plus rapides et potentiellement plus robustes (vous devez les utiliser correctement pour avoir ces bénéfices).

Malheureusement, toutes les bases de données ne supportent pas les transactions, donc, PDO doit s’exécuter en mode “auto-commit” lorsque vous ouvrez pour la première fois la connexion. Le mode “auto-commit” signifie que toutes les requêtes que vous exécutez ont leurs transactions implicites, si la base de données le supporte ou aucune transaction si la base de données ne les supporte pas. Si vous avez besoin d’une transaction, vous devez utiliser la méthode PDO::beginTransaction() pour l’initialiser. Si le driver utilisé ne supporte pas les transactions, une exception PDO sera lancée (en accord avec votre gestionnaire d’erreurs : ceci est toujours une erreur sérieuse). Une fois que vous êtes dans une transaction, vous devez utiliser la fonction PDO::commit() ou la fonction PDO::rollBack() pour la terminer, suivant le succès de votre code durant la transaction.

Lorsque le script se termine ou lorsque la connexion est sur le point de se fermer, si vous avez une transaction en cours, PDO l’annulera automatiquement. Ceci est une mesure de sécurité afin de garantir la consistance de vos données dans le cas où le script se termine d’une façon inattendue. Si vous ne validez pas explicitement la transaction, alors, on présume que quelque chose s’est mal passé et l’annulation de la transaction intervient afin de garantir la sécurité de vos données.

Dans l’exemple suivant, supposons que nous allons créer un jeu d’entrées pour un nouvel employé, dont le numéro d’ID sera 23. En plus des données basiques sur cette personne, nous devons également lui enregistrer son salaire. Il est très simple d’effectuer deux mises à jour séparées, mais en les enfermant dans les appels des fonctions PDO::beginTransaction() et PDO::commit(), nous garantissons que personne ne pourra voir ces modifications tant qu’elles ne seront pas complètes. Si quelque chose tourne mal, le bloc de capture annulera toutes les modifications effectuées depuis le début de la transaction et affichera un message d’erreur.

<?php
try {
    $dbh = new PDO('odbc:SAMPLE', 'db2inst1', 'ibmdb2',
        array(PDO::ATTR_PERSISTENT => true));
    echo "Connecté\n";
    $dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
 
    $dbh->beginTransaction();
    $dbh->exec("insert into staff (id, first, last) values (23, 'Joe', 'Bloggs')");
    $dbh->exec("insert into salarychange (id, amount, changedate) 
    values (23, 50000, NOW())");
    $dbh->commit();
 
} catch (Exception $e) {
    $dbh->rollBack();
    echo "Échec : " . $e->getMessage();
}
?>

Vous n’êtes pas limité dans le nombre de mises à jour dans une transaction ; vous pouvez également y effectuer des requêtes complexes et bien sûr, utiliser ces informations pour construire d’autres mises à jour et requêtes ; durant l’activité de la transaction, vous êtes garanti que personne d’autre ne peut effectuer des modifications alors que vous êtes au milieu de vos modifications. En réalité, ceci n’est pas 100% correct, mais cela reste une très bonne introduction aux transactions.

La plupart des bases de données supportent le concept des requêtes préparées. Qu’est-ce donc ? Vous pouvez les voir comme une sorte de modèle compilé pour le SQL que vous voulez exécuter, qui peut être personnalisé en utilisant des variables en guise de paramètres. Les requêtes préparées offrent deux fonctionnalités essentielles :

• La requête ne doit être analysée (ou préparée) qu’une seule fois, mais peut être exécutée plusieurs fois avec des paramètres identiques ou différents. Lorsque la requête est préparée, la base de données va analyser, compiler et optimiser son plan pour exécuter la requête. Pour les requêtes complexes, ce processus peut prendre assez de temps, ce qui peut ralentir vos applications si vous devez répéter la même requête plusieurs fois avec différents paramètres. En utilisant les requêtes préparées, vous évitez ainsi de répéter le cycle analyser/compilation/optimisation. Pour résumer, les requêtes préparées utilisent moins de ressources et s’exécutent plus rapidement.
• Les paramètres pour préparer les requêtes n’ont pas besoin d’être entre guillemets ; le driver le gère pour vous. Si votre application utilise exclusivement les requêtes préparées, vous pouvez être sûr qu’aucune injection SQL n’est possible (Cependant, si vous construisez d’autres parties de la requête en vous basant sur des entrées utilisateurs, vous continuez à prendre un risque).

Les requêtes préparées sont tellement pratiques que c’est l’unique fonctionnalité que PDO émule pour les drivers qui ne les supportent pas. Ceci assure de pouvoir utiliser la même technique pour accéder aux données, sans se soucier des capacités de la base de données.

Cet exemple effectue une requête INSERT en y substituant un “nom” et une “valeur” pour les marqueurs nommés.

<?php
$stmt = $dbh->prepare("INSERT INTO REGISTRY (nom, valeur) VALUES (:nom, :valeur)");
$stmt->bindParam(':nom', $nom);
$stmt->bindParam(':valeur', $valeur);
 
// insertion d'une ligne
$nom = 'one';
$valeur = 1;
$stmt->execute();
 
// insertion d'une autre ligne avec des valeurs différentes
$nom = 'two';
$valeur = 2;
$stmt->execute();
?>

Cet exemple effectue une requête INSERT en y substituant un “nom” et une “valeur” pour les marqueurs “?”.

<?php
$stmt = $dbh->prepare("INSERT INTO REGISTRY (nom, valeur) VALUES (?, ?)");
$stmt->bindParam(1, $nom);
$stmt->bindParam(2, $valeur);
 
// insertion d'une ligne
$nom = 'one';
$valeur = 1;
$stmt->execute();
 
// insertion d'une autre ligne avec différentes valeurs
$nom = 'two';
$valeur = 2;
$stmt->execute();
?>

Cet exemple récupère des données basées sur la valeur d’une clé fournie par un formulaire. L’entrée utilisateur est automatiquement échappée, il n’y a donc aucun risque d’attaque par injection SQL.

<?php
$stmt = $dbh->prepare("SELECT * FROM REGISTRY where nom = ?");
if ($stmt->execute(array($_GET['nom']))) {
while ($row = $stmt->fetch()) {
print_r($row);
}
}
?>

Si le driver de la base de données le supporte, vous pouvez également lier des paramètres aussi bien pour l’entrée que pour la sortie. Les paramètres de sortie sont utilisés typiquement pour récupérer les valeurs d’une procédure stockée. Les paramètres de sortie sont un peu plus complexe à utiliser que les paramètres d’entrée car vous devez savoir la longueur d’un paramètre donné pourra atteindre lorsque vous le liez. Si la valeur retournée est plus longue que la taille qui vous auriez suggéré, une erreur sera émise.

<?php
$stmt = $dbh->prepare("CALL sp_returns_string(?)");
$stmt->bindParam(1, $return_value, PDO::PARAM_STR, 4000);
 
// Appel de la procédure stockée
$stmt->execute();
 
print "La procédure a retourné : $return_value\n";
?>

Vous devez également spécifier les paramètres qui gèrent les valeurs aussi bien pour l’entrée que pour la sortie ; la syntaxe est similaire aux paramètres de sortie. Dans le prochain exemple, la chaîne ‘Bonjour’ est passée à la procédure stockée et lorsqu’elle retourne la valeur, ‘Bonjour’ est remplacée par la valeur retournée par la procédure.

<?php
$stmt = $dbh->prepare("CALL sp_takes_string_returns_string(?)");
$value = 'Bonjour';
$stmt->bindParam(1, $value, PDO::PARAM_STR|PDO::PARAM_INPUT_OUTPUT, 4000); 
 
// appel de la procédure stockée
$stmt->execute();
 
print "La procédure a retourné : $value\n";
?>

<?php
$stmt = $dbh->prepare("SELECT * FROM REGISTRY where nom LIKE '%?%'");
$stmt->execute(array($_GET['nom']));
 
// un marqueur doit être utilisé à la place d'une valeur complète
$stmt = $dbh->prepare("SELECT * FROM REGISTRY where nom LIKE ?");
$stmt->execute(array("%$_GET[nom]%"));
?>

PDO offre la possibilité de gérer les erreurs de 3 façons différentes, pour coller au mieux au style de votre application.

• “PDO::ERRMODE_SILENT”

C’est le mode par défaut. PDO définit simplement le code erreur pour vous afin de l’inspecter en utilisant les méthodes PDO::errorCode() et PDO::errorInfo() sur la requête ou sur les objets de la base de données ; si l’erreur est issue d’un appel à un objet de requête, vous devriez invoquer les méthodes PDOStatement::errorCode() ou PDOStatement::errorInfo() sur cet objet. Si l’erreur est issue d’un appel sur un objet de la base de données, vous devriez invoquer à la place les méthodes de cet objet.

• “PDO::ERRMODE_WARNING”

En plus de définir le code erreur, PDO émettra un message de niveau E_WARNING. Ce comportement est très utile lors de la phase de test/débogage, si vous voulez juste voir le problème qui survient sans pour autant stopper le flot de l’application.

• “PDO::ERRMODE_EXCEPTION”

En plus de définir le code erreur, PDO lancera une exception PDOException et y définit ces propriétés pour refléter le code erreur et l’information sur l’erreur. Ce comportement est utile également durant la période de débogage car il va stopper l’application à l’endroit même de l’erreur et pointer l’endroit où se trouve potentiellement l’erreur dans votre code (souvenez-vous : les transactions sont automatiquement annulées si l’exception fait que le script se termine).
Le mode lançant des exceptions est également utile pour structurer la gestion de vos erreurs plus clairement que par la traditionnelle gestion des erreurs de PHP et avec moins de code, plutôt que le mode silencieux et l’analyse explicite des valeurs retournées par chaque appel à la base de données.
Lisez la documentation sur les exceptions pour plus de détails sur les exceptions en PHP.

PDO standardise les codes erreurs en utilisant SQL-92 SQLSTATE ; les drivers individuels PDO sont responsables du mapping de leurs propres codes avec les codes SQLSTATE appropriées. La méthode PDO::errorCode() retourne un seul code SQLSTATE. Si vous avez besoin de plus d’informations sur une erreur, PDO fournit également la méthode PDO::errorInfo() qui retourne un tableau contenant le code SQLSTATE, le code erreur spécifique du driver et la chaîne erreur spécifique au driver.

À un moment dans votre application, vous pourriez avoir besoin de stocker de larges données dans votre base de données. “Large” signifie typiquement des données d’environ 4ko ou plus, bien que certaines bases de données peuvent gérer plus de 32ko avant que les données deviennent “larges”. Les objets larges peuvent être de nature textuelle ou binaire. PDO vous permet de travailler avec ce type de larges données en utilisant le code type “PDO::PARAM_LOB” dans vos appels aux fonctions PDOStatement::bindParam() ou PDOStatement::bindColumn(). “PDO::PARAM_LOB” demande à PDO de mapper les données en un flux que vous pourrez manipuler en utilisant l’API PHP sur les flux.

Cet exemple lie un LOB dans une variable nommée $lob et l’envoie au navigateur en utilisant la fonction fpassthru(). Étant donné qu’un LOB est représenté en un flux, les fonctions comme fgets(), fread() et stream_get_contents() peuvent être utilisées sur ce flux.

<?php
$db = new PDO('odbc:SAMPLE', 'db2inst1', 'ibmdb2');
$stmt = $db->prepare("select contenttype, imagedata from images where id=?");
$stmt->execute(array($_GET['id']));
$stmt->bindColumn(1, $type, PDO::PARAM_STR, 256);
$stmt->bindColumn(2, $lob, PDO::PARAM_LOB);
$stmt->fetch(PDO::FETCH_BOUND);
 
header("Content-Type: $type");
fpassthru($lob);
?>

Cet exemple ouvre un fichier et passe le pointeur de fichier à PDO pour l’insérer en tant que LOB. PDO fera son possible pour récupérer le contenu du fichier et l’insérer dans la base de données de la manière la plus efficace possible.

<?php
$db = new PDO('odbc:SAMPLE', 'db2inst1', 'ibmdb2');
$stmt = $db->prepare("insert into images (id, contenttype, imagedata) values (?, ?, ?)");
$id = get_new_id(); // fonction pour allouer un nouvel ID
 
// assumons que nous récupérons un fichier depuis un formulaire
// vous pouvez trouver plus de détails dans la documentation de PHP
 
$fp = fopen($_FILES['file']['tmp_name'], 'rb');
 
$stmt->bindParam(1, $id);
$stmt->bindParam(2, $_FILES['file']['type']);
$stmt->bindParam(3, $fp, PDO::PARAM_LOB);
 
$stmt->beginTransaction();
$stmt->execute();
$stmt->commit();
?>

Oracle requiert une syntaxe légèrement différente pour y insérer un LOB depuis un fichier. Il est également essentiel d’effectuer votre insertion au sein d’une transaction, sinon, votre nouveau LOB sera inséré avec une longueur de zéro :

<?php$db = new PDO('oci:', 'scott', 'tiger');
$stmt = $db->prepare("insert into images (id, contenttype, imagedata) " .
"VALUES (?, ?, EMPTY_BLOB()) RETURNING imagedata INTO ?");
$id = get_new_id(); // fonction pour allouer un nouvel ID
 
// assumons que nous récupérons un fichier depuis un formulaire
// vous pouvez trouver plus de détails dans la documentation de PHP
 
$fp = fopen($_FILES['file']['tmp_name'], 'rb');
 
$stmt->bindParam(1, $id);
$stmt->bindParam(2, $_FILES['file']['type']);
$stmt->bindParam(3, $fp, PDO::PARAM_LOB);
 
$stmt->beginTransaction();
$stmt->execute();
$stmt->commit();
?>

Représente une connexion entre PHP et un serveur de base de données.

• PDO - construit un nouvel objet PDO

• beginTransaction - commence une transaction
• commit - valide une transaction
• errorCode - récupère un code erreur, s’il y en a, depuis la base de données
• errorInfo - récupère un tableau contenant les informations sur l’erreur, s’il y en a, depuis la base de données
• exec - exécute une requête SQL et retourne le nombre de lignes affectées
• getAttribute - récupère un attribut d’une connexion à une base de données
• lastInsertId - récupère la valeur de la dernière ligne insérée dans une table
• prepare - prépare une requête SQL pour exécution
• query - exécute une requête SQL et retourne le jeu de résultats
• quote - retourne une version protégée d’une chaîne pour utilisation dans une requête SQL
• rollBack - annule une transaction
• setAttribute - définit un attribut d’une connexion à une base de données

Représente une requête préparée et, après exécution de la requête, un jeu de résultat associatif.

• bindColumn - lie une variable PHP à une colonne de sortie dans un jeu de résultats
• bindParam - lie une variable PHP à un paramètre dans une requête préparée
• bindValue - lie une valeur à un paramètre dans une requête préparée
• closeCursor - ferme le curseur, autorisant la requête à être exécutée une nouvelle fois
• columnCount - retourne le nombre de colonnes dans un jeu de résultats
• errorCode - récupère le code erreur, s’il y en a, depuis une requête
• errorInfo - récupère un tableau contenant les informations sur une erreur, s’il y en a, depuis une requête
• execute - exécute une requête préparée
• fetch - récupère une ligne depuis un jeu de résultats
• fetchAll - récupère un tableau contenant toutes les lignes depuis un jeu de résultats
• fetchColumn - retourne les données depuis une colonne d’un jeu de résultats
• getAttribute - récupère un attribut PDOStatement
• getColumnMeta - récupère les méta-informations pour une colonne d’un jeu de résultats
• nextRowset - récupère la ligne suivante (du jeu de résultats)
• rowCount - retourne le nombre de lignes affectées par l’exécution d’une requête SQL
• setAttribute - définit un attribut PDOStatement
• setFetchMode - définit le mode de récupération pour une PDOStatement

Représente une erreur émise par PDO. Vous ne devriez pas lancer une exception PDOException depuis votre propre code. Lisez la documentation sur les Exceptions pour plus de détails sur les exceptions en PHP.

<?php
class PDOException extends Exception
{
public $errorInfo = null;    // correspond à PDO::errorInfo()
// ou PDOStatement::errorInfo()
protected $message;          // message d'erreur textuel
// utiliser Exception::getMessage() pour y accéder
protected $code;             // code erreur SQLSTATE
// utiliser Exception::getCode() pour y accéder
}
?>

Ces constantes sont définies par cette extension, et ne sont disponibles que si cette extension a été compilée avec PHP, ou bien chargée au moment de l’exécution.

“PDO::PARAM_BOOL” (entier)

Représente le type de données booléen.

“PDO::PARAM_NULL” (entier)

Représente le type de données NULL SQL.

“PDO::PARAM_INT” (entier)

Représente le type de données INTEGER SQL.

“PDO::PARAM_STR” (entier)

Représente les types de données CHAR, VARCHAR ou les autres types de données sous forme de chaîne de caractères SQL.

“PDO::PARAM_LOB” (entier)

Représente le type de données “objet large” SQL.

“PDO::PARAM_STMT” (entier)

Représente un type de jeu de résultats. N’est actuellement pas supporté par tous les drivers.

“PDO::PARAM_INPUT_OUTPUT” (entier)

Spécifie que le paramètre est un paramètre INOUT pour une procédure stockée. Vous devez utiliser l’opérateur OR avec un type de données explicite PDO::PARAM_*.

“PDO::FETCH_LAZY” (entier)

Spécifie que la méthode de récupération doit retourner chaque ligne en tant qu’objet avec les noms de variables correspondant aux noms des colonnes retournées dans le jeu de résultats. PDO::FETCH_LAZY crée les noms des variables de l’objet comme ils sont rencontrés.

“PDO::FETCH_ASSOC” (entier)

Spécifie que la méthode de récupération doit retourner chaque ligne dans un tableau indexé par les noms des colonnes comme elles sont retournées dans le jeu de résultats correspondant. Si le jeu de résultats contient de multiples colonnes avec le même nom, PDO::FETCH_ASSOC retourne une seule valeur par nom de colonne.

“PDO::FETCH_NAMED” (entier)

Spécifie que la méthode de récupération doit retourner chaque ligne dans un tableau indexé par les noms des colonnes comme elles sont retournées dans le jeu de résultats correspondant. Si le jeu de résultats contient de multiples colonnes avec le même nom, PDO::FETCH_NAMED retourne un tableau de valeurs par nom de colonne.

“PDO::FETCH_NUM” (entier)

Spécifie que la méthode de récupération doit retourner chaque ligne dans un tableau indexé par le numéro des colonnes comme elles sont retournées dans le jeu de résultats correspondant, en commençant à 0.

“PDO::FETCH_BOTH” (entier)

Spécifie que la méthode de récupération doit retourner chaque ligne dans un tableau indexé par les noms des colonnes ainsi que leurs numéros, comme elles sont retournées dans le jeu de résultats correspondant, en commençant à 0.

“PDO::FETCH_OBJ” (entier)

Spécifie que la méthode de récupération doit retourner chaque ligne dans un objet avec les noms de propriétés correspondant aux noms des colonnes comme elles sont retournées dans le jeu de résultats.

“PDO::FETCH_BOUND” (entier)

Spécifie que la méthode de récupération doit retourner “TRUE” et assigner les valeurs des colonnes du jeu de résultats dans les variables PHP auxquelles elles sont liées avec la méthode PDOStatement::bindParam() ou la méthode PDOStatement::bindColumn().

“PDO::FETCH_COLUMN” (entier)

Spécifie que la méthode de récupération doit retourner uniquement une seule colonne demandée depuis la prochaine ligne du jeu de résultats.

“PDO::FETCH_CLASS” (entier)

Spécifie que la méthode de récupération doit retourner une nouvelle instance de la classe demandée, liant les colonnes aux propriétés nommées dans la classe.

“PDO::FETCH_INTO” (entier)

Spécifie que la méthode de récupération doit mettre à jour une instance existante de la classe demandée, liant les colonnes aux propriétés nommées dans la classe.

“PDO::FETCH_FUNC” (entier)

“PDO::FETCH_GROUP” (entier)

“PDO::FETCH_UNIQUE” (entier)

“PDO::FETCH_CLASSTYPE” (entier)

“PDO::FETCH_SERIALIZE” (entier)

Disponible depuis PHP 5.1.0.

“PDO::FETCH_PROPS_LATE” (entier)

Disponible depuis PHP 5.2.0

“PDO_ATTR_AUTOCOMMIT” (entier)

Si la valeur vaut “FALSE”, PDO tente de désactiver l’auto-validation lorsque la connexion commence une transaction.

“PDO::ATTR_PREFETCH” (entier)

Définir la taille de la pré-récupération vous permet d’accroître les performances de votre application. Toutes les combinaisons bases de données / drivers ne supportent pas cette fonctionnalité. Ceci accroît les performances au détriment de la consommation de mémoire vive.

“PDO::ATTR_TIMEOUT” (entier)

Définit la valeur d’attente en secondes pour les communications avec la base de données.

“PDO::ATTR_ERRMODE” (entier)

“PDO::ATTR_SERVER_VERSION” (entier)

Attribut en lecture seule ; il retourne des informations sur la version de la base de données à laquelle PDO est connecté.

“PDO::ATTR_CLIENT_VERSION” (entier)

Attribut en lecture seule ; il retourne des informations sur la version de la bibliothèque cliente utilisée par PDO.

“PDO::ATTR_SERVER_INFO” (entier)

Attribut en lecture seule ; il retourne quelques meta-informations sur le serveur de base de données auquel PDO est connecté.

“PDO::ATTR_CONNECTION_STATUS” (entier)

“PDO::ATTR_CASE” (entier)

Force les noms des colonnes dans une casse spécifiée par les constantes PDO::CASE_*.

“PDO::ATTR_CURSOR_NAME” (entier)

Récupère ou définit le nom à utiliser pour un curseur. Très utile lors de l’utilisation de curseurs scrollables et des mises à jour positionnées.

“PDO::ATTR_CURSOR” (entier)

Sélectionne le type de curseur. PDO supporte actuellement soit “PDO::CURSOR_FWDONLY”, soit “PDO::CURSOR_SCROLL”. Conserver “PDO::CURSOR_FWDONLY” tant que vous savez que vous avez besoin d’un curseur scrollable.

“PDO::ATTR_DRIVER_NAME” (chaîne de caractères)

Retourne le nom du driver.

<?php
if ($db->getAttribute(PDO::ATTR_DRIVER_NAME) == 'mysql') {
   echo "Utilisation de mysql ; fait quelque chose de spécifique à mysql ici\n";
}
?>

“PDO::ATTR_ORACLE_NULLS” (entier)

Convertit les chaînes vides en valeurs NULL SQL dans les données récupérées.

“PDO::ATTR_PERSISTENT” (entier)

“PDO::ATTR_STATEMENT_CLASS” (entier)

“PDO::ATTR_FETCH_CATALOG_NAMES” (entier)

Ajoute le contenu du catalogue de noms dans chaque nom de colonnes retourné dans le jeu de résultat. Le catalogue de noms et les noms de colonnes sont séparés par un point (.). Le support de cet attribut n’est pas disponible pour tous les drivers ; il peut ne pas être disponible pour votre driver.

“PDO::ATTR_FETCH_TABLE_NAMES” (entier)

Ajoute le contenu de la table de noms dans chaque nom de colonne retourné dans le jeu de résultats. La table de nom et les noms de colonnes sont séparés par un point (.). Le support de cet attribut n’est pas disponible pour tous les drivers ; il peut ne pas être disponible pour votre driver.

“PDO::ATTR_STRINGIFY_FETCHES” (entier)

“PDO::ATTR_MAX_COLUMN_LEN” (entier)

“PDO::ATTR_DEFAULT_FETCH_MODE” (entier)

Disponible depuis PHP 5.2.0.

“PDO::ATTR_EMULATE_PREPARES” (entier)

Disponible depuis PHP 5.1.3.

“PDO::ERRMODE_SILENT” (entier)

“PDO::ERRMODE_WARNING” (entier)

“PDO::ERRMODE_EXCEPTION” (entier)

“PDO::CASE_NATURAL” (entier)

Laisse les noms de colonnes comme retournés par le driver de base de données.

“PDO::CASE_LOWER” (entier)

Force les noms de colonnes en minuscule.

“PDO::CASE_UPPER” (entier)

Force les noms des colonnes en majuscule.

“PDO::NULL_NATURAL” (entier)

“PDO::NULL_EMPTY_STRING” (entier)

“PDO::NULL_TO_STRING” (entier)

“PDO::FETCH_ORI_NEXT” (entier)

Récupère la prochaine ligne d’un jeu de résultats. Valide seulement pour les curseurs scrollables.

“PDO::FETCH_ORI_PRIOR” (entier)

Récupère la ligne précédente d’un jeu de résultats. Valide seulement pour les curseurs scrollables.

“PDO::FETCH_ORI_FIRST” (entier)

Récupère la première ligne d’un jeu de résultats. Valide seulement pour les curseurs scrollables.

“PDO::FETCH_ORI_LAST” (entier)

Récupère la dernière ligne d’un jeu de résultats. Valide seulement pour les curseurs scrollables.

“PDO::FETCH_ORI_ABS” (entier)

Récupère la ligne demandée par un numéro de ligne d’un jeu de résultats. Valide seulement pour les curseurs scrollables.

“PDO::FETCH_ORI_REL” (entier)

Récupère la ligne demandée par une position relative à la position courante du curseur d’un jeu de résultats. Valide seulement pour les curseurs scrollables.

“PDO::CURSOR_FWDONLY” (entier)

Crée un objet PDOStatement avec un curseur uniquement de retour. C’est le choix par défaut pour le curseur, car il est rapide et l’accès aux données est commun pour les masques en PHP.

“PDO::CURSOR_SCROLL” (entier)

Crée un objet PDOStatement avec un curseur scrollable. Passez la constante PDO::FETCH_ORI_* pour contrôler les lignes récupérées du jeu de résultats.

“PDO::ERR_NONE” (chaîne de caractères)

Correspond à SQLSTATE ‘00000’, ce qui signifie que la requête SQL a réussi sans erreur, ni avertissement. Cette constante est utile lorsque vous utilisez PDO::errorCode() ou PDOStatement::errorCode() pour déterminer si une erreur est survenue. Cependant, vous devez déjà savoir si c’est le cas en examinant le code retourné par la méthode qui a lancée l’erreur.

“PDO::PARAM_EVT_ALLOC” (entier)

Alloue un événement

“PDO::PARAM_EVT_FREE” (entier)

Désalloue un événement

“PDO::PARAM_EVT_EXEC_PRE” (entier)

Toujours faire un trigger avant l’éxécution d’une requête préparée.

“PDO::PARAM_EVT_EXEC_POST” (entier)

Toujours effectuer un trigger de sous séquence avant l’exécution d’une requête préparée.

“PDO::PARAM_EVT_FETCH_PRE” (entier)

Toujours effectuer un trigger avant de récupérer un résultat d’un jeu de résultats.

“PDO::PARAM_EVT_FETCH_POST” (entier)

Toujours effectuer un trigger de sous séquence avant de récupérer un résultat d’un jeu de résultats.

“PDO::PARAM_EVT_NORMALIZE” (entier)

Toujours effectuer un trigger lors de l’enregistrement des paramètres liés permettant au driver de normaliser le nom des paramètres.

Table des matières

PDO::beginTransaction –  Démarre une transaction PDO::commit –  Valide une transaction PDO::__construct –  Crée une instance PDO qui représente une connexion à une base de données 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 –  Retourne un tableau des pilotes PDO disponibles 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 –  Définie un attribut 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’objetPDOStatement::getAttribute –  Récupère un attribut de requête PDOStatement::getColumnMeta –  Retourne les méta-donné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