RevoluGame | Class SQL

Voici l'explication d'une class SQL faite par Jarod (www.webinformatic.fr) avec l'aide de fonctions de Raymond Irving. Cette class permet, entre autre, de se connecter à une base, de faire des requêtes, de supprimer des données, et bien d'autre choses encore.

L'initialisation

Voici quelques variables à définir avant tout pour le bon fonctionnement de cette class.

/**
 * Préfixe de vos tables dans la base de donnée.
 */
public $prefixe;
/**
 * Identifie de manière unique la connexion courante au serveur. 
 * (Id est retourné par mysql_connect)
 */
public $link_id;
public $query_result;
/**
 * Permet de retourner le nombre de requête effectué. 
 * Variable initialisé à 0 bien évidemment.
 */
public $nb_requete = 0;

Le constructeur

Tout d'abord, comme vous pouvez le deviner, commençons par le constructeur.
Il permet la connexion à la base de donnée.

function __construct($db_host, $db_username, $db_password, $db_name, $db_prefixe) {
    // connexion à la base de donnée , 
    // récupération de l'id de connexion si celle-ci a réussi.
    $this->prefixe = $db_prefixe; 
    $this->link_id = @mysql_connect($db_host, $db_username, $db_password);
    // si on a un ID de retour, on a bien une connexion au serveur donc on peut continuer en 
    // sélectionnant la base de donnée demandée.
    if ($this->link_id)  {
        if (@mysql_select_db($db_name, $this->link_id))
            // si la base existe, on retourne l'identifiant synonyme d'une connexion réussie.
            return $this->link_id;
        else // sinon on arrˆte tout et on retourne une erreur
            die('Impossible de sélectionner la base de données: '.mysql_error());
    }
    else
        die('Impossible de se connecter au serveur MySQL: '.mysql_error());
}

Voilà pour ce qui est du constructeur.
Vous suivez ? Alors on continue ...

La méthode permettant de faire une requête de type select

function select($fields = "*", $from = "", $where = "", $orderby = "", $limit = "") {
    // execute une requête de type 'select' et retourne une ressource,
    if (!$from) // si on a pas de donnée pour la variable $from, on retourne une erreur.
        return false;
    else {
        $table = $from;
        $where = ($where != "") ? "WHERE $where" : "";
        $orderby = ($orderby != "") ? "ORDER BY $orderby " : ""; 
        // si la variable $orderby est définie, on ajoute à la requête un champ ORDER BY.
        $limit = ($limit != "") ? "LIMIT $limit" : "";
        ++$this->nb_requete;  // on incrémente la variable pour le calcul du nombre de requête
        return $this->r = mysql_query("SELECT $fields FROM $table $where $orderby $limit");
    }
}

Méthode d'execution d'une requête

function requete($sql, $unbuffered = false) {
    // exécution de la requête $sql
    if ($unbuffered)
        $this->query_result = @mysql_unbuffered_query($sql, $this->link_id);
    else
        $this->query_result = @mysql_query($sql, $this->link_id);
    // si la requête s'est bien déroulé on incrémente le compteur de requête
    if ($this->query_result) {
        ++$this->nb_requete;
        // et on retourne l'identifiant de réussite de la requête
        return $this->query_result;
    }
    else {
        return false;
    }
}

Cette méthode execute une requete passée en paramètre par la variable $sql. La variable $buffered permet d'utiliser ou non le mode buffered. Elle retourne ensuite un identifiant si la requete a bien fonctionnée, faux sinon.

Pour plus d'explication sur le mode buffered : par ici !

Méthode de suppression

function delete($from,$where='',$fields='') {
    // supprime un enregistrement de la table $from
    if (!$from)
        return false;
    else {
        $table = $from;
        $where = ($where != "") ? "WHERE $where" : ""; 
        // si la variable $where est définie, on ajoute à la requête un champ de type WHERE.
        ++$this->nb_requete;
        // incrementation de la variable du nombre de requete
        return $this-> r = mysql_query("DELETE $fields FROM $table $where");
    }
}

Méthode de mise à jour

function update($fields, $table, $where = "") {
    if (!$table)
        return false;
    else {
        if (!is_array($fields)) // on test si la variable n'est pas un tableau
            $flds = $fields;
        else { // on transforme le tableau en chaîne de caractère dont les champs sont séparés par une virgule.
            $flds = '';
            foreach ($fields as $key => $value) {
                if (!empty ($flds))
                    $flds .= ",";
                $flds .= $key . "=";
                $flds .= "'" . $value . "'";
            }
        }
        $where = ($where != "") ? "WHERE $where" : "";
        // on ajoute un champ WHERE si la variable $where est définie.
        ++$this->nb_requete; 
        // incrementation de la variable qui permet de connaître le nombre de requête effectué.
        return $this-> r = mysql_query("UPDATE $table SET $flds $where");
    }
}

Méthode d'insertion

