PHP

Class PHP5 de gestion de requetes SQL simples

Recherche :

Mot : Pseudo : Filtrer
Page : 1 2 Page Suivante Page Précédente Bas de page
Auteur	Sujet : Class PHP5 de gestion de requetes SQL simples

the_bigboo

voila j'ai fait cette petite class en PHP5 car je trouve que meme si c'est assez facile de gérer ses requetes SQL, c'est bien pratique car le code en est d'autant plus simplifié. Elle fait tout de meme 650 lignes

donc l'avantage ,c'est qu'au lieu de faire :

Code :

$SQL = mysql_connect('localhost','root','') or die (mysql_error()) ;
mysql_select_db('base_sql',$SQL) or die(mysql_error()) ;
// Requete SQL
$Query = 'SELECT champ_1,champ_2,champ_3 FROM ma_table WHERE champ_4 > 5 AND champ_5="valeur" ORDER BY champ_1 DESC LIMIT 10,20' ;
$ExeSQL = mysql_query($Query) or die(mysql_error()) ;
// Exploitation des résultat
while ( $Data = mysql_fetch_array($ExeSQL) )
{
.............................. // Code
}

vous ferez :

Code :

$GetData = new MySQL_select ;
$GetData->From('ma_table');
$GetData->SetFilter('champ_4','>',5) ;
$GetData->SetFilter('champ_5','=','valeur') ;
$GetData->SQLOrder('champ_1','DESC') ;
$GetData->SetStart(10) ;
$GetData->SetLimit(20) ;
// On veux récupérer un tableau de donnée
$GetData->ReturnValue('rows') ;
// Récupération des données
$RecupData = $GetData->Make() ;

Le gain ne se situe pas sur la longueur du code qui ne change que tres peu, ca permet surtout un évolution nettement plus facile

Les procédures sont sensiblements les memes pour les autres classes, le gain de se fait pas sur la compacité du code mais sur sa facilité a évoluer.

Code :

