Búsqueda de sitios web

Cómo usar procedimientos almacenados en MySQL

El autor seleccionó el programa Write for DOnations.

Introducción

Por lo general, cuando trabaja con una base de datos relacional, emite DELETE individuales, directamente desde el código de su aplicación. Esas declaraciones funcionan y manipulan las tablas de bases de datos subyacentes directamente. Si se utilizan las mismas declaraciones o grupo de declaraciones dentro de varias aplicaciones que acceden a la misma base de datos, a menudo se duplican en aplicaciones individuales.

MySQL, al igual que muchos otros sistemas de administración de bases de datos relacionales, admite el uso de procedimientos almacenados. Los procedimientos almacenados ayudan a agrupar una o varias instrucciones SQL para su reutilización bajo un nombre común, encapsulando la lógica comercial común dentro de la propia base de datos. Tal procedimiento puede llamarse desde la aplicación que accede a la base de datos para recuperar o manipular datos de manera consistente.

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

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

requisitos previos

Para seguir esta guía, necesitará una computadora que ejecute un sistema de administración de bases de datos relacionales (RDBMS) basado en SQL. Las instrucciones y los ejemplos de esta guía se validaron utilizando el siguiente entorno:

  • Un servidor que ejecuta Ubuntu 20.04, con un usuario no raíz con privilegios administrativos y un firewall configurado con UFW, como se describe en nuestra guía de configuración inicial del servidor para Ubuntu 20.04.
  • MySQL instalado y protegido en el servidor, como se describe en el Paso 3.
  • Familiaridad básica con la ejecución de consultas SELECT para recuperar datos de la base de datos como se describe en nuestra guía Cómo SELECCIONAR filas DE tablas en SQL.

Nota: tenga en cuenta que muchos RDBMS utilizan sus propias implementaciones únicas de SQL y la sintaxis de los procedimientos almacenados no forma parte del estándar SQL oficial. Aunque los comandos descritos en este tutorial pueden funcionar en otros RDBMS, los procedimientos almacenados son específicos de la base de datos y, por lo tanto, la sintaxis o el resultado exactos pueden diferir si los prueba en un sistema que no sea MySQL.

También necesitará una base de datos vacía en la que podrá crear tablas que demuestren el uso de procedimientos almacenados. Le recomendamos que consulte la siguiente sección Conexión a MySQL y configuración de una base de datos de muestra para obtener detalles 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 muestra

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

Para esta guía, utilizará una colección de autos imaginarios. Almacenará detalles sobre los automóviles que posee actualmente, con su marca, modelo, año de fabricación y valor.

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

  1. ssh sammy@your_server_ip

Luego abra el indicador del servidor MySQL, reemplazando sammy con el nombre de su cuenta de usuario de MySQL:

  1. mysql -u sammy -p

Cree una base de datos llamada procedures:

  1. CREATE DATABASE procedures;

Si la base de datos se creó correctamente, recibirá un resultado como este:

Output
Query OK, 1 row affected (0.01 sec)

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

  1. USE procedures;

Recibirá el siguiente resultado:

Output
Database changed

Después de seleccionar la base de datos, puede crear tablas de muestra dentro de ella. La tabla cars contendrá datos simplificados sobre los coches en la base de datos. Contendrá las siguientes columnas:

  • marca: esta columna contiene la marca de cada automóvil propio, expresada mediante el tipo de datos varchar con un máximo de 100 caracteres.< /li>
  • modelo: esta columna contiene el nombre del modelo de automóvil, expresado con 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 el tipo de datos int para contener 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.

Cree la tabla de muestra con el siguiente comando:

  1. CREATE TABLE cars (

  2.     make varchar(100),

  3.     model varchar(100),

  4.     year int,

  5.     value decimal(10, 2)

  6. );

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

