Erreur d'insertion dans la BDD

Version imprimable

J'ai cette requete basique qui ne veut pas marcher, pourtant j'ai verifié 10 fois et il me semble pas avoir fait d'erreur.

Code:

1
2
3
4
5
6
7
8
9
 
class inventaire extends mysql {
 
	public function ajouter($sexe, $categorie, $taille, $quantite, $description) {
			$dbh = mysql::getInstance();
			$sql = "INSERT INTO inventaire VALUES ('$sexe', '$categorie', '$taille', '$quantite', '$description', '0')";
			$result = $dbh->execute($sql);
 
		}

Et donc voici l'erreur qui ne me parle vraiement pas :

Code:

1
2
3
 
exception 'PDOException' with message 'invalid data source name' in C:\xxx\includes\class\mysql.php:19 Stack trace: #0 C:\xxx\includes\class\mysql.php(19): PDO->__construct('DB_DNS', 'root', '') #1 C:\xxx\includes\class\inventaire.php(6): mysql::getInstance() #2 C:\xxx\template\inventaire.php(85): inventaire->ajouter('fille', 'Tee-shirt', '1', NULL, NULL) #3 C:\xxx\index.php(14): include('C:\wamp\www\elz...') #4 {main}
Fatal error: Call to a member function execute() on a non-object in C:\xxx\includes\class\inventaire.php on line 8

Hello

Je suppose que mysql est un singleton PDO je me trompe ? et que donc $dbh est une référence sur un objet PDO.

Si tel est bien le cas, c'est la méthode PDO::exec que tu dois appeller.
'execute' est une méthode de PDOStatement que tu dois appeller sur l'objet retourné par PDO::prepare.

Tu devrais munir ton singleton d'une méthode statique 'exec' afin de faire directement mysql::exec() au lieu de récupérer la référence à chaque fois.

Au passage, si l'exeption "invalid data source name" c'est que ton DSN est mauvais et donc l'instanciation de PDO à échoué.

Read more: http://www.php.net/manual/en/book.pdo.php

Edit ---

Je te file ma classe singleton pour PDO:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
class Database {
 
    protected static $_pdo_instance;
 
    private function __construct () { }
 
    public function instance () {
        if (!isset(static::$_pdo_instance)) {
            $args = func_get_args();
            try {
                switch (count($args)) {
                    case 0:
                        throw new InvalidArgumentException("The first parameter is mandatory"); break;
                    case 1:
                        static::$_pdo_instance = new PDO($args[0]);
                        break;
                    case 2:
                        static::$_pdo_instance = new PDO($args[0], $args[1]);
                        break;
                    case 3:
                        static::$_pdo_instance = new PDO($args[0], $args[1], $args[2]);
                        break;
                    case 4:
                        static::$_pdo_instance = new PDO($args[0], $args[1], $args[2], $args[3]);
                        break;
                    default:
                        throw new BadMethodCallException(__METHOD__ . " takes at least 1 parameter and at most 4 parameters");
                        break;
                }
            }
            catch (Exception $e) {
                throw new RuntimeException("Cannot connect to database", 0, $e);
            }
        }
        return static::$_pdo_instance;
    }
 
    public static function beginTransaction () {
        return static::$_pdo_instance->beginTransaction();
    }
 
    public static function commit () {
        return static::$_pdo_instance->commit();
    }
 
    public static function errorCode () {
        return static::$_pdo_instance->errorCode();
    }
 
    public static function errorInfo () {
        return static::$_pdo_instance->errorInfo();
    }
 
    public static function exec ($statement) {
        return static::$_pdo_instance->exec($statement);
    }
 
    public static function getAttribute ($attribute) {
        return static::$_pdo_instance->getAttribute($attribute);
    }
 
    public static function getAvailableDrivers () {
        return static::$_pdo_instance->getAvailableDrivers();
    }
 
    public static function lastInsertId ($name = null) {
        return static::$_pdo_instance->lastInsertId($name);
    }
 
    public static function prepare ($statement, $driver_options = array()) {
        return static::$_pdo_instance->prepare($statement, $driver_options);
    }
 
    public static function query ($statment) {
        return static::$_pdo_instance->query($statment);
    }
 
    public static function quote ($string, $parameter_type = PDO::PARAM_STR) {
        return static::$_pdo_instance->quote($string, $parameter_type);
    }
 
    public static function rollBack () {
        return static::$_pdo_instance->rollBack();
    }
 
    public static function setAttribute ($attribute, $value) {
        return static::$_pdo_instance->setAttribute($attribute, $value);
    }
}

Merci

Mais ma classe a toujours bien fonctionné, et oui je me susi trompé dans le code, c'est execute() mais exec() mais ce la ne change strictement rien a l'erreur.

Voici ma classe que je j'utilise depuis plusieurs années deja :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
<?php
class mysql extends PDO {
 
	private static $_instance;
 
	/* Constructeur : héritage public obligatoire par héritage de PDO */
	public function __construct( ) {
 
	}
	// End of PDO2::__construct() */
 
