Está en la página 1de 21

-- ---------------------------------------------------------------------------

-- 1. Construya los siguiente procedimientos Almacenados para inserción de


registros:
-- ---------------------------------------------------------------------------
-- ---------------------------------------------------------------------------
-- ---------------------------------------------------------------------------
-- En MySQL; para las tablas Profesor, Curso, Estudiante, Estudiantexcurso.
-- ---------------------------------------------------------------------------
-- ---------------------------------------------------------------------------
-- ---------------------------------------------------------------------------
-- STORED PROCEDURE PARA INSERTAR UN REGISTRO EN LA TABLA PROFESOR
-- ---------------------------------------------------------------------------

DELIMITER $$
CREATE PROCEDURE SP_INSERTAR_PROFESOR(
IN CED VARCHAR(11),
IN NOM VARCHAR(30),
IN APE VARCHAR(30),
IN CAT INT(11),
IN SAL INT(11)
)
BEGIN
INSERT INTO laboratoriosql.profesores
(doc_prof,
nom_prof,
ape_prof,
cate_prof,
sal_prof)
VALUES (CED, NOM, APE, CAT, SAL);
END$$
DELIMITER ;

-- ---------------------------------------------------------------------------
-- STORED PROCEDURE PARA INSERTAR UN REGISTRO EN LA TABLA CURSO
-- ---------------------------------------------------------------------------
DELIMITER $$
CREATE PROCEDURE SP_INSERTAR_CURSO(
IN COD VARCHAR(7),
IN NOM VARCHAR(100),
IN HORAS INT(11),
IN VALOR INT(11)
)
BEGIN
INSERT INTO laboratoriosql.cursos
(cod_curs,
nom_curs,
horas_curs,
valor_curs)
VALUES
(COD, NOM, HORAS, VALOR);
END$$
DELIMITER ;

-- ---------------------------------------------------------------------------
-- STORED PROCEDURE PARA INSERTAR UN REGISTRO EN LA TABLA ESTUDIANTE
-- ---------------------------------------------------------------------------
DELIMITER $$
CREATE DEFINER=`root`@`localhost` PROCEDURE `SP_INSERTAR_ESTUDIANTE`(
IN CED VARCHAR(11),
IN NOM VARCHAR(30),
IN APE VARCHAR(30),
IN EDAD INT(11)
)
BEGIN
INSERT INTO laboratoriosql.estudiantes
(doc_est,
nom_est,
ape_est,
edad_est)
VALUES
(CED, NOM, APE, EDAD);
END$$
DELIMITER ;

-- ---------------------------------------------------------------------------
-- STORED PROCEDURE PARA INSERTAR REGISTRO EN LA TABLA ESTUDIANTEXCURSO
-- ---------------------------------------------------------------------------
DELIMITER $$
CREATE DEFINER=`root`@`localhost` PROCEDURE `SP_INSERTAR_ESTUDIANTEXCURSO`(
IN COD_CUR VARCHAR(7),
IN DOC_EST VARCHAR(11),
IN FECHA DATE
)
BEGIN
INSERT INTO laboratoriosql.estudiantesxcursos
(cod_cur_estcur,
doc_est_estcur,
fec_ini_estcur)
VALUES
(COD_CUR, DOC_EST, FECHA);
END$$
DELIMITER ;

-- ////////////////////////////////////////////////////////
-- ---------------------------------------------------------------------------
-- En ORACLE; para las tablas Cliente, Articulo, Pedido.
-- ---------------------------------------------------------------------------
-- ////////////////////////////////////////////////////////
-- ---------------------------------------------------------------------------
-- STORED PROCEDURE PARA INSERTAR REGISTRO EN LA TABLA CLIENTE
-- ---------------------------------------------------------------------------
create or replace PROCEDURE INSERTAR_CLIENTE
(
ID IN VARCHAR2
, NOMBRE IN VARCHAR2
, APELLIDO IN VARCHAR2
, DIRECCION IN VARCHAR2
, DEPARTAMENTO IN VARCHAR2
, MES_NACIMIENTO IN VARCHAR2
) AS
BEGIN
INSERT INTO cliente (
id_cli,
nom_cli,
ape_cli,
dir_cli,
dep_cli,
mes_cum_cli
) VALUES (
ID,
NOMBRE,
APELLIDO,
DIRECCION,
DEPARTAMENTO,
MES_NACIMIENTO
);
END INSERTAR_CLIENTE;

-- ---------------------------------------------------------------------------
-- STORED PROCEDURE PARA INSERTAR REGISTRO EN LA TABLA ARTICULO
-- ---------------------------------------------------------------------------
create or replace PROCEDURE SP_INSERTAR_ARTICULO (
ID IN INT,
TITULO IN VARCHAR2,
AUTOR IN VARCHAR2,
EDITORIAL IN VARCHAR2,
PRECIO INT
) AS
BEGIN
INSERT INTO articulo (
id_art,
tit_art,
aut_art,
edi_art,
prec_art
) VALUES (
ID,
TITULO,
AUTOR,
EDITORIAL,
PRECIO
);
END SP_INSERTAR_ARTICULO;

-- ---------------------------------------------------------------------------
-- STORED PROCEDURE PARA INSERTAR REGISTRO EN LA TABLA PEDIDO
-- ---------------------------------------------------------------------------
create or replace PROCEDURE SP_INSERTAR_PEDIDO (
ID IN INT,
CEDULA IN VARCHAR2,
FECHA IN VARCHAR2,
VALOR INT
) AS
BEGIN
INSERT INTO pedido (
id_ped,
id_cli_ped,
fec_ped,
val_ped
) VALUES (
ID,
CEDULA,
FECHA,
VALOR
);
END SP_INSERTAR_PEDIDO;