<?php
// Librairie MySQL optimisée PHP5
class MySQL {
// Déclaration des variables de parametres
private $MySQLServer = '' ;
private $MySQLLogin = '' ;
private $MySQLPasswd = '' ;
// Base de donnée(s)
private $MySQLBdd = '' ;
// Options
private $OptLog = false ;
// Variables techniques
static $MySQLHandle ;
static $MySQLNbQueries ;
static $MySQLResult = array() ;
// Fin de déclaration des variables
// Déclaration des constructeurs/destructeurs de class
// Constructeur
function __construct()
{
// Connexion a la base
$this->OpenSQLAccess() ;
}
// Destructeur
function __destruct()
{
}
// Fin de déclaration des constructeurs/destructeurs de class
// Déclaration des procédures privées
// Connexion base de donnée
private function OpenSQLAccess()
{
// Instanciation de la connexion
$this->MySQLHandle = mysql_connect($this->MySQLServer,$this->MySQLLogin,$this->MySQLPasswd) ;
// Selection de la base de donnée
mysql_select_db($this->MySQLBdd,$this->MySQLHandle) ;
}
// Fermeture de connexion base de donnée
private function CloseSQLAccess()
{
// Fermeture de connexion SQL
mysql_close($this->MySQLHandle) ;
// Valeur de retour
return true ;
}
// Type de requetes
private function QueryType($Query)
{
if(ereg("^UPDATE",$Query))
$return = "UPD" ;
elseif(ereg("^INSERT",$Query))
$return = "INS" ;
elseif(ereg("^DELETE",$Query))
$return = "DEL" ;
else
$return = "SEL" ;
// Retour final
return $return ;
}
//Déclaration des procédures publiques
// Execution des requetes
public function Execute($SQLQuery,$Back)
{
// $Return (rows|res|null)
if(!is_array($SQLQuery))
{
$SQL = $SQLQuery ;
$SQLQuery = array($SQL) ;
// Réexecution de la procédure
$this->Execute($SQLQuery,$Back) ;
}
else
{
// On execute en boucle
foreach($SQLQuery As $Query)
{
// Execution de la requete
$ExecuteQuery = mysql_query($Query,$this->MySQLHandle) ;
// Type de requete
$QueryType = $this->QueryType($Query);
// Switch de retour
// switch sur la fonction a renvoyer
switch($QueryType)
{
// Select
case 'SEL':
// Switch de back
switch(strtoupper($Back))
{
case 'RES': $return = mysql_num_rows($ExecuteQuery) ; break ;
case 'ROWS' : $return = mysql_fetch_array($ExecuteQuery) ; break ;
default : $return = mysql_num_rows($ExecuteQuery) ; break ;
}
break ;
// Update
case 'UPD':
$return = mysql_affected_rows($this->MySQLHandle) ;
break ;
// Delete
case 'DEL':
$return = mysql_affected_rows($this->MySQLHandle) ;
break ;
// Insert
case 'INS':
switch($Back)
{
case 'RES': $return = mysql_affected_rows($this->MySQLHandle) ; break ;
case 'ID' : $return = mysql_insert_id(MySQL::$MySQLHandle) ; break ;
default : $return = mysql_affected_rows($this->MySQLHandle) ; break ;
}
break ;
case 'NULL':
$return = true ;
break ;
}
}
}
// Incrémentation des requetes
MySQL::$MySQLNbQueries++ ;
// Sauvegarde des résultats de la requete
MySQL::$MySQLResult[] = $return ;
// Renvoi final
return $return ;
}
// Fonction de log
public function LogEvent($Text)
{
// Si option activée
if( $this->OptLog )
{
// Ouverture
$fichier=fopen('mysql.log','w');
// Ecriture
fwrite($fichier,"[".date("d-m-Y H:i:s" )."] ".$Text."\n" );
fclose($fichier);
}
}
}
// Class annexes - Insert
class MySQL_insert extends MySQL {
// Déclaration des variables statiques
static $AllInsertQueries = array() ;
// Déclaration des variables privéres
private $SQLTable ;
private $FieldsToUse ;
private $Options ;
private $Return = 'NULL' ;
// Déclaration des procédures privées
// Fonction de création de la requete SQL
private function BuildSQLQuery()
{
// On commence par verifier qu'on a toutes les informations en notre possession
if( empty( $this->SQLTable) )
{
// Le nom de la table SQL est vide - on log
$this->LogEvent('Impossible de construire la requete SQL, le nom de la table a utiliser non précisé');
// Renvoi faux
$return = false ;
}
// Ou si la liste des champs a insérer est vide
elseif( sizeof( $this->FieldsToUse ) == 0 )
{
// On log
$this->LogEvent('Liste des champs a insérer vide');
// Renvoi faux
$return = false ;
}
// Sinon tout est OK
else
{
// Début de la requete :
$SQLQuery = 'INSERT INTO '.$this->SQLTable.' (' ;
// On colle la liste des champs
$SQLQuery .= implode(',',array_keys($this->FieldsToUse)) ;
// Fermeture du nom des champs
$SQLQuery .= ') VALUES ("' ;
// Liste des valeurs de champs
$SQLQuery .= implode( '","',$this->FieldsToUse ) ;
// Fin de la requete
$SQLQuery .= '" )' ;
// On renvoie la requete
$return = $SQLQuery ;
}
// Renvoi final
return $return ;
}
// Déclaration des procédures publiques
// Selection de la table
public function Into($TblName)
{
if(!ereg("^([:alnum:]+)$",$TblName))
{
// Nom de table uniquement alphanumérique
$this->LogEvent('Table SQL non alphanumerique');
// Renvoi faux
$return = false ;
}
else
{
// On enregistre le nom de la table
$this->SQLTable = strtolower($TblName) ;
// Renvoi vrai
$return = true ;
}
// Renvoi final
return $return ;
}
// Ajouts des paramètres
public function SetValue($FieldName,$Value)
{
if(ereg("^([:alnum:]+)$",$FieldName))
{
// S'assure que ca ne soit pas vide
$this->FieldsToUse[] = array('Name' =>$FieldName,
'Value' =>str_replace('"','\"',$Value) );
// Renvoi vrai
$return = true ;
}
else
{
// Le nom du champ est vide, on log une erreur
$this->LogEvent('Parametre des champs a ajouter sont vides ou ne sont pas alphanumeriques');
// Renvoi final
$return = false ;
}
// Renvoi final
return $return ;
} //
// Application des options
public function Option($Field,$ArrayOfFunctions)
{
// On vérifie que le champ a été répertorié
if(!isset($this->FieldsToUse[$Field]))
{
// On logue mais on ne bloque pas la procédure
$this->LogEvent('Impossible d\'utiliser des fontions sur le champ '.$Field.' car celui ci n\'est pas répertorié');
}
else
{
// on applique la/les options
if( is_array($ArrayOfFunctions) )
{
// On fait une boucle
foreach($ArrayOfFunctions As $Function)
{
// Si la fonction existe
if(function_exists($Function))
{
// On applique la fonction
$this->FieldsToUse[$Field] = $Function($this->FieldsToUse[$Field]) ;
}
else
{
// On logue mais on bloque pas
$this->LogEvent('Fonction '.$Function.' non déclarée');
}
}
}
}
}
// Attribution de la valeur de retour
public function ReturnValue($Choice)
{
// rows|res|id|null
$AcceptedValues = array('ROWS','RES','ID','NULL') ;
// Si ce n'est pas dans les valeur acceptées, on log mais on ne bloque pas
if( in_array($Choice,$AcceptedValues))
{
$this->Return = strtoupper($Choice) ;
// Renvoi vrai
$return = true ;
}
else
{
// On log
$this->LogEvent('Valeur de retour non acceptée : '.$Choice.' dans la procérure ReturnValue()');
// renvoi faux
$return = false ;
}
// renvoi final
return $return ;
}
// Execution de la requete
public function Make()
{
// On commence par générer la requete
$SQLQuery = $this->BuildSQLQuery() ;
MySQL_insert::$AllInsertQueries[] = $SQLQuery ;
// On verifie que le résultat n'est pas 'false'
if( $SQLQuery == false )
{
// Une erreur s'est produite - elle est loguée de toute facon
$this->LogEvent('Arret de procédure Make(), class MySQL_insert');
// Renvoi faux
$return = false ;
}
else
{
// On execute la requete
$return = $this->Execute($SQLQuery,$this->Return) ;
// Prendra faux automatiquement en cas d'erreur
}
// renvoi final
return $return ;
}
}
// Class annexes - Select
class MySQL_select extends MySQL {
// Declaration des variables statiques
static $AllSelectQueries ;
// Declaration des variables privées
private $SQLTable ;
private $SQLFilters ;
private $SQLExtractionFields ;
private $SQLOrder = array ('field'=>'' , 'sens'=>'' );
private $SQLLimit = array('start'=> false , 'lenght' => false ) ;
private $Return = 'ROWS' ;
// Déclaration des procédures privées
private function BuildSQLQuery()
{
// Debut de la requete
$SQLQuery = 'SELECT ' ;
// Liste des champs a extraire
$SQLQuery .= implode(',',$this->SQLExtractionFields) ;
// Nom de la table
$SQLQuery .= ' FROM '.$this->SQLTable ;
// Ajout des clauses de conditions si nécessaire
if( sizeof( $this->SQLExtractionFields ) > 0 )
{
$EachFilter = array() ;
// Continuation de la mise en forme de la requete
$SQLQuery .= ' WHERE ' ;
// On met en forme les filtres
foreach( $this->SQLFilters As $Filter )
{
if(!ereg("^[0-9]$",$Filter['value']))
{
$Filter['value'] = '"'.$Filter['value'].'"' ;
}
// On ajoute le filtre
$EachFilter[] = $Filter['field'].$Filter['op'].$Filter['value'] ;
}
// On colle les filtres avec du implode
$SQLQuery .= implode(' AND ',$EachFilter) ;
// On rajoute une clause eventuelle d'ordre
if( strlen($this->SQLOrder['field']) > 0 )
{
// On rajoute la clause
$SQLQuery .= ' ORDER BY '.$this->SQLOrder['field'] ;
// Si le sens est précisé on le rajoute
if( strlen($this->SQLOrder['sens']) > 0 )
{
$SQLQuery .= ' '.$this->SQLOrder['sens'] ;
}
}
// On vérifie l'attribut LIMIT
if($this->SQLLimit['lenght']!=false && $this->SQLLimit['start']!=false)
{
// LIMIT complet
$SQLQuery .= ' LIMIT '.$this->SQLLimit['start'].','.$this->SQLLimit['lenght'] ;
}
elseif($this->SQLLimit['lenght']!=false && $this->SQLLimit['start']==false )
{
// LIMIT semi-complet
$SQLQuery .= ' LIMIT '.$this->SQLLimit['lenght'] ;
}
// Requete SQL Complete
$return = $SQLQuery ;
}
else
{
// Aucun champ a extraire
$this->LogEvent('Aucun champ a extraire dans MySQL_select');
// Renvoi faux
$return = false ;
}
// Renvoi final
return $return ;
}
// Fin de déclaration des procédures privées
// Déclaration des procédures publiques
// Selection de la table SQL
public function From($TblName)
{
if(!ereg("^([:alnum:]+)$",$TblName))
{
// Nom de table uniquement alphanumérique
$this->LogEvent('Table SQL non alphanumerique');
// Renvoi faux
$return = false ;
}
else
{
// On enregistre le nom de la table
$this->SQLTable = strtolower($TblName) ;
// Renvoi vrai
$return = true ;
}
// Renvoi final
return $return ;
}
// Mise en place des filtres
public function SetFilter($Field,$Op,$Value)
{
// Operateurs acceptés
$AcceptedOperators = array('>','<','<=','>=','==','!=') ;
// Si $Value est un chiffre on ne met pas de guillemets
if(!ereg("^[0-9]$",$Value)){ $PutFilterValue = '"'.$Value.'"' ; }else{ $PutFilterValue = $Value ; }
// Si l'opérateur n'est pas reconnu
if( in_array($Op,$AcceptedOperators))
{
// On log
$this->SQLFilters[] = array('field'=>$Field,'op'=>$Op,'value'=>$PutFilterValue) ;
}
else
{
// On log
$this->LogEvent('Operateur logique non reconnu');
// Renvoi faux
$return = false ;
}
// renvoi final
return $return ;
}
// Longueur de l'extraction
public function SetLimit($Int)
{
if(!ereg("^[0-9]$",$Int))
{
// ce n'est pas un chiffre
$this->LogEvent('La limit doit etre de type Integer');
// renvoi faux
$return = false ;
}
else
{
$this->SQLLimit['lenght'] = $Int ;
// Renvoi vrai
$return = true ;
}
// renvoi final
return $return ;
}
// Debut de l'xtraction
public function SetStart($Int)
{
if(!ereg("^[0-9]$",$Int))
{
// ce n'est pas un chiffre
$this->LogEvent('La limit de début doit etre de type Integer');
// renvoi faux
$return = false ;
}
else
{
$this->SQLLimit['start'] = $Int ;
// Renvoi vrai
$return = true ;
}
// renvoi final
return $return ;
}
// Attribution de la valeur de retour
public function ReturnValue($Choice)
{
// rows|res|id|null
$AcceptedValues = array('ROWS','RES','ID','NULL') ;
// Si ce n'est pas dans les valeur acceptées, on log mais on ne bloque pas
if( in_array($Choice,$AcceptedValues))
{
$this->Return = strtoupper($Choice) ;
// Renvoi vrai
$return = true ;
}
else
{
// On log
$this->LogEvent('Valeur de retour non acceptée : '.$Choice.' dans la procérure ReturnValue()');
// renvoi faux
$return = false ;
}
// renvoi final
return $return ;
}
// Execution de la requete
public function Make()
{
// On commence par générer la requete
$SQLQuery = $this->BuildSQLQuery() ;
MySQL_select::$AllSelectQueries[] = $SQLQuery ;
// On verifie que le résultat n'est pas 'false'
if( $SQLQuery == false )
{
// Une erreur s'est produite - elle est loguée de toute facon
$this->LogEvent('Arret de procédure Make(), class MySQL_insert');
// Renvoi faux
$return = false ;
}
else
{
// On execute la requete
$return = $this->Execute($SQLQuery,$this->Return) ;
// Prendra faux automatiquement en cas d'erreur
}
// renvoi final
return $return ;
}
// Fin de déclaration des procédures publiques
}
// Class annexes - Update
class MySQL_update extends MySQL {
// Déclaration des variables statiques
static $AllUpdatesQueries ;
// Déclaration des variables privées
private $SQLtable ;
private $SQLFilters = array() ;
private $SQLLimit = false ;
private $SQLUpdateFields = array();
private $Return = 'NULL';
// Déclaration des procédures privées
private function BuildSQLQuery()
{
// Début de la requete
$EachFieldToUpdate = array() ;
$EachFilterToSet = array() ;
// Vérification de la présence de toutes les informations
if(!empty($this->SQLtable))
{
// On vérifie qu'un champ au moins est a mettre a jour
if( sizeof($this->SQLUpdateFields) > 0 )
{
$SQLQuery = 'UPDATE '.$this->SQLtable.' SET ' ;
// On créé un tableau pour coller tous les éléments de la requete
foreach( $this->SQLUpdateFields As $Update )
{
$EachFieldToUpdate[] = $Update['field'].'="'.$Update['value'].'"' ;
}
// On colle les champs a mettre a jours
$SQLQuery .= implode(', ',$EachFieldToUpdate) ;
// On regarde ou non la présence d'une clause WHERE
if( sizeof($this->SQLFilters) > 0 )
{
// On ajoute la clause WHERE dans la raquete SQL
$SQLQuery .= ' WHERE ' ;
// Boucle pour créer les éléments de la boucle
foreach( $this->SQLFilters As $Filter )
{
$EachFilterToSet[] = $Filter['field'].$Filter['op'].$Filter['value'] ;
}
// On colle les conditions
$SQLQuery .= implode(' AND ',$EachFilterToSet) ;
}
// Ajout des attributs de LIMIT
if( $this->SQLLimit != false )
{
$SQLQuery .= ' LIMIT '.$this->SQLLimit ;
}
// Renvoi final
$return = $SQLQuery ;
}
else
{
// Aucun champ a mettre a jour
$this->LogEvent('Aucun champ a mettre à jour');
// Renvoi faux
$return = false ;
}
}
else
{
// Nom de table non renseigné
$this->LogEvent('Nom de table non renseigné');
// Renvoi faux
$return = false ;
}
// Renvoi global
return $return ;
}
// Mise en place des filtres
public function SetFilter($Field,$Op,$Value)
{
// Operateurs acceptés
$AcceptedOperators = array('>','<','<=','>=','==','!=') ;
// Si $Value est un chiffre on ne met pas de guillemets
if(!ereg("^[0-9]$",$Value)){ $PutFilterValue = '"'.$Value.'"' ; }else{ $PutFilterValue = $Value ; }
// Si l'opérateur n'est pas reconnu
if( in_array($Op,$AcceptedOperators))
{
// On log
$this->SQLFilters[] = array('field'=>$Field,'op'=>$Op,'value'=>$PutFilterValue) ;
}
else
{
// On log
$this->LogEvent('Operateur logique non reconnu');
// Renvoi faux
$return = false ;
}
// renvoi final
return $return ;
}
// Mise en place de la limit
public function SetLimit($Int)
{
// Uniquement un chiffre
if(ereg("^[:alnum:]$",$Int))
{
// On enregistre la limite
$this->SQLLimit = $Int ;
// renvoi vrai
$return = true ;
}
else
{
// N'est pas un chiffre
$this->LogEvent('La limite n\'est pas de type numérique, action ignorée');
// Renvoi faux ;
$return = false ;
}
// renvoi final
return $return ;
}
// Execution de la requete
public function Make()
{
// On commence par générer la requete
$SQLQuery = $this->BuildSQLQuery() ;
MySQL_update::$AllUpdatesQueries[] = $SQLQuery ;
// On verifie que le résultat n'est pas 'false'
if( $SQLQuery == false )
{
// Une erreur s'est produite - elle est loguée de toute facon
$this->LogEvent('Arret de procédure Make(), class MySQL_update');
// Renvoi faux
$return = false ;
}
else
{
// On execute la requete
$return = $this->Execute($SQLQuery,$this->Return) ;
// Prendra faux automatiquement en cas d'erreur
}
// renvoi final
return $return ;
}
}
?>

