Skip to content

Les bases de données

Toutes les fonctions débutant par mysql_* sont compilées directement dans PHP, alors que pour les autres SGBD, il faut activer les extensions dans le PHP.ini.

Les extensions

  • Sybase
  • SQLite : c’est un SGBD type fichier.
  • PDO : Avec cette extension on peut acceder aux bases de données suivantes :
    • Sqlite
    • Postgresql
    • Interbase
    • Firebird
    • Informix
    • MSSQL
    • MySQL
    • Oracle
    • ODBC
    • sybase
    • DB2
    • OCI8 (Oracle)
    • MySQL / MySQLi (mySQL > 4.0 => pas de transactions, ni de prepared statements)
    • ODBC
    • Firebird
    • Interbase
    • Informix
    • MaxDB (SGBDR concu pour gérer les produits de SAP qui est un client MySQL)
    • Frontbase
    • MSQL

    PHP permet donc d’exploiter quasiment toutes les BDD soit directement, soit via ODBC

    Utilisation des extensions

    Les APIs : tout ce qui est procédural et objets

    Les erreurs : exceptions ou erreurs

      API Erreur  
    Extension Procédure Objet PHP Exception
    ODBC X   X  
    MySQL X   X  
    MySQLi X X X  
    PDO   X X  
    SQLite X X    

    PDO : avantages et inconvéniants

    PDO signifiant PHP Data Object, est une couche d’abstraction pour l’acces aux données. PDO fournit un ensemble de fonctions communes à tout les SGBD. Les requêtes par contre restent dépendantes du SGBD (ex: on peut utiliser LIMIT avec MYSQL alors qu’avec MSSQL non.)

    Avantages Inconvéniants
    Les API communes à tout les SGBD. Il y à moins de fonctionnalitées spécifiques aux SGBD
    PDO émule les requête préparées même pour les SGBD ne les supportant pas. Plus Lent que les extensions de bases
    Supporte un grand nombre de SGBD.  

    Pour utiliser PDO, il faut activer l’extension php_pdo.dll dans le php.ini et activer les drivers pour le SGBD souhaité (php_pdo_*).

    ODBC

    Pour pouvoir utiliser ODBC, il faut installer le client.

    $cnx = odbc_connect('mysql_world', 'root', '');
$requete = 'SELECT COUNT(*) FROM Country';
$res = odbc_exec($cnx,$requete);
var_dump(odbc_fetch_array($res));
odbc_close($cnx);

    MySQLi

    La diférence entre MySQL et MySQLi réside dans le fait qu’il faut toujours stocker la connexion dans une variable pour ensuite la passer dans une fonction MySQLi*

    Il est possible de créer des requêtes préparées avec MySQLi? Pour travailler avec MySQLi, il faudra se connecter avec mysqli_connect :

    $identifiant = mysqli_connect(host,user[, passe, nom base de données, port, socket]);

    Pour réaliser la requête préparée, on utilisera mysqli_prepare

    Attention : MySQLi ne peut executer une autre requête a condition d’avoir consommer l’ensemble du jeu de resultat précédent. A défaut de la consommer entierement, il faudra libérer le resultat de la requête manuellement. Cela ne s’applique uniquement au tampon (mysqli_query les requetes sont mise en tampon).

    MySQLi permet de réaliser plusiers requêtes à la fois, grâce à mysqli_multi_query. Pour parcourir ses multirésultat, on emploira mysqli_next_result. MySQLi peut utiliser aussi une version orientée objet car en employant la méthode query(requete) de la connexion ($objet = $cnx->query($sql) ), on obtiendra un objet. On pourra, via cet objet, manipuler les données. Ex : 

    $cnx = mysqli_connect(...);
$obj = $cnx->query($requete);
var_dump($obj->fetch_assoc());
$obj->free_result(); //Libere le tampon

    Exemple avec des requetes multiples :

    //Connexion à la BDD
$link = mysqli_connect('localhost','root','mysql50','world','3306');
 
//Requetes
$query  = "SELECT Name FROM country LIMIT 10;";
$query .= "SELECT Name FROM City LIMIT 10";
 
