Class de connexion DB

Version imprimable

1 pièce(s) jointe(s)

Bonjour tout le monde,

J'ai un code de class pour insérer des données dans une table, tout va bien, sauf que lors de l'insertion des données, la valeur du dernier champs qui est insérée dans tous les champs, et la le type de valeur (INT, BOOL,...) retourne toujours le chiffre 2, voici le code:

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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
 
<?php
 
final class crud {
 
 
    public function __construct($connexionName) {
 
        $this->connexionName  = $connexionName;
    }
 
 
    public final function insert($tableName, $fields=array()){
 
            $this->tableName = $tableName;
            $this->fields    = $fields;
 
 
            foreach ($this->fields as $vf) {
 
                $inKeys[]       = $vf;
                $inKeysDotted[] = ':' . $vf;
 
                $insImKeys       = implode(', ', $inKeys);
                $insImKeysDotted = implode(', ', $inKeysDotted);
 
 
                $this->insImKeys         = $insImKeys;
                $this->insImKeysDotted   = $insImKeysDotted;
 
            }
 
                $this->insertedKeys         = $inKeys;
                $this->insertedKeysDotted   = $inKeysDotted;
 
                //print_r($this->insertedKeys);
 
                //echo '<br />';
 
            $sql = "INSERT INTO `$this->tableName` ($this->insImKeys) VALUES ($this->insImKeysDotted);";
            //echo $sql.'<br />';
 
            $insertItems = $this->connexionName->prepare($sql);
 
            $this->insertItems    = $insertItems;
 
            //print_r($insertItems).'<br />';
 
    } // end prepareStm()
 
 
    public final function bindParams($setValues=array()){
 
 
        $combine = array_combine($this->insertedKeys, $setValues);
 
        foreach ($combine as $getKey => $getVal) {
 
            switch ($getVal) {
            case is_int($getVal):
                //echo $getVal .' is INT<br />';
                $setType = PDO::PARAM_INT;
                //return PDO::PARAM_INT;
                break;
            case is_bool($getVal):
                //echo $getVal .' is BOOL<br />';
                $setType = PDO::PARAM_BOOL;
                //return PDO::PARAM_BOOL;
                break;
            case is_null($getVal):
                //echo $getVal .' is NULL<br />';
                $setType = PDO::PARAM_NULL;
                //return PDO::PARAM_NULL;
                break;
            default:
                //echo $getVal .' is STR<br />';
                $setType = PDO::PARAM_STR;
                //return PDO::PARAM_STR;
                break;
 
            return $setType;
        }
 
 
       echo "this->insertItems->bindParam($getKey, $getVal, $setType)<br />";
       $this->insertItems->bindParam($getKey, $getVal, $setType);
 
       //echo '<pre>';
       //print_r($this->insertItems);
       //echo '</pre>';
 
 
        }
 
 
    } // end bindParams()
 
 
    public final function executeQuery(){
        return $this->insertItems->execute();
    }
 
 
 
}
 
require_once '../Included_Files/Connect.php';
 
 
 
$con = new crud($connexion);
 
echo '<br />';
 
$con->insert('test', array('field1', 'field2', 'field3'));
$con->bindParams(array('pour field1', 'pour field2', 'pour field3'));
$con->executeQuery();
 
?>

Le résultat des echo et print_r sont:

Citation:

INSERT INTO `test` (field1, field2, field3) VALUES (:field1, :field2, :field3);
this->insertItems->bindParam(field1, pour field1, 2)

this->insertItems->bindParam(field2, pour field2, 2)

this->insertItems->bindParam(field3, pour field3, 2)

Les champs insérés sont "pour field3" pour tous.

Pièce jointe 197472

Merci pour votre aide

08/01/2016, 19h49
sabotage

bindParam lie le nom de la variable, donc tu obtiens 3 fois la valeur qu'a la variable au moment de l'execution.
C'est binValue qu'il te faut.

Salut,

Tu te prends la tête avec les bind. Essaies de faire quelque chose de plus générique.

Une bonne idée est de désactiver l'émulateur pdo de php ce qui permet d'utiliser celui de mysql. Ainsi les champs seront formatés selon les types attendus par la bdd. Et donc on pourra passer un tableau dans le execute sans souci. par exemple :

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
class  Crud {
 
    private $values = [];
    private $sql = '';
 