Output
Query OK, 0 rows affected (0.00 sec)

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

  1. INSERT INTO cars

  2. VALUES

  3. ('Porsche', '911 GT3', 2020, 169700),

  4. ('Porsche', 'Cayman GT4', 2018, 118000),

  5. ('Porsche', 'Panamera', 2022, 113200),

  6. ('Porsche', 'Macan', 2019, 27400),

  7. ('Porsche', '718 Boxster', 2017, 48880),

  8. ('Ferrari', '488 GTB', 2015, 254750),

  9. ('Ferrari', 'F8 Tributo', 2019, 375000),

  10. ('Ferrari', 'SF90 Stradale', 2020, 627000),

  11. ('Ferrari', '812 Superfast', 2017, 335300),

  12. ('Ferrari', 'GTC4Lusso', 2016, 268000);

La operación INSERTAR EN agregará diez autos deportivos de muestra a la mesa, con cinco modelos Porsche y cinco Ferrari. El siguiente resultado indica que se agregaron las cinco filas:

Output
Query OK, 10 rows affected (0.00 sec)
Records: 10  Duplicates: 0  Warnings: 0

Con eso, está listo para seguir el resto de la guía y comenzar a usar procedimientos almacenados en SQL.

Introducción a los procedimientos almacenados

Los procedimientos almacenados en MySQL y en muchos otros sistemas de bases de datos relacionales son objetos con nombre que contienen una o más instrucciones diseñadas y luego ejecutadas por la base de datos en una secuencia cuando se les llama. En el ejemplo más básico, un procedimiento almacenado puede guardar una declaración común bajo una rutina reutilizable, como recuperar datos de la base de datos con filtros de uso frecuente. Por ejemplo, podría crear un procedimiento almacenado para recuperar los clientes de la tienda en línea que realizaron pedidos en los últimos meses. En los escenarios más complejos, los procedimientos almacenados pueden representar programas extensos que describen una lógica comercial compleja para aplicaciones sólidas.

El conjunto de instrucciones en un procedimiento almacenado puede incluir declaraciones SQL comunes, como consultas INSERT, que devuelven o manipulan datos. Además, los procedimientos almacenados pueden hacer uso de:

  • Parámetros pasados al procedimiento almacenado o devueltos a través de él.
  • Variables declaradas para procesar los datos recuperados directamente dentro del código del procedimiento.
  • Declaraciones condicionales, que permiten la ejecución de partes del código del procedimiento almacenado dependiendo de ciertas condiciones, como las instrucciones IF o CASE.
  • Los bucles, como WHILE, LOOP y REPEAT, permiten ejecutar partes del código varias veces, como para cada fila en un conjunto de datos recuperados.
  • Instrucciones de manejo de errores, como devolver mensajes de error a los usuarios de la base de datos que acceden al procedimiento.
  • Llamadas a otros procedimientos almacenados en la base de datos.

Nota: la amplia sintaxis admitida por MySQL permite escribir programas robustos y resolver problemas complejos con procedimientos almacenados. Esta guía cubre solo el uso básico de los procedimientos almacenados con instrucciones SQL encerradas en el cuerpo del procedimiento almacenado y los parámetros de entrada y salida. La ejecución de código condicional, el uso de variables, bucles y el manejo personalizado de errores están fuera del alcance de esta guía. Le recomendamos que obtenga más información sobre los procedimientos almacenados en la documentación oficial de MySQL.

Cuando el procedimiento es llamado 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 apropiados para ejecutar el procedimiento dado. Este requisito de permisos proporciona una capa de seguridad, no permite el acceso directo a la base de datos y brinda a los usuarios acceso a procedimientos individuales que se garantiza que son seguros de ejecutar.

Los procedimientos almacenados se ejecutan directamente en el servidor de la base de datos, realizan todos los cálculos localmente y devuelven los resultados al usuario que llama solo cuando finaliza.

Si desea cambiar el comportamiento del procedimiento, puede actualizar el procedimiento en la base de datos, y las aplicaciones que lo utilizan tomarán automáticamente la nueva versión. Todos los usuarios comenzarán a utilizar inmediatamente el nuevo código de procedimiento sin necesidad de ajustar sus aplicaciones.

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

  1. DELIMITER //

  2. CREATE PROCEDURE procedure_name(parameter_1, parameter_2, . . ., parameter_n)

  3. BEGIN

  4.     instruction_1;

  5.     instruction_2;

  6.     . . .

  7.     instruction_n;

  8. END //

  9. DELIMITER ;

