Bagaimana cara men-debug permintaan basis data PDO?


140

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?


4
Hal ini login file: /var/log/mysql/*. Parameter terikat PDO tidak dapat menyebabkan kesalahan sintaks sehingga yang Anda butuhkan adalah kueri SQL yang disiapkan.
Xeoncross

1
lihat kode di stackoverflow.com/questions/210564/… (tidak ada dalam jawaban yang diterima). Bukan berarti ada beberapa pembaruan yang diposting.
Mawg mengatakan mengembalikan Monica

1
Satu baris sederhana via Komposer: github.com/panique/pdo-debug
Sliq

2
Jawaban Xeoncross membantu saya. Berikut adalah artikel yang menjelaskan cara mengaktifkan fitur ini. Ini menjadi default pada banyak instalasi server. pontikis.net/blog/how-and-when-to-enable-mysql-logs
mrbinky3000

2
Coba denganvar_dump($pdo_instance->debugDumpParams())
Daniel Petrovaliev

Jawaban:


99

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.


1
Penjelasan hebat - terima kasih. Rupanya saya hanya punya ide kabur tentang cara kerjanya. Saya kira ketika pernyataan disiapkan, objek yang dihasilkan berisi ID hash atau numerik yang dapat dikirim kembali ke database dengan parameter untuk plug-in.
Nathan Long

Sama-sama :-) ;;; Saya tidak tahu bagaimana ini diterapkan secara terperinci, tapi saya kira ini sesuatu yang seperti itu - hasilnya persis seperti itu ;;; itulah salah satu hal yang menyenangkan dengan pernyataan yang disiapkan: jika Anda harus melakukan query yang sama berkali-kali, itu hanya akan dikirim ke DB dan disiapkan sekali: untuk setiap eksekusi, hanya data yang akan dikirim.
Pascal MARTIN

1
Pembaruan: Aaron Patterson menyebutkan di Railsconf 2011 bahwa ia menambahkan pernyataan yang lebih siap untuk Rails, tetapi manfaatnya jauh lebih berat di PostgreSQL daripada di MySQL. Dia mengatakan bahwa ini karena MySQL tidak benar-benar membuat rencana kueri hingga Anda menjalankan kueri yang disiapkan.
Nathan Long

85

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.


1
Hanya sebuah catatan - saya harus melarikan diri dari garis miring di my.ini. Jadi, entri saya terlihat seperti log = "C: \\ temp \\ MySQL \\ mysql.log".
Jim

4
Ini dapat bekerja tergantung pada pengaturan PDO::ATTR_EMULATE_PREPARES. Lihat jawaban ini untuk info lebih lanjut: stackoverflow.com/questions/10658865/#answer-10658929
webbiedave

23
Saya benci PDO karena ini.
Salman

1
@webbiedave - oh, wow! Jawaban Anda yang ditautkan menyiratkan bahwa jawaban saya hanya berfungsi ketika PDO tidak berfungsi secara optimal, tetapi mengirimkan seluruh permintaan untuk kompatibilitas mundur dengan versi MySQL lama atau driver lama. Menarik.
Nathan Long

13
Dalam MySQL 5.5+ yang Anda butuhkan general_logbukan log. Lihat dev.mysql.com/doc/refman/5.5/en/query-log.html
Adrian Macneil

17

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

Anda tidak akan menelepon ->querysaat menggunakan pernyataan yang disiapkan?
EoghanM

17

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.


2
Satu-satunya masalah adalah bahwa itu output debug bukannya menyimpannya secara internal tanpa 'Echoing' itu. Saya tidak bisa login dengan cara ini.
Ricardo Martins

3
Anda dapat menggunakan buffering output (ob_start () ...) untuk menyimpan output dan mencatatnya.
Cranio

bugs.php.net/bug.php?id=52384 diperbaiki pada 7.1 Anda dapat melihat nilai-nilai :) agak terlambat tapi ini php
Sander Visser

12

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

1
Untuk fungsi serupa yang juga dapat menangani parameter numerik, lihat jawaban saya (terima kasih kepada komentator di php.net).
Matt Browne

9

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

Mengapa "Mark" menggunakan titik dua sebelum $ k str_replace(":$k" ....? Indeks asosiatif sudah memilikinya dalam array $ params.
Alan

Pertanyaan bagus ... ini mungkin menjelaskannya: stackoverflow.com/questions/9778887/… . Secara pribadi saya menggunakan fungsi ini untuk men-debug permintaan Doktrin, dan saya pikir Doktrin menggunakan parameter bernomor daripada dinamai jadi saya tidak melihat masalah ini. Saya memperbarui fungsi sehingga akan berfungsi baik dengan atau tanpa titik dua memimpin sekarang.
Matt Browne

perhatikan, bahwa solusi ini diganti :name_longdengan :name. Setidaknya jika :namedatang sebelumnya :name_long. Pernyataan disiapkan MySQL dapat menangani ini dengan benar, jadi jangan biarkan itu membingungkan Anda.
Zim84

8

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

Saya tidak pernah berpikir untuk memeriksa log DB. Saya mencari-cari di direktori MySQL dan tidak melihat file log, tapi mungkin logging adalah opsi yang harus saya aktifkan di suatu tempat.
Nathan Long

Ya, Anda harus menyalakannya. Saya tidak tahu secara spesifik tetapi secara default tidak mencatat setiap permintaan.
ryeguy

5

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


2
Ini cara yang salah. PDO cukup pintar untuk membuat kode ini tidak berguna. Katakan saja untuk melemparkan pengecualian pada kesalahan. PHP akan melakukan sisanya, jauh lebih baik daripada fungsi terbatas ini. Selain itu, tolong , pelajari untuk tidak mencetak semua kesalahan langsung ke browser. Ada cara yang lebih baik.
Akal Sehat Anda

3
itulah dokumentasi resmi, dan tentu saja tidak ada yang akan mencetak kesalahan dalam produksi, sekali lagi ini adalah contoh dari situs resmi (php.net), lihat tautan di bawah kode contoh. Dan yang pasti jauh lebih baik adalah menggunakan params tambahan $ db-> setAttribute (PDO :: ATTR_ERRMODE, PDO :: ERRMODE_EXCEPTION) dalam instantiation PDO tetapi sayangnya Anda tidak dapat memiliki akses ke kode itu
Zippp

4

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;

1
Bekerja untukku. Anda memiliki kesalahan dalam contoh kode kedua: ));seharusnya );(hanya satu putaran braket).
Jasom Dotnet

2

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

}

2

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"

1

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.


0

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.


0

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


0

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

0

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!


0

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='a@b.co' 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!


0

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.


tidak semua orang menggunakan mysql.
Titik koma yang ditakuti
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.