    public function __construct($connexionName) 
    {
                $this->connexionName  = $connexionName;
 
		// Utilise le moteur pdo du sgbdd. Permet de se renseigner sur le type attendu des champs dans la bdd. Les valeurs seront formatées suivant la valeur indiquée en bdd
		$this->connexionName->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);
 
		// Mode exception 
		$this->connexionName->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    }
 
 
    public function insert($tableName, $fields=array(), $values=array())
    {
		$this->values = $values;
		$fields = implode(',',$fields);
		$marqueurs = implode(',',array_fill(0, count($this->values), '?'));		
 
		$this->sql = "INSERT INTO $tableName ($fields) VALUES ($marqueurs)";
    }
 
 
    public function countTable($tableName)
    { 
		$this->sql = "SELECT count(*) FROM $tableName";
    }
 
 
    public function executeQuery ()
    {
		$values = $this->values;
		$sql = $this->sql;
 
		// Réinitialise les variables
		$this->values = [];
		$this->sql = '';
 
		if (count($values) == 0)
		{
			try
			{
				$resultat = $this->connexionName->query($sql); // exécution directe
 
				return $resultat;
			}
			catch (PDOException  $e)
			{
				// message complet en développement
				echo $e->getMessage();
			}
		}
		else 
		{
			try
			{
				$resultat = $this->connexionName->prepare($sql); // requête préparée
				if($resultat) $resultat->execute($values); // exécution
 
				return $resultat;
			}
			catch (PDOException  $e)
			{
				// message complet en développement
				echo $e->getMessage();
			}
		}		
    }
}
 
 
 
$con = new crud($connexion);
 
$champs = array('field1', 'field2', 'field3');
$valeurs = array('pour field1', 'pour field2', 'pour field3');
 
$con->insert('test', $champs, $valeurs);
$con->executeQuery();
 
$con->countTable('test');
$result = $con->executeQuery();
echo $result->fetchColumn();

09/01/2016, 04h34
Fredy007

Citation:

Envoyé par sabotage

bindParam lie le nom de la variable, donc tu obtiens 3 fois la valeur qu'a la variable au moment de l'execution.
C'est binValue qu'il te faut.

J'ai changé bindParam avec bindValue, ca donne le meme resultat
09/01/2016, 04h36
Fredy007

@ ABCIWEB: Dans votre code il n y a pas de bind, est ce qu'il n'est pas dangereux pour l'insertion des données dans la table?
09/01/2016, 17h56
ABCIWEB

Salut,

Non, pas besoin de bind quand on passe un tableau dans la méthode execute(). Les valeurs du tableau sont associées (et donc "bindées") aux marqueurs dans l'ordre de leur écriture, le premier élément du tableau est associé au premier marqueur, le second au second marqueur etc.

Et comme déjà dit, si on utilise le moteur pdo de la base de données, le type associé est celui attendu par la base de données. Pour ce faire il suffit de désactiver l'émulateur pdo de php et c'est ce que je fais avec setAttribute(PDO::ATTR_EMULATE_PREPARES, false);.

Donc ça roule beaucoup plus simplement. La seule chose à faire attention est que l'ordre des éléments du tableau corresponde à l'ordre des marqueurs.

Cette possibilité de passer un tableau dans le execute() avec pdo est un des gros avantages par rapport à l'extension mysqli qui ne propose pas cette fonctionnalité. On voit ici que c'est très pratique pour faire un code générique beaucoup plus simplement.

Et donc pour répondre directement à ta question, non y'a pas de problème de sécurité, la sécurité sera la même que tu utilises l'une ou l'autre des méthodes.

Salut,

Je me suis amusé à aller un peu plus loin avec un modèle légèrement différent mais qui permet plus de choses :

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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
class  Crud {
 
	private $values = [];
	private $sql = '';
	private $prepare = false;
 
        public function __construct($connexionName) {
 
        $this->connexionName = $connexionName;
 
		// Utilise l'émulation pdo du sgbdd. Permet de se renseigner sur le type attendu par la bdd.
		$this->connexionName->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);
 
