Cómo usar procedimientos almacenados en MySQL

Introducción

Normalmente, al trabajar con una base de datos relacional, se utilizan instrucciones SQL (Structured Query Language) para recuperar o manipular datos, como SELECT, INSERT, UPDATE o DELETE, directamente desde el código de la aplicación. Estas instrucciones operan directamente sobre las tablas de la base de datos subyacente y las manipulan. Si las mismas instrucciones o un mismo conjunto de instrucciones se utilizan en varias aplicaciones que acceden a la misma base de datos, suelen repetirse en cada aplicación.

MySQL, al igual que muchos otros sistemas de gestión de bases de datos relacionales, admite el uso de procedimientos almacenados. Estos procedimientos permiten agrupar una o más instrucciones SQL para su reutilización bajo un nombre común y encapsular la lógica de negocio común dentro de la propia base de datos. Un procedimiento de este tipo puede ser invocado desde una aplicación que accede a la base de datos para recuperar o manipular datos de forma consistente.

Mediante procedimientos almacenados, puede crear rutinas reutilizables para tareas comunes que se utilizarán en múltiples aplicaciones, validar datos o proporcionar una capa adicional de seguridad de acceso a los datos al restringir el acceso directo de los usuarios de la base de datos a las tablas subyacentes y la realización de consultas arbitrarias.

En este tutorial, aprenderá qué son los procedimientos almacenados y cómo crear procedimientos almacenados básicos que devuelvan datos y utilicen parámetros de entrada y salida.

Requisitos previos

Para seguir esta guía, necesita un ordenador con un sistema de gestión de bases de datos relacionales (SGBDR) basado en SQL. Las instrucciones y los ejemplos de esta guía se han validado en el siguiente entorno:

• Un servidor con Ubuntu 20.04, con un usuario sin privilegios de administrador pero con privilegios administrativos y un cortafuegos configurado con UFW.
• MySQL está instalado y protegido en el servidor.
• Introducción básica a la ejecución de consultas SELECT para recuperar datos de la base de datos.

Nota: Tenga en cuenta que muchos sistemas de gestión de bases de datos relacionales (SGBDR) utilizan su propia implementación de SQL y la sintaxis de los procedimientos almacenados no forma parte del estándar SQL oficial. Si bien los comandos mencionados en este tutorial pueden funcionar en otros SGBDR, los procedimientos almacenados son específicos de cada base de datos y, por lo tanto, la sintaxis o el resultado exactos pueden variar si los prueba en un sistema distinto a MySQL.

También necesitará una base de datos vacía en la que pueda crear tablas mediante procedimientos almacenados. Le recomendamos consultar la sección «Conexión a MySQL y configuración de una base de datos de ejemplo» que aparece a continuación para obtener más información sobre cómo conectarse a un servidor MySQL y crear la base de datos de prueba utilizada en los ejemplos de esta guía.

Conexión a MySQL y configuración de una base de datos de ejemplo

En esta sección, se conectará al servidor MySQL y creará una base de datos de ejemplo para que pueda utilizar los ejemplos de esta guía.

Para esta guía, utilizarás una colección de coches ficticia. Almacenarás información sobre los coches que posees actualmente, incluyendo su marca, modelo, año de fabricación y valor.

Si su sistema de base de datos SQL se ejecuta en un servidor remoto, conéctese a su servidor mediante SSH desde su máquina local:

ssh sammy@tu_ip_del_servidor

A continuación, abre la consola del servidor MySQL y sustituye Sami por tu nombre de usuario de MySQL:

mysql -u sammy -p

Crea una base de datos llamada procedimientos:

Procedimientos CREATE DATABASE;

Si la base de datos se creó correctamente, recibirá el siguiente resultado:

Resultado de la consulta correcto, 1 fila afectada (0,01 segundos)

Para seleccionar la base de datos de procedimientos, ejecute la siguiente instrucción USE:

UTILICE procedimientos;

Obtendrás el siguiente resultado:

La base de datos de salida cambió

Una vez seleccionada una base de datos, puede crear tablas de instancias dentro de ella. La tabla «máquinas» contendrá datos simplificados sobre las máquinas de la base de datos. Contiene las siguientes columnas:

