PDO'ya geçmeden önce, dizeleri birleştirerek PHP'de SQL sorguları oluşturdum. Ben veritabanı sözdizimi hatası var, ben sadece son SQL sorgu dizesini yankı, veritabanında kendim deneyin ve ben hatayı düzeltene kadar tweak, sonra tekrar koda koyabilirsiniz.

Hazırlanan PDO ifadeleri daha hızlı ve daha iyi ve daha güvenli, ancak bir şey beni rahatsız ediyor: Veritabanına gönderildiği için son sorguyu asla göremiyorum. Apache günlüğümdeki veya özel günlük dosyamdaki sözdizimi hakkında hatalar aldığımda (bir catchblok içindeki hataları günlüğe kaydediyorum ), bunlara neden olan sorguyu göremiyorum.

PDO tarafından veritabanına gönderilen tam SQL sorgusunu yakalamanın ve bir dosyaya kaydetmenin bir yolu var mı?

Bunu söyle :

Veritabanına gönderildiğinden son sorguyu asla göremiyorum

Aslında, hazırlanmış ifadeleri kullanırken, " son sorgu " diye bir şey yoktur :

• İlk olarak DB'ye bir açıklama gönderilir ve orada hazırlanır
  • Veritabanı sorguyu ayrıştırır ve sorgunun dahili bir temsilini oluşturur
• Değişkenleri bağlayıp deyimi yürüttüğünüzde veritabanına yalnızca değişkenler gönderilir
  • Ve veritabanı değerleri ifadenin dahili gösterimine "enjekte eder"

Sorunuzu cevaplamak için:

PDO tarafından veritabanına gönderilen tam SQL sorgusunu yakalamanın ve bir dosyaya kaydetmenin bir yolu var mı?

Hayır: hiçbir yerde " tam SQL sorgusu " olmadığından, onu yakalamanın bir yolu yoktur.

Hata ayıklama amacıyla yapabileceğiniz en iyi şey, değerleri deyimin SQL dizesine enjekte ederek "gerçek" bir SQL sorgusunu "yeniden yapılandırmak" tır.

Bu tür durumlarda genellikle yaptığım şey:

• ifadeye karşılık gelen SQL kodunu yer tutucularla yankılama
• ve parametrelerin değerlerini görüntülemek için hemen sonra var_dump (veya eşdeğerini) kullanın
• Bu, yürütebileceğiniz herhangi bir "gerçek" sorgunuz olmasa bile, olası bir hatayı görmek için genellikle yeterlidir.

Hata ayıklama söz konusu olduğunda bu harika değil - ancak hazırlanan ifadelerin fiyatı ve getirdikleri avantajlar.

Veritabanı günlüğüne bakma

Pascal MARTIN , PDO'nun tam sorguyu bir kerede veritabanına göndermediği konusunda doğru olmasına rağmen , ryeguy'un DB'nin günlük işlevini kullanma önerisi, tam sorguyu veritabanı tarafından birleştirilmiş ve yürütülmüş olarak görmemi sağladı.

İşte yapmanız gerekenler: (Bu talimatlar bir Windows makinesindeki MySQL içindir - kilometreniz değişebilir)

• In my.inialtında [mysqld]bölümünde, bir ekleme loggibi komutulog="C:\Program Files\MySQL\MySQL Server 5.1\data\mysql.log"
• MySQL'i yeniden başlatın.
• Bu dosyadaki her sorguyu günlüğe kaydetmeye başlar.

Bu dosya hızlı bir şekilde büyüyecektir, bu nedenle sildiğinizden ve testi tamamladığınızda günlüğe kaydetmeyi kapattığınızdan emin olun.

Bu modu kullanarak hata ayıklayabilirsiniz Tabii {{ PDO::ATTR_ERRMODE }} sorgunuzdan önce yeni satır ekleyin, sonra hata ayıklama satırlarını gösterecektir.

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

Muhtemelen yapmak istediğiniz şey deyim tutamacında debugDumpParams () kullanmaktır. Bunu, hazırlanmış sorguya değerleri bağladıktan sonra istediğiniz zaman çalıştırabilirsiniz ( execute()ifadeye gerek yoktur ).

Hazırlanan ifadeyi sizin için oluşturmaz, ancak parametrelerinizi gösterir.

Eski bir yazı ama belki birisi bunu yararlı bulacaktır;

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