		// Mode exception 
		$this->connexionName->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        }
 
 
	public function insertOne($tableName, $insert=[])
	{
		$this->values = array_values($insert);
		$fields = implode(',',array_keys($insert));
		$marqueurs = implode(',',array_fill(0, count($insert), '?'));		
 
		$this->sql = "INSERT INTO $tableName ($fields) VALUES ($marqueurs)";
		return $this->executeQuery ();
       }
 
 
	public function insertMultiple($tableName, $fields=[])
	{
		$this->prepare = false;
 
		$marqueurs = implode(',',array_fill(0, count($fields), '?'));
		$fields = implode(',',$fields);
		try
		{
			$this->prepare = $this->connexionName->prepare("INSERT INTO $tableName ($fields) VALUES ($marqueurs)");
			return $this->prepare;
		}
		catch (PDOException  $e)
		{
			// message complet en développement
			echo $e->getMessage();
		}
        }
 
 
	public function countTable($tableName)
	{ 
		$this->sql = "SELECT count(*) FROM $tableName";
		return $this->executeQuery ();
        }
 
 
	public function selectWhereAnd($tableName, $fields=[], $where=[], $limite=null)
	{ 
		$this->values = array_values($where);
 
		$conditions = [];
		foreach ($where as $champ => $value) $conditions[] =  $champ.' = ?';				
		$conditions = implode(' AND ', $conditions);
 
		if(is_array($limite) && count($limite) > 0) 
		{
			$this->values = array_merge($this->values,$limite);
			$conditions .= ' LIMIT '.implode(',',array_fill(0, count($limite), '?'));															
		}
 
		$fields = implode(',',$fields);
 
		$this->sql = "SELECT ($fields) FROM $tableName WHERE $conditions";
		return $this->executeQuery ();
        }
 
 
	public function executeQuery ($values_user = null)
	{
		$values = is_array($values_user) ? $values_user : $this->values;
		$sql = $this->sql;
 
		// Réinitialise les variables
		$this->values = [];
		$this->sql = '';
 
		if (count($values) == 0)
		{
			try
			{
				$resultat = $this->connexionName->query($sql); // exécution directe
 
				return $resultat;
			}
			catch (PDOException  $e)
			{
				// message complet en développement
				echo $e->getMessage();
			}
		}
		else 
		{
			try
			{
				$resultat = is_array($values_user) && $this->prepare !== false ? $this->prepare : $this->connexionName->prepare($sql); // requête préparée
				if($resultat !== false) $resultat->execute($values); // exécution
 
				return $resultat;
			}
			catch (PDOException  $e)
			{
				// message complet en développement
				echo $e->getMessage();
			}
		}		
	}
}

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
$con = new crud($connexion);
 
// Insertion d'une ligne avec une requête préparée et la méthode "insertOne" (tableau avec champ=>valeur)
$insert_tab = ['field1'=>'0 pour field1', 'field2'=>'0 pour field2', 'field3'=>'0 pour field3'];
$insert = $con->insertOne('test', $insert_tab);
echo '<br>';
 
// Insertion de plusieurs lignes avec une requête préparée et la méthode "insertMultiple"
$field = ['field1','field2','field3']; // champs ciblés
$values [] = ['1 pour field1','1 pour field2','1 pour field3']; // tableau de valeurs 
$values [] = ['2 pour field1','2 pour field2','2 pour field3'];
 
$prepare = $con->insertMultiple('test', $field);
if($prepare !== false) foreach ($values as $tab) $con->executeQuery($tab);
echo '<br>';
 
// Compter la table avec une requête directe
$count_table = $con->countTable('test');
if($count_table) echo 'nombre de lignes = '.$count_table->fetchColumn();
echo '<br>';
 
// Sélectionner des champs avec la clause Where en fonction d'une ou plusieurs valeurs toutes nécessaires (AND) et éventuellement la clause LIMIT
$fields = ['field1','field2']; // champs à retourner
$where = ['field2'=>'2 pour field2','field3'=>'2 pour field3']; // champs à vérifier [champ=>valeur]
$limite = [0,2]; // limite (facultatif)
 
$select = $con->selectWhereAnd('test', $fields, $where, $limite);
if($select) print_r($select->fetchAll());
echo '<br>';

Enfin bon c'est un exemple parmi tant d'autres.
Mais au passage tu pourras tester la différence de comportement si la ligne

Code:

$this->connexionName->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);

est présente ou non dans le constructeur de la classe. Si tu l'efface alors tu auras une erreur dans la dernière requête de sélection si tu utilises la clause limit comme dans l'exemple.
Sans cette ligne c'est l'émulateur pdo de php qui fonctionne et par défaut il formate toutes les valeurs du tableau passées dans le execute() en string. Et donc la clause limit qui demande des entiers va bugguer. Si tu remets cette ligne, plus d'erreur car le moteur pdo de la base de donnée va typer la valeur suivant la valeur attendue par la base de donnée.

1 pièce(s) jointe(s)