-- ////////////////////////////////////////////////////////////////////////////
-- /// En el Motor de su preferencia (ORACLE O MySQL), para las tablas, //////
-- /// Compañía, TiposAutomotores, Automotores, Aseguramientos, Incidentes. /
-- /////////////////////////////////////////////////////////////////////////
-- ---------------------------------------------------------------------------
-- ////////////////////////////////////////////////////////
-- /////////////////// M Y S Q L ////////////////////
-- //////////////////////////////////////////////////////

-- ---------------------------------------------------------------------------
-- STORED PROCEDURE PARA INSERTAR REGISTRO EN LA TABLA COMPANY
-- ---------------------------------------------------------------------------
DELIMITER $$
CREATE PROCEDURE SP_INSERTAR_COMPANY(
IN NIT VARCHAR(11),
IN NOMBRE VARCHAR(30),
IN FUND_YEAR INT(11),
IN REPRES VARCHAR(100)
)
BEGIN
INSERT INTO laboratoriosql.company
(com_nit,
com_nom,
com_year_fund,
com_repr_legal)
VALUES
(NIT, NOMBRE, FUND_YEAR, REPRES);
END$$
DELIMITER ;

-- ---------------------------------------------------------------------------
-- STORED PROCEDURE(SP) PARA INSERTAR REGISTRO EN LA TABLA TIPOSAUTOMOTORES
-- ---------------------------------------------------------------------------
DELIMITER $$
CREATE PROCEDURE SP_INSERTAR_TIPOSAUTOMOTORES(
IN AUT INT(11),
IN DESCRIP VARCHAR(30)
)
BEGIN
INSERT INTO laboratoriosql.tiposautomotores
(aut_tipo,
descripcion)
VALUES
(AUT, DESCRIP);
END$$
DELIMITER ;

-- ---------------------------------------------------------------------------
-- STORED PROCEDURE(SP) PARA INSERTAR REGISTRO EN LA TABLA AUTOMOTORES
-- ---------------------------------------------------------------------------
DELIMITER $$
CREATE PROCEDURE SP_INSERTAR_AUTOMOTORES(
IN PLACA VARCHAR(6),
IN MARCA VARCHAR(30),
IN TIPO INT(11),
IN MODELO INT(11),
IN PASAJEROS INT(11),
IN CILINDRAJE INT(11),
IN CHASIS VARCHAR(20)
)
BEGIN
INSERT INTO laboratoriosql.automotores
(
auto_placa,
auto_marca,
auto_tipo,
auto_modelo,
auto_num_pasajeros,
auto_cilindraje,
auto_num_chasis
)
VALUES
(PLACA,MARCA,TIPO,MODELO,PASAJEROS,CILINDRAJE,CHASIS);
END$$
DELIMITER ;

-- ---------------------------------------------------------------------------
-- STORED PROCEDURE(SP) PARA INSERTAR REGISTRO EN LA TABLA ASEGURAMIENTOS
-- ---------------------------------------------------------------------------
DELIMITER $$
CREATE PROCEDURE SP_INSERTAR_ASEGURAMIENTOS(
IN COD INT(11),
IN INICIO DATE,
IN EXPIRACION DATE,
IN VALOR INT(11),
IN ESTADO ENUM('VIGENTE','VENCIDO'),
IN COSTO INT(11),
IN PLACA VARCHAR(6)
)
BEGIN
INSERT INTO laboratoriosql.aseguramientos
( ase_cod,
ase_fechaInicio,
ase_fechaExpiracion,
ase_valorAsegurado,
ase_estado,
ase_costo,
ase_placa
)
VALUES
(COD,INICIO,EXPIRACION,VALOR,ESTADO,COSTO,PLACA);

END$$
DELIMITER ;

-- ---------------------------------------------------------------------------
-- STORED PROCEDURE(SP) PARA INSERTAR REGISTRO EN LA TABLA INCIDENTES
-- ---------------------------------------------------------------------------
DELIMITER $$
CREATE PROCEDURE SP_INSERTAR_INCIDENTES(
cod int(11) ,
fecha date,
placa varchar(6),
lugar varchar(40) ,
cant_heridos int(11) ,
cant_fatalidades int(11) ,
cant_autos_involucrados int(11)
)
BEGIN
INSERT INTO laboratoriosql.incidentes
(
inci_cod,
inci_fecha,
inci_placa,
inci_lugar,
inci_cant_heridos,
inci_cant_fatalidades,
inci_cant_autos_involucrados
)
VALUES
(cod,
fecha,
placa,
lugar,
cat_heridos,
cant_fatalidades,
cant_autos_involucrados);
END$$
DELIMITER ;

-- /////////////////////////////////////////////////////////////////////////
-- 2. En Oracle construya los procedimientos almacenados para realizar
-- los siguientes procesos.
-- ////////////////////////////////////////////////////////////////////////

