从 PDO 准备好的语句中获取原始 SQL 查询字符串

Question

在准备好的语句上调用 PDOStatement::execute() 时，有没有办法让原始 SQL 字符串执行？出于调试目的，这将非常有用。

Answer 1

/**
 * Replaces any parameter placeholders in a query with the value of that
 * parameter. Useful for debugging. Assumes anonymous parameters from 
 * $params are are in the same order as specified in $query
 *
 * @param string $query The sql query with parameter placeholders
 * @param array $params The array of substitution parameters
 * @return string The interpolated query
 */
public static function interpolateQuery($query, $params) {
    $keys = array();

    # build a regular expression for each parameter
    foreach ($params as $key => $value) {
        if (is_string($key)) {
            $keys[] = '/:'.$key.'/';
        } else {
            $keys[] = '/[?]/';
        }
    }

    $query = preg_replace($keys, $params, $query, 1, $count);

    #trigger_error('replaced '.$count.' keys');

    return $query;
}

Answer 2

我修改了该方法以包括处理 WHERE IN (?) 等语句的数组输出。

更新：刚刚添加了对 NULL 值和重复 $params 的检查，因此实际的 $param 值不会被修改。

干得好，bigwebguy，谢谢！

/**
 * Replaces any parameter placeholders in a query with the value of that
 * parameter. Useful for debugging. Assumes anonymous parameters from 
 * $params are are in the same order as specified in $query
 *
 * @param string $query The sql query with parameter placeholders
 * @param array $params The array of substitution parameters
 * @return string The interpolated query
 */
public function interpolateQuery($query, $params) {
    $keys = array();
    $values = $params;

    # build a regular expression for each parameter
    foreach ($params as $key => $value) {
        if (is_string($key)) {
            $keys[] = '/:'.$key.'/';
        } else {
            $keys[] = '/[?]/';
        }

        if (is_string($value))
            $values[$key] = "'" . $value . "'";

        if (is_array($value))
            $values[$key] = "'" . implode("','", $value) . "'";

        if (is_null($value))
            $values[$key] = 'NULL';
    }

    $query = preg_replace($keys, $values, $query);

    return $query;
}

Answer 3

解决方案是主动在查询中添加错误并打印错误消息：

//Connection to the database
$co = new PDO('mysql:dbname=myDB;host=localhost','root','');
//We allow to print the errors whenever there is one
$co->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

//We create our prepared statement
$stmt = $co->prepare("ELECT * FROM Person WHERE age=:age"); //I removed the 'S' of 'SELECT'
$stmt->bindValue(':age','18',PDO::PARAM_STR);
try {
    $stmt->execute();
} catch (PDOException $e) {
    echo $e->getMessage();
}

标准输出：

SQLSTATE[42000]：语法错误或访问冲突：[...] 第 1 行'ELECT * FROM Person WHERE Age=18' 附近

请务必注意，它仅打印前 80 个字符的查询。

Answer 4

可能有点晚了，但现在有了 PDOStatement::debugDumpParams

将准备好的语句中包含的信息直接转储到
输出。它将提供正在使用的SQL查询，数量
使用的参数（Params），参数列表及其名称，
type (paramtype) 作为一个整数，它们的键名或位置，以及
查询中的位置（如果 PDO 驱动程序支持，
否则，将为-1)。

您可以在 官方 php 文档 上找到更多信息

示例：

