Transacciones y sql procedural EN MySQL

“2013; Año de Belisario Domínguez”

“2013; Año por una Cultura de Conservación Ambiental”

INSTITUTO TECNOLOGICO SUPERIOR

DE

FELIPE CARRILLO PUERTO

INVESTIGACION:

U5 TRANSACCIONES

U6 SQL PROCEDURAL

D O C E N T E:

M.C. Arizbé del S. Arana Kantún

P R E S E N T A

Angulo Estrella Jesús Alberto González May Patricio Ketz López Andrea Lara Domínguez Efraín Pool Pc Jose Ángel Yama May José Luis

No. De Control 111K0030 No. De Control 111K0040 No. De Control 111K0042 No. De Control 111K0043 No. De Control 111K0050 No. De Control 111K0056

Aula: J2 Grupo: B

C A R R E R A:

Ingeniería en sistemas computacionales

M A T E R I A:

Taller de Base de Datos

Felipe Carrillo Puerto, Quintana Roo a 27 de Noviembre de 2013

U5 Transacciones y U6 SQL Procedural

Taller de Base de Datos 2

CONTENIDO

INTRODUCCIÓN .............................................................................................................................. 3

DISPARADORES DE BASES DE DATOS (Trigger) ................................................................ 4

La Estructura Básica De Un Trigger .......................................................................................... 5

Tipos de Triggers .......................................................................................................................... 5

Características .............................................................................................................................. 5

Disparadores en MySQL ............................................................................................................. 6

Ejemplos ........................................................................................................................................ 6

SQL PROCEDURAL ....................................................................................................................... 8

Tipos de datos ............................................................................................................................... 8

Identificadores ............................................................................................................................... 9

Operadores .................................................................................................................................... 9

Variables ...................................................................................................................................... 10

Constantes................................................................................................................................... 10

Procedimientos ........................................................................................................................... 10

Paquetes ...................................................................................................................................... 11

PROCEDIMIENTO ALMACENADO ........................................................................................... 12

Aplicaciones De Los Procedimientos Almacenados ............................................................. 13

Ventajas ....................................................................................................................................... 13

Procedimientos Almacenados En MySQL .............................................................................. 14

CONCLUSIÓN ................................................................................................................................ 15



INTRODUCCIÓN

En este trabajo de investigación se recopila información referente a los

temas que se abordan dentro de las unidades 5 y 6 de la materia de base de

datos, los cuales corresponden a los temas Transacciones y SQL Procedural.

Ambos son importantes para toda aquella persona que esté desarrollando algún

proyecto en el cual se tenga la necesidad de una base de datos, ya que ayudan

a mejorar el funcionamiento de la gestión de datos, mediante algunas

herramientas que en ocasiones se desconoce su utilidad o simplemente no se

tenía en cuenta de que existían.

De manera más específica, se incluye información acerca de los

Disparadores de bases de datos, los cuales también se les conoce como

Triggers. Un Triggers es un tipo especial de procedimiento almacenado asociado

a una tabla que se ejecuta al realizar una operación “básica”

(INSERT, DELETE o UPDATE) sobre ésta, como se puede observar todas las

acciones relacionadas a este complemento sirven para la manipulación de la

información que se encuentra almacenado dentro de las tablas de nuestra base

de datos.

SQL Procedural, es otro de los temas tratados, en primera instancia

encontrara información acerca del lenguaje PL en Oracle, que sirve para la

creación de procedimientos almacenados; se habla principalmente de los

aspectos más importantes a tomar en cuenta al crear procedimientos, que tipo

de valores de utilizan, que operadores y como se definen los procedimientos, así

como de las partes de un paquete, los cuales sirven para agrupar

procedimientos.

Lo siguiente y que va relacionado con el mismo tema, será sobre los

procedimientos almacenados, con la finalidad de aclarar que son, como los

puede utilizar o aplicar a su base de datos, cuales son las ventajas que usted

obtendría al utilizar procedimientos almacenados en su BD, y también se

especifica más acerca del uso de este complementos en el gestor de bases de

datos más popular, MySQL.



DISPARADORES DE BASES DE DATOS (Trigger)

Un trigger (o disparador) en una Base de datos, es un procedimiento que se

ejecuta cuando se cumple una condición establecida al realizar una operación.

Dependiendo de la base de datos, los Triggers pueden ser de inserción (INSERT),

