Sebelum pindah ke PDO, saya membuat query SQL di PHP dengan merangkai string. Jika saya mendapat kesalahan sintaksis basis data, saya bisa menggaungkan string kueri SQL final, coba sendiri di database, dan atur sampai saya memperbaiki kesalahan, kemudian masukkan kembali ke dalam kode.

Pernyataan PDO yang disiapkan lebih cepat dan lebih baik dan lebih aman, tetapi satu hal yang menggangguku: Saya tidak pernah melihat permintaan terakhir karena dikirim ke database. Ketika saya mendapatkan kesalahan tentang sintaks di log Apache saya atau file log kustom saya (saya mencatat kesalahan di dalam catchblok), saya tidak bisa melihat permintaan yang menyebabkannya.

Apakah ada cara menangkap kueri SQL lengkap yang dikirim oleh PDO ke database dan mencatatnya ke file?

Anda mengatakan ini:

Saya tidak pernah melihat permintaan terakhir karena dikirim ke database

Sebenarnya, ketika menggunakan pernyataan yang disiapkan, tidak ada yang namanya " permintaan akhir " :

• Pertama, pernyataan dikirim ke DB, dan disiapkan di sana
  • Database mem-parsing query, dan membangun representasi internal
• Dan, ketika Anda mengikat variabel dan menjalankan pernyataan, hanya variabel yang dikirim ke database
  • Dan database "menyuntikkan" nilai-nilai ke dalam representasi internal pernyataan tersebut

Jadi, untuk menjawab pertanyaanmu :

Apakah ada cara menangkap kueri SQL lengkap yang dikirim oleh PDO ke database dan mencatatnya ke file?

Tidak: karena tidak ada " permintaan SQL lengkap " di mana saja, tidak ada cara untuk menangkapnya.

Hal terbaik yang dapat Anda lakukan, untuk tujuan debugging, adalah "membangun kembali" sebuah query SQL "nyata", dengan menyuntikkan nilai-nilai ke dalam string SQL pernyataan.

Apa yang biasanya saya lakukan, dalam situasi seperti ini, adalah:

• gema kode SQL yang sesuai dengan pernyataan, dengan placeholder
• dan gunakan var_dump (atau yang setara) setelahnya, untuk menampilkan nilai-nilai parameter
• Ini umumnya cukup untuk melihat kemungkinan kesalahan, bahkan jika Anda tidak memiliki kueri "nyata" yang dapat Anda jalankan.

Ini tidak bagus, ketika datang untuk debugging - tapi itu harga pernyataan yang disiapkan dan keuntungan yang mereka bawa.

Mencari di log basis data

Meskipun Pascal MARTIN benar bahwa PDO tidak mengirim permintaan lengkap ke database sekaligus, saran ryeguy untuk menggunakan fungsi logging DB benar-benar memungkinkan saya untuk melihat permintaan lengkap yang dikumpulkan dan dieksekusi oleh database.

Begini caranya: (Instruksi ini untuk MySQL pada mesin Windows - jarak tempuh Anda mungkin beragam)

• Di my.ini, di bawah [mysqld]bagian, tambahkan logperintah, sepertilog="C:\Program Files\MySQL\MySQL Server 5.1\data\mysql.log"
• Mulai ulang MySQL.
• Ini akan mulai mencatat setiap permintaan dalam file itu.

File itu akan tumbuh dengan cepat, jadi pastikan untuk menghapusnya dan mematikan pencatatan ketika Anda selesai menguji.

Tentu Anda dapat men-debug menggunakan mode ini. {{ PDO::ATTR_ERRMODE }} Cukup tambahkan baris baru sebelum permintaan Anda, maka Anda akan menunjukkan garis debug.

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

Mungkin yang ingin Anda lakukan adalah menggunakan debugDumpParams () pada pernyataan pegangan. Anda dapat menjalankannya kapan saja setelah mengikat nilai ke kueri yang disiapkan (tidak perlu execute()pernyataan).

Itu tidak membangun pernyataan yang disiapkan untuk Anda, tetapi itu akan menunjukkan parameter Anda.

Posting lama tapi mungkin seseorang akan menganggap ini berguna;

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

Berikut adalah fungsi untuk melihat apa SQL yang efektif akan, diadaptasi dari komentar oleh "Mark" di 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;
}

