PDO select et conditions multiples sur la même colonne

Version imprimable

Bonjour,

J’essaie de faire une requête préparée comme ça :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 SELECT COUNT(idDimmoAds) FROM `dimmoAds` WHERE `dimmoAds`.`typeAds` = :typeAds AND `dimmoAds`.`typeProperty` != :typeProperty AND `dimmoAds`.`typeProperty` != :typeProperty AND `dimmoAds`.`typeProperty` != :typeProperty AND `dimmoAds`.`typeProperty` != :typeProperty
Voici le code php qui me permet de "bindder" mes paramètres :
Code:

1 2 3 4 5 6 if (!empty($selectOption)) { foreach ($selectOption as $key => $options) { echo 'Valeur'.'->'.$options['value']; $stmt->bindValue(":$options[field]", $options['value']); } }
Le "echo 'Valeur'.'->'.$options['value'];" m'affiche bien les bonnes valeurs :
- Valeur->Location
- Valeur->Immeuble
- Valeur->Maison
- Valeur->Terrain
- Valeur->Parking

Mais le log MySql me dit que c'est cette requête qui est passée :
Code:

1 2 3 4 5 6 7 8 9 10 SELECT COUNT(idDimmoAds) FROM `dimmoAds` WHERE `dimmoAds`.`typeAds` = 'Vente' AND `dimmoAds`.`typeProperty` != 'Parking' AND `dimmoAds`.`typeProperty` != 'Parking' AND `dimmoAds`.`typeProperty` != 'Parking' AND `dimmoAds`.`typeProperty` != 'Parking'
Je n'ai pas du tout comprendre aux requêtes préparées moi :(

Quelqu'un peut m'aider ?

Tu ne peux pas avoir plusieurs fois le même nom de paramètre.

Tu peux composer ta requête automatiquement :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
$sql = 'SELECT COUNT(idDimmoAds) FROM 
    `dimmoAds` 
WHERE 
    `dimmoAds`.`typeAds` = :typeAds'
 
$param[] = $typeAds
 
if (!empty($selectOption)) {
            foreach ($selectOption as $key => $options) {
                $sql .= ' AND  `dimmoAds`.`' . $options['field'] . '` !=  ?'
                $param[] = $options['value'];
            }
        }
$stmt->execute($param);

Bonjour à tous!
Pour optimiser la requête, il serait mieux d'utiliser une liste pour les valeurs que ne doit pas avoir typeProperty.
Code:

1 2 3 4 5 6 7 SELECT COUNT(idDimmoAds) FROM `dimmoAds` WHERE `dimmoAds`.`typeAds` = ? AND `dimmoAds`.`typeProperty` NOT IN (?, ?, ?, ?)
Cela donnera donnera donc comme code php
Code:

1 2 3 4 5 6 7 $query = 'SELECT COUNT(idDimmoAds) FROM `dimmoAds WHERE `dimmoAds`.`typeAds` = :typeAds AND `dimmoAds`.`typeProperty` NOT IN (:typeProperty1, :typeProperty2, :typeProperty3, :typeProperty4)
Ensuite tu lies les paramètres et tu exécute ta requête

Merci beaucoup les gars, c'est vrai que je n'utilise jamais les '?' dans mes requêtes car j'avais jamais vraiment eu à les utiliser (jusqu'à aujourd’hui en tout cas :? )

Là, je ne m'en sort pas. Le but de mon code est d'avoir une classe "manager" de table de données qui implémente les méthodes dont on a toujours besoin :
ajout, listing, lecture, mise à jour, suppression, compter, existence.

Mais je pense que mon code est finalement contre productif et je dois faire fausse route.

Je donne ma méthode pour compter les éléments d'une table en fonction de critères. Elle commence à être compliquée et je ne vous en voudrai pas de ne pas prendre le temps ;)

De toute façon je pense que je fait fausse route.

