Przed przejściem na PDO tworzyłem zapytania SQL w PHP, łącząc ciągi znaków. Jeśli wystąpił błąd składni bazy danych, mogłem po prostu powtórzyć końcowy ciąg zapytania SQL, wypróbować go samodzielnie w bazie danych i poprawić go, aż naprawię błąd, a następnie wstawić go z powrotem do kodu.

Przygotowane wyciągi PDO są szybsze, lepsze i bezpieczniejsze, ale przeszkadza mi jedno: nigdy nie widzę końcowego zapytania, gdy jest wysyłane do bazy danych. Kiedy otrzymuję błędy dotyczące składni w moim dzienniku Apache lub niestandardowym pliku dziennika (rejestruję błędy w catchbloku), nie widzę zapytania, które je spowodowało.

Czy istnieje sposób na przechwycenie całego zapytania SQL wysłanego przez PDO do bazy danych i zapisanie go do pliku?

Ty to mówisz :

Nigdy nie widzę ostatecznego zapytania wysyłanego do bazy danych

Cóż, właściwie w przypadku korzystania z przygotowanych instrukcji nie ma czegoś takiego jak „ ostateczne zapytanie ” :

• Najpierw do bazy danych jest wysyłana instrukcja i tam przygotowywana
  • Baza danych analizuje zapytanie i tworzy jego wewnętrzną reprezentację
• A kiedy łączysz zmienne i wykonujesz instrukcję, tylko zmienne są wysyłane do bazy danych
  • Baza danych „wstrzykuje” wartości do swojej wewnętrznej reprezentacji instrukcji

A więc odpowiadając na twoje pytanie:

Czy istnieje sposób na przechwycenie całego zapytania SQL wysłanego przez PDO do bazy danych i zapisanie go do pliku?

Nie: ponieważ nigdzie nie ma „ pełnego zapytania SQL ”, nie ma możliwości jego przechwycenia.

Najlepszą rzeczą, jaką możesz zrobić dla celów debugowania, jest „rekonstruowanie” „prawdziwego” zapytania SQL, poprzez wstrzyknięcie wartości do ciągu SQL instrukcji.

To, co zwykle robię w tego typu sytuacjach, to:

• odwzoruj kod SQL odpowiadający instrukcji, z symbolami zastępczymi
• i użyj var_dump (lub odpowiednika) tuż po, aby wyświetlić wartości parametrów
• Zwykle jest to wystarczające, aby zobaczyć możliwy błąd, nawet jeśli nie masz żadnego „prawdziwego” zapytania, które możesz wykonać.

Nie jest to świetne, jeśli chodzi o debugowanie - ale taka jest cena przygotowanych wyciągów i korzyści, jakie niosą.

Szukam w logu bazy danych

Chociaż Pascal MARTIN ma rację, że PDO nie wysyła od razu całego zapytania do bazy danych, sugestia ryeguy , aby użyć funkcji logowania bazy danych, faktycznie pozwoliła mi zobaczyć całe zapytanie jako złożone i wykonane przez bazę danych.

Oto jak: (Te instrukcje dotyczą MySQL na komputerze z systemem Windows - Twój przebieg może się różnić)

• W sekcji my.iniw [mysqld]sekcji dodaj logpolecenie, na przykładlog="C:\Program Files\MySQL\MySQL Server 5.1\data\mysql.log"
• Uruchom ponownie MySQL.
• Rozpocznie rejestrowanie każdego zapytania w tym pliku.

Ten plik będzie się szybko rozwijał, więc pamiętaj, aby go usunąć i wyłączyć rejestrowanie po zakończeniu testów.

Pewnie, że możesz debugować w tym trybie. {{ PDO::ATTR_ERRMODE }} Po prostu dodaj nową linię przed zapytaniem, a zobaczysz linie debugowania.

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

Prawdopodobnie to, co chcesz zrobić, to użyć debugDumpParams () na uchwycie instrukcji. Możesz to uruchomić w dowolnym momencie po powiązaniu wartości z przygotowanym zapytaniem (bez konieczności execute()wykonywania instrukcji).

Nie buduje przygotowanego zestawienia dla Ciebie, ale pokaże Twoje parametry.

Stary post, ale być może ktoś uzna to za przydatne;

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

Oto funkcja pozwalająca zobaczyć, jaki będzie efektywny SQL, zaadaptowana na podstawie komentarza „Mark” na 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;
}

