Wie debuggen Sie gespeicherte MySQL-Prozeduren?

Mein aktueller Prozess zum Debuggen gespeicherter Prozeduren ist sehr einfach. Ich erstelle eine Tabelle namens "debug", in die ich während der Ausführung Variablenwerte aus der gespeicherten Prozedur einfüge. Auf diese Weise kann ich den Wert einer Variablen an einem bestimmten Punkt im Skript anzeigen. Gibt es jedoch eine bessere Möglichkeit, gespeicherte MySQL-Prozeduren zu debuggen?

Ich mache dir etwas sehr ähnliches.

Normalerweise füge ich einen DEBUG-Parameter hinzu, der standardmäßig false ist, und ich kann zur Laufzeit auf true setzen. Wickeln Sie dann die Debug-Anweisungen in einen "If DEBUG" -Block.

Ich verwende auch eine Protokollierungstabelle mit vielen meiner Jobs, damit ich Prozesse und das Timing überprüfen kann. Dort wird auch mein Debug-Code ausgegeben. Ich füge den Namen des aufrufenden Parameters, eine kurze Beschreibung, die Anzahl der betroffenen Zeilen (falls zutreffend), ein Kommentarfeld und einen Zeitstempel hinzu.

Gute Debugging-Tools sind einer der traurigen Fehler aller SQL-Plattformen.

Die folgende debug_msgProzedur kann aufgerufen werden, um einfach eine Debug-Nachricht an die Konsole auszugeben:

DELIMITER $$

DROP PROCEDURE IF EXISTS `debug_msg`$$
DROP PROCEDURE IF EXISTS `test_procedure`$$

CREATE PROCEDURE debug_msg(enabled INTEGER, msg VARCHAR(255))
BEGIN
  IF enabled THEN
    select concat('** ', msg) AS '** DEBUG:';
  END IF;
END $$

CREATE PROCEDURE test_procedure(arg1 INTEGER, arg2 INTEGER)
BEGIN
  SET @enabled = TRUE;

  call debug_msg(@enabled, 'my first debug message');
  call debug_msg(@enabled, (select concat_ws('','arg1:', arg1)));
  call debug_msg(TRUE, 'This message always shows up');
  call debug_msg(FALSE, 'This message will never show up');
END $$

DELIMITER ;

Führen Sie den Test dann folgendermaßen aus:

CALL test_procedure(1,2)

Dies führt zu folgender Ausgabe:

** DEBUG:
** my first debug message
** DEBUG:
** arg1:1
** DEBUG:
** This message always shows up

Ja, es gibt spezielle Tools für diese Art von Dingen - MySQL Debugger .

So debuggen Sie eine gespeicherte MySQL-Prozedur.

Debugger des armen Mannes:

1. Erstellen Sie eine Tabelle namens logtable mit zwei Spalten. id INT und log VARCHAR(255).

2. Führen Sie eine automatische Inkrementierung der ID-Spalte durch.

3. Verwenden Sie dieses Verfahren:

   delimiter //
   DROP PROCEDURE `log_msg`//
   CREATE PROCEDURE `log_msg`(msg VARCHAR(255))
   BEGIN
       insert into logtable select 0, msg;
   END

4. Platzieren Sie diesen Code an einer beliebigen Stelle, an der Sie eine Nachricht in der Tabelle protokollieren möchten.

   call log_msg(concat('myvar is: ', myvar, ' and myvar2 is: ', myvar2));

Es ist ein netter schneller und schmutziger kleiner Logger, um herauszufinden, was los ist.

Es gibt GUI-Tools zum Debuggen gespeicherter Prozeduren / Funktionen und Skripte in MySQL. Ein anständiges Tool, das dbForge Studio für MySQL bietet und über umfangreiche Funktionen und Stabilität verfügt.

Der Debugger für MySQL war gut, aber nicht kostenlos. Das benutze ich jetzt:

DELIMITER GO$

DROP PROCEDURE IF EXISTS resetLog

GO$