En espérant que ca vous aidera autant que ca m'aide, j'integrerai sous peu les jointures dans la class SELECT

En passant j'aimerais avoir des suggestions d'optimisation ou des idées, bref des avis...

Message cité 1 fois
Message édité par the_bigboo le 28-04-2006 à 00:49:19

Publicité

Mackila

J'ai une suggestion.

Tu nous présente un cas d'utilisation pour appater le client, car un pavé comme ca ca me donne pas envie de le lire pour savoir comment l'utiliser. Pis les commentaires c'est bien, tant que ca fait pas "mis la juste pour le principe de mettre une ligne de commentaire par ligne de code"...

Message cité 1 fois

zapan666

Tout est relatif

Uhm, ton objet Mysql_select, il ne peut faire un select que sur une table ? Mes jointures, je les fais comment ?

Ta fonction QueryType($Query), je la pige pas, tu fais un objet mysql_select pour les selects, un objet mysql_update pour des updates (je trouve ça bizare, mais bon...), donc tu connais le type de requête via l'objet, et tu refais une fonction pour connaitre le type de requête que tu fais dès fois que tu es pas sur [:petrus dei]

[:jean-guitou] et en pratique, tout ça, ça marche facilement ?

Message cité 1 fois
Message édité par zapan666 le 28-04-2006 à 00:36:08