La primera y la última instrucción en este fragmento de código son DELIMITER // y DELIMITER ;. Por lo general, MySQL usa el símbolo de punto y coma (;) para delimitar declaraciones e indicar cuándo comienzan y terminan. Si ejecuta varias declaraciones en la consola de MySQL separadas por punto y coma, se tratarán como comandos separados y se ejecutarán de forma independiente, una tras otra. Sin embargo, el procedimiento almacenado puede incluir varios comandos que se ejecutarán secuencialmente cuando se llame. Esto plantea una dificultad al intentar decirle a MySQL que cree un nuevo procedimiento. El motor de la base de datos encontraría el signo de punto y coma en el cuerpo del procedimiento almacenado y pensaría que debería dejar de ejecutar la instrucción. En esta situación, la declaración prevista es todo el código de creación del procedimiento, no una sola instrucción dentro del procedimiento en sí, por lo que MySQL malinterpretaría sus intenciones.

Para evitar esta limitación, utilice el comando DELIMITER para cambiar temporalmente el delimitador de ; a // durante la duración del llamada CREAR PROCEDIMIENTO. Luego, todos los puntos y coma dentro del cuerpo del procedimiento almacenado se pasarán al servidor tal cual. Una vez finalizado todo el procedimiento, el delimitador se vuelve a cambiar a ; con el último DELIMITER;.

El corazón del código para crear un nuevo procedimiento es la llamada CREATE PROCEDURE seguida del nombre del procedimiento: procedure_name en el ejemplo. El nombre del procedimiento va seguido de una lista opcional de parámetros que aceptará el procedimiento. La última parte es el cuerpo del procedimiento, encerrado en declaraciones BEGIN y END. Dentro está el código del procedimiento, que puede contener una sola declaración SQL, como una consulta SELECT o un código más complejo.

El comando END termina con //, un delimitador temporal, en lugar del típico punto y coma.

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

Crear un procedimiento almacenado sin parámetros

En esta sección, creará su primer procedimiento almacenado encapsulando una sola instrucción SQL SELECT para devolver la lista de autos propios ordenados por su marca y valor en orden descendente.

Comience ejecutando la instrucción SELECT que va a utilizar:

  1. SELECT * FROM cars ORDER BY make, value DESC;

La base de datos devolverá la lista de autos de la tabla cars, primero ordenados por marca y luego, dentro de una sola marca, por valor en orden descendente:

Output
+---------+---------------+------+-----------+
| make    | model         | year | value     |
+---------+---------------+------+-----------+
| Ferrari | SF90 Stradale | 2020 | 627000.00 |
| Ferrari | F8 Tributo    | 2019 | 375000.00 |
| Ferrari | 812 Superfast | 2017 | 335300.00 |
| Ferrari | GTC4Lusso     | 2016 | 268000.00 |
| Ferrari | 488 GTB       | 2015 | 254750.00 |
| Porsche | 911 GT3       | 2020 | 169700.00 |
| Porsche | Cayman GT4    | 2018 | 118000.00 |
| Porsche | Panamera      | 2022 | 113200.00 |
| Porsche | 718 Boxster   | 2017 |  48880.00 |
| Porsche | Macan         | 2019 |  27400.00 |
+---------+---------------+------+-----------+
10 rows in set (0.00 sec)

El Ferrari más valioso está en la parte superior de la lista y el Porsche menos valioso aparece en la parte inferior.

Suponga que esta consulta se usará con frecuencia en varias aplicaciones o por varios usuarios y suponga que desea asegurarse de que todos usen exactamente la misma forma de ordenar los resultados. Para hacerlo, desea crear un procedimiento almacenado que guardará esa declaración en un procedimiento con nombre reutilizable.

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

  1. DELIMITER //

  2. CREATE PROCEDURE get_all_cars()

  3. BEGIN

  4.     SELECT * FROM cars ORDER BY make, value DESC;

  5. END //

  6. DELIMITER ;

