[PDO] Deux fois le même paramètre dans la requête préparée

Version imprimable

Bonjour,

Jusque là, je n'ai jamais eu de souci avec ça donc je me demande si c'est une nouveauté PHP 7...

Soit la requête suivante :
Code:

1 2 3 4 5 6 7 8 9 10 11 $sql = " SELECT diplomeId, diplomeCode, diplomeLibelleCourt, diplomeLibelleLong FROM v_diplome_superieur "; // (...) $sql.= "WHERE diplomeLibelleCourt LIKE :nomDiplome OR diplomeLibelleLong LIKE :nomDiplome "; $param = array('param' => ':nomDiplome', 'value' => trim($nomDiplome).'%', 'data_type' => \PDO::PARAM_STR); // (...) $result = self::executerRequete($sql, array($param));
J'ai donc deux fois le même paramètre :nomDiplome et je ne vois pas pourquoi il faudrait que je l'envoie deux fois, non ?

Voilà ce que j'obtiens à l'exécution :

Citation:

Erreur PDO : SQLSTATE[HY093]: Invalid parameter number dans le fichier /srv/www/htdocs/pef/Application/Controller/Modele.php à la ligne 83
Requête : SELECT diplomeId, diplomeCode, diplomeLibelleCourt, diplomeLibelleLong FROM v_diplome_superieur WHERE diplomeLibelleCourt LIKE :nomDiplome OR diplomeLibelleLong LIKE :nomDiplome
Paramètres :

Array
(
[0] => Array
(
[param] => :nomDiplome
[value] => Licence en économie et sociologie%
[data_type] => 2
)

)

Bonjour,

~~Sauf erreur~~ après test *, ça fonctionne avec ->bindValue()...

...encore faudrait-il voir le code de executerRequete()...

* Test :
Code:

1 2 3 4 5 6 7 8 9 10 $search = 'chaz'; $rech_query = "SELECT * FROM contact WHERE mail LIKE :search OR nom LIKE :search ;"; try { $pdo_select = $pdo->prepare($rech_query); $pdo_select->bindValue(':search', $search.'%', PDO::PARAM_STR); $pdo_select->execute();

J'ai remplacé bindParam par bindValue dans executerRequete (voir code ci-dessous) mais j'ai le même résultat ! :calim2:

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
	/**
	 * Exécute une requête SQL éventuellement paramétrée
	 * @param string $sql : Requête SQL à exécuter
	 * @param array $params : Tableau de paramètres éventuels (param, value, data_type)
	 * @return mixed
	 */
	protected static function executerRequete($sql, $params = null)
	{
		// Détermination du type de requête à exécuter
		$mots = explode(' ', $sql, 2);
		$typeRequete = trim($mots[0]);
 
		try
		{
			// Exécution de la requête
			if ($params == null)
			{
				$prep = self::getBdd()->query($sql);    // exécution directe
			}
			else
			{
				$prep = self::getBdd()->prepare($sql);  // requête préparée
 
				foreach($params as $param)
				{
					if(count($param) == 4)
					{
						// Paramètre en sortie
						$prep->bindValue($param['param'], $param['value'], $param['data_type'], $param['length']);
					}
					else
					{
						$prep->bindValue($param['param'], $param['value'], $param['data_type']);
					}
				}
 
				$prep->execute();
			}
 
			// Envoi du résultat ou pas selon type de requête
			switch ($typeRequete)
			{
				case "SELECT":
					// Requête de type SELECT envoi de toutes les lignes de résultat sous forme de tableau
					$resultat = $prep->fetchAll(PDO::FETCH_ASSOC);
					break;
				case 'INSERT':
					// Requête de type INSERT => envoi de l'identifiant inséré
					$resultat = self::getBdd()->lastInsertId();
					break;
				default:
					// Autre type => pas de résultat à retourner
					$resultat = '';
			}
 
			$prep->closeCursor();
		}
		catch (\PDOException $e)
		{
			echo '<br />Erreur PDO : '.$e->getMessage().' dans le fichier '.$e->getFile().' à la ligne '.$e->getLine();
			echo '<br />Requête : '.$sql;
			echo '<br />Paramètres : <pre>';
			print_r($params);
			echo '</pre>';
			// TODO : à gérer avec les erreurs de l'application
		}
 
		return $resultat;
	}

Bonjour,

As-tu testé directement ?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 $sql = " SELECT diplomeId, diplomeCode, diplomeLibelleCourt, diplomeLibelleLong FROM v_diplome_superieur "; // (...) $sql.= "WHERE diplomeLibelleCourt LIKE :nomDiplome OR diplomeLibelleLong LIKE :nomDiplome "; try { $pdo_select = $pdo->prepare($sql); $pdo_select->bindValue(':nomDiplome', trim($nomDiplome).'%', PDO::PARAM_STR); $pdo_select->execute(); $rech_rowAll = $pdo_select->fetchAll(); } catch (PDOException $e){ echo 'Erreur SQL : '. $e->getMessage().'<br/>'; die(); }
Sinon... Il faut mettre 2 placeholders différents.

N.B. Il semblerait qu'on ne puisse pas le faire :
https://www.php.net/manual/fr/pdosta...lue.php#118662

Citation:

When binding parameters, apparently you can't use a placeholder twice (e.g. "select * from mails where sender=:me or recipient=:me"), you'll have to give them different names otherwise your query will return empty handed (but not fail, unfortunately).

https://www.php.net/manual/fr/pdo.prepare.php#69291

Citation:

Using a placeholder multiple times inside a statement doesn't work. PDO just translates the first occurance und leaves the second one as is.

Pourtant mon test (#2) a fonctionné correctement ! 8O

14/01/2020, 11h43
Celira

Par rapport à ton cas de départ, je suppose que tu passes ton tableau de paramètres directement à execute. La doc dit seulement :

Citation:

Un tableau de valeurs avec autant d'éléments qu'il y a de paramètres à associer dans la requête SQL qui sera exécutée. Toutes les valeurs sont traitées comme des constantes PDO::PARAM_STR.

La liaison de plus de valeurs que spécifié n'est pas possible ; s'il y a plus de clés dans input_parameters que dans le code SQL utilisé pour PDO::prepare(), alors la requête préparée échouera et une erreur sera levée.

Je suppose que le "autant d'éléments" est testé indifféremment du nom des paramètres, donc ":nomDiplome" est compté comme deux paramètres (ce qui est un peu stupide quand même :koi:)

Désolé, mais je peux en mettre autant que je veux : ça fonctionne !

Code:

1
2
3
4
5
6
7
8
9
10
	$rech_query = "SELECT *
				FROM contact
				WHERE mail LIKE :search OR nom LIKE :search OR prenom LIKE :search
				;";
  try {
	$pdo_select = $pdo->prepare($rech_query);
	$pdo_select->bindValue(':search', 	'%'.$search.'%',	PDO::PARAM_STR);
 
	$pdo_select->execute();
...

J'obtiens bien les résultats voulus.

14/01/2020, 12h08
CinePhil

Oui, je viens de lire toute la doc de pdoPrepare et j'y ai trouvé plusieurs choses :

Citation:

Envoyé par doc PHP

Vous devez inclure un marqueur avec un nom unique pour chaque valeur que vous souhaitez passer dans la requête lorsque vous appelez PDOStatement::execute(). Vous ne pouvez pas utiliser un marqueur avec deux noms identiques dans une requête préparée, à moins que le mode émulation ne soit actif.

Citation:

Envoyé par doc PHP

With PDO_MYSQL you need to remember about the PDO::ATTR_EMULATE_PREPARES option.

The default value is TRUE, like
$dbh->setAttribute(PDO::ATTR_EMULATE_PREPARES,true);

This means that no prepared statement is created with $dbh->prepare() call. With exec() call PDO replaces the placeholders with values itself and sends MySQL a generic query string.

The first consequence is that the call $dbh->prepare('garbage');
reports no error. You will get an SQL error during the $dbh->exec() call.
The second one is the SQL injection risk in special cases, like using a placeholder for the table name.

The reason for emulation is a poor performance of MySQL with prepared statements. Emulation works significantly faster.

J'ai pourtant PDO::ATTR_EMULATE_PREPARES => false dans la création de ma connexion PDO !
jreaux62, peut-être que ça fonctionne avec la valeur par défaut à TRUE ; je vais essayer mais si j'avais mis ça, je pense que c'est pour un autre souci, peut-être avec l'exécution des procédures... je ne sais plus.

Citation:

Envoyé par doc PHP

Attention using MySQL and prepared statements.
Using a placeholder multiple times inside a statement doesn't work. PDO just translates the first occurance und leaves the second one as is.

select id,name from demo_de where name LIKE :name OR name=:name

You have to use

select id,name from demo_de where name LIKE :name OR name=:name2

and bind name two times. I don't know if other databases (for example Oracle or MSSQL) support multiple occurances. If that's the fact, then the PDO behaviour for MySQL should be changed.

Je vais donc envoyer deux fois le paramètre, ce sera plus simple.

Merci pour vos réponses

Ma config :

Code:

1
2
3
4
5
6
$pdo_conn['extraParam']	= array(
	PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,		// rapport d'erreurs sous forme d'exceptions
	PDO::ATTR_PERSISTENT => true, 						// Connexions persistantes
	PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, 	// fetch mode par defaut
	PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES utf8"	// encodage UTF-8
	);

Mes tests fonctionnent... mais je ne sais pas dire pourquoi !... :koi:

14/01/2020, 15h04
CinePhil

Et bien c'est parce que tu as la valeur par défaut TRUE à PDO::ATTR_EMULATE_PREPARES.

Je l'ai passé à TRUE et ça fonctionne.

Je verrai si ça a d'autres conséquences mais pour le moment toutes mes requêtes sont passées. On va donc dire que c'est résolu.
14/01/2020, 15h19
Invité

Maintenant que tu en parles.... :aie:

... il est fort possible que j'ai supprimé de ma config. (PDO::ATTR_EMULATE_PREPARES,false), il y a bien longtemps.
Mais je ne me souviens pas si c'était pour cette raison.

J'avoue que je code de façon empirique : "Tant que ça marche,... je ne touche à rien"
15/01/2020, 17h00
Dendrite

Et sinon, ceci pourrait-il avoir un rapport ?

Citation:

PDO::PARAM_STR (entier)
Représente les types de données CHAR, VARCHAR ou les autres types de données sous forme de chaîne de caractères SQL.
PDO::PARAM_STR_NATL (integer)
Indicateur pour désigner une chaîne utilise le jeu de caractères national. Disponible à partir de PHP 7.2.0
PDO::PARAM_STR_CHAR (integer)
Indicateur pour désigner une chaîne utilise le jeu de caractères normal. Disponible à partir de PHP 7.2.0
15/01/2020, 17h48
CinePhil

A priori, non, Dendrite, pas de rapport avec le Scmilblick.