actualización (UPDATE) o borrado (DELETE). Algunas bases de datos pueden

ejecutar Triggers al crear, borrar o editar usuarios, tablas, bases de datos u otros

objetos.

Son usados para mejorar la administración de la Base de datos, sin

necesidad de contar con que el usuario ejecute la sentencia de SQL. Además,

pueden generar valores de columnas, previene errores de datos, sincroniza tablas,

modifica valores de una vista, etc. Permite implementar programas basados en

paradigma lógico (sistemas expertos, deducción). Sirve para tener bases de datos

relacionales y modificarlas a su gusto.

También se dice que Un disparador (o trigger) es un tipo especial de procedimiento

almacenado asociado a una tabla que se ejecuta al realizar una operación “básica”

(INSERT, un DELETE o un UPDATE) sobre ésta. La operación básica que despierta al

trigger es conocida como sentencia disparadora.

La ejecución del disparador puede ser antes (before) o después (after) de llevar a cabo la sentencia disparadora. Es posible especificar condiciones adicionales para la ejecución del disparador (restrictores).

Dado que una sentencia disparadora puede afectar una o más filas de una tabla, es necesario especificar si se quiere que el disparador se ejecute para cada una de las filas afectadas o para el bloque en general.

Para diseñar un disparador hay que cumplir dos requisitos:

Especificar las condiciones en las que se va a ejecutar el disparador. Esto se

descompone en un evento que causa la comprobación del disparador y

una condición que se debe cumplir para ejecutar el disparador. Especificar las acciones que se van a realizar cuando se ejecute el disparador.

Los Triggers constituyen una potente herramienta para mantener la integridad de la base de datos, ya que pueden llevar a cabo cualquier acción que sea necesaria para el mantenimiento de dicha integridad.

Los Triggers pueden llamar a otros procedimientos y disparar otros Triggers, pero no admiten parámetros y no pueden ser invocados desde otros procedimientos. Los disparadores sea activan al crearlos.



La Estructura Básica De Un Trigger

La estructura general que puede tener un disparador o trigger está compuesta por

los siguientes aspectos:

Llamada de activación: es la sentencia que permite "disparar" el código a

ejecutar.

Restricción: es la condición necesaria para realizar el código. Esta restricción

puede ser de tipo condicional o de tipo nulidad.

Acción a ejecutar: es la secuencia de instrucciones a ejecutar una vez que

se han cumplido las condiciones iniciales.

Tipos de Triggers

Existen dos tipos de disparadores que se clasifican según la cantidad de

ejecuciones a realizar:

Row Triggers (o Disparadores de fila): son aquellas que se ejecutaran n-

veces si se llama n-veces desde la tabla asociada al trigger

Statement Triggers (o Disparadores de secuencia): son aquellos que sin

importar la cantidad de veces que se cumpla con la condición, su ejecución

es única.

Pueden ser de sesión y almacenados; pero no son de fila y se elimina todo.

Características

No aceptan parámetros o argumentos (pero podrían almacenar los datos

afectados en tablas temporales)

No pueden ejecutar las operaciones COMMIT o ROLLBACK por que estas

son parte de la sentencia SQL del disparador (únicamente a través de

transacciones autónomas)

Pueden causar errores de mutaciones en las tablas, si se han escrito de

manera deficiente.

Un sencillo ejemplo (para SQL Server) sería crear un Trigger para insertar un pedido

de algún producto cuando la cantidad de éste, en nuestro almacén, sea inferior a un

valor dado.

BEFORE UPDATE ON tabla_almacen FOR ALL records IF NEW.producto < 100 THEN INSERT INTO tabla_pedidos(producto) VALUES ('1000'); END IF; SELECT DBO.POLVE.TEST END



Disparadores en MySQL

Los disparadores son soportados en MySQL a partir de la versión 5.0.2. Algunos de los soportes existentes son los disparadores para las sentencias INSERT, UPDATE y DELETE. El estándar SQL: 2003 requiere que los disparadores den a los

programadores acceso a las variables de un registro utilizando una sintaxis

como REFERENCING NEW AS n. Por ejemplo, si un disparador está monitoreando

los cambios en la columna salario, podría escribirse un disparador como:

CREATE TRIGGER ver_salario BEFORE UPDATE ON empleados REFERENCING NEW ROW AS n, OLD ROW AS o FOR EACH ROW IF n.salario <> o.salario THEN END IF;

Como en MySQL las sentencias se ejecutan luego de escribir el signo punto

y coma (;), cabe destacar que para crear un disparador en MySQL, antes se escribe

la sentencia DELIMITER seguida de un carácter tal como |, la cual asigna la función

del punto y coma (;) a otro carácter permitiendo que el disparador sea escrito usando

los punto y comas sin que se ejecute mientras se escribe; después de escrito el

disparador se escribe nuevamente la sentencia DELIMITER ; para asignar al punto

y coma su función habitual.

Ejemplos

Temporalidad del Evento: AFTER / BEFORE

° BEFORE: Ejecutan la acción asociada antes de que la sentencia sea ejecutada

Decidir si la acción debe realizarse o no

Utilizar valores alternativos para la sentencia

° AFTER: Ejecutan la acción asociada después de que se haya ejecutado la sentencia



La sintaxis de un disparador en dos de los gestores de bases de datos más

utilizados en la actualidad puede ser como se muestra en la siguiente imagen:



SQL PROCEDURAL

PL/SQL (Procedural Language/Structured Query Language) es un lenguaje de programación incrustado en Oracle.

PL/SQL soportara todas las consultas, ya que la manipulación de datos que se usa es la misma que en SQL, incluyendo nuevas características:

El manejo de variables.

Estructuras modulares.

Estructuras de control de flujo y toma de decisiones.

Control de excepciones.

El lenguaje PL/SQL está incorporado en: Servidor de la base de datos.

Herramientas de Oracle (Forms, Reports,..).

En un entorno de base de datos los programadores pueden construir bloques PL/SQL para utilizarlos como procedimientos o funciones, o bien pueden escribir estos bloques como parte de scripts SQL*Plus. Los programas o paquetes de PL/SQL se pueden almacenar en la base de datos como otro objeto, y todos los usuarios que estén autorizados tienen acceso a estos paquetes. Los programas se ejecutan en el servidor para ahorrar recursos a los clientes.

Tipos de datos

A continuación se muestra un listado de los tipos de datos disponibles en

Oracle / PLSQL. Hemos tratado de diferenciar los tipos de datos entre las versiones

de Oracle 8i y Oracle 9i.



Nota: los tipos de valores que aparecen listadas en la tabla anterior no son las únicas, estas son solo por mencionar algunas, las cuales son las más conocidas y utilizadas en la mayoría de los gestores de bases de datos.

Identificadores

Un identificador es un nombre que se le pone a un objeto que interviene en un programa, que puede ser variable, constante, procedimientos, excepciones, cursores... Debe tener un máximo de 30 caracteres que empiece siempre por una letra, y puede contener letras, números, los símbolos $, #, _, y mayúsculas y minúsculas indiferentemente. Los identificadores no pueden ser palabras reservadas (SELECT, INSERT, DELETE, UPDATE, DROP).

Operadores

A continuación se listan los operadores más comunes que se utilizan, los cuales tal vez la mayoría ya conoce y tiene idea de la forma de utilizarlos.



Variables

Las variables son nombres para procesar los elementos de los datos. Declaración:

Nombre_variable tipo [NOT NULL] [:= valor | DEFAULT valor]

:= y DEFAULT son lo mismo. Si ponemos NOT NULL es obligatorio inicializar la variable.

Ejemplos:

num_dep NUMBER(2) NOT NULL :=20

nom_emple VARCHAR2(15) DEFAULT ‘Pedro’

También se puede definir una variable a partir de un campo mediante los atributos %TYPE y %ROWTYPE, con esto damos el tipo y longitud a la variable de otra variable u objeto ya definido.

%TYPE es la que se utiliza normalmente, %ROWTYPE es para claves de registro. El NOT NULL y el valor inicial no se heredan, sólo el tipo de dato y longitud de ese dato.

Por ejemplo:

num_dep emple.dept_no%TYPE

Constantes

Las constantes son como las variables pero no puede modificarse su valor. Se declaran de la siguiente manera:

nombre_constante CONSTANT tipo_de_dato := valor

Por ejemplo, el IVA es un valor fijo, y para declararlo lo haríamos de la siguiente manera:

Imp_iva CONSTANT NUMBER(2,2) := 12,5

Procedimientos

