Prima di passare a PDO, ho creato query SQL in PHP concatenando le stringhe. Se ho riscontrato l'errore di sintassi del database, potrei semplicemente echeggiare la stringa di query SQL finale, provarla sul database e modificarla fino a quando non ho risolto l'errore, quindi reinserirla nel codice.

Le istruzioni PDO preparate sono più veloci, migliori e più sicure, ma una cosa mi disturba: non vedo mai la query finale quando viene inviata al database. Quando ricevo errori sulla sintassi nel mio registro Apache o nel mio file di registro personalizzato (registro errori all'interno di un catchblocco), non riesco a vedere la query che li ha causati.

Esiste un modo per acquisire la query SQL completa inviata da PDO al database e registrarla in un file?

Dici questo:

Non vedo mai la query finale come viene inviata al database

Bene, in realtà, quando si usano istruzioni preparate, non esiste una " query finale " :

• Innanzitutto, una dichiarazione viene inviata al DB e preparata lì
  • Il database analizza la query e crea una rappresentazione interna di essa
• E, quando si associano le variabili e si esegue l'istruzione, solo le variabili vengono inviate al database
  • E il database "inietta" i valori nella sua rappresentazione interna dell'istruzione

Quindi, per rispondere alla tua domanda:

Esiste un modo per acquisire la query SQL completa inviata da PDO al database e registrarla in un file?

No: poiché non esiste una " query SQL completa " da nessuna parte, non è possibile acquisirla.

La cosa migliore che puoi fare, per scopi di debug, è "ricostruire" una query SQL "reale", iniettando i valori nella stringa SQL dell'istruzione.

Quello che faccio di solito, in questo tipo di situazioni, è:

• fare eco al codice SQL che corrisponde all'istruzione, con segnaposto
• e usare var_dump (o un equivalente) subito dopo, per visualizzare i valori dei parametri
• Questo è generalmente sufficiente per vedere un possibile errore, anche se non si dispone di alcuna query "reale" che è possibile eseguire.

Questo non è eccezionale, quando si tratta di debug, ma questo è il prezzo delle dichiarazioni preparate e dei vantaggi che apportano.

Cerca nel registro del database

Sebbene Pascal MARTIN abbia ragione sul fatto che PDO non invia la query completa al database in una sola volta, il suggerimento di ryeguy di utilizzare la funzione di registrazione del DB in realtà mi ha permesso di vedere la query completa come assemblata ed eseguita dal database.

Ecco come: (Queste istruzioni sono per MySQL su un computer Windows - il tuo chilometraggio può variare)

• In my.ini, sotto la [mysqld]sezione, aggiungi un logcomando, comelog="C:\Program Files\MySQL\MySQL Server 5.1\data\mysql.log"
• Riavvia MySQL.
• Inizierà a registrare ogni query in quel file.

Tale file crescerà rapidamente, quindi assicurati di eliminarlo e di disattivare la registrazione al termine del test.

Sicuro che puoi eseguire il debug usando questa modalità {{ PDO::ATTR_ERRMODE }} Aggiungi solo una nuova riga prima della tua query, quindi mostrerai le linee di debug.

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

Probabilmente quello che vuoi fare è usare debugDumpParams () sull'handle dell'istruzione . Puoi eseguirlo in qualsiasi momento dopo aver associato i valori alla query preparata (non è necessario per execute()l'istruzione).

Non crea l'istruzione preparata per te, ma mostrerà i tuoi parametri.

Un vecchio post ma forse qualcuno lo troverà utile;

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

Ecco una funzione per vedere quale sarà l'SQL efficace, adattato da un commento di "Mark" su 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;
}

No. Le query PDO non sono preparate sul lato client. PDO invia semplicemente la query SQL e i parametri al server di database. Il database è ciò che fa la sostituzione (del ?'s). Hai due opzioni:

• Usa la funzione di registrazione del tuo DB (ma anche in questo caso viene normalmente mostrato come due istruzioni separate (cioè "non finale") almeno con Postgres)
• Invia la query SQL e i parametri e mettila insieme tu stesso

non è stato detto quasi nulla sulla visualizzazione degli errori ad eccezione del controllo dei log degli errori, ma esiste una funzionalità piuttosto utile:

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

( link alla fonte )

è chiaro che questo codice può essere modificato per essere utilizzato come messaggio di eccezione o qualsiasi altro tipo di gestione degli errori

per esempio hai questa dichiarazione 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,
));

ora puoi ottenere la query eseguita definendo un array come questo:

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

Cercando su Internet ho trovato questa soluzione accettabile. Viene utilizzata una classe diversa anziché le funzioni DOP e PDO vengono chiamate tramite chiamate di funzioni magiche. Non sono sicuro che ciò crei gravi problemi di prestazioni. Ma può essere utilizzato fino a quando una funzione di registrazione sensibile non viene aggiunta a DOP.

Quindi, come per questo thread , puoi scrivere un wrapper per la tua connessione PDO che può registrare e genera un'eccezione quando ricevi un errore.

Ecco un semplice esempio:

class LoggedPDOSTatement extends PDOStatement    {

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

}

così puoi usare quella classe invece di PDOStatement:

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

Ecco una menzionata implementazione del decoratore DOP:

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

}

Per accedere a MySQL in WAMP , è necessario modificare my.ini (ad es. In wamp \ bin \ mysql \ mysql5.6.17 \ my.ini)

e aggiungi a [mysqld]:

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

Ecco una funzione che ho creato per restituire una query SQL con parametri "risolti".

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