Merci ABCIWEB pour votre code, il est supper bien, mais c'est un peu avancé, je vais essayer de développer mon code afin d'y arriver avec des insertions multiples, suppresion et mise à jour, le but de mon code avec bind, c'est de créer une class où il y a toutes les données et aux utilisateurs de choisir ce qu'il leur ait besoin:

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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
 
<?php
 
 
final class crud {
 
    private $connexionName, $sql = '';
 
    public function __construct($connexionName) {
 
        $this->connexionName  = $connexionName;
    }
 
 
    public final function insert($tableName, $fields=array()){
 
            $this->tableName = $tableName;
            $this->fields    = $fields;
 
 
            foreach ($this->fields as $vf) {
 
                $inKeys[]       = $vf;
                $inKeysDotted[] = ':' . $vf;
 
 
                $insImKeys       = implode(', ', $inKeys);
                $insImKeysDotted = implode(', ', $inKeysDotted);
 
 
                $this->insImKeys         = $insImKeys;
                $this->insImKeysDotted   = $insImKeysDotted;
 
            }
 
                $this->insertedKeys         = $inKeys;
                $this->insertedKeysDotted   = $inKeysDotted;
 
 
            $sql = "INSERT INTO `$this->tableName` ($this->insImKeys) VALUES ($this->insImKeysDotted);";
            //echo $sql.'<br />';
 
            $insertItems = $this->connexionName->prepare($sql);
 
            $this->insertItems    = $insertItems;
 
            //print_r($insertItems).'<br />';
 
    } // end prepareStm()
 
    public final function checkValType($valToCheck){
 
        $this->valToCheck     = $valToCheck;
 
        // http://php.net/manual/en/function.gettype.php
        $valType = gettype($this->valToCheck);
 
        //echo $valType.'<br />';
 
        $this->valType    = $valType;
 
        switch ($this->valType) {
            case 'boolean':
                $PDOType = PDO::PARAM_BOOL;
                break;
 
            case 'integer':
                $PDOType = PDO::PARAM_INT;
                break;
 
            case 'NULL':
                $PDOType = PDO::PARAM_NULL;
                break;
 
            default: // string
                $PDOType = PDO::PARAM_STR;
                break;
        }
 
        //echo $PDOType.'<br />';
 
        $this->PDOType    = $PDOType;
        //return $this->valType;
        return $this->PDOType;
 
    } // end checkValType()
 
 
    public final function bindParams($setValues=array()){
 
 
        $combine = array_combine($this->insertedKeys, $setValues);
 
        foreach ($combine as $getKey => $getVal) {
 
            //echo gettype($getVal), "<br>";
 
            $setType    = $this->checkValType($getVal);
 
 
       //echo "this->insertItems->bindValue($getKey, $getVal, $setType)<br />";
       $this->insertItems->bindValue($getKey, $getVal, $setType);
 
       //echo '<pre>';
       //print_r($this->insertItems);
       //echo '</pre>';
 
 
        }
 
 
    } // end bindParams()
 
 
    public final function executeQuery(){
        return $this->insertItems->execute();
    }
 
 
 
}
 
require_once '../Included_Files/Connect.php';
 
$con = new crud($connexion);
 
echo '<br />';
 
$con->insert('test', array('field1', 'field2', 'field3'));
//$con->checkValType(19);
$con->bindParams(array('pour field1', 'pour field2', 'pour field3'));
$con->executeQuery();
 
?>

Si mon code est bien, je vais apres "setAttribute(PDO::ATTR_EMULATE_PREPARES, false)" et essayer des faire une insertion multiples, la fonction bind est séparée, mais dans mes prochains code je vais pas l'utiliser.

EDIT:

J'ai change pour field1 par "'<script>alert(\'hello\');</script>'" et le script est injecté par une attaque XSS:

Pièce jointe 197657

11/01/2016, 16h50
ABCIWEB

Bah oui bien sûr que le code est injecté, sinon comment je pourrais le lire sur ce forum ?

C'est à l'affichage que l'on protège le code pour qu'il ne soit pas interprété avec la fonction htmlspecialchars. Donc typiquement pour afficher le texte dans le html on fait : <?= htmlspecialchars($texte) ?>
11/01/2016, 17h34
ABCIWEB

Ah oui et pour ton code, quand on indique un type avec bindValue on met le type attendu par la bdd, et non pas le type fourni par la variable car on ne doit pas faire confiance à une variable utilisateur.
12/01/2016, 05h05
Fredy007

Donc par exemple si field1 en BDD est VARCHAR je mets STR, si en INT, je mets INT, ainsi de suite,..

Merci pour le conseil
12/01/2016, 18h43
ABCIWEB

Oui, le problème est qu'il faut connaître le type du champ de la bdd et inscrire le type correspondant en dur dans le code php...

Donc impossible de faire une classe de requêtes génériques avec ce système. Alors qu'en désactivant l'émulateur pdo de php, le moteur pdo de la bdd pourra faire le travail à notre place.

On a toujours intérêt à désactiver l'émulateur pdo de php. Il a été conçu pour pallier à l'absence de support pdo par certains sgbdd et aujourd'hui cela doit être rare.

Par ailleurs tous les sgbdd qui supportent pdo ont un gestionnaire pdo bien plus à jour et performant que celui de php qui n'a été conçu que comme une béquille de secours.

Et puis comme php fait bien les choses, même si tu désactive l'émulateur pdo de php et que malencontreusement tu utiliserais un des rares sgbdd qui ne supporte pas pdo (je n'en connais pas pour les sgbdd utilisés habituellement avec php), alors l'émulateur php se remet en route automatiquement :)

Oui, j'ai bien compris le principe, sur cela j'ai change mon code, est j'ai ajoute un champs pour declarer le type de la variable, mais je tombe dans cette erreur:

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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
 
<?php
 
 
final class crud {
 
    public function __construct($connexionName) {
 
        $this->connexionName  = $connexionName;
    }
 
 
    public final function insert($tableName, $fields=array()){
 
            $this->tableName = $tableName;
            $this->fields    = $fields;
 
            foreach ($this->fields as $kf => $vf) {
 
                $inKeys[]       = $vf;
                $inKeysDotted[] = ':' . $vf;
 
                $insImKeys       = implode(', ', $inKeys);
                $insImKeysDotted = implode(', ', $inKeysDotted);
 
 
                $this->insImKeys            = $insImKeys;
                $this->insImKeysDotted      = $insImKeysDotted;
 
 
            }
 
 
                $this->insertedKeys         = $inKeys;
                $this->insertedKeysDotted   = $inKeysDotted;
 
                //print_r($this->insertedKeys);
 
                echo '<br />';
 
            $sql = "INSERT INTO $this->tableName ($this->insImKeys) VALUES ($this->insImKeysDotted)";
 
            //echo $sql.'<br />';
 
            $insertItems = $this->connexionName->prepare($sql);
 
            $this->insertItems    = $insertItems;
 
            //echo '<pre>';
            //print_r($insertItems).'<br />';
            //echo '</pre>';
 
    } // end prepareStm()
 
 
    public final function bindParams($setValues=array()){
 
        $combine = array_combine($this->insertedKeys, $setValues);
 
        foreach ($combine as $kkey => $vval) {
 
            $ss = array_keys($setValues, $vval);
 
         switch ($vval){
 
                case 'INT':
                    $setType = PDO::PARAM_INT;
                    break;
 
                case 'BOOL':
                    $setType = PDO::PARAM_BOOL;
                    break;
 
                case 'NULL':
                    $setType = PDO::PARAM_NULL;
                    break;
 
                default:
                    $setType = PDO::PARAM_STR;
                    break;              
 
            } // end switch
 
            $paramss[] = "bindValue($kkey, $ss[0], $setType);";
 
        }
 
           echo '<pre>';
        echo 'params <br />';
        print_r($paramss);
        echo '</pre>';
 
        foreach($paramss as $bind){
 
            $this->insertItems->$bind; // voici la ligne 94
 
 
        }
 
 
    } // end bindParams()
 
 
    public final function executeQuery(){
        return $connexion->execute();
    }
 
 
 
}
 
require_once '../Included_Files/Connect.php';
 
 
 
$con = new crud($connexion);
 
echo '<br />';
 
$con->insert('test', array('field1', 'field2', 'field3'));
$con->bindParams(array('pour field1'=>'INT', 'pour field2'=>'STR', 'pour field3'=>'INT'));
 
?>

Code:

1
2
 
PHP Notice:  Undefined property: PDOStatement::$bindValue(field3, pour field1, 1); in crud.php on line 94

15/01/2016, 03h45
ascito

Citation:

Je me suis amusé à aller un peu plus loin avec un modèle légèrement différent mais qui permet plus de choses :

certe... Ne manque t'il pas une méthode lastInsertId, ou équivalent, pour le récupérer?