GESTIONNAIRE DE MODÈLES SQL
destinyfr
Messages postés
106
Date d'inscription
samedi 19 mai 2007
Statut
Membre
Dernière intervention
13 avril 2009
-
26 nov. 2008 à 19:15
codefalse Messages postés 1123 Date d'inscription mardi 8 janvier 2002 Statut Modérateur Dernière intervention 21 avril 2009 - 1 déc. 2008 à 23:57
codefalse Messages postés 1123 Date d'inscription mardi 8 janvier 2002 Statut Modérateur Dernière intervention 21 avril 2009 - 1 déc. 2008 à 23:57
Cette discussion concerne un article du site. Pour la consulter dans son contexte d'origine, cliquez sur le lien ci-dessous.
https://codes-sources.commentcamarche.net/source/48539-gestionnaire-de-modeles-sql
https://codes-sources.commentcamarche.net/source/48539-gestionnaire-de-modeles-sql
1 déc. 2008 à 23:57
Merci d'avoir relevé l'erreur, je corrigerai au plus vite ! :)
1 déc. 2008 à 20:57
Ta table ce nom : User
Dans le code tu recherche sur : opel.Users
Voilà l'erreur ^^
Tin voilà une chose qui pourrais ce voir être rajouté :) éviter les grosses lignes comme ça dès qu'une erreur arrive :)
Encore désolé :)
1 déc. 2008 à 20:53
C'est en ce qui concerne la source ^^
Désolé je pensais avoir posté l'erreur :
Fatal error: Uncaught exception 'PDOException' with message 'SQLSTATE[42000]: Syntax error or access violation: 1142 SELECT command denied to user '******'@'*******' for table 'Users'' in /testclass/classes/Models/Mysql/Users.php:24 Stack trace: #0 /testclass/classes/Models/Mysql/Users.php(24): PDOStatement->execute(Array) #1 /testclass/index.php(18): Users->selectFromId(1) #2 {main} thrown in /testclass/classes/Models/Mysql/Users.php on line 24
Y a du bordel ^^ (un message comme celui la jamais vu encore XD).
J'ai bien essayé de rajouter dans les dns (page index.php) le nom de la base de donnée mais rien à faire :(
1 déc. 2008 à 18:24
Ma source à été testé sur mon serveur, pourrais tu donner plus de détails sur l'erreur générée ?
Merci :)
1 déc. 2008 à 18:11
peut-être que cela vien de moi ?
1 déc. 2008 à 17:24
1 déc. 2008 à 16:25
En règle générale, je nomme mes variables ainsi : typeNom, avec type la première lettre du type de variable (i pour integer, s pour string, o pour object, a pour array). Ensuite je lui donne un nom précis (genre pour pdo : oPdo).
$o, en fait c'est pour faire vite, donc c'est juste pour dire que c'est un objet, mais la variable n'a pas de nom au sens ou je lui en donne.
Ce n'est pas vraiment une nomenclature, juste une façon de procéder. Chaque personne à sa méthode, certain font pareils, ca dépend des gens :)
1 déc. 2008 à 16:01
1 déc. 2008 à 16:00
L'utilisation de la nomentlature
$o signifie que cette variable n'est instancié qu'une seule fois(once)?
$m signifie que cette variable est une variable membre d'une classe?
29 nov. 2008 à 13:12
Par ailleurs, et pour faire simple, String (l'objet) fonctionne en type hinting tout simplement car ... c'est un objet ! :)
Pour ce qui est des références, encore une fois j'avais vu ca dans la doc (que "tout" est référence en php5) mais encore une fois, je ne m'en rappelais plus ! En fait j'apprends des notions, je les appliques et j'oublie les notions ensuite, c'est pas trop pédagogue tout ca :p
Mais merci pour ces piqûres de rappel ! :)
29 nov. 2008 à 10:36
en fait, je vais nuancer tes propos Dighan : il y a des subtilités, j'avais lu cette remarque dans les commentaires de la doc :
<?php
class a {
public $bar = 1;
}
class b {
public $bar = 2;
}
$a = new a;
$b = new b;
$tmp = $a;
$a = $b;
$b = $tmp;
var_dump($a);
var_dump($b);
$a = new a;
$b = new b;
$tmp = $a;
$a = & $b;
$b = $tmp;
var_dump($a);
var_dump($b);
?>
Pour rester simple, de ce que j'en comprends, PHP5 utilise en fait des "copies"... : quand vous passez un objet en paramètre à une méthode/fonction, vous avez bien 2 variables distinctes. Mais ces 2 variables référencent un même identifiant (repéré par le #X dans un var_dump()), et cet identifiant POINTE vers une valeur. Etant donné qu'elles REFERENCENT le même identifiant, on parle de "références".
Avec le & (ampersand), vous créez un alias : c'est exactement la même variable, qui va posséder 2 noms différents, si vous voulez. Dans le 2ème cas de mon exemple donc, nous avons bien de vraies références. Contrairement au 1er cas.
C'est une petite subtilité qui peut amener à pas mal d'incompréhensions.
un clone effectue une copie conforme de l'objet. Une vraie copie : nous avons alors 2 identifiants.
Donc :
<?php
class a {
public $bar = 1;
}
class b {
public $bar = 2;
}
$a = new a;
$b = new b;
$a = $b;
$c = clone $a;
var_dump($a, $b, $c);
$a = new a;
$b = new b;
$a = & $b;
$c = clone $a;
var_dump($a, $b, $c);
?>
MAIS :
<?php
class a {
public $bar = 1;
}
class b {
public $bar = 2;
}
$a = new a;
$b = new b;
$c = clone $a;
$a = $b;
$b = $c;
var_dump($a, $b, $c);
$a = new a;
$b = new b;
$c = clone $a;
$a = & $b;
$b = $c;
var_dump($a, $b, $c);
?>
Bref, ce n'est pas si simple que ça...
29 nov. 2008 à 01:03
J'aimerai juste revenir sur ce qu'aKheNathOn a ecrit concernant les "pointeurs".
En PHP5 (comme en PHP4) la notion de pointeurs est inexistante, il n'y a que des références (objets) ou des copies (scalaires, array).
Le code suivant est donc obsolète (pour PHP >= 5 et pour de l'affectation) :
public function __construct (PDO &$oPdo) $this->_oPdo =& $oPdo;
Exemple à l'appui:
$a = new stdClass();
$b = $a;
$b->val = 2;
var_dump($a, $b);
// $a $b object(stdClass)#1 (1) {["val"]=> int(2) }
Cet exemple n'est pas toujours vrai surtout si vous travaillez avec PHP < version 5.
28 nov. 2008 à 21:24
<?php
class string {
protected $sValue;
public function __construct($sString) {
if(!is_string($sString)) {
throw new Exception('argument must be a string');
}
$this->sValue = $sString;
}
public function __toString() {
return $this->sValue;
}
}
$toto = new string('toto');
echo str_replace('o', 'i', $toto);
function say(string $bar) {
echo $bar;
}
echo say($toto);
?>
28 nov. 2008 à 21:16
function maFonction(array $var1, string $var2) {
}
Ca, ça ne fonctionne pas réellement. Les seuls types autorisés pour du "type hinting" dans les appels de méthodes ou de fonctions sont array et les objets.
Quand tu fais
function foo(string $bar) {
}
ta fonction attend une variable $bar de type string...mais un objet string! Bref, une instance d'une classe appelée string. Idem pour int, ou float...bref juste array et les objets.
Par exemple :
foo('toto');
renverra une erreur "catchable".
mais
class string{}
$var = new string;
foo($var);
fonctionnera.
Sauf que ce n'est pas une chaîne...ce n'est pas une variable de type "string".
Après, rien n'empêche de réécrire les types classiques sous forme de classes...évidemment.
28 nov. 2008 à 15:52
Bon, j'espère que l'on te reverra rapidement ! :)
Bon taff à toi.
28 nov. 2008 à 14:22
Oui ça faisait un moment, je manque vraiment de temps là...
28 nov. 2008 à 14:15
Vos idées sont intéressantes et méritent réflexion. Je ne sais pas trop encore comment je pourrais m'y prendre, mais c'est vrai que jouer directement avec l'instance sans la retourner, ce n'est pas mal.
@Malalam : Ca faisait un moment non ? :)
Personnellement je préfère un mix de vous deux, c'est à dire un :
$o->attach ('modA');
$o->modA->getUsers ();
ou
$o->attach ('modA', 'users');
$o->users->getUsers ();
Sinon, déçu que CS ne fasse pas les balises bb ou autre pour le code :( du coup le post de malalam est dure à digérer (MALALAM ! On t'a dit quoi sur l'indentation !! RALALA !! :p)
Je vais voir pour retravailler ca ! :)
28 nov. 2008 à 13:48
je lirai et testerai, merci Akhé :-)
Voilà un petit exemple de ce que j'entendais par utiliser __call() :
<?php
class A {
protected $oMods;
public function __construct() {
$this->oMods = new ArrayIterator;
}
public function __call($sMethod, $aArgs) {
foreach($this->oMods as $oMod) {
if(method_exists($oMod, $sMethod)) {
return call_user_func_array(array($oMod, $sMethod), $aArgs);
}
}
}
public function attach($oModule) {
if(!$oModule instanceof module) {
throw new Exception('Not an instance of module');
}
if(false === $this->contains($oModule)) {
$this->oMods[get_class($oModule)] = $oModule;
}
}
public function detach($mModule) {
if((is_object($mModule) && $oModule instanceof module) || is_string($mModule)) {
foreach($this->oMods as $idx => $oMod) {if ((is_object($mModule) && $mModule $oMod) || (is_string($mModule) && $mModule $idx)) {
unset($this->oMods[$idx]);
$this->oMods->rewind();
return;
}
}
}
}
protected function contains($mModule) {
if (is_object($mModule)) {
foreach($this->oMods as $oMod) {
if ($oMod === $mModule) {
return true;
}
}
}
return false;
}
}
interface module {}
class modA implements module {
public function foo() {
echo 'foo';
}
}
class modB implements module {
public function bar() {
echo 'bar';
}
}
$A = new A;
$A->attach(new modA);
$A->attach(new modB);
$A->foo();
$A->bar();
$A->detach('modB');
$A->bar();
?>
28 nov. 2008 à 09:49
Toujours en allant dans le sens de malalam, j'aurais trouvé ça fun de pouvoir directement faire :
$oPdoInstance->Users()->Update('...');
Une vérif aurait checké si users est chargé en tant que module, dans le cas contraire il l'aurais instancié et mis en cache. Il en retournerais son instance :)
Destiny, en réalité je me suis pas mal penché sur l'optimisation de certains codes dans des frameworks et je me suis rendu compte que même si PHP gère automatiquement les pointeurs, ce n'est pas toujours fait, du coup je prends des précautions :
Exemple :
public function __construct (PDO &$oPdo) {
$this->_oPdo =& $oPdo;
}
Dans l'argument je lui dit que j'ai besoin d'une référence à l'objet pdo et non d'une valeur clonée. Ensuite je le sauvegarde dans une variable privée de ma classe, mais toujours en tant que référence. Sinon, dans certains cas il me duplique l'objet qui est pourtant une référence.
Malalam, je ne sais pas si ça relève du bug ou bien s'il faut bien tout déclarer, la plus part du temps je ne le fais pas - du coup des fois j'ai des perfs flinguées et des résultats incohérents.
Tu peux tester, la version SVN est à cet emplacement :
https://dotview.svn.sourceforge.net/svnroot/dotview/trunk
T'as rien à installer, juste déclarer le répertoire démo en tant qu'allias demo puis aller à sa racine.
Ca va te générer une erreur normale vu que t'as pas configuré les bases de données - et à droite de l'erreur t'as le debug stack. Il est vide...
dans dotview/core/debug.class.php modifies ça :
... &getInstance()... ligne 12
dans dotview/core/core.class.php
... &debug() ... ligne 8
Ce qui est étonnant c'est que le comportement change si on utilise une version antérieur de PHP.
27 nov. 2008 à 19:34
sympa.
Ce que je ferais moi, néanmoins, c'est utiliser __call(). Pourquoi ? Pour te permettre de ne pas utiliser $oUsers.
Disons que "users" devient un "module" de pdomanager dès qu'on le charge. A ce moment, pdo manager peut implémenter une méthode magique __call() qui va chercher dans les modules chargés la méthode qu'on tente de lui faire appeler :
$pdomanager->update(bla bla);
va appeler $this->oModules['users']->update(bla bla);
L'inconvénient étant que chaque méthode de tes modules doit avoir un nom différent.
Mais c'est un confort appréciable à l'utilisation.
Rectification sur les commentaires d'Akhé : le typage dans les appels de méthodes/fonctions est disponible à partir de php5.1, pas de php5 tout court (php5.0.4 ne connait pas, par exemple).
Encore Akhé : j'aimerais bien un exemple de ce que tu dis sur php5.2 qui clonerait parfois, rendant erratique l'utilisation de méthodes statiques "non pointées"? Je n'ai jamais rencontré ce problème, et j'aimerais autant voir de quoi il retourne avant de le rencontrer :-)
27 nov. 2008 à 18:32
function maFonction(int &$argument) {
$argument = -99;
}
Comme ceci :
function maFonction(int &$argument) {
$argument =& -99;
}
Comme tu la fait dans cette exemple :
public function __construct (PDO &$oPdo) {
$this->_oPdo =& $oPdo;
}
27 nov. 2008 à 18:15
Tu lui envoies des arguments et elle te renvoie un résultat.
Pour les argument tu peux lui passer une valeur genre VRAI/FAUX ou 10/-10, ou bien lui passer une référence.
La référence c'est que tu lui envoies non pas une donnée mais une variable - la nuance c'est qu'en lui envoyant la variable tu peux la modifier dans la fonction.
Exemple :
$val1 = 10;
function maFonction(int &$argument) {
$argument = -99;
}
echo $val1.'
';
maFonction($val1);
echo $val1;
Ca va afficher :
10
-99
---
Les références sont importante à utiliser dans le passage d'objets, car en cas d'ommission il duplique l'objet et pour de gros objets cela est couteux en temps (exemple typique la structure dom d'un XML)
---
Autre détails, le résultat d'une fonction peut être envoyé en référence également, en utilisant :
function &maFonction() {
return new PDO(...);
}
C'est utile surtout quand tu as des classes de type singleton ou factory (design patterns)
27 nov. 2008 à 18:09
Déjà les variables des fonctions, la plus part du temps tu peux avoir :
function maFonction($var1, $var2) {
...
}
Mais à aucun moment tu ne dis à quoi correspond var1 ou var2 en tant que type de variable - du coup php accepterais que t'appelles ta fonction ainsi :
$resultat = maFonction(true, 10);
ou $resultat = maFonction("Salut !", new PDO(...));
Tu vois, on peut à peu près tout faire, et dans la pluspart des cas elle va planter à moins que tu tartines des tonnes de vérifications pour expliquer la vraie cause de l'erreur.
Ben sinon depuis php 5 tu peux typer tes arguments :
function maFonction(array $var1, string $var2) {
}
Si c'est un objet, tu indiques le nom de la classe, comme ...(PDO $varPDO)...
27 nov. 2008 à 17:52
Tout ça m'intéresse ^^ mais bon sa semble dur à appliquer :s
Si j'ai compris, plutôt que de déclarer par exemple une variable comme ça :
$aServerConfig = array();
On fait : $aServerConfig;
et dans la fonction il devient : functionName(array $aServerConfig) {
De plus faut t-il obligatoirement rajouter & devant le nom de la fonction du coup ?
&functionName(array $aServerConfig) { ?
Peux-tu m'expliquer l'utilisation des & dans le constructeur suivant :
public function __construct (PDO &$oPdo) {
$this->_oPdo =& $oPdo;
}
et à quoi sert PDO ? A indiquer que c'est une base ?
Merci de répondre :)
27 nov. 2008 à 15:27
Pour ce qui est du typage, c'est une bonne nouvelle !
Merci de l'info :)
27 nov. 2008 à 14:52
Du coup, du moment ou l'instance n'est pas à cloner j'en met des couches. Juste sans mettre des pointeurs, rajouttes ça dans tes classes :
public function __clone() {
throw new Exception('Should not clone :(');
}
J'ai plusieurs instance de serveurs avec différentes versions et j'ai eu ce bug sous WAMP 2.0 - PHP 5.2.6
Pour le typage, essayes ça :
<?php
function debugArray(array $arg) {
print_r($arg);
}
debugArray(array('Valeur 1', 'Valeur 2'));
debugArray('Some text !');
?>
En retour tu auras :
Array
(
[0] => Valeur 1
[1] => Valeur 2
)
Catchable fatal error: Argument 1 passed to debugArray() must be an array, string given, called in C:\..\test.php on line 3
27 nov. 2008 à 14:23
Pour ce qui est du manque de notion d'ORM, c'est volontaire. Le code présenté ici n'à que pour but de séparer le modèle du reste du code (si l'on prends une structure MVC). Un ORM serait une sorte de complément, extension au code présenté ici. La plupart des frameworks actuels proposent une séparation des différentes couches sans imposer un ORM, mais le propose en plus, si l'utilisateur le désir.
De toute facon la partie ORM doit plus te concerner d'après tes sources n'est-ce pas ;)
Cependant, ton histoire avec les pointeurs me perturbe, car à t'écouter, il faut mettre des & partout dans le code, genre une cinquantaine par lignes ;)
Pour le typage, j'avais entendu dire que php ne supportait que le typage de classes (comme PDO), pas des autres éléments (array, string, etc). D'ou une abscence de typage pour le Array et la présence pour PDO !
Va falloir que je regarde cela de plus prêt.
Tu aurais un article pour l'histoire des pointeurs, histoire que je comprenne mieux le pourquoi du comment s'il te plait ?
Merci :)
27 nov. 2008 à 13:52
Juste quelques remarques :
Sur tes fonctions mets des pointeurs car à partir de php 5.2 il clone les objets dans certains cas de figures. Déclares tes fonctions genre : public static function &init(
A partir de php 5 tu peux typer tes déclarations :
public static function init ($aServerConfig) {
Devient :
public static function &init (array $aServerConfig) {
Plus la peine de vérifier que c'est un array, d'ailleurs sur le constructeur de PdoModel tu l'avais renseigné.
D'ailleurs en parlant de pointeurs :
public function __construct (PDO &$oPdo) {
$this->_oPdo =& $oPdo;
}
----
Sinon :
- Le code est bien fait / structuré
- Super simple d'utilisation
- Manque quelques fonctions dans le helper genre le stripslashes / le helper est en principe spécifique au driver
- Manque des notions d'ORM mais c'est déjà tellement mieux que de faire du SQL directement dans les vues.
27 nov. 2008 à 07:18
26 nov. 2008 à 22:56
26 nov. 2008 à 21:00
En revanche j'étais sur que tu utilisé un variable pour rien, mais j'ai encore rêvé XD, elle est utilisé sur la ligne du dessous looooool.
Enfin merci quand même pour la réponse ^^.
Pour ce qui est de sqlite, étant donné que tu utilise isset pour vérifier si c'est existant, sqlite devrait passer. Sinon il suffisait juste de faire un petit teste : si user, password etc... faire cette action, sinon faire celle la.
26 nov. 2008 à 19:38
$this->_aLoadedClasses[$sFile] = new $sFile ($this->_oPdo);
Je ne vois pas ce qui dérange ici.
En fait je stocke l'instance des modèles chargés afin d'éviter qu'ils ne se relancent une seconde fois (c'est inutile dans 99% des cas, et comme les 1% ne me concernent pas (encore) :p).
En effet, juste avant, je vérifie qu'il n'existe déjà pas une instance similaire dans ce tableau, si elle existe, je ne fait que la retourner, sinon je l'instancie.
Ca évite des traitements inutiles.
Si c'est pas ce que tu avais compris, précise, je t'expliquerai en détail :p
Sinon, de rien (;
26 nov. 2008 à 19:15
Déjà merci pour l'exemple :)
J'ai regardé ta classe, et d'après moi, le gros avantage de ta classe c'est que tu déclare qu'une seul fois la connexion à la base dans une instance que tu utilise ensuite dans les autres fichiers. C'est bien pensé, le problème c'est que cette classe est plutôt faite pour les bases de type mysql, car dans le constructeur, tu vérifie que tous les champs nécessaires à la connexion existent, or si c'est du sqlite, un seul paramètre est utilisé.
Ce qui est bien, c'est le chargement de classes, tu charge la ou tu veux la classe nécessaire à ce que tu veux faire. Peut-tu par contre m'expliquer un petis poins dessus ?
$this->_aLoadedClasses[$sFile] = new $sFile ($this->_oPdo); -> A quoi cela sert t'il ?
Pour ce qui est de la différence avec ma classe, c'est que tu utilise 2 classes principales qui vont ensuite gérer les modules ce trouvant dans le dossier spécifié. C'est très pratique si tu as beaucoup de classe :)
Je vais essayer d'améliorer ma classe en me basant sur ton exemple :) (notamment pour la gestion des classes avec la fonction load).
Merci pour cette exemple, et merci de répondre à ma question ^^