如何调试PDO数据库查询？

Question

在转向 PDO 之前，我通过连接字符串在 PHP 中创建了 SQL 查询。如果我遇到数据库语法错误，我可以只回显最终的 SQL 查询字符串，自己在数据库上尝试，并调整它直到修复错误，然后将其放回代码中。

准备好的 PDO 语句更快、更好、更安全，但有一件事困扰着我：当最终查询发送到数据库时，我从未看到它。当我在 Apache 日志或自定义日志文件中收到有关语法的错误（我将错误记录在 catch 块内）时，我看不到导致这些错误的查询。

有没有办法捕获 PDO 发送到数据库的完整 SQL 查询并将其记录到文件中？

Answer 1

你这样说：

我从来没有看到最终的查询，因为它是
发送到数据库

嗯，实际上，当使用准备好的语句时，不存在“最终查询”这样的东西：

• 首先，一条语句被发送到数据库，然后在那里准备
  • 数据库解析查询，并构建其内部表示
• 并且，当您绑定变量并执行语句时，只有变量被发送到数据库
  • 数据库将值“注入”到语句的内部表示中

所以，回答你的问题：

有没有办法捕获完整的
PDO 向数据库发送 SQL 查询
并将其记录到文件中？

否：因为任何地方都没有“完整的 SQL 查询”，因此无法捕获它。

出于调试目的，您可以做的最好的事情是通过将值注入到语句的 SQL 字符串中来“重新构造”“真实”SQL 查询。

在这种情况下，我通常做的是：

• 回显与该语句相对应的 SQL 代码，并使用占位符
• 并在其后使用 var_dump （或等效项），显示参数的值
• 这通常足以看到可能的错误，即使您没有任何可以执行的“真实”查询。

当涉及到调试时，这并不是很好——但这就是准备好的语句的代价及其带来的优势。

Answer 2

查看数据库日志

虽然Pascal MARTIN是正确的，PDO不会一次将完整的查询发送到数据库，但是ryeguy建议使用数据库的日志记录功能实际上让我可以看到数据库组装和执行的完整查询。

方法如下：
（这些说明适用于 Windows 计算机上的 MySQL - 您的情况可能会有所不同）

• 在 my.ini 中的 [mysqld] 部分下，添加 log code> 命令，如 log="C:\Program Files\MySQL\MySQL Server 5.1\data\mysql.log"
• 重新启动 MySQL。
• 它将开始记录该文件中的每个查询。

该文件会快速增长，因此请务必在完成测试后将其删除并关闭日志记录。

Answer 3

当然您可以使用此模式进行调试 {{ PDO::ATTR_ERRMODE }}
只需在查询之前添加新行即可显示调试行。

$db->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_WARNING );
$db->query('SELECT *******');  

Answer 4

也许您想要做的是在语句句柄上使用 debugDumpParams() 。您可以在将值绑定到准备好的查询后随时运行该命令（无需 execute() 语句）。

它不会为您构建准备好的语句，但会显示您的参数。

Answer 5

一篇旧文章，但也许​​有人会发现这很有用；

function pdo_sql_debug($sql,$placeholders){
    foreach($placeholders as $k => $v){
        $sql = preg_replace('/:'.$k.'/',"'".$v."'",$sql);
    }
    return $sql;
}

Answer 6

下面是一个函数，用于查看有效的 SQL 是什么，改编自“Mark”在 的评论php.net：

function sql_debug($sql_string, array $params = null) {
    if (!empty($params)) {
        $indexed = $params == array_values($params);
        foreach($params as $k=>$v) {
            if (is_object($v)) {
                if ($v instanceof \DateTime) $v = $v->format('Y-m-d H:i:s');
                else continue;
            }
            elseif (is_string($v)) $v="'$v'";
            elseif ($v === null) $v='NULL';
            elseif (is_array($v)) $v = implode(',', $v);

            if ($indexed) {
                $sql_string = preg_replace('/\?/', $v, $sql_string, 1);
            }
            else {
                if ($k[0] != ':') $k = ':'.$k; //add leading colon if it was left out
                $sql_string = str_replace($k,$v,$sql_string);
            }
        }
    }
    return $sql_string;
}

Answer 7

不会。PDO 查询不是在客户端准备的。 PDO 只是将 SQL 查询和参数发送到数据库服务器。 数据库是（？的）替换的内容。您有两个选择：

• 使用数据库的日志记录功能（但即使如此，至少对于 Postgres，它通常显示为两个单独的语句（即“不是最终的”））
• 输出 SQL 查询和
  参数并将其拼凑在一起
  你自己

Answer 8

除了检查错误日志之外，几乎没有提到错误显示，
但有一个相当有用的功能：（

