comprendre les bases d'un framework en PHP


CV PHP  - precedent    sommaire    suivant   


II. Base de données
II-A. Analyse de l'attendu
II-B. Connexion à la base
II-C. Lancer une requête
II-D. lancer une requête a l'aide d'un fichier SQL
II-E. Automatiser les requêtes
II-F. conclusion


II. Base de données

info Ce chapitre entier s'adresse aux débutants les moins aguerris, seules quelques notions en SQL sont recommandées. Si vous possédez une quelconque expérience en PHP, vous pouvez sauter directement au chapitre suivant!
C'est partit!
Nous allons enfin mettre la main dans du code... Apres avoir analysé ce que nous voulons faire...


II-A. Analyse de l'attendu

Nous devons créer des fonctions dédiées à gérer l'interfaçage (la connexion) avec une base MySQL.
Mais quelles "briques" (fonctions) créer? Essayons de décomposer les différentes possibilités :

  1. se connecter à la base
  2. lancer une requête
Ces deux fonctions sont les plus évidentes, mais que pouvons nous faire d'autre?

  1. lancer une requête à partir d'un fichier texte
  2. automatiser les requêtes
Autant le premier élément de cette liste se comprend de lui- même, autant le second mérite une explication :
Le langage SQL me barbe! Pourquoi toujours saisir les mots SELECT, WHERE, FROM,... et bien, en effet, pourquoi? Il suffit de créer des fonctions qui les rajoutent pour nous, et le tours est joué. En passant, on peut en profiter pour lancer des contrôles sur l'utilisée de certaines requêtes (ne vous inquiétez pas si ce n'est pas très clair, on y reviendra).



info Tout au long de ce chapitre, vous verrez apparaître une fonction nommée "dbgStore()", ce n'est pas une fonction interne à PHP. En réalité, elle sera implémentée dans le troisième chapitre, consacré au debug. Pour le moment, nous allons la considérer comme un simple echo, et a cette fin, allons créer une fonction temporaire à intégrer au code :
define("TOUS", 0);
define("INDEFINI", 1);
define("FASTBDD", 4);
define( "REQUETE", 5);
define( "CONTROLEUR", 6);
define( "TRAITEMENT", 7);
define( "TEMPLATE", 8);
define( "TEMPLATEDYN", 9);
function dbgStore($message, $type) {
	echo $message;
}


II-B. Connexion à la base

Comment faire pour se connecter à la base?
Si vous avez lut le chapitre I-B, vous devriez en avoir déjà une petite idée... Vous voulez utiliser une fonction de PHP, mais vous ne savez pas son nom?
Rendez vous sur php.net, tapez mysql dans la case "search for", et... vous arrivez ici
Pas la peine de tout lire, survolez la doc., jusqu'à arriver a la partie "Table des matières", là, concentrez vous peu.
PHP propose toujours des noms de fonction très compréhensibles. Vous voulez vous connecter à la base... regardez ceci :

idea mysql_connect -- Ouvre une connexion à un serveur MySQL
Difficile de faire plus clair. Cliquons sur le lien, que voyons-nous dorénavant? Et bien, nous avons sous les yeux tout ce qu'il faut pour utiliser cette fonction : la liste des paramètres, leur rôle, ainsi que leur différente valeur possible.
Dans la suite de l'article, nous considérerons que les paramètres suivants permettent de se connecter à la base :
	    $hote = "localhost";
	    $user = 'root';
	    $pwd = '';
	    $base = "tuto";