İşte kısmındaki "Mark" tarafından bir yorumu da uyarlanabilir ve etkili SQL ne olacağını görmek için bir fonksiyon, var 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;
}

Hayır. PDO sorguları istemci tarafında hazırlanmaz. PDO sadece SQL sorgusu ve parametreleri veritabanı sunucusuna gönderir. Veritabanı (ikamesini yaptığı iştir ?'s). İki seçeneğiniz var:

• DB'nizin günlüğe kaydetme işlevini kullanın (ancak o zaman bile normalde en az Postgres ile iki ayrı ifade (yani, "son değil") olarak gösterilir)
• SQL sorgusu ve parametre belirleyicilerin çıktısını al

hata günlüklerini kontrol etme dışında hata görüntüleme hakkında neredeyse hiçbir şey söylenmedi, ancak oldukça yararlı bir işlevsellik var:

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

( kaynak bağlantısı )

bu kodun istisna mesajı veya başka türlü hata işleme olarak kullanılmak üzere değiştirilebileceği açıktır

örneğin şu pdo ifadesine sahipsiniz:

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

şimdi böyle bir dizi tanımlayarak yürütülen sorguyu alabilirsiniz:

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

İnternette arama yapmayı kabul edilebilir bir çözüm olarak buldum. PDO yerine farklı bir sınıf kullanılır ve sihirli fonksiyon çağrıları ile PDO fonksiyonları çağrılır. Bunun ciddi performans sorunları yarattığından emin değilim. Ancak PDO'ya mantıklı bir kayıt özelliği eklenene kadar kullanılabilir.

Bu iş parçacığına göre , PDO bağlantınız için bir hata aldığınızda günlüğe kaydedip bir istisna atabilecek bir sarıcı yazabilirsiniz.

İşte basit bir örnek:

class LoggedPDOSTatement extends PDOStatement    {

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

}

böylece PDOStatement yerine bu sınıfı kullanabilirsiniz:

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

Burada bahsedilen bir PDO dekoratör uygulaması:

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

}

MySQL giriş yapmak için WAMP , Düzenlemeye my.ini gerekir (ör altında wamp \ bin \ mysql \ mysql5.6.17 \ my.ini)

ve ekle [mysqld]:

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

İşte "çözülmüş" parametreleri ile bir SQL sorgusu döndürmek için yaptığım bir işlev.

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

Böyle yürüttüğünüzü varsayarsak

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

Bu işlev sorgulara tırnak işareti DEĞİLDİR ancak işi benim için yapar.

Hata ayıklama amacıyla PDO muafiyetlerini yakalamak için çözüm ile yaşadım sorun sadece PDO muafiyetlerini (duh) yakaladı, ancak php hataları olarak kaydedilen sözdizimi hatalarını yakalamadığıdır (bunun neden olduğundan emin değilim, ama " neden "çözümle alakasızdır). Tüm PDO çağrıları, tüm tablolarla tüm etkileşimlerim için genişlediğim tek bir tablo modeli sınıfından geliyor ... hata ayıklamaya çalıştığımda bu karmaşık şeyler, çünkü hata yürütme çağrımın olduğu php kod satırını kaydederdi aradım, ama aslında çağrının nereden yapıldığını söylemedi. Bu sorunu çözmek için aşağıdaki kodu kullandım:

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

Yani, yukarıdaki kod İKİ PDO istisnaları VE php sözdizimi hatalarını yakalar ve aynı şekilde davranır. Hata işleyicim şöyle görünür:

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

Herkes hata işleyiciye ilgili bilgi almak için tablo değişkeni bir genel değişken olarak ayarlamak daha iyi bir fikir varsa, duymak ve kodumu düzenlemek için mutlu olurdu.

bu kod benim için harika çalışıyor:

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

$ Verilerini ve $ sorgusunu adlarınızla değiştirmeyi unutmayın

PDO hata ayıklamak için bu sınıfı kullanın ( Log4PHP ile )

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

Burada tam olarak bunun için modern bir Composer yüklü proje / depo oluşturdum:

pdo-ayıklama

Projenin GitHub sayfasını burada bulun, burada açıklayan bir blog yayınına bakın . Composer.json'ınıza eklemek için bir satır ve sonra bunu şöyle kullanabilirsiniz:

echo debugPDO($sql, $parameters);