---------------
my flick r - Just Tab it !

the_bigboo

Mackila a écrit :

J'ai une suggestion.
Tu nous présente un cas d'utilisation pour appater le client, car un pavé comme ca ca me donne pas envie de le lire pour savoir comment l'utiliser. Pis les commentaires c'est bien, tant que ca fait pas "mis la juste pour le principe de mettre une ligne de commentaire par ligne de code"...

C'est vrai que je devrais mettre un exemple, quant aux commentaires moi je preferes les mettre en littéral plutot qu'en technique comme on le ferait en Java ou en C#, je trouve ca plus clair. Et un commentaire par ligne permet de bien expliquer le fonctionnement voila tout

J'ai edité

Message cité 1 fois

zapan666

Tout est relatif

the_bigboo a écrit :

ouais mais bon, des commentaires comme ça

Code :

// Renvoi faux
$return = false ;

On peut s'en passer je pense [:ddr555]

Message cité 1 fois
Message édité par zapan666 le 28-04-2006 à 00:49:35

---------------
my flick r - Just Tab it !

the_bigboo

zapan666 a écrit :

Uhm, ton objet Mysql_select, il ne peut faire un select que sur une table ? Mes jointures, je les fais comment ?

Ta fonction QueryType($Query), je la pige pas, tu fais un objet mysql_select pour les selects, un objet mysql_update pour des updates (je trouve ça bizare, mais bon...), donc tu connais le type de requête via l'objet, et tu refais une fonction pour connaitre le type de requête que tu fais dès fois que tu es pas sur [:petrus dei]
[:jean-guitou] et en pratique, tout ça, ça marche facilement ?

Les jointures, je n'en utilises pas vraiment , la plupart du temps je n'en ai pas besoin mais je pense effectivement implémenter les jointures sous peu, comme dit, c'est a l'heure actuelle concu pour des requetes simple

Comcernant la procédure queryType elle concerne les valeur de retour des procédures makes des objets
Par exemple sir tu veux avoir un nombre de résultat en retour, pour un SELECt tu utiliseras mysql_num_rows(), mais pour un UPDATE, ca sera mysql_affected_rows() Ca sert pour le switch

Message cité 1 fois

the_bigboo

zapan666 a écrit :

ouais mais bon, des commentaires comme ça

Code :

// Renvoi faux
$return = false ;

On peut s'en basser je pense [:ddr555]

oui, mais c'est une habitude, on a tous ses tics Et je me fais pas d'idée , si ca vous gene, il suffit de tater de la touche suppr :whistle:

Message édité par the_bigboo le 28-04-2006 à 00:47:59

zapan666

Tout est relatif

the_bigboo a écrit :

et pourquoi dans Mysql, tu ne mets pas la fonction Execute en abstrait, et tu la défini dans chaqun de tes objets ?

Et quand on mets un switch, dans du code objet, la plupart du temps, c'est pas normal.

Message cité 1 fois

---------------
my flick r - Just Tab it !

the_bigboo

zapan666 a écrit :

parce que ce qui me gene c'est que j'utilise $this dans chacun des objets et que je ne connais pas le comporteme,t que ca aurait si je la mettai en abstrait, si tu préfere je sais pas si elle va utiliser la classe parente ou le classe enfant , c'est p'tetre con mais bon...

Si tu me renseigne, je serai ravi de coriger :jap:

En quoi n'est-ce pas normal d'utiliser un switch dans du code objet :??:

Message cité 1 fois
Message édité par the_bigboo le 28-04-2006 à 00:51:56

zapan666

Tout est relatif

the_bigboo a écrit :

Code :

// Appel au parent
parent::mafonction();
parent::$mavariable;
// Appel à l'objet (ça peut appeler une fonction du parents si la fonction n'est pas surchargé)
$this->mafonction();
$this->mavariable;

the_bigboo a écrit :

En quoi n'est-ce pas normal d'utiliser un switch dans du code objet :??:

[:dao] Parce que

Bon, j'ai pas trouvé de la doc intéressante, mais normalement, tu peux t'en passer, genre sur ton code.
http://www.parashift.com/c++-faq-l [...] n-cpp.html

---------------
my flick r - Just Tab it !

Publicité

Djebel1

Nul professionnel

euh, on peut grave pas utiliser les fonctionnalités d'une bdd avec ton truc là.
Et tu te prends bien la tête, par exemple il suffit d'une fonction balançant les requetes à la base, pas la peine de faire dix milles fonctions et conditions en fonction des requetes.

Et donc là, comment je me connecte à plusieurs bdd, ou avec plusieurs comptes, comment je fais mes jointures, mes transactions, mes appels de procédure stockée ?
T'as voulu te faire un truc trop défini, donc pas du tout évolutif, et limité forcément à tes connaissances SQL puisque tu essayes de prévoir chaque cas.

Critiquer c'est facile, donc demain au taf je mettrai la mienne, histoire de me faire poutrer (enfin je la pense bien plus fonctionnelle que la tienne malgré tout )

Message cité 1 fois
Message édité par Djebel1 le 28-04-2006 à 04:02:56

the_bigboo

Djebel1 a écrit :