<?php
/* Provoke an error -- bogus SQL syntax */
$stmt = $dbh->prepare('bogus sql');
if (!$stmt) {
    echo "\PDO::errorInfo():\n";
    print_r($dbh->errorInfo());
}
?>

源链接）

很明显，可以将此代码修改为用作异常消息
或任何其他类型的错误处理

Answer 9

例如，您有这个 pdo 语句：

$query="insert into tblTest (field1, field2, field3)
values (:val1, :val2, :val3)";
$res=$db->prepare($query);
$res->execute(array(
  ':val1'=>$val1,
  ':val2'=>$val2,
  ':val3'=>$val3,
));

现在您可以通过定义如下数组来获取执行的查询：

$assoc=array(
  ':val1'=>$val1,
  ':val2'=>$val2,
  ':val3'=>$val3,
);
$exQuery=str_replace(array_keys($assoc), array_values($assoc), $query);
echo $exQuery;

Answer 10

在互联网上搜索我发现这是一个可以接受的解决方案。使用不同的类代替 PDO，并且通过魔术函数调用来调用 PDO 函数。我不确定这会造成严重的性能问题。但在 PDO 中添加合理的日志记录功能之前，它可以使用。

因此，根据这个 线程 ，您可以为 PDO 连接编写一个包装器，它可以在出现错误时记录并抛出异常。

这是一个简单的示例：

class LoggedPDOSTatement extends PDOStatement    {

function execute ($array)    {
    parent::execute ($array);
    $errors = parent::errorInfo();
    if ($errors[0] != '00000'):
        throw new Exception ($errors[2]);
    endif;
  }

}

因此您可以使用该类而不是 PDOStatement：

$this->db->setAttribute (PDO::ATTR_STATEMENT_CLASS, array ('LoggedPDOStatement', array()));

这里提到了 PDO 装饰器实现：

class LoggedPDOStatement    {

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

function execute ($params = null)    {
    $result = $this->stmt->execute ($params); 
    if ($this->stmt->errorCode() != PDO::ERR_NONE):
        $errors = $this->stmt->errorInfo();
        $this->paint ($errors[2]);
    endif;
    return $result;
}

function bindValue ($key, $value)    {
    $this->values[$key] = $value;    
    return $this->stmt->bindValue ($key, $value);
}

function paint ($message = false)    {
    echo '<pre>';
    echo '<table cellpadding="5px">';
    echo '<tr><td colspan="2">Message: ' . $message . '</td></tr>';
    echo '<tr><td colspan="2">Query: ' . $this->stmt->queryString . '</td></tr>';
    if (count ($this->values) > 0):
    foreach ($this->values as $key => $value):
    echo '<tr><th align="left" style="background-color: #ccc;">' . $key . '</th><td>' . $value . '</td></tr>';
    endforeach;
    endif;
    echo '</table>';
    echo '</pre>';
}

function __call ($method, $params)    {
    return call_user_func_array (array ($this->stmt, $method), $params); 
}

}

Answer 11

要在WAMP中记录MySQL，您需要编辑my.ini（例如在wamp\bin\mysql\mysql5.6.17\my.ini下）

并添加到[mysqld]：

general_log = 1
general_log_file="c:\\tmp\\mysql.log"

Answer 12

这是我创建的一个函数，用于返回带有“已解析”参数的 SQL 查询。