Los procedimientos tienen la utilidad de fomentar la reutilización de programas que se usan comúnmente. Una vez compilado, queda almacenado en la base de datos (por eso es también llamado 'Procedimiento almacenado') y puede ser utilizado por múltiples aplicaciones.

La sintaxis es la siguiente

CREATE [OR REPLACE] PROCEDURE nombre_procedimiento

[nombre_parametro modo tipodatos_parametro ]

IS | AS

bloque de código



Donde "modo" puede contener los valores IN, OUT, IN OUT. Por defecto tiene el valor IN si no se pone nada. IN indica que el parámetro es de entrada y no se podrá modificar. OUT indica que el parámetro es de salida con lo que el procedimiento devolverá un valor en él. IN OUT indica que el parámetro es de entrada/salida. Con lo que al llamar al procedimiento se le dará un valor que luego podrá ser modificado por el procedimiento y devolver este nuevo valor.

Paquetes

Se usan para agrupar procedimientos y funciones. Facilitan la descomposición modular y el mantenimiento. Constan de dos partes: la especificación o prototipo y el cuerpo.

Especificación

Se declaran los elementos públicos que componen el paquete, es decir, variables, funciones y procedimientos que serán accesibles desde fuera del paquete. De las funciones y procedimientos sólo indicamos la cabecera, no el cuerpo.

CREATE [OR REPLACE] PACKAGE nombrePaquete

IS|AS

variables, constantes, cursores, etc (públicos)

cabecera de procedimientos y funciones

END nombrePaquete;

Cuerpo

Se realiza la definición de los procedimientos indicados en la especificación del paquete. También es posible la declaración de miembros privados. Una vez terminado el paquete se compila.

CREATE [OR REPLACE] PACKAGE BODY nombrePaquete

IS|AS

variables, constantes, cursores, etc (privados)

cuerpo de procedimientos y funciones

END nombrePaquete;



PROCEDIMIENTO ALMACENADO

Un procedimiento almacenado (Stored Procedure en inglés) es

un programa (o procedimiento) el cual es almacenado físicamente en una base de

datos. Su implementación varía de un gestor a otro. La ventaja de un procedimiento

almacenado es que al ser ejecutado, en respuesta a una petición de usuario, es

ejecutado directamente en el motor de bases de datos, el cual usualmente corre en

un servidor separado. Como tal, posee acceso directo a los datos que necesita

manipular y sólo necesita enviar sus resultados de regreso al usuario,

deshaciéndose de la sobrecarga resultante de comunicar grandes cantidades de

datos salientes y entrantes.

Usos típicos para procedimientos almacenados incluyen la validación de

datos siendo integrados a la estructura de base de datos (los procedimientos

almacenados utilizados para este propósito a menudo son llamados

disparadores; Triggers en inglés), o encapsular un proceso grande y complejo. El

último ejemplo generalmente ejecutará más rápido como un procedimiento

almacenado que de haber sido implementado como, por ejemplo, un programa

corriendo en el sistema cliente y comunicándose con la base de datos mediante el

envío de consultas SQL y recibiendo sus resultados.

Los procedimientos pueden ser ventajosos: Cuando una base de datos es

manipulada desde muchos programas externos. Al incluir la lógica de la aplicación

en la base de datos utilizando procedimientos almacenados, la necesidad de

embeber la misma lógica en todos los programas que acceden a los datos es

reducida. Esto puede simplificar la creación y, particularmente, el mantenimiento de

los programas involucrados.

Podemos ver un claro ejemplo de estos procedimientos cuando requerimos

realizar una misma operación en un servidor dentro de algunas o todas las bases

de datos y a la vez dentro de todas o algunas de las tablas de las bases de datos

del mismo. Para ello podemos utilizar a los Procedimientos almacenados

autocreables que es una forma de generar ciclos redundantes a través de los

procedimientos almacenados.

Estos procedimientos, se usan a menudo, pero no siempre, para realizar

consultas SQL sobre los objetos de la base de datos de una manera abstracta,

desde el punto de vista del cliente de la aplicación. Un procedimiento

almacenado permite agrupar en forma exclusiva parte de algo específico que se

desee realizar o, mejor dicho, el SQL apropiado para dicha acción.



Aplicaciones De Los Procedimientos Almacenados

Los usos 'típicos' de los procedimientos almacenados se aplican en la validación de