Nie. Zapytania PDO nie są przygotowywane po stronie klienta. PDO po prostu wysyła zapytanie SQL i parametry do serwera bazy danych. Baza danych jest tym, co podstawia (z ?'s). Masz dwie możliwości:

• Użyj funkcji logowania swojej bazy danych (ale nawet wtedy jest ona zwykle wyświetlana jako dwie oddzielne instrukcje (tj. „Nie ostateczne”), przynajmniej w Postgres)
• Wyprowadź zapytanie SQL i parametry, a następnie połącz je samodzielnie

prawie nic nie zostało powiedziane o wyświetlaniu błędów poza sprawdzaniem dzienników błędów, ale istnieje dość przydatna funkcja:

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

( link do źródła )

jasne jest, że ten kod można zmodyfikować, aby był używany jako komunikat o wyjątku lub do innego rodzaju obsługi błędów

na przykład masz to oświadczenie 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,
));

teraz możesz uzyskać wykonane zapytanie, definiując tablicę w następujący sposób:

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

Szukając w Internecie, uznałem to za akceptowalne rozwiązanie. Zamiast funkcji PDO używana jest inna klasa, a funkcje PDO są wywoływane przez wywołania funkcji magicznych. Nie jestem pewien, czy stwarza to poważne problemy z wydajnością. Można go jednak używać do czasu dodania sensownej funkcji rejestrowania do PDO.

Tak więc zgodnie z tym wątkiem możesz napisać opakowanie dla połączenia PDO, które może rejestrować i zgłaszać wyjątek, gdy pojawi się błąd.

Oto prosty przykład:

class LoggedPDOSTatement extends PDOStatement    {

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

}

więc możesz użyć tej klasy zamiast PDOStatement:

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

Tutaj wspomniana implementacja dekoratora 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); 
}

}

Aby zalogować MySQL w WAMP , musisz edytować plik my.ini (np. W wamp \ bin \ mysql \ mysql5.6.17 \ my.ini)

i dodaj do [mysqld]:

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

Oto funkcja, którą wykonałem, aby zwrócić zapytanie SQL z „rozwiązanymi” parametrami.

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

Zakładając, że wykonasz w ten sposób

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

Ta funkcja NIE dodaje cytatów do zapytań, ale wykonuje to za mnie.

Problem, który miałem z rozwiązaniem do przechwytywania wyjątków PDO do celów debugowania polega na tym, że wychwycił on tylko wyłączenia PDO (duh), ale nie przechwycił błędów składniowych, które zostały zarejestrowane jako błędy php (nie jestem pewien, dlaczego tak jest, ale „ dlaczego ”nie ma znaczenia dla rozwiązania). Wszystkie moje wywołania PDO pochodzą z jednej klasy modelu tabeli, którą rozszerzyłem dla wszystkich moich interakcji ze wszystkimi tabelami ... to skomplikowane rzeczy, gdy próbowałem debugować kod, ponieważ błąd zarejestrowałby wiersz kodu php, w którym znajdowało się moje wywołanie wykonania zadzwonił, ale nie powiedział mi, skąd właściwie dzwoni. Użyłem poniższego kodu, aby rozwiązać ten problem:

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

Tak więc powyższy kod wyłapuje ZARÓWNO wyjątki PDO ORAZ błędy składniowe php i traktuje je w ten sam sposób. Mój program obsługi błędów wygląda mniej więcej tak:

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

Jeśli ktoś ma lepszy pomysł, jak uzyskać odpowiednie informacje do mojego modułu obsługi błędów niż ustawienie modelu tabeli jako zmiennej globalnej, byłbym szczęśliwy, słysząc to i edytując swój kod.

ten kod działa świetnie dla mnie:

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

Nie zapomnij zastąpić $ data i $ query swoimi nazwami

używam tej klasy do debugowania PDO (z 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);
    }
}

Stworzyłem nowoczesny projekt / repozytorium ładowane przez Composer dla dokładnie tego tutaj:

pdo-debug

Znajdź stronę główną projektu na GitHub tutaj , zobacz post na blogu wyjaśniający to tutaj . Jedna linia do dodania w pliku composer.json, a następnie możesz jej używać w następujący sposób:

echo debugPDO($sql, $parameters);