Create Procedure resetLog() 
BEGIN   
    create table if not exists log (ts timestamp default current_timestamp, msg varchar(2048)) engine = myisam; 
    truncate table log;
END; 

GO$

DROP PROCEDURE IF EXISTS doLog 

GO$

Create Procedure doLog(in logMsg nvarchar(2048))
BEGIN  
  insert into log (msg) values(logMsg);
END;

GO$

Verwendung in gespeicherten Prozeduren:

call dolog(concat_ws(': ','@simple_term_taxonomy_id',  @simple_term_taxonomy_id));

Verwendung der gespeicherten Prozedur:

call resetLog ();
call stored_proc();
select * from log;

Ein anderer Weg wird hier vorgestellt

http://gilfster.blogspot.co.at/2006/03/debugging-stored-procedures-in-mysql.html

mit benutzerdefinierten Debug-MySQL-Prozeduren und Protokollierungstabellen.

Sie können auch einfach eine Auswahl in Ihren Code einfügen und prüfen, ob er ausgeführt wird.

SELECT 'Message Text' AS `Title`; 

Ich habe diese Idee von

http://forums.mysql.com/read.php?99,78155,78225#msg-78225

Außerdem hat jemand eine Vorlage für benutzerdefinierte Debug-Prozeduren auf GitHub erstellt.

Siehe hier

http://www.bluegecko.net/mysql/debugging-stored-procedures/ https://github.com/CaptTofu/Stored-procedure-debugging-routines

Wurde hier erwähnt

Wie kann man Ausnahmen in Triggern und Speicherprozeduren für MySQL abfangen?

Ich platziere einfach select-Anweisungen in Schlüsselbereichen der gespeicherten Prozedur, um den aktuellen Status von Datensätzen zu überprüfen, und kommentiere sie dann aus (--select ...) oder entferne sie vor der Produktion.

Ich bin zu spät zur Party, habe aber noch mehr Bier mitgebracht:

http://ocelot.ca/blog/blog/2015/03/02/the-ocelotgui-debugger/ und https://github.com/ocelot-inc/ocelotgui

Ich habe es versucht, und es scheint ziemlich stabil zu sein, Breakpoints und Variable Inspection zu unterstützen.

Es ist keine komplette Suite (nur 4,1 MB), hat mir aber sehr geholfen!

So funktioniert es: Es lässt sich in Ihren MySQL-Client integrieren (ich verwende Ubuntu 14.04) und nach der Ausführung:

$install
$setup yourFunctionName

Auf Ihrem Server wird eine neue Datenbank installiert, die den Debugging-Prozess steuert. So:

$debug yourFunctionName('yourParameter')

Sie haben die Möglichkeit, Schritt für Schritt durch Ihren Code zu gehen und Ihre Variablen zu "aktualisieren". So können Sie besser sehen, was in Ihrem Code vor sich geht.

Wichtiger Tipp: Während des Debuggens werden Sie möglicherweise Änderungen vornehmen (die Prozedur neu erstellen). Führen Sie nach einer Neuerstellung Folgendes aus: $ exit und $ setup vor einem neuen $ debug

Dies ist eine Alternative zu den Methoden "Einfügen" und "Protokollieren". Ihr Code bleibt frei von zusätzlichen "Debug" -Anweisungen.

Bildschirmfoto:

MySQL Connector / Net 6.6 bietet eine Funktion zum Debuggen gespeicherter Prozeduren und Funktionen

Debugger installieren

So aktivieren Sie den Debugger für gespeicherte Prozeduren:

• Für Connector / Net 6.6: Installieren Sie Connector / Net 6.6 und wählen Sie die Option Vollständig.
• Für Connector / Net 6.7 und höher: Installieren Sie das Produkt MySQL für Visual Studio, zu dem der Debugger für gespeicherte Prozeduren gehört.

Starten des Debuggers

Gehen Sie folgendermaßen vor, um den Debugger zu starten:

• Wählen Sie im Visual Studio Server Explorer eine Verbindung aus.
• Erweitern Sie den Ordner Gespeicherte Prozeduren. Nur gespeicherte Prozeduren können direkt debuggt werden. Erstellen Sie eine gespeicherte Funktion, um eine benutzerdefinierte Funktion zu debuggen
  Prozedur, die die Funktion aufruft.
• Klicken Sie auf einen Knoten für gespeicherte Prozeduren, klicken Sie mit der rechten Maustaste und wählen Sie im Kontextmenü die Option Debug-Routine.

MySql Connector / NET enthält auch einen Debugger für gespeicherte Prozeduren, der ab Version 6.6 in Visual Studio integriert ist. Das Installationsprogramm und die Quelle finden Sie hier: http://dev.mysql.com/downloads/connector/net/

Einige Dokumentationen / Screenshots: https://dev.mysql.com/doc/visual-studio/en/visual-studio-debugger.html

Sie können den Ankündigungen hier folgen: http://forums.mysql.com/read.php?38,561817,561817#msg-561817

UPDATE: MySql für Visual Studio wurde von Connector / NET in ein separates Produkt aufgeteilt. Sie können es (einschließlich des Debuggers) hier auswählen: https://dev.mysql.com/downloads/windows/visualstudio/1.2.html (noch) kostenlos & Open Source).

HAFTUNGSAUSSCHLUSS: Ich war der Entwickler, der die Debugger-Engine für gespeicherte Prozeduren für das Produkt MySQL for Visual Studio erstellt hat.

Der erste und stabile Debugger für MySQL befindet sich in dbForge Studio für MySQL

Ich hatte zwei verschiedene Tools zum Debuggen von Prozeduren und Funktionen verwendet:

1. dbForge - viele funktionale MySQL-GUI.
2. MyDebugger - spezialisiertes Tool zum Debuggen ... praktisches Tool zum Debuggen. Abstimmung http://tinyurl.com/voteimg

Die benutzerdefinierte MySQL-Variable (in der Sitzung freigegeben) kann als Protokollierungsausgabe verwendet werden:

DELIMITER ;;
CREATE PROCEDURE Foo(tableName VARCHAR(128))
BEGIN
  SET @stmt = CONCAT('SELECT * FROM ', tableName);
  PREPARE pStmt FROM @stmt;
  EXECUTE pStmt;
  DEALLOCATE PREPARE pStmt;
  -- uncomment after debugging to cleanup
  -- SET @stmt = null;
END;;
DELIMITER ;

call Foo('foo');
select @stmt;

wird ausgegeben:

SELECT * FROM foo

Kröte MySQL. Es gibt eine Freeware-Version http://www.quest.com/toad-for-mysql/

Antwort auf entsprechende diese durch @Brad Parks Nicht sicher über die MySQL - Version, aber ich war 5,6, also ein wenig Zwicken Werke:

Ich habe eine Funktion erstellt, debug_msgdie Funktion (keine Prozedur) ist und Text zurückgibt (keine Zeichenbeschränkung), und dann die Funktion als SELECT debug_msg(params) AS aufgerufen my_res_set, Code wie folgt :

CREATE DEFINER=`root`@`localhost` FUNCTION `debug_msg`(`enabled` INT(11), `msg` TEXT) RETURNS text CHARSET latin1
    READS SQL DATA
BEGIN
    IF enabled=1 THEN
    return concat('** DEBUG:', "** ", msg);
    END IF;
END

DELIMITER $$
CREATE DEFINER=`root`@`localhost` PROCEDURE `proc_func_call`(
 IN RegionID VARCHAR(20),
 IN RepCurrency INT(11),
 IN MGID INT(11),
 IN VNC VARCHAR(255)
)
BEGIN
    SET @enabled = TRUE;
    SET @mainQuery = "SELECT * FROM Users u";
    SELECT `debug_msg`(@enabled, @mainQuery) AS `debug_msg1`;
    SET @lastQuery = CONCAT(@mainQuery, " WHERE u.age>30);
    SELECT `debug_msg`(@enabled, @lastQuery) AS `debug_msg2`;
END $$
DELIMITER