Procedimientos almacenados
| ||||||
Procedimientos almacenados. Conjunto de comandos que pueden ser ejecutados directamente en el servidor, es decir, será ejecutado por el servidor de Base de Datos y no por el programa cliente que lo accede, permitiendo la ejecución de una acción o conjunto de acciones especificas.
Sumario
Características
Se almacenan en la propia Base de Datos y constituyen un objeto más dentro de esta. Tienden a mejorar el rendimiento de los sistemas producto a que reducen en intercambio entre cliente y servidor. Los procedimientos almacenados son reutilizables, de manera que los usuarios mediante la aplicación cliente no necesitan relanzar los comandos individuales, sino que pueden llamar el procedimiento para ejecutarlo en el servidor tantas veces como sea necesario.
Utilidades
Los procedimientos almacenados son muy útiles sobre todo en arquitecturas cliente/servidor donde hay un servidor muy potente el cual se puede aprovechar para ejecutar procesos, consultas y actualizaciones complejas en la base de datos.
Posibles usos que pueden darse a estos objetos de la base de datos
Por ejemplo, si deseamos obtener un reporte complejo que incluya instrucciones condicionales y cálculos complejos con datos obtenidos de varias tablas, un procedimiento almacenado es nuestro mejor aliado. También se pueden ejecutar complejos procesos que a veces tardan horas cuando son ejecutados desde el cliente, ya que en tales casos la información debe pasar del servidor al cliente y viceversa.
Casi siempre las computadoras servidores son poderosas máquinas con mucha memoria, discos rápidos y uno o más procesadores también muy rápidos. Por lo tanto, al ejecutar los procesos mediante procedimientos almacenados estamos aprovechando toda esa capacidad de cómputo disponible en el hardware del servidor.
Algunos casos en que pueden resultar particularmente útiles
Cuando múltiples aplicaciones cliente se escriben en distintos lenguajes o funcionan en distintas plataformas, pero necesitan realizar la misma operación en la base de datos. Cuando la seguridad es muy importante. Los bancos, por ejemplo, usan procedimientos almacenados para todas las operaciones comunes.
Esto proporciona un entorno seguro y consistente, y los procedimientos pueden asegurar que cada operación se loguea apropiadamente. En tal entorno, las aplicaciones y los usuarios no obtendrían ningún acceso directo a las tablas de la base de datos, sólo pueden ejectuar algunos procedimientos almacenados.
Elementos de los procedimientos almacenados
Los procedimientos almacenados están compuestos por algunos de estos elementos:
- Parámetros de entrada (pueden esperar parámetros)
- Parámetros de salida (pueden devolver resultados)
- Declaración de variables (puede usarse variables en su cuerpo)
- Cuerpo del procedimiento (en su cuerpo se indican las acciones a realizar)
Tanto los parámetros de entrada como los de salida son opcionales. Podemos tener un procedimiento que no tenga parámetros de entrada, pero sí de salida y viceversa. Como todo buen programador sabe, los parámetros de entrada sirven para pasarle datos al procedimiento que necesita para llevar a cabo una acción determinada. Los parámetros de salida devuelven al programa cliente que ejecutó el procedimiento el resultado del mismo.
Sintaxis
Para crear un procedimiento almacenado debemos emplear la sentencia CREATE PROCEDURE.
CREATE PROCEDURE <nombre_procedure> [@param1 <tipo>, ...]
AS
-- Sentencias del procedure
Para modificar un procedimiento almacenado debemos emplear la sentencia ALTER PROCEDURE.
ALTER PROCEDURE<nombre_procedure> [@param1 <tipo>, ...]
AS
-- Sentencias del procedure
El siguiente ejemplo muestra un procedimiento almacenado, llamado spu_addCliente que añade clientes, o sea, inserta un registro en la tabla ‘Clientes’:
CREATE PROCEDURE spu_addCliente @nombre varchar(100),
@apellidos varchar(100),
@f_Naciento datetime,
@email varchar(50)
AS
NSERT INTO CLIENTES (nombre, apellidos, f_nacimiento, email)
VALUES (@nombre, @apellidos, @f_naciento, @email)
Ejemplos
USE [bd_inventario]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
-- =============================================
-- Autor: Yosbany
-- Fecha:
-- Descripción:
-- =============================================
ALTER PROCEDURE [dbo].[Insertar_Inventario]
--Parámetros de entrada
@Descripcion char(15) = '',
@No_inv char(15),
@Marca char(15),
@Modelo char(15),
@No_serie char(15),
@Puesto char(3),
@id int = 0
AS
BEGIN
SET NOCOUNT ON;
-- Sentencia del procedimiento
INSERT INTO Inventario (id, Descripcion, No_inventario, Marca, Modelo, No_serie, Puesto)
VALUES(@id, @Descripcion, @No_inv, @Marca, @Modelo, @No_serie, @Puesto);
END
Llamando el procedimiento
En este caso veremos cómo llamarlo desde el lenguaje de programación C++, usando la tecnología ADO que trae C++Builder6:
Por ejemplo, si tenemos un procedimiento almacenado que elimina un registro según el id que se le pase, de esta manera, en el gestor SQL Server:
USE [bd_inventario]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
-- =============================================
-- Author: Yosbany
-- Fecha:
-- Description:
-- =============================================
CREATE PROCEDURE Eliminar_Inventario
-- parámetro id por el que va a eliminar. El procedimiento espera este parámetro para eliminar el registro que lo contenga.
@id int = 0
AS
BEGIN
SET NOCOUNT ON;
-- sentencia del procedimiento
DELETE FROM Inventario WHERE id = @id;
END
Desde C++ lo llamaríamos así: (Usando el componente ADOStoredProc)
ADOStoredProc1->ProcedureName = "Eliminar_inventario"; //Nombre del procedimiento
ADOStoredProc1->Active=false; // Lo desactivamos
TParameters *parameters = ADOStoredProc1->Parameters;
parameters->Clear();
parameters->AddParameter(); //Añadimos el parámetro que espera el procedimiento
(*parameters)[0]->DataType = ftString;
(*parameters)[0]->Direction = pdInput;
(*parameters)[0]->Size = DBEdit1->Text.Length();
(*parameters)[0]->Value = DBEdit1->Text;
ADOStoredProc1->ExecProc(); // Y finalmente lo ejecutamos
Los procedimientos almacenados permiten aprovechar los recursos del servidor, ahorrar tiempo creando consultas complejas desde el servidor y permiten interactuar con otros objetos, generadores, excepciones, tablas y vistas. Por lo tanto, es importante para todo desarrollador utilizarlos correctamente y saber todo lo que se puede hacer con ellos.
