Können PHP PDO-Anweisungen den Tabellen- oder Spaltennamen als Parameter akzeptieren?

Warum kann ich den Tabellennamen nicht an eine vorbereitete PDO-Anweisung übergeben?

$stmt = $dbh->prepare('SELECT * FROM :table WHERE 1');
if ($stmt->execute(array(':table' => 'users'))) {
    var_dump($stmt->fetchAll());
}

Gibt es eine andere sichere Möglichkeit, einen Tabellennamen in eine SQL-Abfrage einzufügen? Mit Safe meine ich, dass ich das nicht tun will

$sql = "SELECT * FROM $table WHERE 1"

Tabellen- und Spaltennamen können in PDO NICHT durch Parameter ersetzt werden.

In diesem Fall möchten Sie die Daten einfach manuell filtern und bereinigen. Eine Möglichkeit, dies zu tun, besteht darin, Kurzparameter an die Funktion zu übergeben, die die Abfrage dynamisch ausführt, und dann mithilfe einer switch()Anweisung eine weiße Liste gültiger Werte zu erstellen, die für den Tabellennamen oder den Spaltennamen verwendet werden sollen. Auf diese Weise wird keine Benutzereingabe direkt in die Abfrage eingegeben. Also zum Beispiel:

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

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

Indem Sie keinen Standardfall belassen oder einen Standardfall verwenden, der eine Fehlermeldung zurückgibt, stellen Sie sicher, dass nur Werte verwendet werden, die Sie verwenden möchten.

Um zu verstehen, warum das Binden eines Tabellen- (oder Spalten-) Namens nicht funktioniert, müssen Sie verstehen, wie die Platzhalter in vorbereiteten Anweisungen funktionieren: Sie werden nicht einfach durch (entsprechend maskierte) Zeichenfolgen ersetzt und die resultierende SQL ausgeführt. Stattdessen erstellt ein DBMS, das aufgefordert wird, eine Anweisung "vorzubereiten", einen vollständigen Abfrageplan für die Ausführung dieser Abfrage, einschließlich der verwendeten Tabellen und Indizes, die unabhängig davon, wie Sie die Platzhalter ausfüllen, identisch sind.

Der Plan für SELECT name FROM my_table WHERE id = :valueist derselbe, den Sie ersetzen :value, aber der scheinbar ähnliche Plan SELECT name FROM :table WHERE id = :valuekann nicht geplant werden, da das DBMS keine Ahnung hat, aus welcher Tabelle Sie tatsächlich auswählen werden.

Dies kann oder sollte auch keine Abstraktionsbibliothek wie PDO umgehen, da dies die beiden Hauptziele vorbereiteter Anweisungen zunichte machen würde: 1) Damit die Datenbank im Voraus entscheiden kann, wie eine Abfrage ausgeführt wird, und diese verwenden kann mehrmals planen; und 2) um Sicherheitsprobleme zu verhindern, indem die Logik der Abfrage von der Variableneingabe getrennt wird.

Ich sehe, dass dies ein alter Beitrag ist, aber ich fand ihn nützlich und dachte, ich würde eine Lösung teilen, die der von @kzqai vorgeschlagenen ähnelt:

Ich habe eine Funktion, die zwei Parameter empfängt wie ...

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

Im Inneren überprüfe ich anhand von Arrays, die ich eingerichtet habe, um sicherzustellen, dass nur Tabellen und Spalten mit "gesegneten" Tabellen zugänglich sind:

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

Dann sieht die PHP-Prüfung vor dem Ausführen von PDO wie folgt aus ...

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);
}

Die Verwendung der ersteren ist von Natur aus nicht sicherer als die der letzteren. Sie müssen die Eingabe bereinigen, unabhängig davon, ob sie Teil eines Parameterarrays oder einer einfachen Variablen ist. Ich sehe also nichts Falsches daran, das letztere Formular mit zu verwenden $table, vorausgesetzt, Sie stellen sicher, dass der Inhalt von $tablesicher ist (Alphanum plus Unterstriche?), Bevor Sie es verwenden.

(Späte Antwort, konsultieren Sie meine Randnotiz).

Die gleiche Regel gilt beim Versuch, eine "Datenbank" zu erstellen.

Sie können keine vorbereitete Anweisung zum Binden einer Datenbank verwenden.

Dh:

CREATE DATABASE IF NOT EXISTS :database

wird nicht funktionieren. Verwenden Sie stattdessen eine Sicherheitsliste.

Randnotiz: Ich habe diese Antwort hinzugefügt (als Community-Wiki), weil sie häufig zum Schließen von Fragen verwendet wurde, bei denen einige Personen ähnliche Fragen stellten, als sie versuchten, eine Datenbank und keine Tabelle und / oder Spalte zu binden .

Ein Teil von mir fragt sich, ob Sie so einfach Ihre eigene Desinfektionsfunktion bereitstellen könnten:

$value = preg_replace('/[^a-zA-Z_]*/', '', $value);

Ich habe nicht wirklich darüber nachgedacht, aber es scheint, als würde alles entfernt, außer Zeichen und Unterstrichen.

Was die Hauptfrage in diesem Thread betrifft, haben die anderen Beiträge deutlich gemacht, warum wir bei der Vorbereitung von Anweisungen keine Werte an Spaltennamen binden können. Hier ist eine Lösung:

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));

Das Obige ist nur ein Beispiel, daher funktioniert Kopieren-> Einfügen natürlich nicht. Passen Sie es an Ihre Bedürfnisse an. Dies bietet möglicherweise keine 100% ige Sicherheit, ermöglicht jedoch eine gewisse Kontrolle über die Spaltennamen, wenn diese als dynamische Zeichenfolgen "eingehen" und auf Benutzerseite geändert werden können. Darüber hinaus ist es nicht erforderlich, ein Array mit den Namen und Typen Ihrer Tabellenspalten zu erstellen, da diese aus dem Informationsschema extrahiert werden.