L'extension PHP Data Objects (PDO) définit une excellente interface pour accéder à une base de données depuis PHP. Chaque pilote de base de données implémenté dans l'interface PDO peut utiliser des fonctionnalités spécifiques de chacune des bases de données en utilisant des extensions de fonctions. Notez que vous ne pouvez exécuter aucune fonction de base de données en utilisant l'extension PDO par elle-même ; vous devez utiliser un driver PDO spécifique à la base de données pour accéder au serveur de base de données.
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.
Procédure 2. PHP 5.1 et supérieur sur les systèmes Unix
Si vous exécutez une version 5.1 de PHP, PDO et PDO_SQLITE sont inclus dans cette distribution ; il devrait être automatiquement activé lorsque vous lancerez le script de configuration de PHP. Il est recommandé de compiler PDO en tant qu'extension partagée, ce qui vous permettra de mettre à jour PDO via PECL. Il est également recommandé d'activer le support zlib (pour l'installeur PECL) lors de la compilation de PHP. Vous devriez également avoir besoin d'activer le driver PDO correspondant à la base de données de votre choix ; consultez la documentation pour les drivers PDO spécifiques à une base de données pour plus d'informations, mais notez que si vous contruisez PDO en tant qu'extension partagée, vous devez également construire les drivers PDO en tant qu'extensions partagées. L'extension SQLite dépend de PDO, donc, si PDO est construit en tant qu'extension partagée, SQLite doit être construit de la même manière.
./configure --with-zlib --enable-pdo=shared --with-pdo-sqlite=shared --with-sqlite=shared
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
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.
Procédure 3. PHP 5.0.0 et supérieur sur les systèmes Unix
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.
Exécutez la commande suivante pour télécharger, compiler et installer la dernière version stable de PDO :
pecl install pdo
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.
Procédure 4. Utilisateurs de Windows avec PHP 5.1.0 et supérieur
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
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
Ces bibliothèques DDLs doivent exister dans le dossier système extension_dir . Notez que PDO_INFORMIX est seulement disponible en tant qu'extension PECL.
Le comportement de ces fonctions est affecté par la configuration dans le fichier php.ini .
Tableau 248. Options de Configuration PDO
| Nom | Par défaut | Modifiable | Historique |
|---|---|---|---|
Voici un éclaircissement sur l'utilisation des directives de configuration.
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 :
| Nom du driver | Bases de données supportées |
|---|---|
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).
Exemple 1904. Connexion à MySQL
<?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.
Exemple 1905. Gestion des erreurs de connexion
<?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();
}
?>
Si votre application n'attrape pas les exceptions lancées depuis le constructeur PDO, l'action par défaut du moteur zend est de terminer le script et d'afficher une trace. Cette trace devrait révéler des détails complets sur la connexion à la base de données, incluant le nom d'utilisateur et le mot de passe. Il en est donc de votre responsabilité d'attraper cette exception, soit explicitement (via l'instruction catch ) ou implicitement via la fonction set_exception_handler() .
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.
Exemple 1906. Fermeture d'une connexion
<?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.
Exemple 1907. Connexions persistantes
<?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.
L'annulation automatique intervient si vous avez initialisé la transaction via PDO->beginTransaction() . Si vous avez manuellement exécuté une requête qui commence une transaction, PDO n'a aucun moyen de le savoir et donc, n'annulera pas automatiquement cette transaction si quelque chose s'est mal passé.
Exemple 1908. Exécution d'un groupe dans une transaction
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 :
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.
Exemple 1909. Insertions répétitives en utilisant les requêtes préparé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
();
?>
Exemple 1910. Insertions répétées en utilisant des requêtes réparées
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
();
?>
Exemple 1911. Récupération des données en utilisant des requêtes préparées
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.
Exemple 1912. Appel d'une procédure stockée avec un paramètre de sortie
<?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.
Exemple 1913. Appel d'une procédure stockée avec un paramètre d'entrée/sortie
<?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"
;
?>
Exemple 1914. Utilisation invalide de marqueur
<?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 .
Exemple 1915. Affichage d'une image depuis une base de données
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
);
?>
Exemple 1916. Insertion d'une image dans une base de données
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
);
$db
->
beginTransaction
();
$stmt
->
execute
();
$db
->
commit
();
?>
Exemple 1917. Insertion d'une image dans une base de données Oracle
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
();
?>
PDO
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
PDOStatement
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
PDOException
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.
Exemple 1918. La classe PDOException
<?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 utilise les constantes de classe depuis PHP 5.1. Les versions antérieures utilisent les constantes globales sous la forme PDO_PARAM_BOOL .
Retourne le nom du driver.
Exemple 1919. Utilisation de PDO::ATTR_DRIVER_NAME
<?php
if (
$db
->
getAttribute
(
PDO
::
ATTR_DRIVER_NAME
) ==
'mysql'
) {
echo
"Utilisation de mysql ; fait quelque chose de spécifique à mysql ici\n"
;
}
?>
PDOException
si une erreur survient. Voir les erreurs et la gestion des erreurs
pour plus d'informations sur cet attribut.