Tidak. Pertanyaan PDO tidak disiapkan di sisi klien. PDO hanya mengirim kueri SQL dan parameter ke server database. Basis data adalah apa yang substitusi (dari ?). Anda memiliki dua opsi:

• Gunakan fungsi pencatatan DB Anda (tetapi meskipun itu biasanya ditampilkan sebagai dua pernyataan terpisah (yaitu, "tidak final") setidaknya dengan Postgres)
• Keluarkan kueri SQL dan paramater dan kumpulkan sendiri

hampir tidak ada yang dikatakan tentang menampilkan kesalahan kecuali memeriksa log kesalahan, tetapi ada fungsi yang cukup membantu:

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

( tautan sumber )

jelas bahwa kode ini dapat dimodifikasi untuk digunakan sebagai pesan pengecualian atau jenis penanganan kesalahan lainnya

misalnya Anda memiliki pernyataan pdo ini:

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

sekarang Anda bisa mendapatkan kueri yang dieksekusi dengan mendefinisikan array seperti ini:

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

Mencari di internet saya menemukan ini sebagai solusi yang dapat diterima. Kelas yang berbeda digunakan sebagai ganti fungsi PDO dan PDO dipanggil melalui panggilan fungsi sulap. Saya tidak yakin ini menciptakan masalah kinerja yang serius. Tapi itu bisa digunakan sampai fitur logging masuk akal ditambahkan ke PDO.

Jadi sesuai utas ini , Anda bisa menulis pembungkus untuk koneksi PDO Anda yang bisa login dan melempar pengecualian ketika Anda mendapatkan kesalahan.

Ini adalah contoh sederhana:

class LoggedPDOSTatement extends PDOStatement    {

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

}

jadi Anda bisa menggunakan kelas itu alih-alih PDOStatement:

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

Berikut implementasi dekorator PDO yang disebutkan:

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

}

Untuk login MySQL di WAMP , Anda perlu mengedit my.ini (mis. Di bawah wamp \ bin \ mysql \ mysql5.6.17 \ my.ini)

dan tambahkan ke [mysqld]:

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

Ini adalah fungsi yang saya buat untuk mengembalikan query SQL dengan parameter "diselesaikan".

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

Dengan asumsi Anda mengeksekusi seperti ini

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

Fungsi ini TIDAK menambahkan kutipan ke pertanyaan tetapi melakukan pekerjaan untuk saya.

Masalah yang saya miliki dengan solusi untuk menangkap pengecualian PDO untuk tujuan debug adalah bahwa ia hanya menangkap pengecualian PDO (duh), tetapi tidak menangkap kesalahan sintaks yang terdaftar sebagai kesalahan php (saya tidak yakin mengapa ini, tapi " mengapa "tidak relevan dengan solusi). Semua panggilan PDO saya berasal dari kelas model tabel tunggal yang saya perpanjang untuk semua interaksi saya dengan semua tabel ... ini hal yang rumit ketika saya mencoba untuk men-debug kode, karena kesalahan akan mendaftarkan baris kode php di mana panggilan eksekusi saya menelepon, tetapi tidak memberi tahu saya dari mana panggilan itu, sebenarnya, dibuat. Saya menggunakan kode berikut untuk mengatasi masalah ini:

/**
 * 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;
        }            
    }
}

Jadi, kode di atas menangkap KEDUA PDO pengecualian DAN kesalahan sintaks php dan memperlakukan mereka dengan cara yang sama. Penangan kesalahan saya terlihat seperti ini:

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

Jika ada yang punya ide yang lebih baik tentang cara mendapatkan info yang relevan untuk penangan kesalahan saya daripada menetapkan model tabel sebagai variabel global, saya akan senang mendengarnya dan mengedit kode saya.

kode ini sangat bagus untuk saya:

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

Jangan lupa mengganti $ data dan $ query dengan nama Anda

saya menggunakan kelas ini untuk men-debug PDO (dengan 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);
    }
}

Saya telah membuat proyek / repositori yang memuat Komposer modern untuk hal ini di sini:

pdo-debug

Temukan rumah GitHub proyek di sini , lihat posting blog yang menjelaskannya di sini . Satu baris untuk ditambahkan di composer.json Anda, dan kemudian Anda dapat menggunakannya seperti ini:

echo debugPDO($sql, $parameters);

$ sql adalah pernyataan SQL mentah, $ parameter adalah array dari parameter Anda: Kuncinya adalah nama placeholder (": user_id") atau jumlah parameter yang tidak disebutkan namanya ("?"), nilainya .. yah, nilai.

Logika di belakang: Script ini hanya akan grad parameter dan menggantinya ke string SQL yang disediakan. Sangat sederhana, tetapi sangat efektif untuk 99% kasus penggunaan Anda. Catatan: Ini hanya emulasi dasar, bukan debugging PDO nyata (karena ini tidak mungkin karena PHP mengirim SQL mentah dan parameter ke server MySQL terpisah).

Terima kasih banyak kepada bigwebguy dan Mike dari utas StackOverflow. Mendapatkan string kueri SQL mentah dari PDO karena pada dasarnya menulis seluruh fungsi utama di belakang skrip ini. Besar!

Bagaimana cara men-debug query database mysql PDO di Ubuntu

TL; DR Log semua pertanyaan Anda dan ikuti log mysql.

Petunjuk ini adalah untuk saya menginstal Ubuntu 14.04. Perintah lsb_release -amengeluarkan untuk mendapatkan versi Anda. Pemasangan Anda mungkin berbeda.

Aktifkan masuk log mysql

1. Pergi ke baris cmd server dev Anda
2. Ubah direktori cd /etc/mysql. Anda akan melihat file bernama my.cnf. Itu file yang akan kita ubah.
3. Pastikan Anda berada di tempat yang tepat dengan mengetik cat my.cnf | grep general_log. Ini memfilter my.cnffile untuk Anda. Anda akan melihat dua entri: #general_log_file = /var/log/mysql/mysql.log&& #general_log = 1.
4. Batalkan komentar dua baris tersebut dan simpan melalui editor pilihan Anda.
5. Mysql Restart: sudo service mysql restart.
6. Anda mungkin perlu me-restart server web Anda juga. (Saya tidak dapat mengingat urutan yang saya gunakan). Untuk menginstal saya, bahwa ini nginx: sudo service nginx restart.

Kerja bagus! Anda sudah siap. Sekarang yang harus Anda lakukan adalah mengekor file log sehingga Anda dapat melihat permintaan PDO yang dibuat aplikasi Anda secara waktu nyata.

Ekor log untuk melihat kueri Anda

Masukkan cmd ini tail -f /var/log/mysql/mysql.log.

Output Anda akan terlihat seperti ini:

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 

Setiap kueri baru yang dibuat aplikasi Anda akan muncul secara otomatis , selama Anda melanjutkan membuntuti log. Untuk keluar dari ekor, tekan cmd/ctrl c.

Catatan

1. Hati-hati: file log ini bisa menjadi besar. Saya hanya menjalankan ini di server dev saya.
2. File log menjadi terlalu besar? Potong itu. Itu berarti file tetap, tetapi isinya dihapus. truncate --size 0 mysql.log.
3. Keren bahwa file log mencantumkan koneksi mysql. Saya tahu salah satunya adalah dari kode mysqli lama saya dari mana saya melakukan transisi. Yang ketiga adalah dari koneksi PDO baru saya. Namun, tidak yakin dari mana datangnya yang kedua. Jika Anda tahu cara cepat untuk menemukannya, beri tahu saya.

Kredit & terima kasih

Huge berteriak untuk jawaban Nathan Long di atas untuk inspirasi untuk mencari tahu ini di Ubuntu. Juga untuk dikirill untuk komentarnya pada posting Nathan yang membawa saya ke solusi ini.

Love you stackoverflow!

Di lingkungan Debian NGINX saya melakukan hal berikut.

Goto /etc/mysql/mysql.conf.dmengedit mysqld.cnfjika Anda menemukan log-error = /var/log/mysql/error.logmenambahkan 2 baris berikut melenguh itu.

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

Untuk melihat log goto /var/log/mysqldan tail -f mysql.log

Ingatlah untuk mengomentari baris-baris ini setelah Anda selesai dengan debugging jika Anda berada dalam lingkungan produksi hapus mysql.logkarena file log ini akan tumbuh dengan cepat dan bisa sangat besar.