• Marca: Esta columna representa cada automóvil que posee, expresado mediante el tipo de datos varchar con un máximo de 100 caracteres.
• Modelo: Esta columna contiene el nombre del modelo del coche, expresado mediante el tipo de datos varchar con un máximo de 100 caracteres.
• año: Esta columna almacena el año de fabricación del automóvil con un tipo de datos int para almacenar valores numéricos.
• Valor: Esta columna almacena el valor del coche utilizando el tipo de datos decimal con un máximo de 10 dígitos y 2 dígitos después del punto decimal.

Crea la tabla de ejemplo con el siguiente comando:

CREAR TABLA coches ( marca varchar(100), modelo varchar(100), año int, valor decimal(10, 2) );

Si se imprime el siguiente resultado, la tabla se ha creado correctamente:

Resultado de la consulta: OK, 0 filas afectadas (0.00 seg)

A continuación, cargue la tabla Cars con datos de muestra ejecutando la siguiente operación INSERT INTO:

INSERTAR EN coches VALORES ('Porsche', '911 GT3', 2020, 169700), ('Porsche', 'Cayman GT4', 2018, 118000), ('Porsche', 'Panamera', 2022, 113200), ('Porsche', 'Macan', 2019, 27400), ('Porsche', '718 Boxster', 2017, 48880), ('Ferrari', '488 GTB', 2015, 254750), ('Ferrari', 'F8 Tributo', 2019, 375000), ('Ferrari', 'SF90 Stradale', 2020, 627000), ('Ferrari', '812 Superfast', 2017, 335300), ('Ferrari', 'GTC4Lusso', 2016, 268000);

La operación INSERT INTO añade diez coches deportivos de muestra a la tabla, cinco modelos Porsche y cinco modelos Ferrari. El siguiente resultado muestra que se han añadido las cinco filas:

Resultado de la consulta correcto, 10 filas afectadas (0,00 seg) Registros: 10 Duplicados: 0 Advertencias: 0

Con esto, ya puedes seguir el resto de la guía y empezar a usar procedimientos almacenados en SQL.

Introducción a los procedimientos almacenados

En MySQL y muchos otros sistemas de bases de datos relacionales, los procedimientos almacenados se denominan objetos y contienen una o más instrucciones que se ejecutan secuencialmente cuando la base de datos los invoca. En el ejemplo más básico, un procedimiento almacenado puede guardar una expresión común en una rutina reutilizable, como la recuperación de datos de una base de datos mediante filtros de uso frecuente. Por ejemplo, se puede crear un procedimiento almacenado para recuperar los clientes de una tienda en línea que hayan realizado pedidos en los últimos meses. En los escenarios más complejos, los procedimientos almacenados pueden representar programas extensos que describen la lógica de negocio compleja para aplicaciones potentes.

El conjunto de instrucciones de un procedimiento almacenado puede incluir instrucciones SQL comunes, como consultas SELECT o INSERT, que devuelven o manipulan datos. Además, los procedimientos almacenados pueden utilizar lo siguiente:

• Los parámetros se pasan al procedimiento almacenado o se devuelven desde él.
• Variables declaradas para procesar los datos recuperados directamente en el código del procedimiento.
• Las sentencias condicionales permiten que se ejecuten secciones del código de un procedimiento almacenado dependiendo de ciertas condiciones, como las sentencias IF o CASE.
• Los bucles como WHILE, LOOP y REPEAT permiten que secciones de código se ejecuten varias veces, por ejemplo, para cada fila de un conjunto de datos recuperado.
• Instrucciones para el manejo de errores, como por ejemplo, devolver mensajes de error a los usuarios de la base de datos que tienen acceso al procedimiento.
• Llamar a otros procedimientos almacenados en la base de datos.

Nota: La amplia sintaxis que admite MySQL permite escribir programas potentes y resolver problemas complejos con procedimientos almacenados. Esta guía solo cubre el uso básico de los procedimientos almacenados con instrucciones SQL incluidas en el cuerpo del procedimiento, así como los parámetros de entrada y salida. La ejecución de código condicional, el uso de variables, los bucles y el manejo de errores personalizado no se tratan en esta guía. Le recomendamos consultar la documentación oficial de MySQL para obtener más información sobre los procedimientos almacenados.

Cuando se llama al procedimiento por su nombre, el motor de la base de datos lo ejecuta tal como está definido, instrucción por instrucción.

El usuario de la base de datos debe tener los permisos adecuados para ejecutar el procedimiento indicado. Este requisito de permisos proporciona una capa de seguridad, impidiendo el acceso directo a la base de datos, pero permitiendo a los usuarios acceder a procedimientos individuales que se pueden ejecutar de forma segura.