	/* Singleton */
	public static function getInstance() {
 
		if (!isset(self::$_instance)) {
 
			try {
 
				self::$_instance = new PDO('xxx', 'xxx', 'xxx');
 
			} catch (PDOException $e) {
 
				echo $e;
			}
		} 
		return self::$_instance; 
	}
	// End of PDO2::getInstance() */
}
?>

Benjamin Delespierre > y'a pas de static pour ta fonction instance ;)

thebarbarius > d'ou sortent les 'xxx' dans : new PDO('xxx', 'xxx', 'xxx'); ?

si vous voulez rendre n'importe quelle classe en Singleton faites :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Database extends PDO
{
    protected static $_instance;    
 
    public static function getInstance()
    {
        if(null === static::$_instance || 0 === func_num_args())
        {        
            $class = new ReflectionClass(__CLASS__);            
            static::$_instance = $class->newInstanceArgs(func_get_args());
        }
 
        return static::$_instance;
    }
}

18/02/2011, 13h41
thebarbarius

Le premier XXX est le host, le suivant le user et l'autre le mot de passe de connexion a mysql.
18/02/2011, 15h30
stealth35

Citation:

Envoyé par thebarbarius

Le premier XXX est le host, le suivant le user et l'autre le mot de passe de connexion a mysql.

oui mais c'est des constantes ou c'est écrit en dur dans le code ?
18/02/2011, 15h49
thebarbarius

C'est erit en gros.

pas de constante ni de variable.
18/02/2011, 15h57
stealth35

ton erreur vient du fait que tu fais execute et pas query/exec

Oui je me suis trompé en recopiant le code

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
class inventaire extends mysql {
 
	public function ajouter($sexe, $categorie, $taille, $quantite, $description, $images) {
			$dbh = mysql::getInstance();
			$sql = "INSERT INTO inventaire (id, sexe, categorie, taille, quantité, description, image, date) 
					VALUES ('', '$sexe', '$categorie', '$taille', '$quantite', '$description', $images, '0')";
			$query = $dbh->query($sql);
			$result = $dbh->exec($query);
 
		}
 
	public function supprimer() {}
	public function editer() {}
	}

Mais l'erreur est la meme sa change rien.

18/02/2011, 16h07
stealth35

c'est tes ta connexion qui est fausse. verfiie bien les valeurs la ton DNS c'est 'DB_DNS' il est considéré comme du texte la
18/02/2011, 16h22
thebarbarius

Je met des constantes alors ?
18/02/2011, 16h30
stealth35

Citation:

Envoyé par thebarbarius

Je met des constantes alors ?

tu mets ce que tu veux dument que ça soit un DSN correct.

Ah c'est bon j'avais omis d'inserer sa

Code:

1
2
 
define ("DB_DNS", "mysql:host=localhost;dbname=dbname");

Ce qui donne :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
<?php
class mysql extends PDO {
 
	private static $_instance;
 
	/* Constructeur : héritage public obligatoire par héritage de PDO */
	public function __construct( ) {
 
	}
	// End of PDO2::__construct() */
 