Supponendo di eseguire in questo modo

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

Questa funzione NON aggiunge citazioni alle query ma fa il lavoro per me.

Il problema che ho avuto con la soluzione per catturare le esenzioni DOP a scopo di debug è che ha rilevato solo esenzioni DOP (duh), ma non ha rilevato errori di sintassi registrati come errori php (non sono sicuro del perché, ma " perché "è irrilevante per la soluzione). Tutte le mie chiamate PDO provengono da una singola classe del modello di tabella che ho esteso per tutte le mie interazioni con tutte le tabelle ... questo complicato cose quando stavo cercando di eseguire il debug del codice, perché l'errore avrebbe registrato la riga di codice php in cui era la mia chiamata di esecuzione ha chiamato, ma non mi ha detto da dove proveniva la chiamata. Ho usato il seguente codice per risolvere questo problema:

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

Quindi, il codice sopra coglie ENTRAMBE le eccezioni DOP E gli errori di sintassi php e le tratta allo stesso modo. Il mio gestore degli errori è simile al seguente:

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

Se qualcuno ha idee migliori su come ottenere informazioni rilevanti per il mio gestore errori rispetto all'impostazione del modello di tabella come variabile globale, sarei felice di ascoltarlo e modificare il mio codice.

questo codice funziona alla grande per me:

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

Non dimenticare di sostituire $ data e $ query con i tuoi nomi

uso questa classe per eseguire il debug di PDO (con 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);
    }
}

Ho creato un moderno progetto / repository caricato da Composer proprio per questo qui:

DOP-debug

Trova la home page del progetto GitHub qui , vedi un post sul blog che lo spiega qui . Una riga da aggiungere nel tuo composer.json e quindi puoi usarla in questo modo:

echo debugPDO($sql, $parameters);

$ sql è l'istruzione SQL non elaborata, $ parametri è un array di parametri: la chiave è il nome segnaposto (": user_id") o il numero del parametro senza nome ("?"), il valore è .. beh, il valore.

La logica dietro: questo script semplicemente classificherà i parametri e li sostituirà nella stringa SQL fornita. Super-semplice, ma super efficace per il 99% dei casi d'uso. Nota: questa è solo un'emulazione di base, non un vero debug PDO (in quanto ciò non è possibile poiché PHP invia SQL grezzi e parametri separati al server MySQL).

Un grande ringraziamento a bigwebguy e Mike dal thread StackOverflow Ottenere una stringa di query SQL non elaborata da PDO per aver scritto sostanzialmente l'intera funzione principale dietro questo script. Grande!

Come eseguire il debug delle query del database mysql DOP in Ubuntu

TL; DR Registra tutte le tue domande e modifica il registro mysql.

Queste indicazioni sono per la mia installazione di Ubuntu 14.04. Emettere il comando lsb_release -aper ottenere la versione. La tua installazione potrebbe essere diversa.

Attiva l'accesso a mysql

1. Vai alla riga cmd del tuo server di sviluppo
2. Cambia directory cd /etc/mysql. Dovresti vedere un file chiamato my.cnf. Questo è il file che cambieremo.
3. Verifica di essere nel posto giusto digitando cat my.cnf | grep general_log. Questo filtra il my.cnffile per te. Dovresti vedere due voci: #general_log_file = /var/log/mysql/mysql.log&& #general_log = 1.
4. Rimuovi il commento da queste due righe e salva tramite l'editor preferito.
5. Mysql restart: sudo service mysql restart.
6. Potrebbe essere necessario riavviare anche il tuo server web. (Non ricordo la sequenza che ho usato). Per la mia installazione, che di nginx: sudo service nginx restart.

Bel lavoro! Sei pronto. Ora tutto ciò che devi fare è mettere in coda il file di registro in modo da poter vedere le query PDO che l'app fa in tempo reale.

Coda il registro per vedere le tue domande

Inserisci questo cmd tail -f /var/log/mysql/mysql.log.

L'output sarà simile al seguente:

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 

Tutte le nuove query effettuate dall'app verranno automaticamente visualizzate , purché continui a modificare il registro. Per uscire dalla coda, premi cmd/ctrl c.

Appunti

1. Attenzione: questo file di registro può diventare enorme. Sto solo eseguendo questo sul mio server di sviluppo.
2. Il file di registro sta diventando troppo grande? Troncalo. Ciò significa che il file rimane, ma i contenuti vengono eliminati. truncate --size 0 mysql.log.
3. Bello che il file di registro elenchi le connessioni mysql. So che uno di questi proviene dal mio codice mysqli legacy da cui sto passando. Il terzo proviene dalla mia nuova connessione DOP. Tuttavia, non sono sicuro da dove provenga il secondo. Se conosci un modo rapido per trovarlo, fammelo sapere.

Credito e grazie

Enorme grido alla risposta di Nathan Long sopra per l'inspo per capirlo su Ubuntu. Anche a Dikirill per il suo commento sul post di Nathan che mi ha portato a questa soluzione.

Ti amo stackoverflow!

Nell'ambiente Debian NGINX ho fatto quanto segue.

Vai a /etc/mysql/mysql.conf.dmodifica mysqld.cnfse trovi log-error = /var/log/mysql/error.logaggiungi le seguenti 2 righe sotto.

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

Per vedere i registri vai a /var/log/mysqle tail -f mysql.log

Ricordarsi di commentare queste righe una volta terminato il debug se ci si trova nell'ambiente di produzione eliminando mysql.logpoiché questo file di registro crescerà rapidamente e può essere enorme.