function paramToString($query, $parameters) {
    if(!empty($parameters)) {
        foreach($parameters as $key => $value) {
            preg_match('/(\?(?!=))/i', $query, $match, PREG_OFFSET_CAPTURE);
            $query = substr_replace($query, $value, $match[0][1], 1);
        }
    }
    return $query;
    $query = "SELECT email FROM table WHERE id = ? AND username = ?";
    $values = [1, 'Super'];

    echo paramToString($query, $values);

假设您像这样执行

$values = array(1, 'SomeUsername');
$smth->execute($values);

此函数不会向查询添加引号，但会为我完成这项工作。

Answer 13

我在这里创建了一个现代 Composer 加载的项目/存储库：

pdo-debug

找到项目的 GitHub回到这里，请参阅此处解释的博客文章。在您的composer.json中添加一行，然后您可以像这样使用它：

echo debugPDO($sql, $parameters);

$sql是原始SQL语句，$parameters是参数数组：关键是占位符名称（“：user_id”）或未命名参数的编号（“？”），该值是..好吧，该值。

背后的逻辑：该脚本将简单地对参数进行分级，并将它们替换为提供的 SQL 字符串。超级简单，但对于 99% 的用例来说超级有效。注意：这只是一个基本的模拟，而不是真正的 PDO 调试（因为这是不可能的，因为 PHP 将原始 SQL 和参数单独发送到 MySQL 服务器）。

非常感谢来自 StackOverflow 线程 从 PDO 获取原始 SQL 查询字符串，用于编写此脚本背后的整个主要函数。大起来！

Answer 14

如何在 Ubuntu 中调试 PDO mysql 数据库查询

TL;DR 记录所有查询并跟踪 mysql 日志。

这些说明适用于我安装的 Ubuntu 14.04。发出命令 lsb_release -a 来获取您的版本。您的安装可能会有所不同。

打开 mysql 中的日志记录

1. 转到您的开发服务器 cmd 行
2. 更改目录 cd /etc/mysql。您应该会看到一个名为 my.cnf 的文件。这就是我们要更改的文件。
3. 输入 cat my.cnf | 验证您是否位于正确的位置。 grep General_log。这将为您过滤 my.cnf 文件。您应该看到两个条目：#general_log_file = /var/log/mysql/mysql.log && #general_log = 1。
4. 取消注释这两行并通过您选择的编辑器保存。
5. 重启mysql：sudo service mysql restart。
6. 您可能还需要重新启动网络服务器。 （我不记得我使用的顺序）。对于我的安装，这是 nginx：sudo service nginx restart。

干得好！你已经准备好了。现在您所要做的就是跟踪日志文件，以便您可以实时查看应用程序进行的 PDO 查询。

跟踪日志以查看您的查询

输入此 cmd tail -f /var/log/mysql/mysql.log。

您的输出将如下所示：

73 Connect  xyz@localhost on your_db
73 Query    SET NAMES utf8mb4
74 Connect  xyz@localhost on your_db
75 Connect  xyz@localhost on your_db
74 Quit 
75 Prepare  SELECT email FROM customer WHERE email=? LIMIT ?
75 Execute  SELECT email FROM customer WHERE email='[email protected]' LIMIT 5
75 Close stmt   
75 Quit 
73 Quit 

只要您继续跟踪日志，您的应用发出的任何新查询都会自动弹出到视图中。要退出尾部，请点击 cmd/ctrl c。

注意

1. 注意：此日志文件可能会变得很大。我只在我的开发服务器上运行它。
2. 日志文件太大？截断它。这意味着文件会保留，但内容会被删除。 截断--size 0 mysql.log。
3. 很酷的是日志文件列出了 mysql 连接。我知道其中之一来自我正在转换的遗留 mysqli 代码。第三个来自我的新 PDO 连接。但是，不确定第二个来自哪里。如果您知道快速找到它的方法，请告诉我。

信用与信用感谢

上面 Nathan Long 的回答，让我们在 Ubuntu 上解决这个问题。还要感谢 dikirill 对 Nathan 帖子的评论，这使我找到了这个解决方案。

爱你堆栈溢出！

Answer 15

我在捕获 PDO 豁免以进行调试的解决方案中遇到的问题是，它只捕获了 PDO 豁免（废话），但没有捕获被注册为 php 错误的语法错误（我不确定这是为什么，但是“为什么”与解决方案无关）。我所有的 PDO 调用都来自一个表模型类，我为与所有表的所有交互扩展了该模型类...当我尝试调试代码时，这很复杂，因为错误会注册我的执行调用所在的 php 代码行打来电话，但没有告诉我电话实际上是从哪里打来的。我使用以下代码来解决这个问题：

/**
 * Executes a line of sql with PDO.
 * 
 * @param string $sql
 * @param array $params
 */
class TableModel{
    var $_db; //PDO connection
    var $_query; //PDO query

    function execute($sql, $params) { 
        //we're saving this as a global, so it's available to the error handler
        global $_tm;
        //setting these so they're available to the error handler as well
        $this->_sql = $sql;
        $this->_paramArray = $params;            

        $this->_db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        $this->_query = $this->_db->prepare($sql);

        try {
            //set a custom error handler for pdo to catch any php errors
            set_error_handler('pdoErrorHandler');

            //save the table model object to make it available to the pdoErrorHandler
            $_tm = $this;
            $this->_query->execute($params);

            //now we restore the normal error handler
            restore_error_handler();
        } catch (Exception $ex) {
            pdoErrorHandler();
            return false;
        }            
    }
}

因此，上面的代码捕获 PDO 异常和 php 语法错误，并以相同的方式处理它们。我的错误处理程序看起来像这样：

function pdoErrorHandler() {
    //get all the stuff that we set in the table model
    global $_tm;
    $sql = $_tm->_sql;
    $params = $_tm->_params;
    $query = $tm->_query;

    $message = 'PDO error: ' . $sql . ' (' . implode(', ', $params) . ") \n";

    //get trace info, so we can know where the sql call originated from
    ob_start();
    debug_backtrace(); //I have a custom method here that parses debug backtrace, but this will work as well
    $trace = ob_get_clean();

    //log the error in a civilized manner
    error_log($message);

    if(admin(){
        //print error to screen based on your environment, logged in credentials, etc.
        print_r($message);
    }
}

如果有人对如何获取与我的错误处理程序相关的信息比将表模型设置为全局变量有更好的想法，我会很高兴听到它并编辑我的代码。

Answer 16

这段代码对我来说非常有用：

echo str_replace(array_keys($data), array_values($data), $query->queryString);

不要忘记用你的名字替换 $data 和 $query

Answer 17

我使用此类来调试 PDO（使用 Log4PHP）

<?php

/**
 * Extends PDO and logs all queries that are executed and how long
 * they take, including queries issued via prepared statements
 */
class LoggedPDO extends PDO
{

    public static $log = array();

    public function __construct($dsn, $username = null, $password = null, $options = null)
    {
        parent::__construct($dsn, $username, $password, $options);
    }

    public function query($query)
    {
        $result = parent::query($query);
        return $result;
    }

    /**
     * @return LoggedPDOStatement
     */
    public function prepare($statement, $options = NULL)
    {
        if (!$options) {
            $options = array();
        }
        return new \LoggedPDOStatement(parent::prepare($statement, $options));
    }
}

/**
 * PDOStatement decorator that logs when a PDOStatement is
 * executed, and the time it took to run
 * @see LoggedPDO
 */
class LoggedPDOStatement
{

    /**
     * The PDOStatement we decorate
     */
    private $statement;
    protected $_debugValues = null;

    public function __construct(PDOStatement $statement)
    {
        $this->statement = $statement;
    }

    public function getLogger()
    {
        return \Logger::getLogger('PDO sql');
    }

    /**
     * When execute is called record the time it takes and
     * then log the query
     * @return PDO result set
     */
    public function execute(array $params = array())
    {
        $start = microtime(true);
        if (empty($params)) {
            $result = $this->statement->execute();
        } else {
            foreach ($params as $key => $value) {
                $this->_debugValues[$key] = $value;
            }
            $result = $this->statement->execute($params);
        }

        $this->getLogger()->debug($this->_debugQuery());

        $time = microtime(true) - $start;
        $ar = (int) $this->statement->rowCount();
        $this->getLogger()->debug('Affected rows: ' . $ar . ' Query took: ' . round($time * 1000, 3) . ' ms');
        return $result;
    }

    public function bindValue($parameter, $value, $data_type = false)
    {
        $this->_debugValues[$parameter] = $value;
        return $this->statement->bindValue($parameter, $value, $data_type);
    }

    public function _debugQuery($replaced = true)
    {
        $q = $this->statement->queryString;

        if (!$replaced) {
            return $q;
        }

        return preg_replace_callback('/:([0-9a-z_]+)/i', array($this, '_debugReplace'), $q);
    }

    protected function _debugReplace($m)
    {
        $v = $this->_debugValues[$m[0]];

        if ($v === null) {
            return "NULL";
        }
        if (!is_numeric($v)) {
            $v = str_replace("'", "''", $v);
        }

        return "'" . $v . "'";
    }

    /**
     * Other than execute pass all other calls to the PDOStatement object
     * @param string $function_name
     * @param array $parameters arguments
     */
    public function __call($function_name, $parameters)
    {
        return call_user_func_array(array($this->statement, $function_name), $parameters);
    }
}

Answer 18

在 Debian NGINX 环境中我做了以下操作。

如果发现 log-error = /var/log/mysql/error.log<，请转到 /etc/mysql/mysql.conf.d 编辑 mysqld.cnf /code> 在其下方添加以下两行。

general_log_file        = /var/log/mysql/mysql.log
general_log             = 1

要查看日志，请转到 /var/log/mysql 和 tail -f mysql.log

如果您在生产环境中，请记住在完成调试后将这些行注释掉删除mysql.log，因为该日志文件会快速增长并且可能会很大。

Answer 19

为了这些目的，我多年前编写了一个 模块 mysqli 的包装器。现在我写这样的查询：

// Getting a result object
$result = $db->query("SELECT * FROM `users` WHERE `name` = '?s' AND `age` = ?i", "d'Artagnan", 41);

// We receive data (in the form of an associative array, for example)
$data = $result->fetchAssoc();

// SQL query not working as expected?
// Not a problem - print it and see the generated SQL query,
// which will already be with the parameters substituted into its body:
echo $db->getQueryString(); // SELECT * FROM `users` WHERE `name` = 'd\'Artagnan' AND `age` = 41