Los procedimientos almacenados se ejecutan directamente en el servidor de la base de datos, realizando todos los cálculos localmente y devolviendo los resultados al usuario que los invocó solo una vez finalizados.

Si desea modificar el comportamiento de un procedimiento, puede actualizarlo en la base de datos y las aplicaciones que lo utilizan recibirán automáticamente la nueva versión. Todos los usuarios comenzarán a usar el nuevo código del procedimiento de inmediato, sin necesidad de ajustar sus aplicaciones.

Esta es la estructura general del código SQL utilizado para crear un procedimiento almacenado:

DELIMITER // CREATE PROCEDURE nombre_procedimiento(parámetro_1, parámetro_2, . . ., parámetro_n) BEGIN instrucción_1; instrucción_2; . . . instrucción_n; END // DELIMITER ;

Las instrucciones inicial y final de este fragmento de código son DELIMITER // y DELIMITER ;. MySQL suele usar el punto y coma (;) para delimitar las sentencias e indicar su inicio y fin. Si se ejecutan varios comandos en la consola de MySQL, separados por punto y coma, se tratan como comandos independientes y se ejecutan uno tras otro. Sin embargo, un procedimiento almacenado puede contener varios comandos que se ejecutan secuencialmente al ser invocados. Esto provoca un problema al intentar crear un nuevo procedimiento en MySQL. El motor de la base de datos encuentra el punto y coma en el cuerpo del procedimiento almacenado y cree que debe detener la ejecución del comando. En este caso, el comando en cuestión es el código completo de creación del procedimiento, no una instrucción individual dentro del procedimiento, por lo que MySQL interpreta erróneamente la intención.

Para superar esta limitación, utilice la instrucción DELIMITER para cambiar temporalmente el delimitador de ; a // durante la ejecución de la llamada a CREATE PROCEDURE. A continuación, todos los puntos y comas dentro del cuerpo del procedimiento almacenado se envían al servidor tal cual. Una vez finalizado el procedimiento, el delimitador vuelve a ser ; con el último DELIMITER ;.

La parte central del código para crear un nuevo procedimiento es la llamada a `CREATE PROCEDURE`, seguida del nombre del procedimiento: `procedure_name` en el ejemplo. A continuación, se incluye una lista opcional de parámetros que el procedimiento acepta. Finalmente, se encuentra el cuerpo del procedimiento, delimitado por las instrucciones `BEGIN` y `END`. Dentro del código del procedimiento se puede incluir una instrucción SQL, como una consulta `SELECT`, o código más complejo.

El comando END termina con //, un separador temporal, en lugar de un punto y coma regular.

En la siguiente sección, creará un procedimiento almacenado básico sin parámetros que encapsula una consulta.

Creación de un procedimiento almacenado sin parámetros

En esta sección, creará su primer procedimiento almacenado que contiene una instrucción SQL SELECT para devolver una lista de automóviles propiedad de un propietario, ordenados por marca y su valor en orden descendente.

Comience ejecutando la instrucción SELECT que desea utilizar:

SELECCIONAR * DE coches ORDENAR POR marca, valor DESC;

La base de datos devuelve una lista de coches de la tabla Coches, primero por marca y luego, dentro de cada marca, por valor en orden descendente:

Salida +---------+---------------+------+-----------+ | hacer modelo | año | valor | +---------+---------------+------+-----------+ | Ferrari | SF90 Stradale 2020 | 627000.00 | | Ferrari | F8 Tributo 2019 | 375000.00 | | Ferrari | 812 súper rápido | 2017 | 335300.00 | | Ferrari | GTC4 Lusso 2016 | 268000,00 | | Ferrari | 488 GTB | 2015 | 254750,00 | | Porsche 911 GT3 | 2020 | 169700.00 | | Porsche Caymán GT4 | 2018 | 118000.00 | | Porsche Panamera 2022 | 113200.00 | | Porsche 718 Boxster | 2017 | 48880.00 | | Porsche Macan | 2019 | 27400.00 | +---------+---------------+------+-----------+ 10 filas en el conjunto (0.00 seg)

El Ferrari más valioso se encuentra en la parte superior de la lista, y el Porsche menos valioso en la parte inferior.

Supongamos que esta consulta se usa repetidamente en varias aplicaciones o por varios usuarios, y que desea asegurarse de que todos usen el mismo método para ordenar los resultados. Para ello, desea crear un procedimiento almacenado que almacene esa expresión en un procedimiento con nombre reutilizable.