function insert($fields, $intotable, $fromfields = "*", $fromtable = "", $where = "", $limit = "") {
    if (!$intotable)
        return false;
    else {
        if (!is_array($fields))
            $flds = $fields;
        else {
            $keys = array_keys($fields);
            $values = array_values($fields);
            $flds = "(" . implode(",", $keys) . ") " .
            (!$fromtable && $values ? "VALUES('" . implode("','", $values) . "')" : "");
            if ($fromtable) {
                $where = ($where != "") ? "WHERE $where" : "";
                $limit = ($limit != "") ? "LIMIT $limit" : "";
                $sql = "SELECT $fromfields FROM $fromtable $where $limit";
            }
        }
        ++$this->nb_requete;
        $rt = $this-> r = mysql_query("INSERT INTO $intotable $flds $sql");
        $lid = $this->insert_id();
        // utilisation de la fonction insert_id qui permet de recupere l'identifiant de la derniere requête de type insert.
        return $lid ? $lid : $rt; // retourne l'etat de la derniere requete.
    }
}

Cette méthode exécute une requête de type insert et retourne l'id provenant de cette meme requete.
La fonction array_key retourne toutes les clés d'un tableau.

Méthode qui retourne les données d'une requête sous forme de tableau

function getRow($ds, $mode = 'assoc') {
    if ($ds) {
        if ($mode == 'assoc') {
            return mysql_fetch_assoc($ds);
        }
        elseif ($mode == 'num') {
            return mysql_fetch_row($ds);
        }
        elseif ($mode == 'both') {
            return mysql_fetch_array($ds, MYSQL_BOTH);
        } 
        else {
            echo("Type inconnu :($mode) Merci de spécifier un des trois modes suivant: 'assoc', 'num' ou 'both'.");
        }
    }
}

La variable $mode permet de retourner un tableau soit de type associatif (par defaut), soit de type normal, ou encore de type indicé numériquement.

Autres méthodes

Méthode qui retourne le dernier identifiant généré par un champ de type AUTO_INCREMENT via un INSERT, sur la connexion MySQL courante ou sûr la connexion spécifiée par link_id, faux sinon.

function insert_id() {
    return ($this->link_id) ? @mysql_insert_id($this->link_id) : false;
}

Méthode qui retourne le nombre de requetes effectuées.

function NbRequete() {
    return $this->nb_requete;
}

Méthode qui protège les données avant d'envoyer la requête à MySQL.

function escape($str) {
    if (function_exists('mysql_real_escape_string'))
        return mysql_real_escape_string($str, $this->link_id);
    else
        return mysql_escape_string($str);
}

Méthode qui retourne le message d'erreur généré par la dernière commande MySQL, ou bien '' (la chaîne vide) si aucune erreur n'est survenue.

function LastError() {
    return mysql_error();
}

Méthode qui permet la fermeture de la connexion courante identifiée par link_id, la fonction retourne true si réussite, false sinon.

function close() {
    if ($this->link_id) {
        if ($this->query_result)
            // libère toute la mémoire et les ressources utilisées
            @mysql_free_result($this->query_result);
            // fermeture de la connexion<
            return @mysql_close($this->link_id);
    }
    else
        return false;
}

Aller plus loin

Au début de cette class, il est utile de tester si la connexion au serveur est possible, c'est pour cela qu'on doit ajouter en tête ces quelques lignes :

if (!function_exists('mysql_connect'))

    exit('MySQL n\'est pas supporté. Consultez la documentation PHP ou contactez votre hébergeur');

Si la connexion ne se fait pas, on arrête l'exécution du script.

Exemple d'utilisation

Tout d'abord, pour la connexion :

$db_host = "localhost";
$db_username = "root";
$db_password = "";
$db_name = "nom_db";// nom de la base de
donnée
$db_prefixe = ""; // préfixe des tables
$db = new Mysql($db_host, $db_username, $db_password,$db_name, $db_password);

On instancie de la classe avec en paramètre les identifiants de connexion. Pour plus de sécurité (et aussi pour vous faciliter la tâche) mettez les variables de connexions dans un fichier config.php dans un dossier protégé par un .htaccess . Et faites :

<?php require'conf/config.php'; ?>

Comme ça, si vous devez changer de mot de passe ou de nom de base de donnée, vous modifierez le fichier, et donc les variables, qu'une seule fois.

Par exemple, je veux faire une requête de type : SELECT email FROM commandes;

Voilà ce que je dois écrire :

<?php 
$req = $db->select("email","commandes","","","");
?>

Vous pouvez également remplir les champs pour les paramètres WHERE, ORDER BY, LIMIT.

Pour une mise à jour :

<?php $db->update("email='webi@wb.fr'","commandes","id=7"); ?>

Ici on va faire une requête du type : UPDATE commandes SET email='webi@wb.fr' WHERE id=7;

Ce qui va permettre de modifier le champs email de la table commandes où l'id est égal à 7.

En fin de fichier, la déconnexion :

<?php $db->close(); ?>

Pour fermer la connexion avec la base de donnée.

Voici le lien pour télécharger la classe et un fichier qui vous permettra de faire des tests : télécharger

Applications

Jeux

Catégories

Class SQL