Como se describió en la sección anterior, el primer y último comando (DELIMITER // y DELIMITER ;) le dicen a MySQL que deje de tratar el carácter de punto y coma como el delimitador de instrucción durante la duración de creación de procedimiento.

El comando SQL CREATE PROCEDURE va seguido del nombre del procedimiento get_all_cars, que puede definir para describir mejor lo que hace el procedimiento. Después del nombre del procedimiento, hay un par de paréntesis () donde puede agregar parámetros. En este ejemplo, el procedimiento no utiliza parámetros, por lo que los paréntesis están vacíos. Luego, entre los comandos BEGIN y END que definen el principio y el final del bloque de código del procedimiento, se escribe palabra por palabra la instrucción SELECT utilizada anteriormente.

Nota: Dependiendo de sus permisos de usuario de MySQL, puede recibir un error al ejecutar el comando CREATE PROCEDURE: ERROR 1044 (42000): acceso denegado para el usuario sammy@ localhost a los procedimientos de la base de datos. Para otorgar permisos para crear y ejecutar procedimientos almacenados a su usuario, inicie sesión en MySQL como root y ejecute los siguientes comandos, reemplazando el nombre de usuario y host de MySQL según sea necesario:

  1. GRANT CREATE ROUTINE, ALTER ROUTINE, EXECUTE on *.* TO 'sammy'@'localhost';

  2. FLUSH PRIVILEGES;

Después de actualizar los permisos de usuario, cierre sesión como root, vuelva a iniciar sesión como usuario y vuelva a ejecutar la instrucción CREATE PROCEDURE.

Puede obtener más información sobre la aplicación de permisos con respecto a los procedimientos almacenados a los usuarios de la base de datos en la documentación de rutinas almacenadas y privilegios de MySQL.

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

Output
Query OK, 0 rows affected (0.02 sec)

El procedimiento get_all_cars ahora está guardado en la base de datos, y cuando se le llame, ejecutará la declaración guardada tal cual.

Para ejecutar procedimientos almacenados guardados, puede usar el comando SQL CALL seguido del nombre del procedimiento. Intente ejecutar el procedimiento recién creado así:

  1. CALL get_all_cars;

El nombre del procedimiento, get_all_cars, es todo lo que necesita para utilizar el procedimiento. Ya no necesita escribir manualmente ninguna parte de la instrucción SELECT que utilizó anteriormente. La base de datos mostrará los resultados como la salida de la instrucción SELECT ejecutada antes:

Output
+---------+---------------+------+-----------+
| make    | model         | year | value     |
+---------+---------------+------+-----------+
| Ferrari | SF90 Stradale | 2020 | 627000.00 |
| Ferrari | F8 Tributo    | 2019 | 375000.00 |
| Ferrari | 812 Superfast | 2017 | 335300.00 |
| Ferrari | GTC4Lusso     | 2016 | 268000.00 |
| Ferrari | 488 GTB       | 2015 | 254750.00 |
| Porsche | 911 GT3       | 2020 | 169700.00 |
| Porsche | Cayman GT4    | 2018 | 118000.00 |
| Porsche | Panamera      | 2022 | 113200.00 |
| Porsche | 718 Boxster   | 2017 |  48880.00 |
| Porsche | Macan         | 2019 |  27400.00 |
+---------+---------------+------+-----------+
10 rows in set (0.00 sec)

Query OK, 0 rows affected (0.00 sec)

Ahora ha creado con éxito un procedimiento almacenado sin ningún parámetro que devuelve todos los autos de la tabla cars ordenados de una manera particular. Puede utilizar el procedimiento en varias aplicaciones.

En la siguiente sección, creará un procedimiento que acepte parámetros para cambiar el comportamiento del procedimiento según la entrada del usuario.

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

En esta sección, incluirá parámetros de entrada en la definición del procedimiento almacenado para permitir que los usuarios que ejecutan el procedimiento le pasen datos. Por ejemplo, los usuarios podrían proporcionar filtros de consulta.

El procedimiento almacenado creado anteriormente get_all_cars recuperaba todos los coches de la tabla cars en todo momento. Creemos otro procedimiento para encontrar automóviles de un año de fabricación determinado. Para permitir eso, definirá un parámetro con nombre en la definición del procedimiento.

Ejecute el siguiente código:

  1. DELIMITER //

  2. CREATE PROCEDURE get_cars_by_year(

  3.     IN year_filter int

  4. )

  5. BEGIN

  6.     SELECT * FROM cars WHERE year = year_filter ORDER BY make, value DESC;

  7. END //

  8. DELIMITER ;

Hay varios cambios en el código de creación de procedimientos de la sección anterior.

Primero, el nombre es get_cars_by_year, que describe el procedimiento: recuperar autos según su año de producción.

Los paréntesis que antes estaban vacíos ahora contienen una sola definición de parámetro: IN year_filter int. La palabra clave IN le dice a la base de datos que el usuario que llama pasará el parámetro dentro del procedimiento. El year_filter es un nombre arbitrario para el parámetro. Lo usará para hacer referencia al parámetro en el código de procedimiento. Finalmente, int es el tipo de datos. En este caso, el año de producción se expresa como un valor numérico.

El parámetro year_filter definido después del nombre del procedimiento aparece en la declaración SELECT en la cláusula WHERE year=year_filter, filtrando la tabla cars contra su año de producción.

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

Output
Query OK, 0 rows affected (0.02 sec)

Intente ejecutar el procedimiento sin pasarle ningún parámetro, tal como lo hizo anteriormente:

  1. CALL get_cars_by_year;

La base de datos MySQL devolverá un mensaje de error:

Error message
ERROR 1318 (42000): Incorrect number of arguments for PROCEDURE procedures.get_cars_by_year; expected 1, got 0

Esta vez, el procedimiento almacenado espera que se proporcione un parámetro, pero no se proporcionó 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 que espera el procedimiento. Para recuperar autos fabricados en 2017, ejecute:

  1. CALL get_cars_by_year(2017);

Ahora, el procedimiento llamado se ejecutará correctamente y devolverá la lista de autos de ese año:

Output
+---------+---------------+------+-----------+
| make    | model         | year | value     |
+---------+---------------+------+-----------+
| Ferrari | 812 Superfast | 2017 | 335300.00 |
| Porsche | 718 Boxster   | 2017 |  48880.00 |
+---------+---------------+------+-----------+
2 rows in set (0.00 sec)

Query OK, 0 rows affected (0.00 sec)

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

En la siguiente sección, usará 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 los dos ejemplos anteriores, los procedimientos almacenados que creó llamaron a una instrucción SELECT para obtener un conjunto de resultados. Pero en algunos casos, es posible que necesite un procedimiento almacenado que devuelva varios valores diferentes juntos en lugar de un único conjunto de resultados para una consulta individual.

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

Para hacerlo, puede usar los parámetros OUT al crear un nuevo procedimiento almacenado. Al igual que los parámetros IN, los parámetros OUT tienen nombres y tipos de datos asociados con ellos. Sin embargo, en lugar de pasar datos al procedimiento almacenado, el procedimiento almacenado puede llenarlos con datos para devolver valores al usuario que llama.

Cree un procedimiento get_car_stats_by_year que devolverá datos resumidos sobre los automóviles de un año de producción determinado utilizando parámetros de salida:

  1. DELIMITER //

  2. CREATE PROCEDURE get_car_stats_by_year(

  3.     IN year_filter int,

  4.     OUT cars_number int,

  5.     OUT min_value decimal(10, 2),

  6.     OUT avg_value decimal(10, 2),

  7.     OUT max_value decimal(10, 2)

  8. )

  9. BEGIN

  10.     SELECT COUNT(*), MIN(value), AVG(value), MAX(value)

  11.     INTO cars_number, min_value, avg_value, max_value

  12.     FROM cars

  13.     WHERE year = year_filter ORDER BY make, value DESC;

  14. END //

  15. DELIMITER ;

Esta vez, junto con el parámetro IN year_filter que se utiliza para filtrar los automóviles por año de producción, se definen cuatro parámetros OUT dentro del bloque de paréntesis. El parámetro cars_number se representa con el tipo de datos int y se utilizará para devolver el número de coches de la colección. 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 en la tabla cars). Estos se utilizarán para devolver información sobre los coches más baratos y más caros de la colección, así como el precio medio de todos los coches coincidentes.

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

