Peut PHP PDO États accepter la table ou de la colonne de nom de paramètre?

Table et les noms de Colonnes NE peuvent pas être remplacés par les paramètres de l'AOP.

Dans ce cas, vous voulez simplement de filtre et nettoyez les données manuellement. Une façon de le faire est de passer en sténographie des paramètres à la fonction qui va exécuter la requête dynamiquement et ensuite utiliser un switch() instruction pour créer une liste de valeurs valides pour être utilisé pour le nom de la table ou de la colonne. De cette façon, aucune intervention de l'utilisateur ne va jamais directement dans la requête. Ainsi, par exemple:

function buildQuery( $get_var ) 
{
    switch($get_var)
    {
        case 1:
            $tbl = 'users';
            break;
    }

    $sql = "SELECT * FROM $tbl";
}

En ne laissant aucun cas de défaut ou à l'aide d'un cas par défaut renvoie un message d'erreur vous assurer que seules les valeurs que vous souhaitez pour vous servir.

Je vois que c'est un vieux post, mais j'ai trouvé utile et j'ai pensé partager une solution similaire à ce que @kzqai suggéré:

J'ai une fonction qui reçoit deux paramètres comme...

function getTableInfo($inTableName, $inColumnName) {
    ....
}

L'intérieur, j'ai de contre-vérifier les tableaux que j'ai mis en place pour s'assurer que les tables et les colonnes avec des "bienheureux" tables sont accessibles:

$allowed_tables_array = array('tblTheTable');
$allowed_columns_array['tblTheTable'] = array('the_col_to_check');

Puis la vérification de PHP avant d'exécuter AOP ressemble...

if(in_array($inTableName, $allowed_tables_array) && in_array($inColumnName,$allowed_columns_array[$inTableName]))
{
    $sql = "SELECT $inColumnName AS columnInfo
            FROM $inTableName";
    $stmt = $pdo->prepare($sql); 
    $stmt->execute();
    $result = $stmt->fetchAll(PDO::FETCH_ASSOC);
}

(Réponse tardive, consulter ma note de côté).

La même règle s'applique lors de la tentative de créer une "base de données".

Vous ne pouvez pas utiliser une requête préparée à se lier à une base de données.

I. e.:

CREATE DATABASE IF NOT EXISTS :database

ne fonctionnera pas. Utiliser une liste fiable à la place.

Note de côté: j'ai ajouté cette réponse (comme un wiki de la communauté) car il est souvent utilisé pour fermer les questions avec les, où certaines personnes affiché des questions semblables à essayer de lier un base de données et non pas un tableau et/ou de la colonne.

Comme pour la question principale dans ce fil, les autres postes, il est clair pourquoi on ne peut pas lier les valeurs pour les noms de colonne lors de la préparation de déclarations, voici donc une solution:

class myPdo{
private $user   = 'dbuser';
private $pass   = 'dbpass';
private $host   = 'dbhost';
private $db = 'dbname';
private $pdo;
private $dbInfo;
public function __construct($type){
$this->pdo = new PDO('mysql:host='.$this->host.';dbname='.$this->db.';charset=utf8',$this->user,$this->pass);
if(isset($type)){
//when class is called upon, it stores column names and column types from the table of you choice in $this->dbInfo;
$stmt = "select distinct column_name,column_type from information_schema.columns where table_name='sometable';";
$stmt = $this->pdo->prepare($stmt);//not really necessary since this stmt doesn't contain any dynamic values;
$stmt->execute();
$this->dbInfo = $stmt->fetchAll(PDO::FETCH_ASSOC);
}
}
public function pdo_param($col){
$param_type = PDO::PARAM_STR;
foreach($this->dbInfo as $k => $arr){
if($arr['column_name'] == $col){
if(strstr($arr['column_type'],'int')){
$param_type = PDO::PARAM_INT;
break;
}
}
}//for testing purposes i only used INT and VARCHAR column types. Adjust to your needs...
return $param_type;
}
public function columnIsAllowed($col){
$colisAllowed = false;
foreach($this->dbInfo as $k => $arr){
if($arr['column_name'] === $col){
$colisAllowed = true;
break;
}
}
return $colisAllowed;
}
public function q($data){
//$data is received by post as a JSON object and looks like this
//{"data":{"column_a":"value","column_b":"value","column_c":"value"},"get":"column_x"}
$data = json_decode($data,TRUE);
$continue = true;
foreach($data['data'] as $column_name => $value){
if(!$this->columnIsAllowed($column_name)){
$continue = false;
//means that someone possibly messed with the post and tried to get data from a column that does not exist in the current table, or the column name is a sql injection string and so on...
break;
}
}
//since $data['get'] is also a column, check if its allowed as well
if(isset($data['get']) && !$this->columnIsAllowed($data['get'])){
$continue = false;
}
if(!$continue){
exit('possible injection attempt');
}
//continue with the rest of the func, as you normally would
$stmt = "SELECT DISTINCT ".$data['get']." from sometable WHERE ";
foreach($data['data'] as $k => $v){
$stmt .= $k.' LIKE :'.$k.'_val AND ';
}
$stmt = substr($stmt,0,-5)." order by ".$data['get'];
//$stmt should look like this
//SELECT DISTINCT column_x from sometable WHERE column_a LIKE :column_a_val AND column_b LIKE :column_b_val AND column_c LIKE :column_c_val order by column_x
$stmt = $this->pdo->prepare($stmt);
//obviously now i have to bindValue()
foreach($data['data'] as $k => $v){
$stmt->bindValue(':'.$k.'_val','%'.$v.'%',$this->pdo_param($k));
//setting PDO::PARAM... type based on column_type from $this->dbInfo
}
$stmt->execute();
return $stmt->fetchAll(PDO::FETCH_ASSOC);//or whatever
}
}
$pdo = new myPdo('anything');//anything so that isset() evaluates to TRUE.
var_dump($pdo->q($some_json_object_as_described_above));

Ci-dessus est juste un exemple, donc inutile de le dire, copiez->coller ne fonctionne pas. Ajuster à vos besoins.
Maintenant, cela peut ne pas fournir la sécurité à 100%, mais il permet un certain contrôle sur les noms de colonne quand ils "viennent" comme des chaînes dynamiques et peuvent être modifiées sur les utilisateurs finaux. En outre, il n'est pas nécessaire de construire un tableau avec votre colonne de la table des noms et des types car ils sont extraits à partir de la information_schema.