-- ---------------------------------------------------------------------------
-- Muestre los salarios de los profesores ordenados por categoría
-- ---------------------------------------------------------------------------
CREATE OR REPLACE PROCEDURE sp_listarSalarios
IS
BEGIN
DECLARE CURSOR c IS
SELECT cate_prof, sal_prof FROM Profesores
ORDER BY cate_prof;
fila c%rowtype;
BEGIN
OPEN c;
LOOP
FETCH c INTO fila;
EXIT WHEN c%NOTFOUND;
DBMS_OUTPUT.PUT_LINE('CATEGORÍA '||fila.cate_prof||' => $ '||
fila.sal_prof);
END LOOP;
CLOSE c;
END;
END;
-- ---------------------------------------------------------------------------
-- Muestre los cursos cuyo valor sea mayor a $500.000.
-- ---------------------------------------------------------------------------
CREATE OR REPLACE PROCEDURE SP_CURSOS_MAYORES_500
IS
BEGIN
DECLARE CURSOR c IS
SELECT nom_curs, valor_curs FROM cursos
WHERE VALOR_CURS > 500000;
fila c%rowtype;
BEGIN
OPEN c;
LOOP
FETCH c INTO fila;
EXIT WHEN c%NOTFOUND;
DBMS_OUTPUT.PUT_LINE(fila.nom_curs||' => $ '||fila.valor_curs);
END LOOP;
CLOSE c;
END;
END;

-- ---------------------------------------------------------------------------
-- Visualizar el nombre, apellido y dirección de todos aquellos clientes
-- que hayan realizado un pedido el día 25 /02/2012.
-- ---------------------------------------------------------------------------
CREATE OR REPLACE PROCEDURE SP_clientesConPedido
IS
BEGIN
DECLARE CURSOR c IS
SELECT pedido.fec_ped AS FECHA,
cliente.nom_cli AS NOMBRE,
cliente.ape_cli AS APELLIDO,
cliente.dir_cli AS DIRECCION
FROM cliente
INNER JOIN pedido ON pedido.id_cli_ped = cliente.id_cli
WHERE pedido.fec_ped = '25-02-2012';
fila c%rowtype;
BEGIN
OPEN c;
LOOP
FETCH c INTO fila;
EXIT WHEN c%NOTFOUND;
DBMS_OUTPUT.PUT_LINE(
fila.NOMBRE||' '
||fila.APELLIDO||' => '
||fila.DIRECCION
);
END LOOP;
CLOSE c;
END;
END;

-- ---------------------------------------------------------------------------
-- Listar todos los pedidos realizados incluyendo el nombre del artículo.
-- ---------------------------------------------------------------------------
CREATE OR REPLACE PROCEDURE SP_articuloXPedido
IS
BEGIN
DECLARE CURSOR c IS
SELECT axp.can_art_artped AS cantidad,
art.tit_art as articulo,
axp.val_ven_art_artped as valor
FROM ARTICULOXPEDIDO axp
INNER JOIN articulo art ON art.ID_ART = axp.ID_ART_ARTPED;
fila c%rowtype;
BEGIN
OPEN c;
LOOP
FETCH c INTO fila;
EXIT WHEN c%NOTFOUND;
DBMS_OUTPUT.PUT_LINE(fila.cantidad||' '
||fila.articulo||' => '
||fila.valor);
END LOOP;
CLOSE c;
END;
END;

-- ---------------------------------------------------------------------------
-- Listar todos los datos de los automotores cuya póliza expira
-- en Septiembre de 2013, este reporte debe visualizar la placa, el modelo,
-- la marca, número de pasajeros, cilindraje nombre de automotor,
-- el valor de la póliza y el valor asegurado.
-- ---------------------------------------------------------------------------
CREATE OR REPLACE PROCEDURE SP_VencimientosPolizasOctubre
IS
BEGIN
DECLARE CURSOR c IS
SELECT ase.ase_placa AS placa,
ase.ase_valorasegurado as valorasegurado,
ase.ase_costo as costo,
aut.auto_modelo as modelo,
aut.auto_marca as marca,
aut.auto_num_pasajeros as pasajeros,
aut.auto_cilindraje as cilin,
tipo.descripcion as descrip
FROM automotores aut
INNER JOIN aseguramientos ase ON ase.ase_placa = aut.AUTO_PLACA
INNER JOIN TIPOSAUTOMOTORES tipo ON tipo.AUT_TIPO = aut.AUTO_TIPO
WHERE ase.ase_fechaexpiracion BETWEEN '01-09-2013' AND '30-09-2013';
fila c%rowtype;
BEGIN
OPEN c;
LOOP
FETCH c INTO fila;
EXIT WHEN c%NOTFOUND;
DBMS_OUTPUT.PUT_LINE(fila.placa||' / '
||fila.valorasegurado||' / '
||fila.costo||' / '
||fila.modelo||' / '
||fila.marca||' / '
||fila.pasajeros||' / '
||fila.cilin||' / '
||fila.descrip||' / '
);
END LOOP;
CLOSE c;
END;
END;

-- /////////////////////////////////////////////////////////////////////////
-- 3. En MySQL construya los procedimientos almacenados para
-- realizar los siguientes procesos
-- ////////////////////////////////////////////////////////////////////////

-- ---------------------------------------------------------------------------
-- Muestre todos los campos de la tabla curso en orden ascendente según el valor.
-- ---------------------------------------------------------------------------
DELIMITER $$
CREATE PROCEDURE SP_ListarCursos()
BEGIN
SELECT * FROM cursos
ORDER BY valor_curs ASC;
END$$
DELIMITER ;