Nota:

Para decirle a la base de datos que los resultados de esa consulta deben almacenarse en los parámetros de salida del procedimiento almacenado, se introduce una nueva palabra clave, INTO. Después de la palabra clave INTO, se enumeran los nombres de cuatro parámetros de procedimiento correspondientes a los datos recuperados. Con esto, MySQL guardará el valor COUNT(*) en el parámetro cars_number, el MIN(value) resultado en el parámetro min_value, y así sucesivamente.

La base de datos confirmará la creación exitosa del procedimiento:

Output
Query OK, 0 rows affected (0.02 sec)

Ahora, ejecute el nuevo procedimiento ejecutando:

  1. CALL get_car_stats_by_year(2017, @number, @min, @avg, @max);

Los cuatro nuevos parámetros comienzan con el signo @. Esos son nombres de variables locales en la consola MySQL que puede usar para almacenar datos temporalmente. Cuando los pasa al procedimiento almacenado que acaba de crear, el procedimiento insertará valores en esas variables.

La base de datos responderá con:

Output
Query OK, 1 row affected (0.00 sec)

Eso es diferente del comportamiento anterior, donde los resultados se mostraban inmediatamente en la pantalla. Esto se debe a que los resultados del procedimiento almacenado se guardaron en parámetros de salida y no se devolvieron como resultado de una consulta. Para acceder a los resultados, puede SELECCIONAR directamente en el shell de MySQL de la siguiente manera:

  1. SELECT @number, @min, @avg, @max;

