Binder des valeurs sous certaines conditions en POO

Version imprimable

Bonjour,

je me mets au MVC POO et dans mon modèle général, je vais créer toutes les fonctions dont l'utilité est redondante à travers mon application.

Elle est d'être finie évidement mais je prends le problème au cas par cas.

Avec mon code ci-dessous, je désire créer un condition pour binder certaines données. Est possible avec le code créé ? Ou je dois crée une autre fonction.

J'estime que cela ne sert à rien de binder toutes les données quand elles ne viennent pas d'un formulaire. Je me trompe ou je m'y prends comme un pied?

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
 
class model{
    private $fields = '*';
    private $table = '';
    private $where = '';
    private $and = '';
    private $limit = '';
    private $order = '';
    private $order_direction = 'DESC';
    private $stmt;
    private $d = array();
 
    public function getExecute(){
        return $this->stmt->execute();
    }
 
    public function find($data = array()){
        if(isset($data['fields'])){
            $this->fields = $data['fields'];
        }
        $this->table = $data['table'];
        if(isset($data['where'])){
            $this->where = ' WHERE '.$data['where'];
        }
        if(isset($data['and'])){
            $this->and = ' AND '.$data['and'];
        }
        if(isset($data['limit'])){
            $this->limit = ' LIMIT '.$data['limit'];
        }
        if(isset($data['order'])){
            $this->order = ' ORDER BY '.$data['order'].' '.$order_direction;
        }
        $this->stmt = Db::getInstance()->prepare('SELECT '.$this->fields.' 
                                                  FROM '.$this->table.$this->where.
                                                  $this->and.$this->order.$this->limit.'');
        $this->getExecute();
        return $this->stmt->fetchAll(PDO::FETCH_OBJ);
    }
}

Exemple de requête

Code:

1
2
3
4
5
6
7
8
9
 
$model = new model();
$sql = $model->find(array(
    'table'=>'users',
    'where'=>'u_login="admin"' // donnée brute mais sera bindé
));
foreach($sql as $row):
    echo $row->u_login.' - '.$row->u_id_level.'<br>';
endforeach;

Merci d'avance de vos réponses.

David

22/07/2013, 14h50
comode

Je trouve ta façon de faire bizarre, mais bon...

Le gros intérêt des requêtes préparées, outre la protection contre les injections SQL, c'est justement d'être préparées. Quand tu exécutes une requête, SQL doit d'abord comprendre ta requête avant de l'exécuter avec les paramètres que tu lui donnes.

La phase de compréhension, qui est gourmande en ressource machine, c'est la préparation. Si tu reconstruis ta requête à chaque appel, ça ne vaut pas le coup d'utiliser un système de requêtes préparées. Dans le cas contraire, ça laisse toute son utilité au bind, même si tes données ne proviennent pas d'un formulaire.

Bref, je pense que t'es parti sur une drôle d'usine à gaz là...

Merci commode de ta réponse.

Que me suggères tu?
Faire des requêtes directement dans mes fonction comme ceci ?

Merci d'avance

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
    public function login($fields, $table, $col_login, $col_password){
        $query = Db::getInstance()->prepare('SELECT '.$fields.' FROM '.$table.' WHERE '.$col_login.' = :login AND '.$col_password.' = :password');
        $query->bindValue(':login',$this->login,PDO::PARAM_STR);
        $query->bindValue(':password',$this->password,PDO::PARAM_STR);
        $query->execute();
        echo count($query);
        if($query->rowCount() > 0){
            $row = $query->fetch();
            return $row;
        }else{
            return false;
        }
        $query->closeCursor();
    }

Et ensuite avant le form:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
if(isset($_POST['login_submit'])){
    if(!empty($_POST['login']) && !empty($_POST['password'])){
        $auth = new auth();
        $auth->setLogin($_POST['login']);
        $auth->setPassword(md5(sha1($_POST['password'])));
        if(($row = $auth->login('u_login,u_email,u_id_level', 'users', 'u_login', 'u_password'))){                 
            $_SESSION['back_office'] = array(
                'login' => $row->u_login,
                'email' => $row->u_email,
                'level' => $row->u_id_level
            );
        }else{
            message::showError('Compte non reconnu');
        }
    }else{
        message::showError('Veuillez remplir tous les champs');
    }
}

22/07/2013, 17h03
comode

Voilà, c'est la voie "classique" !

Note cependant que même avec la PDO, préparer une requête n'est pas obligatoire si :
- ta requête sera exécuté qu'une seule fois
- tu ne veut pas bénéficier de la protection contre les injection SQL

Auquel cas, tu peux directement utiliser la fonction

Code:

$pdo_statement = Db::getInstance()->query('select * ... where truc = '.$machin.'...');

ou encore

Code:

$pdo_statement = Db::getInstance()->exec('insert into chose (truc) values ('.$machin.')');

Query et exec ne préparent pas les requêtes. Exec ne retourne pas de PDOStatement et est inadapté aux select.

Enfin, juste pour info, tu peux racourcir un peu ton code en passant un tableau associatif nom_du_camp => valeur directement à la fonction execute plutot que de bindé un par un les paramètres.
22/07/2013, 17h13
andaman

Merci encore,

J'étais parti sur des codes plus complexes quand j'ai vu certains exemples.

Effectivement, je n'ai pas besoin de préparer des requete de login. Car logiqueemnt quand le gars est connecté on enregistre en session certaines données et voilà !

Cependant une chose me chipote. SI je désire effectuer une requete classique sans binder, comment je peux sécuriser les données avec des antislashes?

Idem que avec mysql ou mysqli? J'ai vu QUOTE de PDO mais pas recommandé...

Peux tu éclairer ma lanterne sur ce point?

EDIT: avant j'utilisais real_escape_string

EDIT 2

Citation:

Enfin, juste pour info, tu peux racourcir un peu ton code en passant un tableau associatif nom_du_camp => valeur directement à la fonction execute plutot que de bindé un par un les paramètres.

Là je suis largué... Où puis je mettre cet array?

Merci

Citation:

Envoyé par andaman

Là je suis largué... Où puis je mettre cet array?

cet exemple :
Code:

1 2 3 4 5 $query = Db::getInstance()->prepare('SELECT '.$fields.' FROM '.$table.' WHERE '.$col_login.' = :login AND '.$col_password.' = :password'); $query->bindValue(':login',$this->login,PDO::PARAM_STR); $query->bindValue(':password',$this->password,PDO::PARAM_STR); $query->execute();
est strictement équivalent à :
Code:

1 2 $query = Db::getInstance()->prepare('SELECT '.$fields.' FROM '.$table.' WHERE '.$col_login.' = :login AND '.$col_password.' = :password'); $query->execute(array(':login' => $this->login, ':password' => $this->password));
Pour la protection des variables en dehors des prépare, j'avoue ne jamais avoir cherché bien loin dans la mesure où (personnellement), je prépare systématiquement les requêtes quand j'ai besoin d'une protection contre les injection de SQL.

La méthode quote de PDO est effectivement à bannir. Je suggère que tu n'hésites pas à utiliser les requêtes préparés quand tu as besoin de sécurité. Dis toi que de toute façon, que ça soit via prepare(), query() ou exec(), la requête sera préparée en interne. La fonction prépare offre juste la possibilité par rapport aux 2 autres de conserver la requête préparée pour un usage ultérieur.