-- ---------------------------------------------------------------------------
-- Mostrar los pedidos con los respectivos artículos
-- (código, nombre, valor y cantidad pedida)
-- ---------------------------------------------------------------------------
DELIMITER $$
CREATE PROCEDURE SP_PedidosConArticulos()
BEGIN
SELECT a.id_art AS CODIGO,
a.tit_art AS NOMBRE,
axp.val_ven_art_artped AS VALOR,
axp.can_art_artped AS CANTIDAD
FROM articulo a
INNER JOIN articuloxpedido axp ON axp.id_art_artped = a.id_art;
END$$
DELIMITER ;

-- ---------------------------------------------------------------------------
-- Visualizar los datos de las empresas fundadas entre el año 1991 y 1998
-- ---------------------------------------------------------------------------
DELIMITER $$
CREATE PROCEDURE SP_EmpresasFundadas1991_1998()
BEGIN
SELECT *
FROM company
WHERE com_year_fund BETWEEN '1991' AND '1998';
END$$
DELIMITER ;

-- ---------------------------------------------------------------------------
-- Visualizar todos los clientes organizados por apellido
-- ---------------------------------------------------------------------------
DELIMITER $$
CREATE PROCEDURE SP_ListarClientesXApellido()
BEGIN
SELECT *
FROM cliente
ORDER BY ape_cli;
END$$
DELIMITER ;

-- ---------------------------------------------------------------------------
-- Visualizar los datos de los incidentes que han tenido un(1) herido,
-- este reporte debe visualizar la placa del automotor,
-- con los respectivos datos de la póliza como son fecha de inicio,
-- valor, estado y valor asegurado
-- ---------------------------------------------------------------------------
DELIMITER $$
CREATE PROCEDURE SP_IncidentesCon1Herido()
BEGIN
SELECT i.inci_placa AS PLACA,
a.ase_fechaInicio AS FECHA_INICIO,
a.ase_costo AS COSTO,
a.ase_estado AS ESTADO,
a.ase_valorAsegurado AS VALOR_ASEGURADO
FROM incidentes i
INNER JOIN aseguramientos a ON a.ase_placa = i.inci_placa;
END$$
DELIMITER ;

-- ---------------------------------------------------------------------------
-- Visualizar los incidentes del vehículo con placas " FLL420",
-- este reporte debe visualizar la fecha, el lugar,
-- la cantidad de heridos del incidente, la fecha de inicio,
-- la de expiración de la póliza y el valor asegurado
-- ---------------------------------------------------------------------------
DELIMITER $$
CREATE PROCEDURE SP_IncidentesPlaca_FLL420()
BEGIN
SELECT i.inci_placa AS PLACA,
i.inci_fecha AS FECHA,
i.inci_lugar AS LUGAR,
i.inci_cant_heridos AS HERIDOS,
a.ase_fechaInicio AS FECHA_INICIO,
a.ase_fechaExpiracion AS EXPIRACION_POLIZA,
a.ase_valorAsegurado AS VALOR_ASEGURADO
FROM incidentes i
INNER JOIN aseguramientos a ON a.ase_placa = i.inci_placa
WHERE i.inci_placa = 'FLL420';
END$$
DELIMITER ;

-- /////////////////////////////////////////////////////////////////////////
-- 4. Realice las Siguientes funciones en MySQL
-- ////////////////////////////////////////////////////////////////////////

-- ---------------------------------------------------------------------------
-- Cuente el número de estudiantes cuya edad sea mayor a 22
-- ---------------------------------------------------------------------------
DELIMITER $$
CREATE FUNCTION MayoresA22()
RETURNS INT
DETERMINISTIC
BEGIN
DECLARE mayoresA22 INT;
SET mayoresA22 =(
SELECT count(edad_est) FROM estudiantes
WHERE edad_est > 22
);
RETURN mayoresA22;
END $$
DELIMITER ;