Con esta consulta, está seleccionando valores de las variables locales, no llamando al procedimiento nuevamente. El procedimiento almacenado guardó sus resultados en esas variables y los datos permanecerán disponibles hasta que se desconecte del shell.

Nota:

La salida mostrará los valores de las variables consultadas:

Output
+---------+----------+-----------+-----------+
| @number | @min     | @avg      | @max      |
+---------+----------+-----------+-----------+
|       2 | 48880.00 | 192090.00 | 335300.00 |
+---------+----------+-----------+-----------+
1 row in set (0.00 sec)

Los valores corresponden a la cantidad de autos producidos en 2017, así como el valor de mercado mínimo, promedio y máximo de los autos de este año de producción.

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

Eliminación de procedimientos almacenados

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

A veces, es posible que el procedimiento que creó ya no sea necesario. En otras circunstancias, es posible que desee cambiar la forma en que funciona el procedimiento. MySQL no permite cambiar la definición del procedimiento después de la creación, por lo que la única forma de hacerlo es eliminar primero el procedimiento y volver a crearlo con los cambios deseados.

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

  1. DROP PROCEDURE get_car_stats_by_year;

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

Output
Query OK, 0 rows affected (0.02 sec)

Puede verificar que el procedimiento se eliminó al intentar llamarlo. Ejecutar:

  1. CALL get_car_stats_by_year(2017, @number, @min, @avg, @max);

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

Error message
ERROR 1305 (42000): PROCEDURE procedures.get_car_stats_by_year does not exist

En esta sección, ha aprendido a eliminar procedimientos almacenados existentes en la base de datos.

Conclusión

Al seguir esta guía, aprendió qué son los procedimientos almacenados y cómo usarlos en MySQL para guardar declaraciones reutilizables en procedimientos con nombre y ejecutarlos más tarde. Creó procedimientos almacenados sin parámetros y procedimientos que usan parámetros de entrada y salida para hacerlos más flexibles.

Puede usar procedimientos almacenados para crear rutinas reutilizables y unificar métodos para acceder a datos en varias aplicaciones, así como implementar comportamientos complejos que excedan las posibilidades que brindan las consultas SQL individuales. Este tutorial cubrió solo los conceptos básicos del uso de procedimientos almacenados. Para obtener más información al respecto, consulte la documentación de MySQL sobre procedimientos almacenados.

Si desea obtener más información sobre los diferentes conceptos relacionados con el lenguaje SQL y cómo trabajar con él, le recomendamos que consulte las otras guías de la serie Cómo usar SQL.