$ sql to nieprzetworzona instrukcja SQL, $ parameters to tablica twoich parametrów: klucz to nazwa symbolu zastępczego („: user_id”) lub numer nienazwanego parametru („?”), wartość to… cóż, wartość.

Logika stojąca za: ten skrypt po prostu oceni parametry i zamieni je na dostarczony ciąg SQL. Super proste, ale super skuteczne w 99% przypadków użycia. Uwaga: jest to tylko podstawowa emulacja, a nie prawdziwy debugowanie PDO (ponieważ nie jest to możliwe, ponieważ PHP wysyła surowy kod SQL i parametry do oddzielnego serwera MySQL).

Wielkie podziękowania dla bigwebguy i Mike'a z wątku StackOverflow Pobieranie surowego ciągu zapytania SQL z PDO za napisanie w zasadzie całej głównej funkcji tego skryptu. Big up!

Jak debugować zapytania bazy danych mysql PDO w Ubuntu

TL; DR Rejestruj wszystkie swoje zapytania i śledź dziennik mysql.

Te wskazówki dotyczą mojej instalacji Ubuntu 14.04. Wydaj polecenie, lsb_release -aaby pobrać swoją wersję. Twoja instalacja może wyglądać inaczej.

Włącz logowanie mysql

1. Przejdź do wiersza cmd serwera deweloperskiego
2. Zmień katalogi cd /etc/mysql. Powinieneś zobaczyć plik o nazwie my.cnf. To plik, który zamierzamy zmienić.
3. Wpisz, czy jesteś we właściwym miejscu cat my.cnf | grep general_log. To filtruje my.cnfplik za Ciebie. Powinieneś zobaczyć dwa wpisy: #general_log_file = /var/log/mysql/mysql.log&& #general_log = 1.
4. Odkomentuj te dwie linie i zapisz za pomocą wybranego edytora.
5. Mysql restart: sudo service mysql restart.
6. Konieczne może być również ponowne uruchomienie serwera internetowego. (Nie pamiętam sekwencji, której użyłem). Dla mojego zainstalować, to nginx: sudo service nginx restart.

Dobra robota! Wszystko gotowe. Teraz wszystko, co musisz zrobić, to dostosować plik dziennika, aby zobaczyć zapytania PDO, które tworzy Twoja aplikacja w czasie rzeczywistym.

Dostosuj dziennik, aby zobaczyć swoje zapytania

Wpisz to cmd tail -f /var/log/mysql/mysql.log.

Twój wynik będzie wyglądał mniej więcej tak:

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 

Wszelkie nowe zapytania wysyłane przez Twoją aplikację będą automatycznie wyświetlane , o ile będziesz kontynuować śledzenie dziennika. Aby wyjść z ogona, uderz cmd/ctrl c.

Uwagi

1. Uwaga: ten plik dziennika może być ogromny. Uruchamiam to tylko na moim serwerze deweloperskim.
2. Plik dziennika staje się zbyt duży? Obetnij to. Oznacza to, że plik pozostaje, ale zawartość jest usuwana. truncate --size 0 mysql.log.
3. Fajnie, że plik dziennika zawiera listę połączeń mysql. Wiem, że jeden z nich pochodzi z mojego starego kodu mysqli, z którego przechodzę. Trzeci pochodzi z mojego nowego połączenia PDO. Jednak nie jestem pewien, skąd pochodzi druga. Jeśli znasz szybki sposób, aby go znaleźć, daj mi znać.

Kredyt i podziękowania

Ogromne okrzyki do odpowiedzi Nathana Longa powyżej, aby inspo odkryło to w Ubuntu. Również dikirill za jego komentarz do posta Nathana, który doprowadził mnie do tego rozwiązania.

Uwielbiam Twój stackoverflow!

W środowisku Debian NGINX wykonałem następujące czynności.

Przejdź do /etc/mysql/mysql.conf.dedycji, mysqld.cnfjeśli znajdziesz log-error = /var/log/mysql/error.logponiżej następujące 2 wiersze.

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

Aby zobaczyć dzienniki, przejdź do /var/log/mysqli tail -f mysql.log

Pamiętaj, aby skomentować te linie, gdy skończysz debugowanie, jeśli jesteś w środowisku produkcyjnym, usuń, mysql.logponieważ ten plik dziennika szybko się rozrośnie i może być ogromny.