//Execute la requête multiple et la met en tampon
if (mysqli_multi_query($link, $query)) {
	//Tant qu'on à des resultats, on affiche les affiche
    do {
		//On stocke le jeu de résultat d'une requete
        if ($result = mysqli_use_result($link)) {
			//Boucle d'affichage
            while (list($name) = mysqli_fetch_row($result)) {
			   echo $name.'<br/>';
            }
			//On libere le tampon
            mysqli_free_result($result);
        }
		//Si on arrive à la fin d'une requete, on sépare les jeux de resultats
        if (mysqli_more_results($link)) {
            echo '<br/><br/><br/>';
        }
    } while (mysqli_next_result($link));
}
mysqli_close($link);

    MySQL

    La librairie MySQL est la librairie la plus répandue et la plus utilisée sur le web.

    1. Connexion avec mysql_connect qui retournera une ressource SGBD. Certains SGBD requiert le nom de la base de données lors de la connexion
    2. Selection de la base en employant mysql_select_db(nom_base,ressource mysql retournée par mysql_connect)
    3. Execution des requetes avec mysql_query(requete[, ressource])
      • Avec un jeu de resultat de type SELECT/SHOW, MySQL renvoi une ressource mysql si la requete est correctement formulée sinon false
      • Avec un jeu de resultat de type CREATE/ALTER/INSERT/DELETE…, MySQL renvoi true si la requete est correctement formulée sinon false
    4. Récupération des erreurs si il y en a avec :
      • mysql_error([ressource]) : renvoi le mesage d’erreur
      • mysql_errno([ressource]) : renvoi le numéro d’erreur
    5. Exploiter le jeu de resultat
      • mysql_fetch_array(ressource sql retournée par mysql_query[, mode de fonctionnement]) : Renvoi le jeu sous forme de tableau. Par défaut, le mode de fonctionnement est MYSQL_BOTH : renvoi une ligne de resulat sous forme de array associatif et nom associatif
        MYSQL_ASSOC : renvoi un tableau associatif
        MYSQL_NUM : renvoi une ligne de resultat sous format tableau numérique
      • mysql_fetch_assoc : equivalent de mysql_fetch_array
      • mysql_fetch_field – Retourne les données enregistrées dans une colonne MySQL sous forme d’objet
      • mysql_fetch_lengths – Retourne la taille de chaque colonne d’une ligne de résultat MySQL dans un tableau
      • mysql_fetch_object – Renvoi un objet de type stdclass. L’objet disposera d’une propriété portant le nom de la colonne.
      • mysql_fetch_row : mysql_fetch_array avec la constant MYSQL_NUM
    6. Libérer la mémoire : la libération de la mémoire s’effectue par mysql_free_result(ressource)
    7. Fermeture de la connexion avec mysql_close([ressource])
    $link = mysql_connect('localhost','root','mysql50') or die(mysql_error());
if(mysql_select_db('world')){
	$query = 'SELECT Name FROM Country LIMIT 10';
	$res = mysql_query($query) or die(mysql_error());
	while(list($name) = mysql_fetch_row($res)){
		echo $name, '<br/>';
	}
	mysql_free_result($res);
}else{
	echo 'Erreur de séléction de base de données : '.mysql_error();
}
mysql_close($link);

    SQLite

    SQLite implémente une bibliothèque C qui permet d’avoir un lmoteur de base de données embarquée. Autrement dit, il permet d’avoir un acces à une base de données sans avoir un serveur SQL. Il est l’interface avec le moteur de base SQLite embeddable SQL Database Engine. Lorsque l’on créera une base SQLite, ce dernier va créer un repertoire ou encore un fichier sur le disque.

    $oSQLite = new SQLiteDatabase('myDB');
//Execution de requete sans valeur de retour
$oSQLite->queryExec($query);
//Requete avec valeur de retour
$oSQLite->query($query);
//Travailler avec le jeu de resultat
$oSQLite->fetch();

    Il est possible d’attribuer une fonction utilisateur à SQLite via la méthode createFunction : 

    void createFunction  ( string $function_name  , callback $callback  [, int $num_args  ] )

    SQLite ne se préoccupe pas du type des champs lors de la création d’une table : 

    //Création de base
$db = new SQLiteDatabase('test.db');
//Création de la table
$db->queryExec('CREATE TABLE test (i)');
//Insertion
$db->query('INSERT INTO test VALUES(8)');
//Requete
$requete = 'SELECT * FROM test';
$resultat = $db->query($requete);
var_dump($resultat->fetch());
//Ajout de fonctions a SQLite
function auCarrePHP($valeur){
	return $valeur*$valeur;
}
$db->createFunction('auCarreSQL','auCarrePHP');
$requete = 'SELECT i, auCarreSQL(i) FROM test';
$resultat = $db->query($requete);
var_dump($resultat->fetch());

    Meme si SQLite ne comprend pas une fonction, il est possible de rajouter nos propres fonctions.

    PHP Data Object

    PDO est une API orientée objet pour l’acces aux bases de données. PDO supporte les requêtes multiples.

    1. Connexion : $pdo = new PDO(‘nom source de données’,'utilisateur’,'mot de passe’,'options’). Le nom de la source de données varie en fonction de le SGBD que l’on souhaite utiliser : driver:… voir ici
    2. Execution des requetes via la méthode exec de l’objet pour récuperer des données ou encore via exec pour les requetes sans retour. On peut comme pour mysqli faire des requetes préparées. Dans ce cas la, on utilisera les méthodes bindParam et bindValue.

      bindParam prend la valeur en parametre par REFERENCE, on pourra donc placer la velur avant ou apres (comme pour mysqli). bindValue provoquera une erreur si on l’attribue apres.
    3. Récuperer les données : on a a notre disposition deux méthodes
      • fetch(FETCH_BOTH,FETCH_ASSOC,FETCH_NUM,FETCH_OBJ)
      • fetchALL(FETCH_BOTH,FETCH_ASSOC,FETCH_NUM,FETCH_OBJ) qui retournera toutes les lignes
    4. Fermer la connexion : destruction de l’objet ( unset() ) ou par la methode closeCursor()

    PDO dispose de ses propres méthodes de traitement, de valeur de retour, et de valeur d’entrée. PDO supporte la méthodologie ACID, il est donc possible de réaliser des transactions en utilisant la méthode beginTransaction de l’objet. Pour réaliser la transaction, on fera un commit() ou rollBack() pour annuler

    Il est possible de gérer des exceptions et de récuperer les erreurs via errorCode() (sql state) et errorInfo() (retourne un tableau)