Classe Manager :

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
class DimmoAdsManager
{
    /**
     * Compte le nombre d'enregistrement.
     *
     * @param array  $selectOption Conditions pour la requête SQL.
     *                             Format : [TABLE][CHAMP][OPERATEUR (=,<,>...)][VALEUR]
     *
     * @return int Nombre d'enregistrement
     */
    public static function count($selectOption)
    {
        $connexion_db = PDO2::getInstance();
 
        /* Construction de la requête SQL en fonction des paramètres */
        $sql = "
            SELECT
                COUNT(idDimmoAds)
            FROM
                `dimmoAds`
        ";
 
        if (!empty($selectOption)) {
            //Critères de sélection dans $selectOption
            $nbeSelectOption = count($selectOption);
 
            if ($nbeSelectOption === 1) {
                //Une seule option
                foreach ($selectOption as $key => $options) {
                    $sql .= "WHERE `$options[table]`.`$options[field]` $options[operator] :$options[field] ";
                }
            }
 
            if ($nbeSelectOption > 1) {
                //Plusieurs options
                $pointer = 1;
                foreach ($selectOption as $key => $options) {
                    if ($pointer === 1) {
                        //Premier passage de la boucle
                        $sql .= "WHERE `$options[table]`.`$options[field]` $options[operator] :$options[field] ";
                    }
                    if ($pointer != 1) {
                        $sql .= "AND `$options[table]`.`$options[field]` $options[operator] :$options[field] ";
                    }
                    $pointer++;
                }
            }
        }
 
        /* Préparation de la requête */
        $stmt = $connexion_db->prepare($sql);
 
        /* Protection des variables de la requête */
        if (!empty($selectOption)) {
            foreach ($selectOption as $key => $options) {
                echo 'Valeur'.'->'.$options['value'];
                $stmt->bindValue(":$options[field]", $options['value']);
            }
        }
 
        self::_executeRequest($stmt);
        return $stmt->fetchColumn();
    }
}

Utilisation :

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
$selectOption = array();
$selectOption[] = array(
    'table' => 'dimmoAds',
    'field' => 'typeAds',
    'operator' => '=',
    'value'=> 'Vente'
);
$selectOption[] = array(
    'table' => 'dimmoAds',
    'field' => 'typeProperty',
    'operator' => '!=',
    'value'=> 'Immeuble'
);
$selectOption[] = array(
    'table' => 'dimmoAds',
    'field' => 'typeProperty',
    'operator' => '!=',
    'value'=> 'Maison'
);
$selectOption[] = array(
    'table' => 'dimmoAds',
    'field' => 'typeProperty',
    'operator' => '!=',
    'value'=> 'Terrain'
);
$selectOption[] = array(
    'table' => 'dimmoAds',
    'field' => 'typeProperty',
    'operator' => '!=',
    'value'=> 'Parking'
);
 
$_dimmoNbeAdsSaleOther = DimmoAdsManager::count($selectOption);

Ya sûrement mieux à faire que de passer des paramètres en tableaux.
Au final ça deviens plus clair de créer la requête dans le modèle et le l'envoyer à la classe ensuite...
Je sais plus :cry:

Salut,

je t'ai repris le code de ta classe afin de le simplifier :

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
class DimmoAdsManager
{
    /**
     * Compte le nombre d'enregistrement.
     *
     * @param array  $selectOption Conditions pour la requête SQL.
     *                             Format : [TABLE][CHAMP][OPERATEUR (=,<,>...)][VALEUR]
     *
     * @return int Nombre d'enregistrement
     */
    public static function count(array $selectOption)
    {
        // suit les tags PDO et leur valeur
        $tags    = array();
        // générateur de tag PDO a->z + A->Z
        $chars   = array_flip(range('a', 'z')) + array_flip(range('A', 'Z'));
        // génère et renvoie un tag (suite aléatoire de 10 lettres)
        $get_tag = function() use ($chars) { return ':'.implode(array_rand($chars, 10)); };
 
        $add_tag =
            function($value) use ($get_tag, &$tags)
            {
                // on s'assure de l'unicité du tag généré pour l'ensemble de la requête
                // si le tag a déjà été généré, on en génère autant de fois que nécéssaire pour préserver l'unicité
                do
                {
                    $tag = $get_tag();
                } while (isset($tags[$tag]));
 
                $tags[$tag] = $value;
 
                return $tag;
            };
 
        // suit les critères du filtre
        $where = array();
 
        foreach ($selectOption as $k => $options)
        {
            $where[] =
<<<SQL
`{$options['table']}`.`{$options['field']}` {$options['operator']} {$add_tag($options['value'])}
SQL;
        }
 
        $sql_where = (empty($where)) ? '' : ' WHERE '.implode('AND', $where);
        $sql       = "SELECT COUNT(`idDimmoAds`) AS nb_rec FROM `dimmoAds` {$sql_where}";
 
        /* Préparation de la requête */
        $cnx  = PDO2::getInstance();
        $stmt = $cnx->prepare($sql);
 
        /* Protection des variables de la requête */
        foreach ($tags as $tag => $value)
        {
            $stmt->bindValue($tag, $value);
        }
 
        self::_executeRequest($stmt);
        return $stmt->fetchColumn();
    }
}