-- ---------------------------------------------------------------------------
-- Muestre el nombre y la edad del estudiante más joven
-- ---------------------------------------------------------------------------
DELIMITER $$
CREATE FUNCTION EstudianteMasJoven()
RETURNS VARCHAR(100)
NO SQL
BEGIN
DECLARE nombre VARCHAR(45);
DECLARE edad INT(11);
-- asigno el nombre a la variable
SET nombre = (SELECT nom_est FROM estudiantes
WHERE edad_est = (SELECT MIN(edad_est) FROM estudiantes));
-- asigno la edad a la variable
SET edad = (SELECT edad_est FROM estudiantes
WHERE edad_est = (SELECT MIN(edad_est) FROM estudiantes)) ;
-- Retorno la información
RETURN concat('EL ESTUDIANTE CON MENOR EDAD ES : ', nombre,' CON
<',edad,'> AÑOS');
END $$
DELIMITER ;

-- ---------------------------------------------------------------------------
-- Calcule el valor promedio de los cursos cuyas horas sean mayores a 40.
-- ---------------------------------------------------------------------------
DELIMITER $$
CREATE FUNCTION ValorPromedioCursos()
RETURNS DECIMAL(11,2)
NO SQL
BEGIN
RETURN (SELECT AVG(valor_curs) FROM cursos);
END $$
DELIMITER ;

-- ---------------------------------------------------------------------------
-- Obtener el sueldo promedio de los profesores de la categoría 1
-- ---------------------------------------------------------------------------
DELIMITER $$
CREATE FUNCTION SalarioPromedioProfesoresCat1()
RETURNS DECIMAL(11,2)
NO SQL
BEGIN
RETURN (
SELECT AVG(sal_prof) FROM profesores
WHERE cate_prof = 1
);
END $$
DELIMITER ;

-- ---------------------------------------------------------------------------
-- Muestre el nombre del profesor con menor sueldo.
-- ---------------------------------------------------------------------------
DELIMITER $$
CREATE FUNCTION NombreProfesorMenorSueldo()
RETURNS VARCHAR(45)
NO SQL
BEGIN
RETURN (
SELECT nom_prof FROM profesores
WHERE sal_prof = (SELECT MIN(sal_prof) FROM profesores)
);
END $$
DELIMITER ;

-- /////////////////////////////////////////////////////////////////////////
-- 5. Realice las Siguientes funciones en ORACLE:
-- ////////////////////////////////////////////////////////////////////////

-- ---------------------------------------------------------------------------
-- Visualizar el nombre del cliente, la fecha y el valor del pedido más costoso.
-- ---------------------------------------------------------------------------
CREATE OR REPLACE FUNCTION MostrarPedidoMasCostoso
RETURN VARCHAR2
IS
CURSOR cur IS
SELECT cli.nom_cli AS NOMBRE,
p.fec_ped AS FECHA,
p.val_ped AS VALOR
FROM pedido p
INNER JOIN cliente cli ON cli.id_cli = p.id_cli_ped
WHERE p.val_ped = (SELECT MAX(val_ped) FROM pedido);
fila cur%ROWTYPE;
BEGIN
OPEN cur;
FETCH cur INTO fila;
CLOSE cur;
RETURN fila.NOMBRE||' / '||fila.FECHA||' / '||fila.VALOR;
END;

-- ---------------------------------------------------------------------------
-- Mostrar cuantos artículos se tienen de cada editorial
-- ---------------------------------------------------------------------------
CREATE OR REPLACE FUNCTION ArticulosxEditorial
RETURN VARCHAR2
IS
articulos VARCHAR2(32766) := '';
CURSOR cur IS
SELECT edi_art AS EDITORIAL,
count(edi_art) AS CANTIDAD
FROM articulo
GROUP BY edi_art;
fila cur%rowtype;
BEGIN
OPEN cur;
LOOP
FETCH cur INTO fila;
EXIT WHEN cur%NOTFOUND;
articulos := articulos||' / '||(fila.EDITORIAL||' => '||fila.CANTIDAD);
END LOOP;
RETURN articulos;
END;

-- ---------------------------------------------------------------------------
-- Visualizar todos los datos de la póliza más costosa
-- ---------------------------------------------------------------------------
CREATE OR REPLACE FUNCTION PolizaMasCostosa
RETURN VARCHAR2
IS
poliza VARCHAR2(32766) := '';
CURSOR cur IS
SELECT ase_cod AS codigo,
ase_fechaInicio AS fecha,
ase_fechaexpiracion AS fechafin,
ase_valorasegurado AS valor,
ase_estado AS estado,
ase_costo AS costo,
ase_placa AS placa
FROM aseguramientos
WHERE ASE_COSTO = (SELECT MAX(ase_costo) from aseguramientos);
fila cur%rowtype;
BEGIN
OPEN cur;
LOOP
FETCH cur INTO fila;
EXIT WHEN cur%NOTFOUND;
poliza := ( ' CODIGO: '||fila.codigo||' / '||
' INICIO: '||fila.fecha||' / '||
' EXPIRA: '||fila.fechafin||' / '||
' VALOR: '||fila.valor||' / '||
' ESTADO: '||fila.estado||' / '||
' COSTO: '||fila.costo||' / '||
' PLACA: '||fila.placa
);
END LOOP;
RETURN poliza;
END;

-- ---------------------------------------------------------------------------
-- Visualizar los incidentes con el mínimo número de autos involucrados,
-- de este incidente visualizar el estado de la póliza y el valor asegurado
-- ---------------------------------------------------------------------------
CREATE OR REPLACE FUNCTION EstadoIncidente
RETURN VARCHAR2
IS
poliza VARCHAR2(32766) := '';
CURSOR cur IS
SELECT ase_valorasegurado AS valor,
ase_estado AS estado
FROM aseguramientos
INNER JOIN incidentes ON incidentes.INCI_PLACA = aseguramientos.ASE_PLACA
WHERE incidentes.INCI_CANT_AUTOS_INVOLUCRADOS
= (SELECT MIN(incidentes.INCI_CANT_AUTOS_INVOLUCRADOS) from incidentes);
fila cur%rowtype;
BEGIN
OPEN cur;
LOOP
FETCH cur INTO fila;
EXIT WHEN cur%NOTFOUND;
poliza := ( ' VALOR: '||fila.valor||' / '||
' ESTADO: '||fila.estado
);
END LOOP;
RETURN poliza;
END;

-- ---------------------------------------------------------------------------
-- Visualizar los datos de la póliza cuyo valor asegurado es el más costoso,
-- este reporte además de visualizar todos los datos de la póliza,
-- debe presentar todos los datos del vehículo que tiene dicha póliza.
-- ---------------------------------------------------------------------------
CREATE OR REPLACE FUNCTION AutoPolizaMasCostosa
RETURN VARCHAR2
IS
poliza VARCHAR2(32766) := '';
CURSOR cur IS
SELECT ase.ase_cod AS codigo,
ase.ase_fechainicio AS inicio,
ase.ase_fechaexpiracion AS fin,
ase.ase_valorasegurado AS valor,
ase.ase_estado AS estado,
ase.ase_costo AS costo,
ase.ase_placa AS placa,
au.auto_marca AS marca,
au.auto_tipo AS tipo,
au.auto_modelo AS modelo,
au.auto_num_pasajeros AS pasajeros,
au.auto_cilindraje AS cilindraje,
au.auto_num_chasis AS chasis
FROM aseguramientos ase
INNER JOIN automotores au ON au.auto_placa = ase.ASE_PLACA
WHERE ase.ASE_VALORASEGURADO
= (SELECT MAX(ase_valorasegurado) from aseguramientos);
fila cur%rowtype;
BEGIN
OPEN cur;
LOOP
FETCH cur INTO fila;
EXIT WHEN cur%NOTFOUND;
poliza := ( ' CODIGO: '||fila.codigo||' / '||
' INICIO: '||fila.inicio||' / '||
' EXPIRA: '||fila.fin||' / '||
' VALOR: '||fila.valor||' / '||
' ESTADO: '||fila.estado||' / '||
' COSTO: '||fila.costo||' / '||
' PLACA: '||fila.placa||' / '||
' MARCA: '||fila.marca||' / '||
' TIPO: '||fila.tipo||' / '||
' MODELO: '||fila.modelo||' / '||
' PASAJEROS: '||fila.pasajeros||' / '||
' CILINDRAJE: '||fila.cilindraje||' / '||
' CHASIS: '||fila.chasis
);
END LOOP;
RETURN poliza;
END;

-- /////////////////////////////////////////////////////////////////////////
-- 6. Construya los siguiente disparadores para controlar
-- la actualización y borrado de registros:
-- ////////////////////////////////////////////////////////////////////////

-- ---------------------------------------------------------------------------
-- Para la creación de los triggers se crean 2 tablas adicionales:
-- una tabla 'bitacoraUpdate', para guardar los datos de las actualizaciones
-- y una tabla 'bitacoraDelete', para los datos elimandos.
-- ---------------------------------------------------------------------------
CREATE TABLE bitacoraUpdate (
id INT AUTO_INCREMENT,
tabla VARCHAR(45) NOT NULL,
id_registro VARCHAR(15) NOT NULL,
dato_anterior VARCHAR(45) NOT NULL,
dato_nuevo VARCHAR(45) NOT NULL,
fecha DATETIME NOT NULL,
usuario VARCHAR(45) NOT NULL,
PRIMARY KEY (id)
) ENGINE=INNODB;

CREATE TABLE bitacoraDelete (


id INT AUTO_INCREMENT,
tabla VARCHAR(45) NOT NULL,
id_registro VARCHAR(15) NOT NULL,
fecha DATETIME NOT NULL,
usuario VARCHAR(45) NOT NULL,
PRIMARY KEY (id)
) ENGINE=INNODB;

-- ---------------------------------------------------------------------------
-- TRIGGERs En MySQL; para las tablas Profesor, Curso, Estudiante.
-- ---------------------------------------------------------------------------
-- ---------------------------------------------------------------------------
-- Actualiza PROFESORES
-- ---------------------------------------------------------------------------
DELIMITER $$
CREATE TRIGGER actualiza_profesor
BEFORE UPDATE ON profesores FOR EACH ROW
BEGIN
IF NEW.nom_prof != OLD.nom_prof THEN
INSERT INTO bitacoraupdate
VALUES
(NULL,'profesores',OLD.doc_prof,OLD.nom_prof,NEW.nom_prof,now(),User());
END IF;
IF NEW.ape_prof != OLD.ape_prof THEN
INSERT INTO bitacoraupdate
VALUES
(NULL,'profesores',OLD.doc_prof,OLD.ape_prof,NEW.ape_prof,now(),User());
END IF;
IF NEW.cate_prof != OLD.cate_prof THEN
INSERT INTO bitacoraupdate
VALUES
(NULL,'profesores',OLD.doc_prof,OLD.cate_prof,NEW.cate_prof,now(),User());
END IF;
IF NEW.sal_prof != OLD.sal_prof THEN
INSERT INTO bitacoraupdate
VALUES
(NULL,'profesores',OLD.doc_prof,OLD.sal_prof,NEW.sal_prof,now(),User());
END IF;
END $$
DELIMITER ;

-- ---------------------------------------------------------------------------
-- Elimina PROFESORES
-- ---------------------------------------------------------------------------
DELIMITER $$
CREATE TRIGGER delete_profesor
BEFORE UPDATE ON profesores FOR EACH ROW
BEGIN
INSERT INTO bitacoradelete
VALUES (NULL,'profesores',doc_prof,now(),user()),
(NULL,'profesores',nom_prof,now(),user()),
(NULL,'profesores',ape_prof,now(),user()),
(NULL,'profesores',cate_prof,now(),user()),
(NULL,'profesores',sal_prof,now(),user());
END $$
DELIMITER ;

-- ---------------------------------------------------------------------------
-- Actualiza CURSOS
-- ---------------------------------------------------------------------------
DELIMITER $$
CREATE TRIGGER actualiza_curso
BEFORE UPDATE ON cursos FOR EACH ROW
BEGIN
IF NEW.nom_curs != OLD.nom_curs THEN
INSERT INTO bitacoraupdate
VALUES (NULL,'cursos',OLD.cod_curs,OLD.nom_curs,NEW.nom_curs,now(),User());
END IF;
--
IF NEW.horas_curs != OLD.horas_curs THEN
INSERT INTO bitacoraupdate
VALUES
(NULL,'cursos',OLD.cod_curs,OLD.horas_curs,NEW.horas_curs,now(),User());
END IF;
--
IF NEW.valor_curs != OLD.valor_curs THEN
INSERT INTO bitacoraupdate
VALUES
(NULL,'cursos',OLD.cod_curs,OLD.valor_curs,NEW.valor_curs,now(),User());
END IF;
--
END $$
DELIMITER ;

-- ---------------------------------------------------------------------------
-- ELIMINA CURSOS
-- ---------------------------------------------------------------------------
DELIMITER $$
CREATE TRIGGER delete_curso
BEFORE UPDATE ON cursos FOR EACH ROW
BEGIN
INSERT INTO bitacoradelete
VALUES (NULL,'cursos',cod_curs,now(),user()),
(NULL,'cursos',nom_curs,now(),user()),
(NULL,'cursos',horas_curs,now(),user()),
(NULL,'cursos',valor_curs,now(),user());
END $$
DELIMITER ;

-- ---------------------------------------------------------------------------
-- Actualiza ESTUDIANTES
-- ---------------------------------------------------------------------------
DELIMITER $$
CREATE TRIGGER actualiza_estudiante
BEFORE UPDATE ON estudiantes FOR EACH ROW
BEGIN
IF NEW.nom_est != OLD.nom_est THEN
INSERT INTO bitacoraupdate
VALUES
(NULL,'estudiantes',OLD.doc_est,OLD.nom_est,NEW.nom_est,now(),User());
END IF;
--
IF NEW.ape_est != OLD.ape_est THEN
INSERT INTO bitacoraupdate
VALUES
(NULL,'estudiantes',OLD.doc_est,OLD.ape_est,NEW.ape_est,now(),User());
END IF;
--
IF NEW.edad_est != OLD.edad_est THEN
INSERT INTO bitacoraupdate
VALUES
(NULL,'estudiantes',OLD.doc_est,OLD.edad_est,NEW.edad_est,now(),User());
END IF;
--
END $$
DELIMITER ;

-- ---------------------------------------------------------------------------
-- ELIMINAR ESTUDIANTES
-- ---------------------------------------------------------------------------
DELIMITER $$
CREATE TRIGGER delete_estudiante
BEFORE UPDATE ON estudiantes FOR EACH ROW
BEGIN
INSERT INTO bitacoradelete
VALUES (NULL,'estudiantes',doc_est,now(),user()),
(NULL,'estudiantes',nom_est,now(),user()),
(NULL,'estudiantes',ape_est,now(),user()),
(NULL,'estudiantes',edad_est,now(),user());
END $$
DELIMITER ;

-- ---------------------------------------------------------------------------
-- En el Motor de su preferencia (ORACLE O MySQL), TRIGGERS para las tablas,
-- Automotores, Aseguramientos, Incidentes.
-- ---------------------------------------------------------------------------
-- ---------------------------------------------------------------------------
-- Actualiza Automotores
-- ---------------------------------------------------------------------------
DELIMITER $$
CREATE TRIGGER actualiza_automotor
BEFORE UPDATE ON automotores FOR EACH ROW
BEGIN
IF NEW.auto_marca != OLD.auto_marca THEN
INSERT INTO bitacoraupdate
VALUES (NULL,'automotores',OLD.auto_placa,OLD.auto_marca,
NEW.auto_marca,now(),User());
END IF;
--
IF NEW.auto_tipo != OLD.auto_tipo THEN
INSERT INTO bitacoraupdate
VALUES (NULL,'automotores',OLD.auto_placa,OLD.auto_tipo,
NEW.auto_tipo,now(),User());
END IF;
--
IF NEW.auto_modelo != OLD.auto_modelo THEN
INSERT INTO bitacoraupdate
VALUES (NULL,'automotores',OLD.auto_placa,OLD.auto_modelo,
NEW.auto_modelo,now(),User());
END IF;
--
IF NEW.auto_num_pasajeros != OLD.auto_num_pasajeros THEN
INSERT INTO bitacoraupdate
VALUES (NULL,'automotores',OLD.auto_placa,OLD.auto_num_pasajeros,
NEW.auto_num_pasajeros,now(),User());
END IF;
--
IF NEW.auto_cilindraje != OLD.auto_cilindraje THEN
INSERT INTO bitacoraupdate
VALUES (NULL,'automotores',OLD.auto_placa,OLD.auto_cilindraje,
NEW.auto_cilindraje,now(),User());
END IF;
--
IF NEW.auto_num_chasis != OLD.auto_num_chasis THEN
INSERT INTO bitacoraupdate
VALUES (NULL,'automotores',OLD.auto_placa,OLD.auto_num_chasis,
NEW.auto_num_chasis,now(),User());
END IF;
--
END $$
DELIMITER ;

-- ---------------------------------------------------------------------------
-- Elimina Automotores
-- ---------------------------------------------------------------------------
DELIMITER $$
CREATE TRIGGER delete_automotor
BEFORE UPDATE ON automotores FOR EACH ROW
BEGIN
INSERT INTO bitacoradelete
VALUES (NULL,'automotores',auto_placa,now(),user()),
(NULL,'automotores',auto_marca,now(),user()),
(NULL,'automotores',auto_tipo,now(),user()),
(NULL,'automotores',auto_modelo,now(),user()),
(NULL,'automotores',auto_num_pasajeros,now(),user()),
(NULL,'automotores',auto_cilindraje,now(),user()),
(NULL,'automotores',auto_num_chasis,now(),user());
END $$
DELIMITER ;

-- ---------------------------------------------------------------------------
-- Actualiza ASEGURAMIENTOS
-- ---------------------------------------------------------------------------
DELIMITER $$
CREATE TRIGGER actualiza_poliza
BEFORE UPDATE ON aseguramientos FOR EACH ROW
BEGIN
IF NEW.ase_fechainicio != OLD.ase_fechainicio THEN
INSERT INTO bitacoraupdate
VALUES (NULL,'aseguramientos',OLD.ase_cod,OLD.ase_fechainicio,
NEW.ase_fechainicio,now(),User());
END IF;
--
IF NEW.ase_fechaexpiración != OLD.ase_fechaexpiración THEN
INSERT INTO bitacoraupdate
VALUES (NULL,'aseguramientos',OLD.ase_cod,OLD.ase_fechaexpiración,
NEW.ase_fechaexpiración,now(),User());
END IF;
--
IF NEW.ase_valorasegurado != OLD.ase_valorasegurado THEN
INSERT INTO bitacoraupdate
VALUES (NULL,'aseguramientos',OLD.ase_cod,OLD.ase_valorasegurado,
NEW.ase_valorasegurado,now(),User());
END IF;
--
IF NEW.ase_estado != OLD.ase_estado THEN
INSERT INTO bitacoraupdate
VALUES (NULL,'aseguramientos',OLD.ase_cod,OLD.ase_estado,
NEW.ase_estado,now(),User());
END IF;
--
IF NEW.ase_costo != OLD.ase_costo THEN
INSERT INTO bitacoraupdate
VALUES (NULL,'aseguramientos',OLD.ase_cod,OLD.ase_costo,
NEW.ase_costo,now(),User());
END IF;
--
IF NEW.ase_placa != OLD.ase_placa THEN
INSERT INTO bitacoraupdate
VALUES (NULL,'aseguramientos',OLD.ase_cod,OLD.ase_placa,
NEW.ase_placa,now(),User());
END IF;
--
END $$
DELIMITER ;
-- ---------------------------------------------------------------------------
-- ELIMINA aseguramientos
-- ---------------------------------------------------------------------------
DELIMITER $$
CREATE TRIGGER delete_poliza
BEFORE UPDATE ON aseguramientos FOR EACH ROW
BEGIN
INSERT INTO bitacoradelete
VALUES (NULL,'aseguramientos',ase_cod,now(),user()),
(NULL,'aseguramientos',ase_fechainicio,now(),user()),
(NULL,'aseguramientos',ase_fechaexpiracion,now(),user()),
(NULL,'aseguramientos',ase_valorAsegurado,now(),user()),
(NULL,'aseguramientos',ase_estado,now(),user()),
(NULL,'aseguramientos',ase_costo,now(),user()),
(NULL,'aseguramientos',ase_placa,now(),user());
END $$
DELIMITER ;

-- ---------------------------------------------------------------------------
-- Actualiza incidentes
-- ---------------------------------------------------------------------------
DELIMITER $$
CREATE TRIGGER actualiza_incidente
BEFORE UPDATE ON incidentes FOR EACH ROW
BEGIN
IF NEW.inci_fecha != OLD.inci_fecha THEN
INSERT INTO bitacoraupdate
VALUES (NULL,'incidentes',OLD.inci_cod,OLD.inci_fecha,
NEW.inci_fecha,now(),User());
END IF;
--
IF NEW.inci_placa != OLD.inci_placa THEN
INSERT INTO bitacoraupdate
VALUES (NULL,'incidentes',OLD.inci_cod,OLD.inci_placa,
NEW.inci_placa,now(),User());
END IF;
--
IF NEW.inci_lugar != OLD.inci_lugar THEN
INSERT INTO bitacoraupdate
VALUES (NULL,'incidentes',OLD.inci_cod,OLD.inci_lugar,
NEW.inci_lugar,now(),User());
END IF;
--
IF NEW.inci_cant_heridos != OLD.inci_cant_heridos THEN
INSERT INTO bitacoraupdate
VALUES (NULL,'incidentes',OLD.inci_cod,OLD.inci_cant_heridos,
NEW.inci_cant_heridos,now(),User());
END IF;
--
IF NEW.inci_cant_fatalidades != OLD.inci_cant_fatalidades THEN
INSERT INTO bitacoraupdate
VALUES (NULL,'incidentes',OLD.inci_cod,OLD.inci_cant_fatalidades,
NEW.inci_cant_fatalidades,now(),User());
END IF;
--
IF NEW.inci_cant_autos_involucrados != OLD.inci_cant_autos_involucrados THEN
INSERT INTO bitacoraupdate
VALUES (NULL,'incidentes',OLD.inci_cod,OLD.inci_cant_autos_involucrados,
NEW.inci_cant_autos_involucrados,now(),User());
END IF;
--
END $$
DELIMITER ;

-- ---------------------------------------------------------------------------
-- ELIMINA incidentes
-- ---------------------------------------------------------------------------
DELIMITER $$
CREATE TRIGGER delete_incidente
BEFORE UPDATE ON incidentes FOR EACH ROW
BEGIN
INSERT INTO bitacoradelete
VALUES (NULL,'incidentes',inci_cod,now(),user()),
(NULL,'incidentes',inci_fecha,now(),user()),
(NULL,'incidentes',inci_placa,now(),user()),
(NULL,'incidentes',inci_lugar,now(),user()),
(NULL,'incidentes',inci_cant_heridos,now(),user()),
(NULL,'incidentes',inci_cant_fatalidades,now(),user()),
(NULL,'incidentes',inci_cant_autos_involucrados,now(),user());
END $$
DELIMITER ;