Jak debugować zapytania do bazy danych PDO?

140

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?

Nathan Long
źródło
4
To jest rejestrowane w pliku: /var/log/mysql/*. Parametry związane z PDO nie mogą powodować błędów składniowych, więc wszystko, czego potrzebujesz, to przygotowane zapytanie SQL.
Xeoncross
1
zobacz kod na stackoverflow.com/questions/210564/… (nie w zaakceptowanej odpowiedzi). Nie żeby było kilka aktualizacji.
Mawg mówi, że przywróć Monikę
1
Prosta jedna linia przez Composer: github.com/panique/pdo-debug
Sliq.
2
Odpowiedź Xeoncross pomogła mi. Oto artykuł wyjaśniający, jak włączyć tę funkcję. Jest to domyślnie wyłączone w wielu instalacjach serwerów. pontikis.net/blog/how-and-when-to-enable-mysql-logs
mrbinky3000
2
Spróbuj zvar_dump($pdo_instance->debugDumpParams())
Daniel Petrovaliev,

Odpowiedzi:

99

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ą.

Pascal MARTIN
źródło
1
Świetne wyjaśnienie - dzięki. Najwyraźniej miałem tylko niejasne pomysły, jak to działa. Przypuszczam, że po przygotowaniu instrukcji wynikowy obiekt zawiera hash lub numeryczny identyfikator, który można odesłać do bazy danych z parametrami do podłączenia.
Nathan Long
Nie ma za co :-) ;;; Nie wiem, jak to jest szczegółowo zaimplementowane, ale przypuszczam, że to coś takiego - i tak rezultat jest dokładnie taki ;;; to jedna z fajnych rzeczy w przypadku przygotowanych instrukcji: jeśli będziesz musiał wykonywać to samo zapytanie wiele razy, zostanie ono wysłane tylko do bazy danych i przygotowane tylko raz: przy każdym wykonaniu zostaną wysłane tylko dane.
Pascal MARTIN
1
Aktualizacja: Aaron Patterson wspomniał na Railsconf 2011, że dodał więcej przygotowanych instrukcji do Railsów, ale korzyści są znacznie większe w PostgreSQL niż w MySQL. Powiedział, że dzieje się tak, ponieważ MySQL tak naprawdę nie tworzy planu zapytań, dopóki nie wykonasz przygotowanego zapytania.
Nathan Long,
85

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.

Nathan Long
źródło
1
Tylko uwaga - musiałem uniknąć cięć w my.ini. Tak więc mój wpis wyglądał jak log = "C: \\ temp \\ MySQL \\ mysql.log".
Jim
4
Może to działać w zależności od ustawienia PDO::ATTR_EMULATE_PREPARES. Zobacz tę odpowiedź, aby uzyskać więcej informacji: stackoverflow.com/questions/10658865/#answer-10658929
webbiedave
23
Z tego powodu nienawidzę PDO.
Salman
1
@webbiedave - o, wow! Twoja połączona odpowiedź oznacza, że ​​moja odpowiedź działa tylko wtedy, gdy PDO nie działa optymalnie, ale raczej wysyła całe zapytanie w celu zapewnienia zgodności wstecznej ze starą wersją MySQL lub starym sterownikiem. Ciekawy.
Nathan Long,
13
W MySQL 5.5+ potrzebujesz general_logzamiast log. Zobacz dev.mysql.com/doc/refman/5.5/en/query-log.html
Adrian Macneil,
18

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 *******');  
Saud Alfadhli
źródło
Nie dzwoniłbyś jednak, ->queryużywając przygotowanych instrukcji?
EoghanM
Dzięki, to bardzo mi pomogło! :)
rozpadło się
17

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.

fijiaaron
źródło
2
Jedynym problemem jest to, że wyprowadza debugowanie zamiast przechowywać je wewnętrznie bez „echa”. Nie mogę tego zarejestrować w ten sposób.
Ricardo Martins
3
Możesz użyć buforowania wyjścia (ob_start () ...) do przechowywania danych wyjściowych i rejestrowania ich.
Cranio
bugs.php.net/bug.php?id=52384 poprawione w 7.1 widać wartości :) trochę późno, ale to php
Sander Visser
12

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;
}
nie pytaj ponownie
źródło
1
Podobną funkcję, która może również obsługiwać parametry numeryczne, zobacz moją odpowiedź (dzięki komentatorowi na php.net).
Matt Browne,
9

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;
}
Matt Browne
źródło
Dlaczego „Mark” używa dwukropka przed $ k in str_replace(":$k" ....? Indeksy asocjacyjne już mają to w tablicy $ params.
Alan
Dobre pytanie ... to może to wyjaśnić: stackoverflow.com/questions/9778887/… . Osobiście użyłem tej funkcji do debugowania zapytań Doctrine i myślę, że Doctrine używa parametrów numerowanych zamiast nazwanych, więc nie zauważyłem tego problemu. Zaktualizowałem funkcję, aby teraz działała z dwukropkami na początku lub bez nich.
Matt Browne
uwaga, że to rozwiązanie zastępuje :name_longsię :name. Przynajmniej jeśli :namenastąpi wcześniej :name_long. Instrukcje przygotowane przez MySQL mogą sobie z tym poradzić, więc nie daj się zmylić.
Zim84
8

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
ryeguy
źródło
Nigdy nie pomyślałem, żeby sprawdzić log DB. Grzebię w katalogu MySQL i nie widzę żadnych plików dziennika, ale może logowanie jest opcją, którą muszę gdzieś włączyć.
Nathan Long
Tak, musisz to włączyć. Nie znam szczegółów, ale domyślnie nie rejestruje każdego zapytania.
ryeguy
5

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

Zippp
źródło
2
To jest zły sposób. PDO jest wystarczająco inteligentny, aby uczynić ten kod bezużytecznym. Po prostu powiedz mu, aby rzucał wyjątki w przypadku błędów. PHP zrobi resztę, znacznie lepiej niż ta ograniczona funkcja. Także, proszę , nie uczyć się, aby wydrukować wszystkie błędy bezpośrednio w przeglądarce. Są lepsze sposoby.
Twój zdrowy rozsądek
3
to jest oficjalna dokumentacja i oczywiście nikt nie zamierzał drukować tego błędu w produkcji, znowu jest to przykład z oficjalnej strony (php.net), zobacz link poniżej przykładu kodu. I na pewno znacznie lepiej jest użyć dodatkowych parametrów $ db-> setAttribute (PDO :: ATTR_ERRMODE, PDO :: ERRMODE_EXCEPTION) w ramach instancji PDO, ale niestety nie mogłeś mieć dostępu do tego kodu
Zippp
4

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;
Alireza
źródło
1
Pracował dla mnie. Wystąpił błąd w drugim przykładzie kodu: ));powinno być );(tylko jeden okrągły nawias).
Jasom Dotnet
2

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

}
bkilinc
źródło
2

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"
Spezi
źródło
1

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.

rezden
źródło
0

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.

Troy Knapp
źródło
0

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

user3553866
źródło
0

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);
    }
}
Janos Szabo
źródło
0

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!

Sliq
źródło
0

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='[email protected]' 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!

elbowlobstercowstand
źródło
0

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.

chan
źródło
nie wszyscy używają mysql.
Przerażający średnik