J'ai essayé de coller à ton approche.
Allez bon courage, je pense que tu vas y passer un peu de temps sur ce bout de code..., désolé
Si tu pousses l'architecture, toute la partie de la gestion des tags est factorisable.

10/08/2013, 20h50
greg91

Merci beaucoup rawsrc, ton code fonctionne :)
Reste qq problèmes avec certains filtres que je vais essayer de régler.

Je repost si à nouveau je ne m'en sort pas :? (là c les vacances)

Et bien merci encore rawsrc, Ton code marche super !

Je l'ai adapté vers quelque choses que je comprenais mieux :) J'ai suivi ton conseil et ai mis la générations des tag dans une méthode privée.
Je post le code final et m'attaque au listing maintenant.

La classe :

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
 
class DimmoAdsManager
{
    /**
     * Compte le nombre d'enregistrement.
     *
     * @param array $selectOption Conditions pour la requête SQL.
     *                            [][OPERATEUR_GENERALE][TABLE][CHAMP][OPERATEUR (=,<,>...)][VALEUR]
     *
     * @return int Nombre d'enregistrement répondant aux conditions de sélections
     */
    public static function count(array $selectOption)
    {
        /**
         * Liste des tags PDO et de leur valeur
         * [TAG_ALEATOIRE][VALEUR]
         * @var Array
         */
        $tags = array();
 
        /**
         * Liste des critères SQL du filtre
         * @var Array
         */
        $where = array();
 
        /* Options de selections */
        foreach ($selectOption as $options) {
            //Génère un nouveau tag
            $tag = self::_generateTag($tags);
 
            //Ajoute le tag et sa valeur
            $tags[$tag] = $options['value'];
 
            /* Ajout de l'option de sélection dans la liste des critères */
            $where[] = "
            {$options['masterOperator']}
            `{$options['table']}`.`{$options['field']}`
            {$options['operator']}
            :{$tag}
            ";
        }
 
        /* Contruction de la requête SQL */
        $sql_where = (empty($where)) ? '' : ' WHERE '.implode(' ', $where);
        $sql       = "SELECT COUNT(`idDimmoAds`) AS nb_rec FROM `dimmoAds` {$sql_where}";
 
        /* Préparation de la requête */
        $connexion_db = PDO2::getInstance();
        $stmt = $connexion_db->prepare($sql);
 
        /* Protection des variables de la requête */
        foreach ($tags as $tag => $value) {
            $stmt->bindValue($tag, $value);
        }
 
        if (!$stmt->execute()) {
            if (CORE_DEBUG === true) {
                //Affiche l'erreur en mode de debug
                print_r($stmt->errorInfo());
            }
        return $stmt->fetchColumn();
    }
 
    /**
     * Génére un nouveau tag unique en controlant qu'il n'a pas déjà été généré
     *
     * @param array  $tags Liste des tags déjà généré par la requête
     *
     * @return string
     */
    private function _generateTag($tags)
    {
        $chars = array_flip(range('a', 'z')) + array_flip(range('A', 'Z'));
 
        do {
            implode(array_rand($chars, 10));
            $tag = Chaine::random(10, 1);
        }
        while (array_key_exists($tag, $tags));
 
        return $tag;
    }
}

Utilisation :

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
 
/* Options de sélection */
$selectOption[] = array(
    'masterOperator' => '',
    'table' => 'dimmoAds',
    'field' => 'typeMandat',
    'operator' => '=',
    'value'=> 'Exclusif'
);
 
$selectOption[] = array(
    'masterOperator' => 'AND',
    'table' => 'dimmoAds',
    'field' => 'typeProperty',
    'operator' => '=',
    'value'=> 'Maison'
);
 
$selectOption[] = array(
    'masterOperator' => 'OR',
    'table' => 'dimmoAds',
    'field' => 'typeProperty',
    'operator' => '=',
    'value' => 'Appartement'
);
 
$selectOption[] = array(
    'masterOperator' => 'AND',
    'table' => 'dimmoAds',
    'field' => 'typeAds',
    'operator' => '=',
    'value'=> 'Vente'
);
 
$test = DimmoAdsManager::count($selectOption);
var_dump($test);