	/* Singleton */
	public static function getInstance() {
 
		if (!isset(self::$_instance)) {
 
			try {
 
				self::$_instance = new PDO(DB_DNS, 'xxx', 'xxx');
 
			} catch (PDOException $e) {
 
				echo $e;
			}
		} 
		return self::$_instance; 
	}
	// End of PDO2::getInstance() */
}
?>

Citation:

Benjamin Delespierre > y'a pas de static pour ta fonction instance

C'est pas grave ça marche quand même vu que les méthodes d'instances peuvent toujours être appellées dans un contexte statique (compatibilité ascendante quand tu nous tiens) :lol:
maix bien vu stealth...
Note que pour ton singleton, tu pourrais le munir d'une méthode statique __callStatic pour appeller les méthodes d'instance nativement. ça ressemblerait plus ou moins à ça:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
final public function __call ($method, $args) {
        if (is_callable(array($this->_internal_reference, $method))) {
            switch (count($args)) {
                case 0: return $this->_internal_reference->$method(); break;
                case 1: return $this->_internal_reference->$method($args[0]); break;
                case 2: return $this->_internal_reference->$method($args[0], $args[1]); break;
                case 3: return $this->_internal_reference->$method($args[0], $args[1], $args[2]); break;
                case 4: return $this->_internal_reference->$method($args[0], $args[1], $args[2], $args[3]); break;
                case 5: return $this->_internal_reference->$method($args[0], $args[1], $args[2], $args[3], $args[4]); break;
                default: return call_user_func_array(array($this->_internal_reference, $method), $args); break;
            }
        }
        else
            return parent::__call($method, $args);
    }

(bon là c'était dans une classe object wrapper, à adapter aux contextes statiques donc.)

Citation:

Envoyé par Benjamin Delespierre

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
final public function __call ($method, $args) {
        if (is_callable(array($this->_internal_reference, $method))) {
            switch (count($args)) {
                case 0: return $this->_internal_reference->$method(); break;
                case 1: return $this->_internal_reference->$method($args[0]); break;
                case 2: return $this->_internal_reference->$method($args[0], $args[1]); break;
                case 3: return $this->_internal_reference->$method($args[0], $args[1], $args[2]); break;
                case 4: return $this->_internal_reference->$method($args[0], $args[1], $args[2], $args[3]); break;
                case 5: return $this->_internal_reference->$method($args[0], $args[1], $args[2], $args[3], $args[4]); break;
                default: return call_user_func_array(array($this->_internal_reference, $method), $args); break;
            }
        }
        else
            return parent::__call($method, $args);
    }

(bon là c'était dans une classe object wrapper, à adapter aux contextes statiques donc.)

non si il n'est pas mis static tu vas avoir une erreur :
Strict Standards: Non-static method mysql ::getInstance() should not be called statically

Pour ma classe pas besoin de faire de __call non plus puisque qu'il retourne l'instance et méthodes existes

et aussi regarde Reflection te permet de contourner ton problème de switch

tien si veux : une classe qui permet de faire du static avec tout les classes de PHP

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Singleton
{
    protected static $_instances;
 
    public static function __callStatic($name, array $arguments)
    {    
        if(empty(static::$_instances[$name]) || !empty($arguments))
        {        	        	
            $class = new \ReflectionClass('\\' . $name);
            static::$_instances[$name] = $class->newInstanceArgs($arguments);
        }
 
        return static::$_instances[$name];
    }
}
 
//Singleton::DOMDocument()->loalHTMLfile($file);
//Singleton::PDO('...')->query('...');

Citation:

et aussi regarde Reflection te permet de contourner ton problème de switch

J'ai fais un benchmark pour ça, et il s'avère qu'un switch est toujours plus rapide. La plupart du temps les méthodes ne dépassent pas 5 paramètres.

Citation:

Pour ma classe pas besoin de faire de __call non plus puisque qu'il retourne l'instance et méthodes existes

Oui mais c'est toujours plus sexy de pouvoir faire directement
MaClasse::maMethodeInstance();
au lieu de
MaClass::getInstance()->maMethodeInstance();

Ton Singleton factory est vraiment pas mal, tu m'en veux pas si je te le pique ?
Remarque, je serais toi je le mettrait cette classe en final sinon bonjour les problèmes quand elle sera héritée... Ou alors tu utilise ce hack:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 class BaseSingleton { public static function instance () { static $instance = null; if (!isset($instance)) { $instance = new static; // do stuff... } return $instance; } }
Tu peux aussi mettre $_instances en private mais les filles devront soit redéfinir la méthode instance soit redéclarer cette propriété.

18/02/2011, 17h37
stealth35

Citation:

Envoyé par Benjamin Delespierre

J'ai fais un benchmark pour ça, et il s'avère qu'un switch est toujours plus rapide. La plupart du temps les méthodes ne dépassent pas 5 paramètres.

oui mais c'est moins "sexy" ;)

Citation:

Envoyé par Benjamin Delespierre

Oui mais c'est toujours plus sexy de pouvoir faire directement
MaClasse::maMethodeInstance();
au lieu de
MaClass::getInstance()->maMethodeInstance();

pas les switch c'est pour la même raison que plus haut ?

Citation:

Envoyé par Benjamin Delespierre

Ton Singleton factory est vraiment pas mal, tu m'en veux pas si je te le pique ?

Bien-sur pas de problème ;)
18/02/2011, 17h50
Benjamin Delespierre

Citation:

oui mais c'est moins "sexy"

Oui mais c'est dans une classe: donc de l'extérieur ça ne se voit pas :p
Et puis j'ai rien inventé, j'ai vu l'idée dans Lithium et j'ai fait un bench, et vu le gain de perfs, je préfère faire comme ça systématiquement plutôt qu'appeler call_user_func ou une classe de réflexion qui sont incroyablement lentes.

Cela étant, il y a un hic avec ton factory, on ne peut pas l'utiliser sur des classe en dehors du namespace racine...
je vais faire un test avec des use statements pour voir...
18/02/2011, 17h54
stealth35

Citation:

Envoyé par Benjamin Delespierre

Oui mais c'est dans une classe: donc de l'extérieur ça ne se voit pas :p
Et puis j'ai rien inventé, j'ai vu l'idée dans Lithium et j'ai fait un bench, et vu le gain de perfs, je préfère faire comme ça systématiquement plutôt qu'appeler call_user_func ou une classe de réflexion qui sont incroyablement lentes.

je comprend ;)

Citation:

Envoyé par Benjamin Delespierre

Cela étant, il y a un hic avec ton factory, on ne peut pas l'utiliser sur des classe en dehors du namespace racine...
je vais faire un test avec des use statements pour voir...

c'est pour ca que j'ai dis "avec toutes les classes de PHP", mais avec use ca marche, bon apres on pourrais poussé plus long avec des_ a la place des \ mais bon, c'est surtout pour les classes native de PHP

Mine de rien ca fait aussi un peu office de Registry