Para crear este procedimiento almacenado, ejecute el siguiente fragmento de código:

DELIMITER // CREATE PROCEDURE get_all_cars() BEGIN SELECT * FROM cars ORDER BY make, value DESC; END // DELIMITER ;

Como se explicó en la sección anterior, las primeras y últimas instrucciones (DELIMITER // y DELIMITER 😉) le indican a MySQL que ignore el carácter punto y coma como separador de instrucciones durante la creación del procedimiento.

La instrucción SQL CREATE PROCEDURE va seguida del nombre del procedimiento get_all_cars, que puede definirse para describir mejor su función. Tras el nombre del procedimiento, hay un par de paréntesis () donde se pueden añadir parámetros. En este ejemplo, el procedimiento no utiliza parámetros, por lo que los paréntesis están vacíos. A continuación, entre las instrucciones BEGIN y END, que definen el inicio y el final del bloque de código del procedimiento, se escribe la instrucción SELECT utilizada anteriormente tal cual.

La base de datos responderá con un mensaje de éxito:

Resultado de la consulta: OK, 0 filas afectadas (0,02 segundos)

El procedimiento get_all_cars ahora está almacenado en la base de datos y, cuando se le llama, ejecuta la instrucción almacenada tal cual.

Para ejecutar un procedimiento almacenado, puede usar el comando SQL CALL seguido del nombre del procedimiento. Intente ejecutar el procedimiento recién creado de la siguiente manera:

LLAMAR obtener_todos_los_coches;

El nombre del procedimiento, get_all_cars, es todo lo que necesita para usarlo. Ya no necesita escribir manualmente ninguna parte de la instrucción SELECT que usaba antes. La base de datos ejecuta los resultados tal como salen de la instrucción SELECT:

Salida +---------+---------------+------+-----------+ | hacer modelo | año | valor | +---------+---------------+------+-----------+ | Ferrari | SF90 Stradale 2020 | 627000.00 | | Ferrari | F8 Tributo 2019 | 375000.00 | | Ferrari | 812 súper rápido | 2017 | 335300.00 | | Ferrari | GTC4 Lusso 2016 | 268000,00 | | Ferrari | 488 GTB | 2015 | 254750,00 | | Porsche 911 GT3 | 2020 | 169700.00 | | Porsche Caymán GT4 | 2018 | 118000.00 | | Porsche Panamera 2022 | 113200.00 | | Porsche 718 Boxster | 2017 | 48880.00 | | Porsche Macan | 2019 | 27400.00 | +---------+---------------+------+-----------+ 10 filas en el conjunto (0.00 seg) Consulta correcta, 0 filas afectadas (0.00 seg)

Has creado correctamente un procedimiento almacenado sin parámetros que devuelve todos los coches de la tabla Coches ordenados de una forma específica. Puedes usar este método en varias aplicaciones.

En la siguiente sección, creará un procedimiento que acepta parámetros para cambiar el comportamiento del procedimiento en función de la entrada del usuario.

Creación de un procedimiento almacenado con parámetros de entrada

En esta sección, se agregan parámetros de entrada a la definición del procedimiento almacenado para permitir que los usuarios que ejecutan el procedimiento le pasen datos. Por ejemplo, los usuarios pueden proporcionar filtros de consulta.

El procedimiento almacenado anterior, `get_all_cars`, siempre recupera todos los coches de la tabla `cars`. Creemos otro procedimiento para encontrar coches de un año de fabricación determinado. Para ello, defina un parámetro llamado `get_all_cars` en la definición del procedimiento.

Ejecuta el siguiente código:

DELIMITER // CREATE PROCEDURE get_cars_by_year( IN year_filter int ) BEGIN SELECT * FROM cars WHERE year = year_filter ORDER BY make, value DESC; END // DELIMITER ;

Se han introducido varios cambios en el código de creación de procedimientos con respecto a la sección anterior.

En primer lugar, el nombre es get_cars_by_year, que describe el método: Recuperar coches en función de su año de fabricación.

Los paréntesis vacíos anteriores ahora contienen la definición de un parámetro: `IN year_filter int`. La palabra clave `IN` indica a la base de datos que el usuario que realiza la llamada está pasando el parámetro al procedimiento. `year_filter` es un nombre arbitrario para el parámetro. Se utilizará para referirse a él en el código del procedimiento. Finalmente, `int` es el tipo de dato. En este caso, el año de fabricación se expresa como un valor numérico.

El parámetro year_filter definido después del nombre del procedimiento aparece en la instrucción SELECT en la cláusula WHERE year = year_filter y filtra la tabla de automóviles por su año de fabricación.

La base de datos responderá una vez más con un mensaje de éxito:

Resultado de la consulta: OK, 0 filas afectadas (0,02 segundos)

Intenta ejecutar el procedimiento sin pasarle ningún parámetro, igual que antes:

LLAMAR obtener_coches_por_año;

La base de datos MySQL devuelve un mensaje de error:

Mensaje de error ERROR 1318 (42000): Número incorrecto de argumentos para el PROCEDIMIENTO procedures.get_cars_by_year; se esperaba 1, se recibió 0

En este caso, el procedimiento almacenado espera que se le proporcione un parámetro, pero no se le ha proporcionado ninguno. Para llamar a un procedimiento almacenado con parámetros, puede proporcionar los valores de los parámetros entre paréntesis en el mismo orden en que el procedimiento los espera. Para recuperar los coches fabricados en 2017, ejecute lo siguiente:

LLAMAR obtener_coches_por_año(2017);

Ahora el procedimiento llamado se ejecuta correctamente y devuelve la lista de coches de ese año:

Salida +---------+---------------+------+-----------+ | marca modelo | año | valor | +---------+---------------+------+-----------+ | Ferrari | 812 Superfast | 2017 | 335300.00 | | Porsche 718 Boxster | 2017 | 48880.00 | +---------+---------------+------+-----------+ 2 filas en el conjunto (0.00 seg) Consulta correcta, 0 filas afectadas (0.00 seg)

En este ejemplo, aprendió cómo pasar parámetros de entrada a procedimientos almacenados y cómo utilizarlos en consultas dentro de un procedimiento para proporcionar opciones de filtro.

En la siguiente sección, utilizará parámetros de salida para crear procedimientos que devuelvan múltiples valores diferentes en una sola ejecución.

Creación de un procedimiento almacenado con parámetros de entrada y salida

En ambos ejemplos anteriores, los procedimientos almacenados que creó llamaron a la instrucción SELECT para devolver un conjunto de resultados. Sin embargo, en algunos casos, es posible que necesite un procedimiento almacenado que devuelva varios valores diferentes en conjunto, en lugar de un único conjunto de resultados para una consulta.

Supongamos que desea crear un procedimiento que proporcione información resumida sobre los automóviles de un año determinado, incluyendo el número de automóviles en la colección y su valor de mercado (mínimo, máximo y promedio).

Para ello, puede usar parámetros OUT al crear un nuevo procedimiento almacenado. Al igual que los parámetros IN, los parámetros OUT tienen un nombre y un tipo de datos asociados. Sin embargo, en lugar de pasar datos al procedimiento almacenado, se pueden rellenar con datos del procedimiento almacenado para devolver valores al usuario que realiza la llamada.

Crea un procedimiento get_car_stats_by_year que devuelva datos resumidos de los coches de un año de producción determinado, utilizando los siguientes parámetros de salida:

DELIMITER // CREATE PROCEDURE get_car_stats_by_year( IN year_filter int, OUT cars_number int, OUT min_value decimal(10, 2), OUT avg_value decimal(10, 2), OUT max_value decimal(10, 2) ) BEGIN SELECT COUNT(*), MIN(value), AVG(value), MAX(value) INTO cars_number, min_value, avg_value, max_value FROM cars WHERE year = year_filter ORDER BY make, value DESC; END // DELIMITER ;

En esta ocasión, además del parámetro de entrada `year_filter`, que se utiliza para filtrar los coches por año de fabricación, se definen cuatro parámetros de salida entre paréntesis. El parámetro `cars_number` es de tipo entero y devuelve el número de coches del conjunto. Los parámetros `min_value`, `avg_value` y `max_value` representan el valor de mercado y se definen con el tipo decimal (10, 2) (similar a la columna `value` de la tabla `cars`). Estos parámetros devuelven información sobre los coches más baratos y más caros del conjunto, así como el precio medio de todos los coches que coinciden con la búsqueda.

La instrucción SELECT busca cuatro valores en la tabla de coches utilizando funciones matemáticas SQL: COUNT para obtener el número total de coches y MIN, AVG y MAX para obtener los valores mínimo, promedio y máximo de la columna de valores.

Para indicar a la base de datos que los resultados de esa consulta deben almacenarse en los parámetros de salida del procedimiento almacenado, se ha introducido una nueva palabra clave llamada INTO. Tras la palabra clave INTO, se enumeran los nombres de los cuatro parámetros del procedimiento relacionados con los datos recuperados. Esto hará que MySQL almacene el valor de COUNT(*) en el parámetro cars_number, el resultado de MIN(value) en el parámetro min_value, y así sucesivamente.

La base de datos confirma la correcta creación del procedimiento:

Resultado de la consulta: OK, 0 filas afectadas (0,02 segundos)

Ahora ejecute la nueva rutina ejecutando lo siguiente:

LLAMAR obtener_estadísticas_de_automóvil_por_año(2017, @número, @min, @avg, @max);

Los cuatro nuevos parámetros comienzan con el símbolo @. Estos son los nombres de variables locales en la consola de MySQL que puede usar para almacenar datos temporalmente. Al pasarlos al procedimiento almacenado que creó, este inserta valores en dichas variables.

La base de datos responderá con lo siguiente:

Resultado de la consulta correcto, 1 fila afectada (0.00 seg)

Esto difiere del comportamiento anterior, donde los resultados se mostraban inmediatamente en pantalla. Esto se debe a que los resultados del procedimiento almacenado se guardan en parámetros de salida y no se devuelven como resultados de la consulta. Para acceder a los resultados, puede seleccionarlos directamente en la consola de MySQL de la siguiente manera:

SELECCIONAR @número, @mínimo, @promedio, @máximo;

Con esta consulta, se seleccionan valores de variables locales, en lugar de volver a llamar al procedimiento. El procedimiento almacenado guarda sus resultados en esas variables, y los datos están disponibles hasta que se cierra la sesión.

Nota: Para obtener más información sobre el uso de variables definidas por el usuario en MySQL, consulte la sección Variables definidas por el usuario de la documentación. En el desarrollo de aplicaciones, la forma de acceder a los datos devueltos por los procedimientos almacenados varía según el lenguaje de programación y el marco de trabajo. En caso de duda, consulte la documentación del lenguaje y el marco de trabajo que utilice.

La salida muestra los valores de las variables de consulta:

Salida +---------+----------+-----------+-----------+ | @número | @mínimo | @promedio | @máximo | +---------+----------+-----------+-----------+ | 2 48880.00 | 192090.00 | 335300.00 | +---------+----------+-----------+-----------+ 1 fila en el conjunto (0.00 seg)

Los valores corresponden al número de coches producidos en 2017, así como al valor de mercado mínimo, medio y máximo de los coches de ese año de producción.

En este ejemplo, aprendió a usar parámetros de salida para devolver varios valores diferentes desde un procedimiento almacenado para su uso posterior. En la siguiente sección, aprenderá a eliminar los procedimientos creados.

Eliminar procedimientos almacenados

En esta sección, eliminará los procedimientos almacenados en la base de datos.

En ocasiones, un procedimiento que hayas creado puede dejar de ser necesario. En otras ocasiones, es posible que desees modificar su funcionamiento. MySQL no permite modificar la definición de un procedimiento una vez creado, por lo que la única solución es eliminarlo y volver a crearlo con los cambios deseados.

Eliminemos el último procedimiento, get_car_stats_by_year. Para ello, puede utilizar la instrucción DROP PROCEDURE:

ELIMINAR PROCEDIMIENTO get_car_stats_by_year;

La base de datos confirma la eliminación exitosa del procedimiento con un mensaje de éxito:

Resultado de la consulta: OK, 0 filas afectadas (0,02 segundos)

Puede comprobar que el procedimiento se ha eliminado intentando llamarlo. Ejecutar:

LLAMAR obtener_estadísticas_de_automóvil_por_año(2017, @número, @min, @avg, @max);

Esta vez, verá un mensaje de error que indica que el procedimiento no existe en la base de datos:

Mensaje de error ERROR 1305 (42000): El procedimiento procedures.get_car_stats_by_year no existe.

En esta sección, aprendió cómo eliminar procedimientos almacenados de una base de datos.

Resultado

Siguiendo esta guía, aprendió qué son los procedimientos almacenados y cómo usarlos en MySQL para guardar instrucciones reutilizables en procedimientos con nombre y ejecutarlas posteriormente. Creó procedimientos almacenados sin parámetros y procedimientos con parámetros de entrada y salida para mayor flexibilidad.