$ sql işlenmemiş SQL ifadesidir, $ parametreleri parametrelerinizin bir dizisidir: Anahtar, yer tutucu adı (": user_id") veya adlandırılmamış parametrenin ("?") sayısıdır, değer .. değer.

Arkasındaki mantık: Bu komut dosyası, parametreleri basitçe kademelendirir ve bunları sağlanan SQL dizesine değiştirir. Süper basit, ancak kullanım durumlarınızın% 99'u için süper etkilidir. Not: Bu sadece temel bir öykünmedir, gerçek bir PDO hata ayıklaması değildir (PHP ayrı ayrı MySQL sunucusuna ham SQL ve parametreler gönderdiğinden bu mümkün değildir).

StackOverflow iş parçacığından bigwebguy ve Mike'a büyük bir teşekkür . Temelde bu komut dosyasının arkasındaki tüm ana işlevi yazmak için PDO'dan ham SQL sorgu dizesi almak . Yukarı çık!

Ubuntu PDO MySQL veritabanı sorguları hata ayıklama

TL; DR Tüm sorgularınızı günlüğe kaydedin ve mysql günlüğünü kuyruğa alın.

Bu talimatlar Ubuntu 14.04 kurulumum içindir. lsb_release -aSürümünüzü almak için komut verin. Yüklemeniz farklı olabilir.

MySQL'de günlüğe kaydetmeyi açma

1. Dev sunucusu cmd hattınıza gidin
2. Dizinleri değiştirin cd /etc/mysql. Adlı bir dosya görmelisiniz my.cnf. Değiştireceğimiz dosya bu.
3. Yazarak doğru yerde olduğunuzu doğrulayın cat my.cnf | grep general_log. Bu my.cnfdosyayı sizin için filtreler . İki giriş görmelisiniz: #general_log_file = /var/log/mysql/mysql.log&& #general_log = 1.
4. Bu iki satırı açın ve seçtiğiniz düzenleyicinizle kaydedin.
5. Yeniden MySQL: sudo service mysql restart.
6. Web sunucunuzu da yeniden başlatmanız gerekebilir. (Kullandığım sırayı hatırlayamıyorum). Benim yüklemek için, o en nginx: sudo service nginx restart.

İyi iş! Hazırsınız. Uygulamanızın gerçek zamanlı yaptığı PDO sorgularını görebilmeniz için tek yapmanız gereken günlük dosyasını kuyruklamaktır.

Sorgularınızı görmek için günlüğü kuyruğa alın

Bu cmd'yi girin tail -f /var/log/mysql/mysql.log.

Çıktınız şöyle görünecektir:

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 

Günlüğünüzü kapatmaya devam ettiğiniz sürece, uygulamanızın yaptığı tüm yeni sorgular otomatik olarak görünecektir . Kuyruktan çıkmak için tuşuna basın cmd/ctrl c.

notlar

1. Dikkat: Bu günlük dosyası çok büyük olabilir. Bunu sadece geliştirme sunucumda çalıştırıyorum.
2. Günlük dosyası çok mu büyüyor? Kesin. Bu, dosyanın kaldığı anlamına gelir, ancak içerik silinir. truncate --size 0 mysql.log.
3. Günlük dosyasının mysql bağlantılarını listelediğini unutmayın. Bunlardan birinin geçiş yaptığım eski mysqli kodumdan olduğunu biliyorum. Üçüncüsü yeni PDO bağlantımdan. Ancak ikincinin nereden geldiğinden emin değilim. Bulmanın hızlı bir yolunu biliyorsanız, bana bildirin.

Kredi ve teşekkürler

İnsanın Ubuntu'da bunu çözmesi için Nathan Long'un yukarıdaki cevabına büyük bir bağırış . Ayrıca Nathan'ın gönderisine yaptığı yorum için beni bu çözüme götüren dikirill'e .

Stackoverflow seviyorum!

Debian NGINX ortamında aşağıdakileri yaptım.

Goto /etc/mysql/mysql.conf.ddüzenleme mysqld.cnfbulursanız log-error = /var/log/mysql/error.logaşağıdaki 2 satır onu feryat ekleyin.

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

Günlükleri görmek için gidin /var/log/mysqlve tail -f mysql.log

Eğer üretim ortamında iseniz hata ayıklama ile tamamlandıktan sonra bu satırları yorum unutmayın unutmayın mysql.logbu günlük dosyası hızla büyüyecek ve büyük olabilir.