Les trois premiers paramètres sont "génériques" : toute base nouvellement installée acceptera ces paramètres et permettra la connexion.
Le 4ème paramètre, quant a lui, est spécifique a chaque base : ici, nous informons MySQL que nous voulons travailler sur la base 'tuto' (bien qu'elle n'existe pas encore, ne provoquera pas d'erreur).
Si vous vous sentez perdus, peut être devriez vous intéresser à un document tel que celui ci, bien que ce ne soit pas obligatoire, il vous permettra de mieux comprendre le rôle des fonctions que nous allons écrire ici. De plus, savoir utiliser un SGBD (une base de donnée) est indispensable en PHP.
Enfin, sachez que tout mot commencent par un $ (dollar) est considéré par php comme une fr variable.

Maintenant que nous avons compris la signification de ces paramètres, encore faut il les utiliser :
function connectDB() {
    $hote = "localhost";
    $user = 'root';
    $pwd = '';
    $base = "tuto";			
    $connexion = mysql_connect($hote , $user , $pwd )
       or die("Impossible de se connecter a la base");
    mysql_select_db($base);
    return $connexion;    
}
Ici, plusieurs nouvelles notions entrent en ligne : énumérons-les :

terme signification manuel PHP
function Une fonction est une série d'action pouvant être appelée depuis n'importe quel endroit du code.
Elles permettent de définir un traitement "générique" pouvant être appelé plusieurs fois
lien
$hote comme nous l'avons vu, c'est une variable lien
"localhost" Les guillemets simples ( ' ) ou doubles ( " ) permettent de définir des chaînes de caractères. lien
$connexion ici aussi, nous avons affaire a une variable, cependant, elle ne contient pas de chaîne de caractère, nous y reviendrons après  
or die("Impossible de se connecter à la base") L'instruction "or die()" permet d'interrompre le programme en cas d'erreur : En effet, par défaut, si PHP n'arrive pas à se connecter, il continuera quand même à s'exécuter, ce qui, dans notre cas, ne sert à rien. lien
return $connexion L'instruction return permet à la fois d'interrompre la fonction, mais en plus, de lui faire renvoyer une valeur.
Nous y reviendrons plus en détail
lien
; Le point virgule est un élément indispensable! Prenez garde a ne pas en oublier! Sa signification est la suivante : "instruction terminée", ainsi, vous pouvez coder une seule instruction sur plusieurs lignes, PHP ne s'en soucie pas, ce qui peut se révéler bien pratique, étant donné que pour lui, seul le ";" est significatif. lien

Une dernière chose est à signaler : les fonctions possèdent leurs propres variables. Qésako?
Une variable déclarée dans une fonction n'est pas accessible depuis une autre fonction, pire, même, lorsque la fonction se termine, la variable est détruite! Vous vous doutez bien qu'il existe des variables dites "globales" (a l'inverses des variables "locales" aux fonctions). Cependant, bien que celles ci se révèlent fort pratiques, elles sont cependant à utiliser avec parcimonie : Elles sont sources d'erreurs, car on a vite fait d'oublier que tel nom de variable est déjà utilisé ou d'effacer leur contenu par mégarde... pour plus d'info : Voyez faq ici, fr ici, ou bien encore .


II-C. Lancer une requête

Vous vous doutez bien que nous n'avons pas parlé de variable globale pour rien... Nous allons les utiliser dans la prochaine fonction :
function query($query) {
    if (! isset ($GLOBALS['connection']) ) {
		$GLOBALS['connection'] = connectDB();
    }
    $result = mysql_query($query, $GLOBALS['connection']);
	
	switch ($result ) {
		case (false) :
			dbgStore("La requete a echoué, message de la BDD : '" 
				. mysql_error($GLOBALS['connection']) . "', erreure numero : " 
				. mysql_errno($GLOBALS['connection']), REQUETE);			
			break;
		default :
			dbgStore("Résultat de la requete : '{$result}'", REQUETE);
	}
    return $result;
}
Allez, plutôt que de tout dire, nous allons faire un petit exercice :
quelle est la variable globale?
Oui... la réponse est facile, c'est $GLOBALS['connection'] Cependant, là n'était point ma question, je reformule :
que contient la variable globale? Afin de répondre, nous devons regarder la valeur de retours de la fonction connectDB()...
Comme par miracle, c'est celle que nous venons d'écrire juste au dessus... Allez, je vous laisse travailler, la marche à suivre est la suivante :
Regardez la variable passé en valeur de retours (mot clef return), puis regardez à quel endroit, dans le code plus haut, la variable est elle modifiée. Quelle valeur prend-elle?
Et oui! $GLOBALS['connection'] sert a stocker l'identifiant de connections. Mais pourquoi le stocker me direz-vous? Et bien, car on en a besoin, regardez dans le manuel php, la fonction fr mysql_query en a besoin en argument.

Bien entendu, nous aurions pu faire :
mysql_query($query, connectDB() );
ou bien encore
$idConnectionBase = connectDB();
mysql_query($query, $idConnectionBase );
Mais il y a une raison a cela : nous pouvons lancer plus d'une requête par page PHP, ainsi, nous devons conserver l'identifiant de connexion, afin de ne pas avoir à nous reconnecter a chaque fois! D'où la première ligne de code :
if (! isset ($GLOBALS['connection']) )
A savoir que, à l'instar des fonctions, une instruction if peut s'étendre sur plusieurs block, d'où les crochets { et } qui délimitent sa portée.

Reste une dernière énigme : mais que veut bien dire ce bloc :
switch ($result ) {
		case (false) :
			dbgStore("La requete a echoué, message de la BDD : '" 
				. mysql_error($GLOBALS['connection']) . "', erreure numero : " 
				. mysql_errno($GLOBALS['connection']), REQUETE);			
			break;
		default :
			dbgStore("Résultat de la requete : '{$result}'", REQUETE);
	}
Il suffit de demander, encore une fois, à notre bon vieux php.net, afin d'avoir une réponse rapide, claire et précise. Si vous voulez une réponse encore plus rapide : switch se traduit par "selon" en français, c'est à dire que selon la valeur de la variable qui suit, on va faire tel, tel ou tel traitement...
le "tel" que je viens de formuler se note case en PHP, donc :
switch ($result ) {
		case (false) :
			echo "faux";
			break;
		case (true) :
			echo "vrai";
			break;
		default :
			echo "ce n'est pas un booléen";
	}
signifie : "Si la variable result a pour valeur :

  • false alors afficher "faux"
  • true alors afficher "vrai"
  • sinon afficher "ce n'est pas un booléen"
Pour plus d'info, comme toujours, n'hésitez pas à vous renseigner sur le site de php en entrant dans la zone de recherche le mot clef "switch"... ou bien le mot clef break, d'ailleurs, essayez d'aller y jeter un coup d'oeil, si vous ne connaissez pas sa signification, elle est fort intéressante!


Voila, cette fonction n'a plus aucun secret pour vous! Heu... attendez une seconde! Vous croyez avoir tout compris? Alors, expliquez moi : Quelle est la requête qui est lancée? Penchons-nous sur le sujet... comment la fonction, qui effectue toujours le même traitement peut-elle lancer telle ou telle requête, suivant les besoins?
Examinons cette portion de code :
function query($query) {
....
}
Vous vous souvenez, nous avions parlés de paramètres, et bien, en voila un : La fonction query prend comme paramètre... $query et si on examine le code, ce paramètre est utilisé à ce niveau :
$result = mysql_query($query, $GLOBALS['connection']);
Si vous voulez savoir ce que fait exactement la fonction mysql_query, regardez dans la doc. PHP. Sachez juste que la variable $query contient une instruction SQL, par exemple :
exemple de code SQL
SELECT * FROM toto
Voila, nous en avons finit avec ces deux fonctions de base. Celles que nous allons étudier dorénavant ne sont pas aussi indispensables, mais vous permettrons de vous familiariser encore un peu avec le langage PHP. De plus, elles peuvent se révéler fort utiles en comparaisons a ces deux fonctions que nous venons de créer qui ne font pas grand chose, au final...


II-D. lancer une requête a l'aide d'un fichier SQL

Le but de cette partie est de lancer une requête, à partir d'un fichier SQL.
PHP possède de nombreuses fonctions de lecture de fichier, entre autre, nous disposons de :

  • file()
  • fgets()
  • fread()
  • readfile()
  • file_put_contents()
  • stream_get_contents()
  • file_get_contents()

Toutes ces fonctions disposent de telle ou telle particularité, qu'il est possible de retrouver, comme toujours, sur le site www.php.net. La plus appropriée a nos besoins serait une fonction qui, à partir d'un nom de fichier, nous retourne son contenu dans une chaîne de caractère étant donné que c'est un fichier complet qui sera envoyé.
Ainsi, file_get_contents() semble tout à fait adapté à nos besoins. Voici le code permettant de l'utiliser :
function QueryFichier($nomFichier) {
	if (! $file = @file_get_contents($nomFichier)) {
		echo "erreure";
		return false;
	}
	return query($file);
}
Ainsi, la fonction QueryFichier() prendra en paramètre le nom du fichier, et lancera toute seule la requête SQL.
Le résultat peut sembler satisfaisant, cependant, deux problèmes se profilent :
Selon le manuel PHP, une requête soumise à la base ne doit pas comporter de point virgule, alors qu'un fichier SQL clôturera généralement toutes ses requêtes de cette façon (visible ici, dans la section "Liste de paramètres").
Un autre problème de cette fonction, est que de nombreux fichiers SQL risquent de comporter plusieurs instructions, justement séparées par un point virgule. Ainsi, il faut adapter le code :
function QueryFichier($nomFichier) {
	dbgStore("On va lancer un fichier SQL : " . $nomFichier);
	if (! $file = @file_get_contents($nomFichier)) {
		dbgStore("Erreure, le fichier n'a pas put etre ouvert", REQUETE);
	}
	//on ne peut lancer pluseures requetes en meme temps, de plus, on pas droit 
	//au ";", on les separes donc en plusieures a l'aide d'explode :
	$requetes = explode(";", $file) ;  		
	foreach ($requetes as $query) {
		if (strlen($query) > 0 ) {
		    return query($query);
		}		
	}
	return false;
}
La partie ajoutée au code précèdent permet donc de séparer le fichier SQL en autant de requêtes qu'il y a de ";". Prenons un exemple :
fichier SQL
INSERT INTO toto (description) VALUES ("0+0");
INSERT INTO toto (description) VALUES ("idiot");
Le code suivant va être tout d'abord lut par file_get_contents() comme une et une seule chaîne de caractère. Ensuite, la fonction explode va remplir la variable $requêtes d'un tableau dont chaque élément est une requête. Ensuite, chacune de ces requêtes va être envoyée à la fonction query().
Afin de vérifier cette affirmation, exécutons le code suivant :
demonstration
$var = 'INSERT INTO toto (description) VALUES ("0+0");
INSERT INTO toto (description) VALUES ("idiot");';

$tab = explode(";", $var);

foreach ($tab as $row) {
	echo $row;
	echo "";
}

var_dump($tab);
Une fois ce code saisi, il suffit de le faire exécuter par le serveur Web, pour voir apparaître la page suivante :
page affichée
INSERT INTO toto (description) VALUES ("0+0")
INSERT INTO toto (description) VALUES ("idiot")

array(3) { [0]=> string(45) "INSERT INTO toto (description) VALUES ("0+0")" [1]=> string(47) "INSERT INTO toto (description) VALUES ("idiot"
)" [2]=> string(0) "" }
Essayez donc d'afficher le code source (menu : "Affichage->source" sous internet explorer), vous verrez que la fonction var_dump prend toute sa valeur ainsi :
source de la page
INSERT INTO toto (description) VALUES ("0+0")
INSERT INTO toto (description) VALUES ("idiot")array(3) {
  [0]=>
  string(45) "INSERT INTO toto (description) VALUES ("0+0")"
  [1]=>
  string(47) "INSERT INTO toto (description) VALUES ("idiot")"
  [2]=>
  string(0) ""
}
Le dernier élément du tableau (d'indice 2) nous permet en outre de comprendre cette ligne de code :
eviter les strings vides
if (strlen($query) > 0 ) {
La fonction strlen (pour string length) retourne la longueur de la chaîne passée en paramètre. Dans notre cas, elle permet de vérifier que la chaîne n'est pas vide. En effet, envoyer une telle requête à la base de données ne servirait à rien.


II-E. Automatiser les requêtes

Vous venez d'apprendre à utiliser des fichiers externes. C'est une méthode de développement saine, car elle permet de regrouper toutes les requête ailleurs que dans le code, ainsi, le jour où une modification de la structure de la base (par exemple), est à prendre en compte, il sera plus facile de ne pas oublier de requête.
Cependant, nous créons un framework, ainsi, nous devons laisser le choix a l'utilisateur, et lui permettre d'intégrer ses requêtes au sein même de ses fichiers PHP. De plus, pourquoi ne pas lui faciliter la tâche? Examinons le code suivant :
requete assistée
function dbInsert ($table, $champ, $value) {

    dbgStore("On est dans dbInsert", FASTBDD);
    
    //on echape les trois parametres :
    mysql_escape_string($table);
    mysql_escape_string($champ);
    mysql_escape_string($value);

    $result = query("INSERT INTO $table ($champ) VALUES ($value)");	
    
    dbgStore("On a lancé la requete d'insertion, le resultat renvoyé est : $result", FASTBDD);
    
    return $result;
}
Cette fonction prend donc trois paramètres, ils prennent tout leur sens a la ligne suivante :
$result = query("INSERT INTO $table ($champ) VALUES ($value)");
Ainsi, ils permettent de lancer une requête sans avoir à saisir les mots clefs SQL, ni de se soucier de la syntaxe. En outre, mysql_escape_string permet de s'assurer que les chaînes passées en paramètre ont été correctement échappées.

Nous venons de créer une fonction d'insertion assistée, faisons de même pour les DELETE et les UPDATE :
function dbDelete($table, $where) {

    dbgStore("On est dans dbDelete", FASTBDD);
    
    //on echape les deux parametres :
    mysql_escape_string($table);
    mysql_escape_string($where);

    $result = query("DELETE FROM $table WHERE $where", FASTBDD);
    dbgStore("On a lancé la requete de delete, le resultat renvoyé est : $result", FASTBDD);
    
	return $result;

}




function dbUpdate ( $table, $set, $where) {

    dbgStore("On est dans dbUpdate", FASTBDD);
    
    //on echape les trois parametres :
    mysql_escape_string($table);
    mysql_escape_string($set);
    mysql_escape_string($where);
    
    $result = query("UPDATE $table SET $set WHERE $where");
    
    dbgStore("On a lancé la requete d'update, le resultat renvoyé est : $result", FASTBDD);
    
    return $result;
}

Ces fonctions suivent la même méthodologie, seule le nombre d'arguments est différent.



II-F. conclusion

Ainsi se termine ce chapitre consacré aux bases de données. Le ton était volontairement (trop?) Didactique, afin de permettre à tous de profiter de ces bases. N'en soyez pas rebutés pour autant, les prochains chapitres, je l'espère seront plus complexes (et plus intéressants?)
avant d'en finir, vous trouverez ci dessous, le code PHP complet de la partie base de données (il comporte quelques fioritures en plus qui n'ont pas été évoquées ici car, il peut être préférable, en terme de performance de s'en tenir aux fonction qui ont été fournies précédemment) :
code complet
/**
* fonction de connection a la base 
*/
function connectDB() {
    $hote = "localhost";
    $user = 'root';
    $pwd = '';
    $base = "dtg";

    $connexion = mysql_connect($hote , $user , $pwd )
       or die("Impossible de se connecter a la base");
    mysql_select_db($base);
    return $connexion;    
}

/**fonction query :
*se connecte a la base si nescessaire
*execute une requete et renvoie la ressource resultante
*/
function query($query) {
    if (! isset ($GLOBALS['connection']) ) {
	$GLOBALS['connection'] = connectDB();
    }
    dbgStore("On va lancer la requete : {$query}", REQUETE);
    $result = mysql_query($query, $GLOBALS['connection']);
	
	switch ($result ) {
		case (false) :
			dbgStore("La requete a echoué, message de la BDD : '" 
				. mysql_error($GLOBALS['connection']) . "', erreure numero : " 
				. mysql_errno($GLOBALS['connection']), REQUETE);			
			break;
		default :
			dbgStore("Résultat de la requete : '{$result}'", REQUETE);
	}
    return $result;
}

/**appelé par la fonction dbInsert (suste en dessous)
*verifie si une insertion est faisable
* @param $table : la table cible
* @param $champ : les champs qui vont etre remplis
* @param $value : les valeurs contenantes
* @see dbInsert
* @see verifUpdate
* @see verifDelete
*/ 
function verifInsert($table, $champ, $value) {
    $query = "SELECT * FROM $table WHERE ";
    $champs = explode(",", $champ);
    $values = explode(",", $value);
    for ($i = 0; $i < count($champs) ; $i ++) {
	    $query .= $champs[$i] . " = " . $values[$i] ;
	    if ($i != (count($champ) - 1) )  
	        $query .= " AND ";
    }
    $result = query($query);  
    $nbRow = mysql_num_rows($result);
    dbgStore("si nbRow == 0, alors on peut inserer : NbRow = $nbRow.", FASTBDD);
    if ($nbRow == 0 ) {
	    return true;
    } else {
	    return false;
    }
}

/**fonction lancant un insertion dans la base 
*elle accepte 3 paramtres :
*@param $table : la table cible
*@param $champ : les champs qui vont etre remplis
*@param $value : les valeurs contenantes
*/
function dbInsert ($table, $champ, $value) {
    dbgStore("On est dans dbInsert", FASTBDD);
    //on echape les trois parametres :
    mysql_escape_string($table);
    mysql_escape_string($champ);
    mysql_escape_string($value);
    if ( verifInsert($table, $champ, $value) ) {
	    $result = query("INSERT INTO $table ($champ) VALUES ($value)");	
        dbgStore("On a lancé la requete d'insertion, le resultat renvoyé est : $result", 
			FASTBDD);
	    return $result;
    } else {
        dbgStore("On n'a pas lancé la requete d'insertion, verif insert a determiné qu'elle etait inutile", 
			FASTBDD);
	    return false;
    }
}

/** fonction ne faisait aucun traitement visible :
* elle se contente de verifier si un update est adapté :
* c'est a dire, s'il va modifier des données, si on le lance.
* @param $table : la ou les tables a appeler
* @param $set : le contenu de la commande sql  SET 
* @param $where : idem : le contenu de la commande sql WHERE
* @return bool
* @see dbUpdate
* @see verifInsert
* @see verifDelete
*/
function verifUpdate($table, $set, $where) {
    //on va verifier si le(les?) champ cible existe
    dbgStore("Premeire verification : le(s) champ(s) cible(s) existe t il?", 
		FASTBDD);
    $result = query("SELECT * FROM $table WHERE $where");
    $nbRow = mysql_num_rows($result);
    dbgStore("si nbRow >= 1, alors on peut lancer le second test : NbRow = $nbRow. (va-t-on ecraser quelque chose?)", 
		FASTBDD);
    if ($nbRow >= 1 ) {
	    //sedonde verif : va-t-on modifier qque chose?
        $where2 = str_replace(",", " AND ", $set);
        $result = query("SELECT * FROM $table WHERE $where2");
        $nbRow = mysql_num_rows($result);
        dbgStore("si nbRow == 0, alors on peut lancer la requete d'update : NbRow = $nbRow.", 
			FASTBDD);
        if ($nbRow == 0 ) {
            return true;
        } 
    } 
    //dans les autres cas, on renvoie false
	return false;
}

/** cette fonction lance un update sur la table.
* avant de se faire elle lance @see verifUpdate qui lui renvoie un bool.
* en cas de succés, l'update est lancé
* @param $table : la ou les tables a appeler
* @param $set : le contenu de la commande sql  SET 
* @param $where : idem : le contenu de la commande sql WHERE
* @return bool
*
*/ 
function dbUpdate ( $table, $set, $where) {
    dbgStore("On est dans dbUpdate", FASTBDD);
    //on echape les trois parametres :
    mysql_escape_string($table);
    mysql_escape_string($set);
    mysql_escape_string($where);
    if ( verifUpdate($table, $set, $where) ) {
        $result = query("UPDATE $table SET $set WHERE $where");
        dbgStore("On a lancé la requete d'update, le resultat renvoyé est : $result", 
			FASTBDD);
	    return $result;
    } else {
        dbgStore("On n'a pas lancé la requete d'update, verif insert a determiné qu'elle etait inutile", 
			FASTBDD);
	    return false;
    }
}

/** de meme que pour verif update, aucun inpact sur les odnnées, se contente de renvoyer un bolléen
* @param $table : la / les table(s) a appeler
* @param $where : la comamnde where 
* @see dbDelete
* @see verifInsert
* @see verifUpdate
* @return bool
*/
function verifDelete($table, $where) {
    $query = "SELECT * FROM $table WHERE $where";    
    $result = query($query);
    $nbRow = mysql_num_rows($result);
    dbgStore("si nbRow > 0, alors on peut delete : NbRow = $nbRow.", FASTBDD);
    if ($nbRow > 0 ) {
	    return true;
    } else {
	    return false;
    }
}

/** lance un delete, 
* @see dbUpdate
* @see dbInsert
* @see verifDelete
* @param $table : la / les table(s) a appeler
* @param $where : la comamnde where 
* @return bool
*/
function dbDelete($table, $where) {
    dbgStore("On est dans dbDelete", FASTBDD);
    //on echape les deux parametres :
    mysql_escape_string($table);
    mysql_escape_string($where);
    if (verifDelete($table, $where) ) {
        $result = query("DELETE FROM $table WHERE $where", FASTBDD);
        dbgStore("On a lancé la requete de delete, le resultat renvoyé est : $result", 
			FASTBDD);
	    return $result;
    } else {
        dbgStore("On n'a pas lancé la requete de delete, verifDelete a determiné qu'elle etait inutile", 
			FASTBDD);
	    return false;
    }    
}

/**
* Fonction permettant de créer une vue
* non fonctionel pour MySQL4.x
* @return bool : renvoie vrai si la vue a ete crée, false sinon.
*/
function dbVue ($nomVue, $select, $from, $where) {
	if (query("DROP VIEW " . $nomVue) ) {
	    if (query("CREATE VIEW " . $nomVue . " AS SELECT " . $select . " FROM " 
			. $from . " WHERE " . $where) ) {
	        dbgStore("On a lancé la requete de creation de vue, le resultat renvoyé est : $result", 
				FASTBDD);
			return true;
	    }
		dbgStore("On n'a pas lancé la requete de creation de vue, car le resultat renvoyé par le drop View est : $result", 
			FASTBDD);
	}

	return false;
}

/**
* Cette fonction se charge de lire le contenu d'un fichier passé en parametre
* et de lancer la requete qu'il contient.
* @param $nomFichier : string contenant le nom du fichier
* @return  la requete lancée
*/
function QueryFichierSELECT($nomFichier) {
	dbgStore("On va lancer un fichier SQL : " . $nomFichier);
	if (! $file = @file_get_contents($nomFichier)) {
		dbgStore("Erreure, le fichier n'a pas put etre ouvert", REQUETE);
	}
	//on ne peut lancer pluseures requetes en meme temps, de plus, on pas droit 
	//au ";", on les separes donc en plusieures a l'aide d'explode :
	$requetes = explode(";", $file) ;  
	foreach ($requetes as $query) {
		if (strlen($query) > 0 ) {
		    query($query);
		}		
	}
	return nl2br($file);
}
/**
* Cette fonction se charge de lire le contenu d'un fichier passé en parametre,
* de lancer la requete qu'il contient et de renvoyer la ressource.
* si plusieures requetes sont dnas le fichier, seule la premiere sera lancée
* @param $nomFichier : string contenant le nom du fichier
* @return resultat de la requete ou false.
*/
function QueryFichier($nomFichier) {
	dbgStore("On va lancer un fichier SQL : " . $nomFichier);
	if (! $file = @file_get_contents($nomFichier)) {
		dbgStore("Erreure, le fichier n'a pas put etre ouvert", REQUETE);
	}
	//on ne peut lancer pluseures requetes en meme temps, de plus, on pas droit 
	//au ";", on les separes donc en plusieures a l'aide d'explode :
	$requetes = explode(";", $file) ;  
	foreach ($requetes as $query) {
		if (strlen($query) > 0 ) {
		    return query($query);
		}		
	}
	return false;
}


CVweb de l'auteurprecedent    sommaire    suivant   

 

Les sources présentés sur cette pages sont libre de droits, et vous pouvez les utiliser à votre convenance. Par contre cette page de présentation de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright ©2006 . Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérets. .

Cet article devait etre a la base publié sur www.developpez.com