datos, integrados dentro de la estructura del banco de datos. Los procedimientos

almacenados usados con tal propósito se llaman comúnmente disparadores,

o Triggers. Otro uso común es la 'encapsulación' de un API para un proceso

complejo o grande que podría requerir la 'ejecución' de varias consultas SQL, tales

como la manipulación de un 'dataset' enorme para producir un resultado resumido.

También pueden ser usados para el control de gestión de operaciones, y ejecutar

procedimientos almacenados dentro de una transacción de tal manera que las

transacciones sean efectivamente transparentes para ellos.

Ventajas

La ventaja de un procedimiento almacenado, en respuesta a una petición de

usuario, está directamente bajo el control del motor del gestor de bases de datos,

que corre generalmente en un servidor distinto del gestor de bases de datos

aumentando con ello la rapidez de procesamiento de las peticiones del gestor de

bases de datos.

El servidor de la base de datos tiene acceso directo a los datos necesarios

para manipular y sólo necesita enviar el resultado final al usuario. Los

procedimientos almacenados pueden permitir que la lógica del negocio se

encuentre como un API en la base de datos, que pueden simplificar la gestión de

datos y reducir la necesidad de codificar la lógica en el resto de los programas

cliente. Esto puede reducir la probabilidad de que los datos se corrompan por el uso

de programas clientes defectuosos o erróneos.

De este modo, el motor de base de datos puede asegurar la integridad de los

datos y su consistencia con la ayuda de procedimientos almacenados. Algunos

afirman que las bases de datos deben ser utilizadas para el almacenamiento de

datos solamente, y que la lógica de negocio sólo debería aplicarse en la capa de

negocio de código, a través de aplicaciones cliente que deban acceder a los datos.

Sin embargo, el uso de procedimientos almacenados no se opone a la utilización de

una capa de negocio.



Procedimientos Almacenados En MySQL

Desde MySQL 5 los procedimientos almacenados empezaron a ser

soportados, como suele suceder en MySQL las sentencias se ejecutan luego de

escribir el signo punto y coma (;), por esta razón antes de escribir el procedimiento

almacenado la función del punto y coma se asigna a otros caracteres usando la

sentencia DELIMITER seguida de un carácter tal como |, de esta manera el

procedimiento puede ser escrito usando los punto y comas sin que se ejecute

mientras se escribe; después de escrito el procedimiento, se escribe nuevamente la

sentencia DELIMITER ; para asignar al punto y coma su función habitual.Fven

El siguiente es un ejemplo de procedimiento almacenado en MySQL:

DELIMITER |

CREATE PROCEDURE autos(IN velocidad INT,IN marca VARCHAR(50))

BEGIN

IF velocidad < 120 THEN

INSERT INTO familiares VALUES(velocidad,marca);

ELSE

INSERT INTO deportivos VALUES(velocidad,marca);

END IF;

END;

|



CONCLUSIÓN

Tener en cuenta todos los complementos y herramientas útiles de un

gestor de base de datos para mejorar el acceso a la información que se

almacena en ella, ayuda a crear bases de datos más funcionales y sobre todo

que sean lo más sencillo posible de utilizar por cualquier persona. No hay que

olvidar que al fin y al cabo el usuario final de la aplicación no serán los

desarrolladores, si no, personas que en la mayoría de los casos solo saben

dar clic a botones en una ventana o ingresar valores desde un formulario,

para trabajar con una base de datos, sin que les interese en lo más mínimo

como es que esos valores se guardan o cual es el proceso que se sigue para

mostrar una consulta.

Todo lo anterior tiene mucha relación con los temas que se presentaron

en este documento, pues son algunas de las herramientas que los creadores

de la base de datos para facilitarle la vida a los usuarios finales y solo tengan

que dar clics para tener acceso a la información que tienen almacenado, para

actualizar o bien para ingresar nuevos valores.

Tanto los procedimientos almacenados, que como se ha visto son

acciones que se crean y se guardan para cumplir cierta función, como los

disparadores de base de datos, forman parte del trabajo más complejo de los

desarrolladores de las bases de datos, pero que tienen una de las finalidades

con mayor importancia, facilitar el proceso de manipulación de los datos para

el usuario.

Transacciones y sql procedural EN MySQL

Education

Transcript of Transacciones y sql procedural EN MySQL