parametros - ¿Cómo se depuran los procedimientos almacenados de MySQL?

procedimientos almacenados mysql workbench

Question

Mi proceso actual para depurar procedimientos almacenados es muy simple. Creo una tabla llamada "depuración" donde inserto valores variables del procedimiento almacenado mientras se ejecuta. Esto me permite ver el valor de cualquier variable en un punto dado del guión, pero ¿hay una mejor manera de depurar los procedimientos almacenados de MySQL?

Answer 1

El depurador de mysql era bueno, pero no es gratis. Esto es lo que uso ahora:

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$

Uso en procedimiento almacenado:

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

uso del procedimiento almacenado:

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

Answer 2

El primer y estable depurador para MySQL está en dbForge Studio for MySQL

Answer 3

Hago algo muy similar a ti.

Por lo general, incluiré un parametro DEBUG que por defecto es falso y puedo establecerlo como verdadero en tiempo de ejecución. A continuación, ajuste las instrucciones de depuración en un bloque "If DEBUG".

También uso una tabla de registro con muchos de mis trabajos para poder revisar los procesos y el tiempo. Mi código Debug sale también allí. Incluyo el nombre del parámetro de llamada, una breve descripción, recuentos de filas afectados (si corresponde), un campo de comentarios y una marca de tiempo.

Buenas herramientas de depuración es uno de los tristes errores de todas las plataformas SQL.

Answer 4

Hay herramientas de GUI para depurar procedimientos / funciones almacenados y scripts en MySQL. Una herramienta decente que dbForge Studio for MySQL tiene una gran funcionalidad y estabilidad.

Answer 5

He usado dos herramientas diferentes para depurar procedimientos y funciones:

1. dbForge - muchas GUI mysql funcional.
2. MyDebugger: herramienta especializada para la depuración ... herramienta práctica para la depuración. vote http://tinyurl.com/voteimg

Answer 6

Llego tarde a la fiesta, pero traje más cerveza:

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

Intenté, y parece bastante estable, admitir puntos de interrupción e inspección de variables.

No es una suite completa (solo 4,1 Mb) ¡pero me ayudó mucho!

Cómo funciona: se integra con tu cliente mysql (estoy usando Ubuntu 14.04) y luego de ejecutar:

$install
$setup yourFunctionName

Instala una nueva base de datos en su servidor, que controla el proceso de depuración. Asi que:

$debug yourFunctionName(''yourParameter'')

le dará la oportunidad de caminar paso a paso por su código, y "refrescar" sus variables para que pueda ver mejor lo que sucede dentro de su código.

Consejo importante: durante la depuración, quizás cambie (vuelva a crear el procedimiento). Después de una recreación, ejecute: $ exit y $ setup antes de una nueva $ depuración

Esta es una alternativa a los métodos de "inserción" y "registro". Su código permanece libre de instrucciones adicionales de "depuración".

Captura de pantalla:

Answer 7

MySQL Connector / Net 6.6 tiene una función para depurar procedimientos almacenados y funciones

Instalando el depurador

Para habilitar el depurador de procedimientos almacenados:

• Para Connector / Net 6.6: Instalar Connector / Net 6.6 y elegir la opción Complete.
• Para Connector / Net 6.7 y posterior: Instale el producto MySQL para Visual Studio, al que pertenece el depurador de procedimientos almacenados.

Iniciando el Depurador

Para iniciar el depurador, siga estos pasos:

• Elija una conexión en el Visual Studio Server Explorer.
• Expanda la carpeta Procedimientos almacenados. Solo los procedimientos almacenados se pueden depurar directamente. Para depurar una función definida por el usuario, crea un archivo almacenado
  procedimiento que llama a la función.
• Haga clic en un nodo de procedimiento almacenado, luego haga clic derecho y desde el menú contextual seleccione la rutina de depuración.

Answer 8

MySql Connector / NET también incluye un depurador de procedimientos almacenados integrado en Visual Studio a partir de la versión 6.6. Puede obtener el instalador y la fuente aquí: http://dev.mysql.com/downloads/connector/net/

Algunas documentaciones / capturas de pantalla: https://dev.mysql.com/doc/connector-net/en/connector-net-visual-studio-debugger.html

Puede seguir los anuncios aquí: http://forums.mysql.com/read.php?38,561817,561817#msg-561817

DESCARGO DE RESPONSABILIDAD: Yo fui el desarrollador que creó el motor de depuración de procedimientos almacenados para MySQL para el producto Visual Studio.

Answer 9

Otra forma se presenta aquí

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

con procedimientos personalizados de depuración mySql y tablas de registro.

También puede simplemente colocar una simple selección en su código y ver si se ejecuta.

SELECT ''Message Text'' AS `Title`;

Tengo esta idea de

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

También alguien creó una plantilla para procedimientos de depuración personalizados en GitHub.

Mira aquí

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

Fue mencionado aquí

¿Cómo atrapar cualquier excepción en desencadenantes y procedimientos de almacenamiento para mysql?

Answer 10

Respuesta correspondiente a @Brad Parks No estoy seguro de la versión de MySQL, pero la mía era 5.6, por lo tanto, un poco de ajuste funciona:

debug_msg una función debug_msg que es función (no procedimiento) y devuelve texto (sin límite de caracteres) y luego llamo a la función como SELECT debug_msg (params) AS my_res_set , código de la siguiente manera:

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

Answer 11

Sí, hay herramientas especializadas para este tipo de cosas: MySQL Debugger .

Answer 12

Simplemente coloco declaraciones seleccionadas en áreas clave del procedimiento almacenado para verificar el estado actual de los conjuntos de datos y luego comentarlos (--select ...) o eliminarlos antes de la producción.

Answer 13

Toad mysql. Hay una versión gratuita http://www.quest.com/toad-for-mysql/

Answer 14

Cómo depurar un procedimiento almacenado de MySQL.

Depurador pobre del hombre:

1. Cree una tabla llamada logtable con dos columnas, id INT y log VARCHAR(255) .

2. Haga que la columna de identificación se autoincremente.

3. Use este procedimiento:

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

4. Coloque este código en cualquier lugar que desee para registrar un mensaje en la mesa.

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

Es un buen y pequeño registrador rápido y sucio para descubrir qué está pasando.

Answer 15

Se puede llamar al siguiente procedimiento debug_msg para que simplemente emita un mensaje de depuración en la consola:

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 BEGIN
select concat("** ", msg) AS ''** DEBUG:'';
END; 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 ;

Luego ejecuta la prueba de esta manera:

CALL test_procedure(1,2)

Dará como resultado la siguiente salida:

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