<?php
/* Execute a prepared statement by binding PHP variables */
$calories = 150;
$colour = 'red';
$sth = $dbh->prepare('SELECT name, colour, calories
    FROM fruit
    WHERE calories < :calories AND colour = :colour');
$sth->bindParam(':calories', $calories, PDO::PARAM_INT);
$sth->bindValue(':colour', $colour, PDO::PARAM_STR, 12);
$sth->execute();

$sth->debugDumpParams();

?>

Answer 5

Mike 在代码中添加了更多内容 - 遍历值以添加单引号

/**
 * Replaces any parameter placeholders in a query with the value of that
 * parameter. Useful for debugging. Assumes anonymous parameters from 
 * $params are are in the same order as specified in $query
 *
 * @param string $query The sql query with parameter placeholders
 * @param array $params The array of substitution parameters
 * @return string The interpolated query
 */
public function interpolateQuery($query, $params) {
    $keys = array();
    $values = $params;

    # build a regular expression for each parameter
    foreach ($params as $key => $value) {
        if (is_string($key)) {
            $keys[] = '/:'.$key.'/';
        } else {
            $keys[] = '/[?]/';
        }

        if (is_array($value))
            $values[$key] = implode(',', $value);

        if (is_null($value))
            $values[$key] = 'NULL';
    }
    // Walk the array to see if we can add single-quotes to strings
    array_walk($values, create_function('&$v, $k', 'if (!is_numeric($v) && $v!="NULL") $v = "\'".$v."\'";'));

    $query = preg_replace($keys, $values, $query, 1, $count);

    return $query;
}

Answer 6

PDOStatement 有一个公共属性 $queryString。它应该是你想要的。

我刚刚注意到 PDOStatement 有一个未记录的方法 debugDumpParams() 您可能还想看看。

Answer 7

为了满足我自己的需要，我花了很多时间研究这种情况。这个和其他几个 SO 线程对我帮助很大，所以我想分享我的想法。

虽然在故障排除时访问插入的查询字符串是一个显着的好处，但我们希望能够仅维护某些查询的日志（因此，为此目的使用数据库日志并不理想）。我们还希望能够使用日志在任何给定时间重新创建表的条件，因此，我们需要确保插入的字符串已正确转义。最后，我们希望将此功能扩展到我们的整个代码库，而必须尽可能少地重写它（截止日期、营销等；你知道它是怎么回事）。

我的解决方案是扩展默认 PDOStatement 对象的功能以缓存参数化值（或引用），并且在执行语句时，使用 PDO 对象的功能在将参数注入回查询时正确转义参数细绳。然后，我们可以结合语句对象的执行方法并记录当时执行的实际查询（或至少尽可能忠实地再现）。

正如我所说，我们不想修改整个代码库来添加此功能，因此我们覆盖了 PDOStatement 的默认 bindParam() 和 bindValue() 方法对象，缓存绑定数据，然后调用parent::bindParam() 或parent::bindValue()。这使得我们现有的代码库能够继续正常运行。

最后，当调用 execute() 方法时，我们执行插值并将结果字符串提供为新属性 E_PDOStatement->fullQuery。这可以输出以查看查询，或者例如写入日志文件。

该扩展以及安装和配置说明可在 github 上找到：

https://github.com/noahheck/E_PDOStatement< /a>

免责声明：
显然，正如我所提到的，我编写了这个扩展。因为它是在许多线程的帮助下开发的，所以我想在这里发布我的解决方案，以防其他人遇到这些线程，就像我一样。

Answer 8

您可以扩展 PDOStatement 类来捕获有界变量并存储它们以供以后使用。然后可以添加 2 种方法，一种用于变量清理 ( debugBindedVariables )，另一种用于打印包含这些变量的查询 ( debugQuery )：

class DebugPDOStatement extends \PDOStatement{
  private $bound_variables=array();
  protected $pdo;

  protected function __construct($pdo) {
    $this->pdo = $pdo;
  }

  public function bindValue($parameter, $value, $data_type=\PDO::PARAM_STR){
    $this->bound_variables[$parameter] = (object) array('type'=>$data_type, 'value'=>$value);
    return parent::bindValue($parameter, $value, $data_type);
  }

  public function bindParam($parameter, &$variable, $data_type=\PDO::PARAM_STR, $length=NULL , $driver_options=NULL){
    $this->bound_variables[$parameter] = (object) array('type'=>$data_type, 'value'=>&$variable);
    return parent::bindParam($parameter, $variable, $data_type, $length, $driver_options);
  }

  public function debugBindedVariables(){
    $vars=array();

    foreach($this->bound_variables as $key=>$val){
      $vars[$key] = $val->value;

      if($vars[$key]===NULL)
        continue;

      switch($val->type){
        case \PDO::PARAM_STR: $type = 'string'; break;
        case \PDO::PARAM_BOOL: $type = 'boolean'; break;
        case \PDO::PARAM_INT: $type = 'integer'; break;
        case \PDO::PARAM_NULL: $type = 'null'; break;
        default: $type = FALSE;
      }

      if($type !== FALSE)
        settype($vars[$key], $type);
    }

    if(is_numeric(key($vars)))
      ksort($vars);

    return $vars;
  }

  public function debugQuery(){
    $queryString = $this->queryString;

    $vars=$this->debugBindedVariables();
    $params_are_numeric=is_numeric(key($vars));

    foreach($vars as $key=>&$var){
      switch(gettype($var)){
        case 'string': $var = "'{$var}'"; break;
        case 'integer': $var = "{$var}"; break;
        case 'boolean': $var = $var ? 'TRUE' : 'FALSE'; break;
        case 'NULL': $var = 'NULL';
        default:
      }
    }

    if($params_are_numeric){
      $queryString = preg_replace_callback( '/\?/', function($match) use( &$vars) { return array_shift($vars); }, $queryString);
    }else{
      $queryString = strtr($queryString, $vars);
    }

    echo $queryString.PHP_EOL;
  }
}


class DebugPDO extends \PDO{
  public function __construct($dsn, $username="", $password="", $driver_options=array()) {
    $driver_options[\PDO::ATTR_STATEMENT_CLASS] = array('DebugPDOStatement', array($this));
    $driver_options[\PDO::ATTR_PERSISTENT] = FALSE;
    parent::__construct($dsn,$username,$password, $driver_options);
  }
}

然后您可以使用这个继承的类进行调试。

$dbh = new DebugPDO('mysql:host=localhost;dbname=test;','user','pass');

$var='user_test';
$sql=$dbh->prepare("SELECT user FROM users WHERE user = :test");
$sql->bindValue(':test', $var, PDO::PARAM_STR);
$sql->execute();

$sql->debugQuery();
print_r($sql->debugBindedVariables());

导致

从用户中选择用户，其中用户='user_test'

数组（
[：测试] =>用户测试
）

Answer 9

现有的答案似乎都不完整或安全，因此我想出了这个函数，它具有以下改进：

• 适用于未命名 (?) 和命名 (:foo< /code>) 参数。

  


• 使用 PDO::quote() 正确转义值不是 NULL、int、float 或 bool。

• 正确处理包含 "?" 和 ":foo" 的字符串值，不会将它们误认为占位符。

    function interpolateSQL(PDO $pdo, string $query, array $params) : string {
        $s = chr(2); // Escape sequence for start of placeholder
        $e = chr(3); // Escape sequence for end of placeholder
        $keys = [];
        $values = [];

        // Make sure we use escape sequences that are not present in any value
        // to escape the placeholders.
        foreach ($params as $key => $value) {
            while( mb_stripos($value, $s) !== false ) $s .= $s;
            while( mb_stripos($value, $e) !== false ) $e .= $e;
        }
        
        
        foreach ($params as $key => $value) {
            // Build a regular expression for each parameter
            $keys[] = is_string($key) ? "/$s:$key$e/" : "/$s\?$e/";

            // Treat each value depending on what type it is. 
            // While PDO::quote() has a second parameter for type hinting, 
            // it doesn't seem reliable (at least for the SQLite driver).
            if( is_null($value) ){
                $values[$key] = 'NULL';
            }
            elseif( is_int($value) || is_float($value) ){
                $values[$key] = $value;
            }
            elseif( is_bool($value) ){
                $values[$key] = $value ? 'true' : 'false';
            }
            else{
                $value = str_replace('\\', '\\\\', $value);
                $values[$key] = $pdo->quote($value);
            }
        }

        // Surround placehodlers with escape sequence, so we don't accidentally match
        // "?" or ":foo" inside any of the values.
        $query = preg_replace(['/\?/', '/(:[a-zA-Z0-9_]+)/'], ["$s?$e", "$s$1$e"], $query);

        // Replace placeholders with actual values
        $query = preg_replace($keys, $values, $query, 1, $count);

        // Verify that we replaced exactly as many placeholders as there are keys and values
        if( $count !== count($keys) || $count !== count($values) ){
            throw new \Exception('Number of replacements not same as number of keys and/or values');
        }

        return $query;
    }

我确信它可以进一步改进。

就我而言，我最终只是记录了实际的“未准备的查询”（即包含占位符的 SQL）以及 JSON 编码的参数。但是，此代码可能会用于某些您确实需要插入最终 SQL 查询的用例。

Answer 10

您可以使用 sprintf(str_replace('?', '"%s"', $sql), ...$params);

这是一个示例：

function mysqli_prepared_query($link, $sql, $types='', $params=array()) {
    echo sprintf(str_replace('?', '"%s"', $sql), ...$params);
    //prepare, bind, execute
}

$link = new mysqli($server, $dbusername, $dbpassword, $database);
$sql = "SELECT firstname, lastname FROM users WHERE userage >= ? AND favecolor = ?";
$types = "is"; //integer and string
$params = array(20, "Brown");

if(!$qry = mysqli_prepared_query($link, $sql, $types, $params)){
    echo "Failed";
} else {
    echo "Success";
}

注意这仅适用于 PHP >= 5.6

Answer 11

提到的 $queryString 属性可能只会返回传入的查询，而不将参数替换为其值。在 .Net 中，我的查询执行器的 catch 部分对参数进行了简单的搜索替换，并将其替换为所提供的值，以便错误日志可以显示用于查询的实际值。您应该能够枚举 PHP 中的参数，并将参数替换为其分配的值。

Answer 12

我知道这个问题有点老了，但是，我很久以前就在使用这段代码（我已经使用了 @chris-go 的响应），现在，这些代码在 PHP 7.2 中已经过时了，

我将发布更新的代码这些代码的版本（主要代码来自 @bigwebguy，@mike 和 @chris-go，所有答案这个问题）：

/**
 * Replaces any parameter placeholders in a query with the value of that
 * parameter. Useful for debugging. Assumes anonymous parameters from 
 * $params are are in the same order as specified in $query
 *
 * @param string $query The sql query with parameter placeholders
 * @param array $params The array of substitution parameters
 * @return string The interpolated query
 */
public function interpolateQuery($query, $params) {
    $keys = array();
    $values = $params;

    # build a regular expression for each parameter
    foreach ($params as $key => $value) {
        if (is_string($key)) {
            $keys[] = '/:'.$key.'/';
        } else {
            $keys[] = '/[?]/';
        }

        if (is_array($value))
            $values[$key] = implode(',', $value);

        if (is_null($value))
            $values[$key] = 'NULL';
    }
    // Walk the array to see if we can add single-quotes to strings
    array_walk($values, function(&$v, $k) { if (!is_numeric($v) && $v != "NULL") $v = "\'" . $v . "\'"; });

    $query = preg_replace($keys, $values, $query, 1, $count);

    return $query;
}

请注意代码的更改是在 array_walk() 函数上，用匿名函数替换 create_function 。这使得这些优秀的代码具有功能并且与 PHP 7.2 兼容（并且希望未来的版本也是如此）。

Answer 13

preg_replace 对我不起作用，当 binding_ 超过 9 时，binging_1 和 binding_10 被 str_replace 替换（留下 0），所以我向后进行了替换：

public function interpolateQuery($query, $params) {
$keys = array();
    $length = count($params)-1;
    for ($i = $length; $i >=0; $i--) {
            $query  = str_replace(':binding_'.(string)$i, '\''.$params[$i]['val'].'\'', $query);
           }
        // $query  = str_replace('SQL_CALC_FOUND_ROWS', '', $query, $count);
        return $query;

}

希望有人觉得它有用。

Answer 14

我需要在绑定参数后记录完整的查询字符串，所以这是我的代码中的一部分。希望这对遇到同样问题的每个人都有用。

/**
 * 
 * @param string $str
 * @return string
 */
public function quote($str) {
    if (!is_array($str)) {
        return $this->pdo->quote($str);
    } else {
        $str = implode(',', array_map(function($v) {
                    return $this->quote($v);
                }, $str));

        if (empty($str)) {
            return 'NULL';
        }

        return $str;
    }
}

/**
 * 
 * @param string $query
 * @param array $params
 * @return string
 * @throws Exception
 */
public function interpolateQuery($query, $params) {
    $ps = preg_split("/'/is", $query);
    $pieces = [];
    $prev = null;
    foreach ($ps as $p) {
        $lastChar = substr($p, strlen($p) - 1);

        if ($lastChar != "\\") {
            if ($prev === null) {
                $pieces[] = $p;
            } else {
                $pieces[] = $prev . "'" . $p;
                $prev = null;
            }
        } else {
            $prev .= ($prev === null ? '' : "'") . $p;
        }
    }

    $arr = [];
    $indexQuestionMark = -1;
    $matches = [];

    for ($i = 0; $i < count($pieces); $i++) {
        if ($i % 2 !== 0) {
            $arr[] = "'" . $pieces[$i] . "'";
        } else {
            $st = '';
            $s = $pieces[$i];
            while (!empty($s)) {
                if (preg_match("/(\?|:[A-Z0-9_\-]+)/is", $s, $matches, PREG_OFFSET_CAPTURE)) {
                    $index = $matches[0][1];
                    $st .= substr($s, 0, $index);
                    $key = $matches[0][0];
                    $s = substr($s, $index + strlen($key));

                    if ($key == '?') {
                        $indexQuestionMark++;
                        if (array_key_exists($indexQuestionMark, $params)) {
                            $st .= $this->quote($params[$indexQuestionMark]);
                        } else {
                            throw new Exception('Wrong params in query at ' . $index);
                        }
                    } else {
                        if (array_key_exists($key, $params)) {
                            $st .= $this->quote($params[$key]);
                        } else {
                            throw new Exception('Wrong params in query with key ' . $key);
                        }
                    }
                } else {
                    $st .= $s;
                    $s = null;
                }
            }
            $arr[] = $st;
        }
    }

    return implode('', $arr);
}

Answer 15

Mike的答案在您使用“重用”绑定值之前效果很好。
例如：

SELECT * FROM `an_modules` AS `m` LEFT JOIN `an_module_sites` AS `ms` ON m.module_id = ms.module_id WHERE 1 AND `module_enable` = :module_enable AND `site_id` = :site_id AND (`module_system_name` LIKE :search OR `module_version` LIKE :search)

Mike的答案只能替换第一个：search，但不能替换第二个。
因此，我重写了他的答案，以使用可以正确重复使用的多个参数。

public function interpolateQuery($query, $params) {
    $keys = array();
    $values = $params;
    $values_limit = [];

    $words_repeated = array_count_values(str_word_count($query, 1, ':_'));

    # build a regular expression for each parameter
    foreach ($params as $key => $value) {
        if (is_string($key)) {
            $keys[] = '/:'.$key.'/';
            $values_limit[$key] = (isset($words_repeated[':'.$key]) ? intval($words_repeated[':'.$key]) : 1);
        } else {
            $keys[] = '/[?]/';
            $values_limit = [];
        }

        if (is_string($value))
            $values[$key] = "'" . $value . "'";

        if (is_array($value))
            $values[$key] = "'" . implode("','", $value) . "'";

        if (is_null($value))
            $values[$key] = 'NULL';
    }

    if (is_array($values)) {
        foreach ($values as $key => $val) {
            if (isset($values_limit[$key])) {
                $query = preg_replace(['/:'.$key.'/'], [$val], $query, $values_limit[$key], $count);
            } else {
                $query = preg_replace(['/:'.$key.'/'], [$val], $query, 1, $count);
            }
        }
        unset($key, $val);
    } else {
        $query = preg_replace($keys, $values, $query, 1, $count);
    }
    unset($keys, $values, $values_limit, $words_repeated);

    return $query;
}

Answer 16

我假设您的意思是您想要最终的 SQL 查询，并将参数值插入其中。我知道这对于调试很有用，但这不是准备好的语句的工作方式。参数不会与客户端的准备好的语句组合，因此 PDO 永远不应该访问与其参数组合的查询字符串。

当你执行prepare()时，SQL语句被发送到数据库服务器，而当你执行execute()时，参数被单独发送。 MySQL 的常规查询日志确实显示了最终的 SQL，其中包含执行（）后插入的值。以下是我的一般查询日志的摘录。我从 mysql CLI 运行查询，而不是从 PDO 运行查询，但原理是相同的。

081016 16:51:28 2 Query       prepare s1 from 'select * from foo where i = ?'
                2 Prepare     [2] select * from foo where i = ?
081016 16:51:39 2 Query       set @a =1
081016 16:51:47 2 Query       execute s1 using @a
                2 Execute     [2] select * from foo where i = 1

如果您设置 PDO 属性 PDO::ATTR_EMULATE_PREPARES，您也可以获得您想要的结果。在此模式下，PDO 将参数插入到 SQL 查询中，并在您执行（）时发送整个查询。 这不是真正的准备好的查询。您将通过在execute() 之前将变量插入到SQL 字符串中来规避准备好的查询的好处。

---

回复 @afilina 的评论：

不，文本 SQL 查询在执行期间不与参数结合。所以 PDO 没有什么可以向您展示的。

在内部，如果您使用 PDO::ATTR_EMULATE_PREPARES，PDO 会在准备和执行之前创建 SQL 查询的副本并在其中插入参数值。但 PDO 不会公开此修改后的 SQL 查询。

PDOStatement 对象有一个属性 $queryString，但这仅在 PDOStatement 的构造函数中设置，并且在使用参数重写查询时不会更新。

对于 PDO 来说，要求他们公开重写的查询是一个合理的功能请求。但即使这样也不会给你“完整”的查询，除非你使用 PDO::ATTR_EMULATE_PREPARES。

这就是为什么我展示了上面使用 MySQL 服务器的通用查询日志的解决方法，因为在这种情况下，即使是带有参数占位符的准备好的查询也会在服务器上重写，并将参数值回填到查询字符串中。但这仅在日志记录期间完成，而不是在查询执行期间完成。