Il n'est pas question de se faire poutrer ou quoi Mais de partager des points de vue
personnelemment je l'ai faite en fonction de mes besoins , je me débrouille toujours pour ne pas avoir besoin de jointure meme si dans certains ca ce serait en effet assez pratique :ange:
D'autre part, les procédures stockées ne m'intéressent pas pour le moment car les applications qui s'executent au niveau PHP n'ont a l'heure actuelle aucun besoin d'etre déporté sur la base.

Effectivement ce serait cool que tu me montre comment tu as fait tes jointures

Message cité 1 fois

anapajari

s/travail/glanding on hfr/gs;

the_bigboo a écrit :

Le truc que je trouve dommange c'est que des librairies d'accès à des bases de données pour le coup il en existe déjà plein en php alors pourquoi en refaire une [:spamafote]

Prenons par exemple adodb(il en existe plein d'autres mais c'est celle que j'ai l'habitude d'utiliser), elle permet de faire tout ton bouzin sauf qu'en plus (entre autre):

c'est une vrai librairie d'abstraction (donc deux lignes à changer dans le config pour passer d'une base db2 à oracle ou même mysql)
elle gère la mise en cache des résultats
elle permet le bind de variables, les transactions, ou la génération automatique de requêtes insert/updates
plein d'autres trucs

Alors autant on peut critiquer les templates(cf vieille conversation), autant là j'aurais du mal à comprendre les avantages de le "refaire" à la main.

Message cité 2 fois

the_bigboo

anapajari a écrit :

Le truc que je trouve dommange c'est que des librairies d'accès à des bases de données pour le coup il en existe déjà plein en php alors pourquoi en refaire une [:spamafote]

Parce que bien que performantes elles sont souvent assez lourdes d'execution et leur utilisation toujours pas tres bien expliquée, j'ai survollé adodb comme tu l'indiquait, mais ya aucune doc d'utilisation ou je suis aveugle :??:

Message cité 1 fois

anapajari

s/travail/glanding on hfr/gs;

the_bigboo a écrit :

Parce que bien que performantes elles sont souvent assez lourdes d'execution

Pourrais-tu expliquer ton propos? Je comprends pas ou tu veux en venir la
Tiens juste à titre d'exemple, deux benchmarks adodb ( le deuxième date un peu mais bon)
http://adodblite.sourceforge.net/benchmark.php
http://phplens.com/lens/adodb/

the_bigboo a écrit :

et leur utilisation toujours pas tres bien expliquée, j'ai survollé adodb comme tu l'indiquait, mais ya aucune doc d'utilisation ou je suis aveugle :??:

T'es aveugle sur le lien donné, deuxieme ligne, "Documentation" et tu tombes sur

Djebel1

Nul professionnel

anapajari a écrit :

c'est une vrai librairie d'abstraction (donc deux lignes à changer dans le config pour passer d'une base db2 à oracle ou même mysql)
elle gère la mise en cache des résultats
elle permet le bind de variables, les transactions, ou la génération automatique de requêtes insert/updates
plein d'autres trucs

Alors autant on peut critiquer les templates(cf vieille conversation), autant là j'aurais du mal à comprendre les avantages de le "refaire" à la main.

complètement d'accord avec toi, mais au moment où je me suis mis sur mon projet, j'en avais pas trouvé qui me plaisaient.
Adodb a l'air de roxer sa maman, j'ai presque envie de modifier mon projet à la volée lol.
Bon bah après avoir un peu regardé, cette classe fait tout ce dont j'ai besoin.
Le seul truc qui me manque (mais c'est ptet dedans), ça serait de pouvoir faire au sein d'une transaction des requetes qui peuvent planter sans annuler la transaction.
Et j'aimerais bien pouvoir empecher la base d'accepter de nouvelles requetes quand une requete plante (mais comme pour les transactions, que ça soit paramétrable).

Tu saurais si ce que je veux faire est facilement faisable avec cette classe ?

anapajari

s/travail/glanding on hfr/gs;

j'ai pas très bien compris ton problème
en gros tu as par exemple:

requete 1: insert ...
requete 2: insert ...
requete 3: update ...
requete 4: insert ...
requete 5: update ...

Et tu voudrais que si la requête 4 "plante", tu n'executes pas la 5 mais que les résultats produient par les 1,2 et 3 restent dans la base ou au contraire ne soient pas pris en compte?

Djebel1

Nul professionnel

j'aimerais deux choses :

- si la requete 4 plante, qu'on continue normalement, et sans annuler la transaction en cours
- si la requete 4 plante, la transaction en cours est annulée (ça aucun problème), mais plus aucune requete ne s'execute ensuite

Message cité 1 fois

Sve@r

http://www.phpscripts-fr.net/scrip [...] ration+BDD
http://www.comscripts.com/scripts/ [...] s.sc1.html
http://sourceforge.net/projects/alyoop

Message édité par Sve@r le 28-04-2006 à 14:03:31

---------------
Vous ne pouvez pas apporter la prospérité au pauvre en la retirant au riche.

Djebel1

Nul professionnel

Bon sinon, j'ai matté la doc de ADODB (elle est très bien fait faut reconnaitre). Malheureusement, plusieurs points ne me donne pas envie de l'utiliser :

- un faible support de mysql 5, par exemple au niveau des procédures stockées.
- je voyais un intéret énorme en terme de portabilité. Et puis en fait non, cf les propres liens de ADODB : http://phplens.com/lens/adodb/tips_portable_sql.htm
Regardez la section 'SQL as a Localization Exercise'. Donc en gros ils te disent que pour être sur d'assurer une bonne portabilité, tu dois inclure des requêtes spécifiques à chaque bdd. Donc au final la portabilité elle est de 0 quoi.
Etant donné que j'ai déjà un "switcher" de base de données, si je dois réécrire les requetes, ça me coutera rien de plus de modifier également ma classe d'accès à la base.
(ADODB est très bien hein, simplement pour utiliser des fonctionnalités avancées des bdd, bah ils y peuvent rien mais c'est pas portable quoi).

Au final, l'intérêt que je vois à utiliser cette classe est que ça "standardise" l'accès à ta bdd, d'autres développeurs n'étant pas perdu s'ils ont déjà utilisé cette librairie. Mais au final, à part ça ...
Donc je préfère ma propre classe, qui inclue les fonctionnalités que j'aime, ni plus, ni moins. Je la commente un peu et je la poste comme convenu.

Message cité 2 fois
Message édité par Djebel1 le 28-04-2006 à 14:04:23

anapajari

s/travail/glanding on hfr/gs;

Djebel1 a écrit :

Pour moi, rien a voir avec la gestion des transactions. C'est plus de la gestion d'erreurs au sein de celles-ci et c'est le developpeur qui doit s'y coller

Djebel1 a écrit :

- je voyais un intéret énorme en terme de portabilité. Et puis en fait non, cf les propres liens de ADODB : http://phplens.com/lens/adodb/tips_portable_sql.htm
Regardez la section 'SQL as a Localization Exercise'. Donc en gros ils te disent que pour être sur d'assurer une bonne portabilité, tu dois inclure des requêtes spécifiques à chaque bdd. Donc au final la portabilité elle est de 0 quoi.

Bin c'est sur que si tu utilises du SQL 'spécifique' à une BDD, la portabilité tu peux oublier [:spamafote]

Djebel1 a écrit :

Donc je préfère ma propre classe, qui inclue les fonctionnalités que j'aime, ni plus, ni moins. Je la commente un peu et je la poste comme convenu.

L'argument ultime: "c'est moi qui l'a fait donc c'est mieux"

Message cité 1 fois
Message édité par anapajari le 28-04-2006 à 14:24:13

the_bigboo

Djebel1 a écrit :

Donc je préfère ma propre classe, qui inclue les fonctionnalités que j'aime, ni plus, ni moins. Je la commente un peu et je la poste comme convenu.

C'est pour ca que j'ai développé la mienne ^^
Maintenant j'ai implémenté les jointures, j'ai passé la matinée a potasser les JOIN...
Utilisez vous plus INNER ? LEFT ? ou RIGHT ?

Message cité 1 fois

Djebel1

Nul professionnel

anapajari a écrit :

L'argument ultime: "c'est moi qui l'a fait donc c'est mieux"

pas du tout : c'est mieux pour moi car ça répond à mes besoins.
En fait j'en ai marre de devoir gérer les erreurs. Je me suis fait une classe qui me permet de ne plus jamais avoir à tester l'erreur provoquée par une requete. Et franchement, c'est la seule et unique raison pour laquelle je ne vais pas utiliser ADODB. Et j'ai bien souligné que je trouvais cette librairie très bien, mais que problème de portabilité pour problème de portabilité, je préfère faire chier le développeur suivant que moi

Djebel1

Nul professionnel

Citation :

si tu utilises du SQL 'spécifique' à une BDD

Le problème étant que pour certains trucs t'es obligé
edit : putain de bouton editer

Message cité 1 fois
Message édité par Djebel1 le 28-04-2006 à 15:30:49

the_bigboo

Djebel1 a écrit :

Le problème étant que pour certains trucs t'es obligé
edit : putain de bouton editer

Oui... Par exemple l'attribut LIMIT ne passe pas sous oracle :sweat:

Djebel1

Nul professionnel

bah ca encore ça va, ADODB te permet de gérer ce genre de problème. C'est pour les trucs pour lesquels ADODB n'a pas d'abstraction le problème

Djebel1

Nul professionnel

Voilà je vous soumets ma classe d'accès à une base MySQL :

Les intérêts qu'elle a pour moi (d'ailleurs c'est marrant, j'ai inclue des fonctionnalités qui se trouve dans ADODB )

- Gestion du debug : 3 niveaux de debug configurable : 1 pour voir toutes les requetes, 1 pour voir uniquement les requetes échouées, 1 pour la phase de prod
- Gestion du debug : mise dans un fichier log des erreurs mysql
- Gestion des transactions : le gestionnaire permet de ne pas imbriquer par erreur plusieurs transactions. Rollback toute transaction non confirmée à la fin de votre script.
- le test du retour des requêtes devient inutile : si une requete échoue, toute transaction sera automatiquement annulée, et la base n'acceptera plus aucune requete. Vous pouvez donc sereinement balancer une serie de requetes sans avoir à verifier la présence d'erreur. A la fin de votre "procédure", il vous suffit de vérifier en une seule instruction si une erreur s'est produite.
Un paramètre optionnel permet de ne pas obtenir ce comportement : une requete échouée ne provoquera pas l'annulation de la transaction, et la base continuera d'accepter des requêtes.
- multiton pattern : votre classe est appelable de n'importe où, et vous garantit la présence d'une seule instanciation en mémoire par connection. Vous pouvez gérer plusieurs connexions simultannées.
- pas de trucs compliqués pour gêrer les requetes, vous pouvez donc toutes les faire. Bien sur, cela implique que si vous changez de bdd, il faudra réécrire les requetes dans votre couche de persistance. Mais comme de toute façon si vous changez de bdd vous devrez réécrire vos requetes ... (comme on en a discuté, une abstraction totale de la bdd est impossible)

Code :

<?php
/**
* Database access class
*
* All requests to the database are channeled through this class.
* This lets you easily change the database or debug applications.
* This class is a multiton. It can be instantiated from anywhere.
*
* @package Database
* @category General
* @version 1. (04/2006)
*/
class Database
{
/**
* array that contains Database objects resources.
* this array is static (this class is a multiton)
*/
private static $_arrObjDatabase;
/**
* link identifier to the current database
*/
private $_link;
/**
* variable needed by the transactManager function
* @see Database::transactManager()
*/
private $_transactManager;
/**
* variable needed by the transactManager function
* @see Database::transactManager()
*/
private $_rollback;
/**
* this var indicates whether the database keep on
* accepting queries or not.
*/
private $_acceptQuery;
/**
* debug level, var needed by the _debug function
* @see Database::_debug()
*/
private $_debug;
/**
* files in wich the mysql errors have to be logged,
* var needed by the _debug function
* @see Database::_debug()
*/
private $_dirLogError;
/**
* private constructor (multiton pattern)
*/
private function __construct()
{
$this->_transactManager = 0;
$this->_rollback = 0;
$this->_acceptQuery = true;
//value to change for application debug
$this->_debug = 2;
$this->_dirLogError = 'error.log';
}
/**
* function that instantiates the Database object, but only if it does not already exist (multiton pattern).
*
* @param string $login login to connect to database
* @param string $password password to connect (not encrypted)
* @param string $base database to choose
* @param string $host database server
* @return resource resource to Database object
*/
public static function connection($login = 'defaultLogin', $password = 'defaultPass',
$base = 'defaultDb', $host = 'defaultHost')
{
$temp = $login.$base.$host;
//$temp to let us know if this object is already instantiated or not
if (!isset(self::$_arrObjDatabase[$temp])) {
self::$_arrObjDatabase[$temp] = new Database();
}
//if self::$_arrObjDatabase[$temp]->_link doesn't exist (no connection, object has just been instantiated)
//or is negative (connection closed by using $this->close), connection to database
if (!isset(self::$_arrObjDatabase[$temp]->_link) || self::$_arrObjDatabase[$temp]->_link == -1) {
self::$_arrObjDatabase[$temp]->_setStatut(self::$_arrObjDatabase[$temp]->_mysqlConnection($login, $password, $base, $host));
}
return self::$_arrObjDatabase[$temp];
}
/**
* connection and choice of the database
*
* @param string $login login to connect to database
* @param string $password password to connect (not encrypted)
* @param string $base database to choose
* @param string $host database server
* @return mixed link identifier on succes, false on error
*/
private function _mysqlConnection($login, $password, $base, $host)
{
$test = mysql_connect($host, $login, $password);
$this->_debug('Connection to database', $test, 1);
if ($test === false) {
return $test;
} else {
$select_db = mysql_select_db($base, $test);
$this->_debug('Database choice', $select_db, 1);
if (!$select_db) {
return $select_db;
}
}
//if everything is alright, return link identifier
return $test;
}
/**
* close connection to database
*/
public function close()
{
if ($this->_link > 0) {
$close = mysql_close ($this->_link);
$this->_debug('Close connection', $close, 1);
if ($close) $this->_setStatut(-1);
}
}
private function _setStatut($value)
{
$this->_link = $value;
}
/**
* to know if a mysql error occured
*
* @return bool true if an error occured, else false
*/
public function getError()
{
if (!$this->_acceptQuery) {
return true;
} else {
return false;
}
}
/**
* manage and debug queries to database
*
* The query will be sent to the database only if
* $this->_acceptQuery is set to true.
*
* @param string $query query to send to database
* @param bool $forceQuery if set to false (default value),
* a failed query will rollback current transaction,
* and force the database to reject following queries.
* If set to true and the query failed, nothing will happen.
* @return mixed resource on succes, false on error
*/
public function request($query, $forceQuery = false)
{
$resource = false;
if ($this->_acceptQuery) {
$resource = @mysql_query($query, $this->_link);
$this->_debug($query, $resource, $forceQuery);
}
return $resource;
}
/**
* Fetch a result row as both an associative array and a numeric array (mysql_fetch_array) .
*
* if they are no more rows, the results are free (mysql_free_result)
*
* @param resource $resource resource from a call to $this->request (mysql_query)
* @param mixed array while there is a result, false if there is no more rows
*/
public function fetch_array($resource)
{
if ($resource !== false) {
$result = mysql_fetch_array($resource);
if ($result === false) {
mysql_free_result($resource);
}
return $result;
} else {
return false;
}
}
/**
* get number of results for a select command
*
* The query will be sent to the database only if
* $this->_acceptQuery is set to true.
*
* @param resource $resource resource from a call to $this->request (mysq_query)
* @param bool $forceQuery if set to false (default value),
* a failed query will rollback current transaction,
* and force the database to reject following queries.
* If set to true and the query failed, nothing will happen.
* @return mixed number of results (int) on succes, false on error
*/
public function numberSelect($resource, $forceQuery = false)
{
$count = false;
if ($this->_acceptQuery) {
$count = @mysql_num_rows($resource);
$this->_debug('Query number of results', $count, $forceQuery);
}
return $count;
}
/**
* get number of affected rows by an insert, delete or update command
*
* The query will be sent to the database only if
* $this->_acceptQuery is set to true.
*
* @param resource $resource resource from a call to $this->request (mysq_query)
* @param bool $forceQuery if set to false (default value),
* a failed query will rollback current transaction,
* and force the database to reject following queries.
* If set to true and the query failed, nothing will happen.
* @return mixed number of affected rows (int) on succes, false on error
*/
public function numberAffected($forceQuery = false)
{
$count = false;
if ($this->_acceptQuery) {
$count = @mysql_affected_rows($this->_link);
$this->_debug('Query number of affected rows', $count, $forceQuery);
}
return $count;
}
/**
* get last auto-increment ID
*
* The query will be sent to the database only if
* $this->_acceptQuery is set to true.
*
* @param bool $forceQuery if set to false (default value),
* a failed query will rollback current transaction,
* and force the database to reject following queries.
* If set to true and the query failed, nothing will happen.
* @return mixed $id last auto_increment ID (int) on succes, false on error
*/
public function insertId($forceQuery = false)
{
$id = false;
if ($this->_acceptQuery) {
$id = @mysql_insert_id($this->_link);
$this->_debug('Query last auto_increment ID', $id, $forceQuery);
}
return $id;
}
/**
* manage transactions
*
* @param string $action action to be proceed (begin transaction, commit or rollback transaction)
* @param string $level level of the transaction, default value serializable
*/
public function transactManager($action, $level='serializable')
{
switch ($action) {
case 'begin' :
//if a second transaction is interleaved,
//the first one will not be stopped
if ($this->_transactManager == 0) {
if ($level == 'read uncommitted' ||
$level == 'read committed' ||
$level == 'repeatable read' ||
$level == 'serializable') {
$this->request('set transaction isolation level '.$level);
}
$this->request('start transaction');
}
$this->_transactManager ++;
break;
case 'rollback' :
//if try to rollback a transaction interleaved by error,
//wait for the end of the first one, and then rollback all of them.
if ($this->_transactManager > 1) {
$this->_rollback = 1;
} elseif ($this->_transactManager == 1) {
$this->request('rollback');
$this->_rollback = 0;
}
if ($this-> _transactManager > 0) {
$this->_transactManager --;
}
break;
case 'commit' :
//commit is allowed only if no interleaved transaction was rollbacked
if (($this->_transactManager == 1) and ($this->_rollback == 0)) {
$this->request('commit');
} elseif (($this->_transactManager == 1) and ($this->_rollback == 1)) {
$this->request('rollback');
$this->_rollback = 0;
}
if ($this->_transactManager > 0) {
$this-> _transactManager --;
}
break;
}
}
/**
* Debug function
*
* Display all database queries, failed database queries, or any,
* depending on the debug level in the class constructor.
* Debug all queries.
*
* @param string $query query to database
* @param resource $resourceResult resource from a query to database (mysql_query, mysql_insert_id, ...)
* @param bool $forceQuery if this var is false and the query has failed,
* current transaction will be rollbacked, error will be logged,
* and database will reject all following queries.
* if this var is true, nothing happens.
*/
private function _debug($query, $resourceResult, $forceQuery = 0)
{
//depending on the debug level
if ($this->_debug == 2) {
//all queries are shown, not to use in production
if ($resourceResult === false) {
echo 'FAILED quey : ';
} else {
echo 'valid query : ';
}
echo htmlentities($query), ' ';
} elseif ($this->_debug == 1) {
//only failed queries are shown, not to use in production
if ($resourceResult === false) {
echo 'FAILED query : ', htmlentities($query), ' ';
}
} else {
//production version
}
//log the errors
if ($resourceResult === false && !$forceQuery) {
//rollback transaction, no more queries will be accepted
$this->transactManager('rollback');
$this->_acceptQuery = false;
//write error in log file
$text = 'The query : '.$query."\r\n".'has returned the error : '.mysql_error($this->_link)."\r\n";
$handle = @fopen($this->_dirLogError, 'ab');
if ($handle) {
@fwrite($handle, $text);
}
}
}
/**
* protect queries to database
*
* @param mixed $value value to protect
* @return mixed $value value protected
*/
public function quoteSmart($value)
{
//stripslashes
if (get_magic_quotes_gpc()) {
$value = stripslashes($value);
}
//protection if not real
if (!is_numeric($value)) {
$value = mysql_real_escape_string($value);
}
return $value;
}
public function __destruct()
{
//rollback all transactions not finished
if ($this->_transactManager > 0) {
$this->request('rollback');
}
}
}
?>

Message édité par Djebel1 le 28-04-2006 à 16:28:36

zapan666

Tout est relatif

moi j'aurais fais une fonction startTransaction, rollback et commit, a la place transactionManager

Parce que ton switch, tu fais une faute de frappe dans $action, il va pas te dire que ça marche pas (quoique, y'a pas de default).

---------------
my flick r - Just Tab it !

Djebel1

Nul professionnel

t'as pas tort, je le modifierai

Je@nb

Kindly give dime

Sinon ya les classes mysqli et PDO (qui implémente un drivers pour sqlite, oracle, pgsql et mysql) et qui sont inclus dans PHP5

Message cité 1 fois

Sve@r

the_bigboo a écrit :

Maintenant j'ai implémenté les jointures, j'ai passé la matinée a potasser les JOIN...
Utilisez vous plus INNER ? LEFT ? ou RIGHT ?

Ca dépend totalement du type de requête voulu.
Exemple simple: 2 tables liées par une relation 0/1 vers n style voiture-marque (avec certaines voitures sans marque, bon je trouve rien deplus pertinent)
Si tu requêtes toutes les voitures avec leur marques dans une requête avec jointure simple (style "from voiture, marque where voiture.marque=marque.id" ), tu n'obtiendras que les voitures ayant une marque (que les voitures où l'identifiant "marque" est rempli) et ça n'affichera pas les voitures sans marque.
Si ton but est d'obtenir toutes les voitures, et d'afficher en plus la marque pour les voitures qui en ont une, alors faut demander un "outer join".
Pour les "left" et "right", c'est aussi d'autres caractéristiques correspondant à d'autres pb similaires. On peut pas dire qu'il faut toujours du left ou toujours du right...

Message cité 1 fois

---------------
Vous ne pouvez pas apporter la prospérité au pauvre en la retirant au riche.

the_bigboo

Sve@r a écrit :

Si ton but est d'obtenir toutes les voitures, et d'afficher en plus la marque pour les voitures qui en ont une, alors faut demander un "outer join".
Pour les "left" et "right", c'est aussi d'autres caractéristiques correspondant à d'autres pb similaires. On peut pas dire qu'il faut toujours du left ou toujours du right...

Pourquoi pas INNER ?

Je@nb

Kindly give dime

Et pourquoi pas regarder un cour sur les jointures ?

nargy

qq idées en vrac:

J'ai découvert le bind de valeurs avec Qt:

Code :

QSqlQuery query;
query.prepare( "INSERT INTO atable (id, forename, surname) "
"VALUES (:id, :forename, :surname)" );
query.bindValue( ":id", 1001 );
query.bindValue( ":forename", "Bart" );
query.bindValue( ":surname", "Simpson" );
query.exec();

C'est peut être le truc le plus interessant.

Sinon, ça me paraît un poil compliqué. J'ai pas tout lu, mais de loin ça ressemble à un nid à bugs. Quand tu jongle bien avec le SQL (qui finalement n'est pas très compliqué) tu peut te passer de la plupart des fonctionnalités ci-dessus.

Ce qui est paraît interessant, c'est la gestion des plantages. Mais j'en connais pas qui soit vraiment utile dans tous les cas.

Un autre truc que j'utilise souvent: une liste de conditions de longueur variable comme dans une page de recherche avec champs facultatifs.

Finalement, ce que je préfère, c'est une classe à part pour encapsuler les requêtes, selon les objets et la base. Je trouve ça plus facile à débugger.

the_bigboo

c'est pour ca que j'ai fait cette class ! Mes besoins sont pas extraordinaires !elle est adaptée a mes besoins et c'est pratique c'est tout

FlorentG

Je@nb a écrit :

Sinon ya les classes mysqli et PDO (qui implémente un drivers pour sqlite, oracle, pgsql et mysql) et qui sont inclus dans PHP5

Attention toutefois à PDO, qui n'est pas une librairie d'abstraction de source de donnée, mais une librairie d'abstraction d'accès aux donnée. Si on code en PDO pour mysql et qu'on fait pas gaffe, y'a de forte chance qu'il faille réécrire toutes les requêtes lors du passage à un autre systus.

AdoDb, par contre, est vraiment un machin d'abstraction de bidule, à savoir que toutes les requêtes sont écrites une fois pour toutes, qu'on soit sous MySql, Oracle, etc.

Message cité 2 fois

FlorentG

the_bigboo a écrit :

Code :

<?php
// Librairie MySQL optimisée PHP5
class MySQL {
[....]
}
// Class annexes - Insert
class MySQL_insert extends MySQL {
[....]
}
?>

J'aurais pas utilisé extends pour MySQL_insert, j'aurais plutôt mis un objet MySql dans MySQL_insert

the_bigboo

probablement, mais l'objet MySQL sert pour d'autres objets aussi... Notament pour charger la configuration.

FlorentG

Là je pense qu'il y a un problème de structure. Tu utilises extends pour utiliser les fonctionnalités de MySQL. MySQL_Insert n'est pas un objet de type MySQL, c'est un objet qui utilise MySQL. You failed Essaye de revoir tes notions de l'orienté objet

Message cité 1 fois

the_bigboo

FlorentG a écrit :

ben tu ferais ca comment toi ? Je vois pas d'autres moyens ! Si je déclare un objet dans l'objet ca va faire du copier/coller de ouf !
En quoi est-ce une faute puisque ca marche tres bien comme ca ??

Publicité

Page : 1 2

Page Suivante

Page Précédente

Haut de page

FORUM HardWare.fr

Programmation

PHP

Class PHP5 de gestion de requetes SQL simples

Sujets relatifs
convertir base de donnée excel en base de donnée SQL	Mailing list + gestion contacts (adresse postale...)
[VB.NET CF2.0] Sql server CE	[SAGE] requete sql via odbc sous sage gestion commercial ligne 100
assembleur ARM - petites questions simples	[PHP] Interface de gestion d'un menu customizable...
[MFC et ODBC] Requete SQL	Gestion des membres via cookie
Gestion des membres via cookie	Comment ouvrir les fichiers *.class?
Plus de sujets relatifs à : Class PHP5 de gestion de requetes SQL simples

Page générée en 0.319 secondes