Este documento presenta procedimientos almacenados para realizar inserciones en las tablas Profesor, Curso, Estudiante y EstudiantexCurso de una base de datos. También incluye funciones, disparadores y procedimientos para consultar y auditar datos almacenados en las tablas.
Este documento contiene 21 ejercicios sobre la creación de procedimientos y funciones en MySQL utilizando las bases de datos Sakila y World. Los ejercicios cubren temas como la creación de procedimientos con parámetros de entrada y salida, funciones, consultas condicionales y manejo de errores.
El documento describe cómo crear una clase Cuenta en Java que represente una cuenta bancaria con atributos como número de cuenta, titular y saldo. La clase incluirá métodos para realizar depósitos, retiros y mostrar el balance. Se proveerán constructores por defecto y con parámetros para inicializar la clase.
Código fuente en .txt para el ejercicio de Atletas Adsi Java , que busca dentro de un array el mejor tiempo y lo muestra al final.
Libre para que lo modifiquen a gusto propio. Por ejemplo ponerle un menu, etc.
Enjoy it :)
El documento explica qué son los triggers en MySQL. Los triggers son procedimientos que se ejecutan automáticamente cuando ocurre una acción específica, como insertar, actualizar o eliminar datos. Tienen un nombre, se disparan antes o después de un evento como INSERT, UPDATE o DELETE, y se usan para mejorar la administración de datos en la base de datos.
El documento describe los conceptos de herencia en programación orientada a objetos. Explica que una subclase hereda los atributos y métodos de su superclase. Incluye ejemplos de cómo implementar herencia para sumar y restar números, así como para modelar personas y empleados. También cubre conceptos como público, privado y protegido y el uso de interfaces gráficas Swing para la entrada y salida de datos.
Este documento presenta un examen final de base de datos en SQL. El objetivo es crear una base de datos con tablas de clientes, habitaciones, reservas y servicios, e insertar y actualizar registros en las tablas a través de consultas SQL. El examen también incluye la creación de vistas para recuperar datos específicos de las tablas.
This document discusses procedures and functions in Oracle. Procedures are reusable blocks of SQL and PL/SQL code that perform a specific task and are stored in the database. There are two types of procedures - anonymous and stored. Stored procedures have a unique name and can accept parameters. Functions are similar to procedures but return a single value. Both procedures and functions can take input parameters of different types. The document provides examples of creating and calling a procedure and function.
Este documento contiene 21 ejercicios sobre la creación de procedimientos y funciones en MySQL utilizando las bases de datos Sakila y World. Los ejercicios cubren temas como la creación de procedimientos con parámetros de entrada y salida, funciones, consultas condicionales y manejo de errores.
El documento describe cómo crear una clase Cuenta en Java que represente una cuenta bancaria con atributos como número de cuenta, titular y saldo. La clase incluirá métodos para realizar depósitos, retiros y mostrar el balance. Se proveerán constructores por defecto y con parámetros para inicializar la clase.
Código fuente en .txt para el ejercicio de Atletas Adsi Java , que busca dentro de un array el mejor tiempo y lo muestra al final.
Libre para que lo modifiquen a gusto propio. Por ejemplo ponerle un menu, etc.
Enjoy it :)
El documento explica qué son los triggers en MySQL. Los triggers son procedimientos que se ejecutan automáticamente cuando ocurre una acción específica, como insertar, actualizar o eliminar datos. Tienen un nombre, se disparan antes o después de un evento como INSERT, UPDATE o DELETE, y se usan para mejorar la administración de datos en la base de datos.
El documento describe los conceptos de herencia en programación orientada a objetos. Explica que una subclase hereda los atributos y métodos de su superclase. Incluye ejemplos de cómo implementar herencia para sumar y restar números, así como para modelar personas y empleados. También cubre conceptos como público, privado y protegido y el uso de interfaces gráficas Swing para la entrada y salida de datos.
Este documento presenta un examen final de base de datos en SQL. El objetivo es crear una base de datos con tablas de clientes, habitaciones, reservas y servicios, e insertar y actualizar registros en las tablas a través de consultas SQL. El examen también incluye la creación de vistas para recuperar datos específicos de las tablas.
This document discusses procedures and functions in Oracle. Procedures are reusable blocks of SQL and PL/SQL code that perform a specific task and are stored in the database. There are two types of procedures - anonymous and stored. Stored procedures have a unique name and can accept parameters. Functions are similar to procedures but return a single value. Both procedures and functions can take input parameters of different types. The document provides examples of creating and calling a procedure and function.
Un disparador es un objeto de base de datos con nombre que se asocia a una tabla, y se activa cuando ocurre un evento en particular para la tabla. Algunos usos para los disparadores es verificar valores a ser insertados o llevar a cabo cálculos sobre valores involucrados en una actualización.
Aqui les dejo un ejemplo de Trigger, que puede servir de referencia, como elemento Accounting, de seguridad para algunas tablas de sus bases de Datos
Dominando las funciones de ventana (window functions) en TSQLSpanishPASSVC
Las funciones de ventana (TSQL window functions), originalmente presentadas en SQL Server han probado ser muy útiles para resolver escenarios complejos de clasificación/ordenamiento y agregación. Las mejoras que nos trae SQL Server 2012 hace imperativo conocer su funcionamiento y aplicación. En esta sesión discutiremos sus componentes principales y como utilizar las mismas tomando como ejemplos situaciones de la vida real.
Taller: Prueba Unitaria con JUnit en NetBeansEmerson Garay
Este documento describe cómo crear pruebas unitarias con JUnit en NetBeans para validar funciones en clases Java. Inicialmente se crean dos clases, Validar y Util, con métodos de validación y utilidad. Luego, se generan clases de prueba JUnit para cada clase aplicando aserciones y validando que los resultados coinciden con los esperados. Finalmente, se muestran técnicas avanzadas como pruebas parametrizadas y suites de pruebas para ejecutar varias pruebas de forma agrupada.
El documento presenta 27 ejemplos de sentencias SQL para manipular datos en dos tablas (DEPARTAMENTO y EMPLEADO) de una base de datos de recursos humanos. Las sentencias incluyen consultas, inserciones, actualizaciones y eliminaciones de registros para explorar funcionalidades básicas de SQL.
SISTEMA DE FACTURACION (Ejemplo desarrollado)Darwin Durand
The document describes the creation of a database in SQL Server to manage invoices and receipts. It includes tables for clients, employees, document headers, and document details. Stored procedures are created to insert data and a form is developed in Visual Studio .NET to manage documents. The form allows searching for clients and employees, adding product details, and printing reports using Crystal Reports.
Este documento explica cómo crear y administrar usuarios y permisos en MySQL. Detalla los comandos para crear usuarios, otorgarles permisos sobre bases de datos y tablas específicas, modificar contraseñas y eliminar usuarios. También cubre la creación de usuarios para acceso remoto y un ejercicio práctico para crear usuarios con permisos específicos sobre la base de datos Clientes.
Procedimientos almacenados en MySQL define un procedimiento almacenado como un conjunto de comandos SQL que se almacenan en el servidor de bases de datos para su reutilización. Ofrecen ventajas como un mejor rendimiento y seguridad al realizar operaciones comunes. Se crean usando comandos CREATE PROCEDURE y se invocan con CALL.
El documento describe la estructura de una base de datos, las diferencias entre una base de datos y un sistema de gestión de bases de datos, y los pasos para diseñar una base de datos. Explica que la estructura de una base de datos incluye los tipos de datos, las relaciones entre los datos y las restricciones. También describe las funciones de definición, manipulación y utilización de un SGBD.
Este documento resume las principales características de seguridad en SQL Server. Comienza explicando la arquitectura de seguridad en SQL Server 2000, incluyendo autenticación, autorización, integridad y privacidad. Luego cubre la creación y gestión de inicios de sesión y roles, así como la asignación de permisos a través de roles, sentencias y objetos específicos. Finalmente, presenta algunas estrategias de seguridad como el uso de vistas, funciones y procedimientos almacenados.
Sql DML Lenguaje de manipulación de datos josecuartas
Este documento describe los principales comandos y cláusulas del lenguaje de manipulación de datos (DML) en SQL. Explica cómo se pueden insertar, actualizar y eliminar datos en una base de datos usando las instrucciones INSERT, UPDATE y DELETE. También describe cómo se pueden consultar y filtrar datos mediante las cláusulas SELECT, WHERE, ORDER BY y JOIN.
Este documento describe un ejercicio en Microsoft Access para crear una base de datos para un colegio con tablas para alumnos, profesores, cursos y evaluaciones. Incluye instrucciones para crear los campos de cada tabla, establecer propiedades como claves principales e índices, y agregar máscaras y validaciones a los campos. También incluye datos de ejemplo para llenar las tablas.
El documento habla sobre los procedimientos almacenados en bases de datos. Explica que un procedimiento almacenado es un programa almacenado físicamente en una base de datos que generalmente está escrito en un lenguaje como PL/SQL. Luego describe algunas ventajas de usar procedimientos almacenados como la compilación, automatización, administración, seguridad y programabilidad. Finalmente resume los tipos, utilidad y sintaxis básica de los procedimientos almacenados.
Procedures in pl/sql,CREATE PROCEDURE Syntax, Compiling and Showing Errors, Parameters, Defining the IN, OUT, and IN OUT Parameter Modes, Parameter Constraint Restrictions, Example – Procedure with No Parameters,Example – Passing IN and OUT Parameters, Dropping a Procedure
El documento describe las estructuras en C. Una estructura permite agrupar múltiples variables de diferentes tipos bajo un nombre. Las estructuras se definen usando la palabra clave struct y contienen campos que almacenan los datos. Las estructuras permiten manipular conjuntos de datos relacionados como un solo objeto.
El documento describe cómo crear y administrar una base de datos y tablas en MySQL usando lenguaje SQL. Inicialmente se crea una base de datos llamada "estudianteBD", luego se crea una tabla dentro de ella y se agregan campos. También se describen cómo insertar, actualizar y eliminar datos, así como eliminar la base de datos. Finalmente, se explica phpMyAdmin como una herramienta para administrar bases de datos MySQL a través de una interfaz web.
El documento explica las reglas de normalización de bases de datos y provee ejemplos de su aplicación. Se describe la transformación de una tabla no normalizada a primera forma normal al eliminar grupos repetidos. Luego se explica cómo aplicar la segunda forma normal para eliminar columnas no llave que no dependen de la llave primaria. Finalmente, se detalla el proceso para alcanzar la tercera forma normal mediante la remoción de columnas no llave dependientes de otras no llave.
Programación II CIP200 Ejercicios resueltos en el Laboratorio de estructuras ...rasave
El programa permite al usuario introducir los nombres, edades y alturas de 10 jugadores. Luego muestra un menú con opciones para listar los nombres, alturas o edades de los jugadores. Usa una estructura para almacenar la información de cada jugador y funciones para recopilar los datos, mostrar el menú y listar la información según la opción seleccionada.
Tutorial Teorico-Practico Sql server 2000 (233 paginas)Martin Murciego
Este documento presenta información sobre la estructura de una base de datos de un hospital, incluyendo las tablas, sus campos y datos de ejemplo. Se describen las tablas de empleados, departamentos, hospitales, médicos, personal, pacientes y salas, además de proporcionar ejemplos de consultas SQL.
El documento describe las funciones básicas del lenguaje SQL y el sistema de gestión de bases de datos MySQL. Explica que SQL consta de dos partes, una para manipular datos y otra para definirlos. MySQL es un SGBD que permite acceder a bases de datos de manera sencilla mediante comandos SQL. El documento también define los lenguajes DDL y DML de SQL y muestra ejemplos básicos de comandos como crear tablas, insertar y consultar datos.
Un trigger es un procedimiento que se ejecuta automáticamente cuando ocurre un evento específico, como insertar, actualizar o eliminar datos de una tabla. Los triggers se usan comúnmente para auditar cambios, aplicar validaciones de datos y preservar la integridad referencial entre tablas.
El documento describe la creación de 7 stored procedures en SQL para realizar el mantenimiento de las tablas de una base de datos. Cada stored procedure recibe parámetros para insertar, actualizar, buscar, listar o eliminar registros de una tabla específica. Las tablas incluyen usuario, sistema, perfil, perfilxusuario, opción, opcionxperfil y opcionxusuario.
Este documento contiene ejemplos de código PL/SQL para declarar y ejecutar bloques, procedimientos y funciones. Incluye ejemplos de cómo crear y usar cursores, así como ejemplos de procedimientos que utilizan cursores para recuperar y mostrar datos de tablas.
Un disparador es un objeto de base de datos con nombre que se asocia a una tabla, y se activa cuando ocurre un evento en particular para la tabla. Algunos usos para los disparadores es verificar valores a ser insertados o llevar a cabo cálculos sobre valores involucrados en una actualización.
Aqui les dejo un ejemplo de Trigger, que puede servir de referencia, como elemento Accounting, de seguridad para algunas tablas de sus bases de Datos
Dominando las funciones de ventana (window functions) en TSQLSpanishPASSVC
Las funciones de ventana (TSQL window functions), originalmente presentadas en SQL Server han probado ser muy útiles para resolver escenarios complejos de clasificación/ordenamiento y agregación. Las mejoras que nos trae SQL Server 2012 hace imperativo conocer su funcionamiento y aplicación. En esta sesión discutiremos sus componentes principales y como utilizar las mismas tomando como ejemplos situaciones de la vida real.
Taller: Prueba Unitaria con JUnit en NetBeansEmerson Garay
Este documento describe cómo crear pruebas unitarias con JUnit en NetBeans para validar funciones en clases Java. Inicialmente se crean dos clases, Validar y Util, con métodos de validación y utilidad. Luego, se generan clases de prueba JUnit para cada clase aplicando aserciones y validando que los resultados coinciden con los esperados. Finalmente, se muestran técnicas avanzadas como pruebas parametrizadas y suites de pruebas para ejecutar varias pruebas de forma agrupada.
El documento presenta 27 ejemplos de sentencias SQL para manipular datos en dos tablas (DEPARTAMENTO y EMPLEADO) de una base de datos de recursos humanos. Las sentencias incluyen consultas, inserciones, actualizaciones y eliminaciones de registros para explorar funcionalidades básicas de SQL.
SISTEMA DE FACTURACION (Ejemplo desarrollado)Darwin Durand
The document describes the creation of a database in SQL Server to manage invoices and receipts. It includes tables for clients, employees, document headers, and document details. Stored procedures are created to insert data and a form is developed in Visual Studio .NET to manage documents. The form allows searching for clients and employees, adding product details, and printing reports using Crystal Reports.
Este documento explica cómo crear y administrar usuarios y permisos en MySQL. Detalla los comandos para crear usuarios, otorgarles permisos sobre bases de datos y tablas específicas, modificar contraseñas y eliminar usuarios. También cubre la creación de usuarios para acceso remoto y un ejercicio práctico para crear usuarios con permisos específicos sobre la base de datos Clientes.
Procedimientos almacenados en MySQL define un procedimiento almacenado como un conjunto de comandos SQL que se almacenan en el servidor de bases de datos para su reutilización. Ofrecen ventajas como un mejor rendimiento y seguridad al realizar operaciones comunes. Se crean usando comandos CREATE PROCEDURE y se invocan con CALL.
El documento describe la estructura de una base de datos, las diferencias entre una base de datos y un sistema de gestión de bases de datos, y los pasos para diseñar una base de datos. Explica que la estructura de una base de datos incluye los tipos de datos, las relaciones entre los datos y las restricciones. También describe las funciones de definición, manipulación y utilización de un SGBD.
Este documento resume las principales características de seguridad en SQL Server. Comienza explicando la arquitectura de seguridad en SQL Server 2000, incluyendo autenticación, autorización, integridad y privacidad. Luego cubre la creación y gestión de inicios de sesión y roles, así como la asignación de permisos a través de roles, sentencias y objetos específicos. Finalmente, presenta algunas estrategias de seguridad como el uso de vistas, funciones y procedimientos almacenados.
Sql DML Lenguaje de manipulación de datos josecuartas
Este documento describe los principales comandos y cláusulas del lenguaje de manipulación de datos (DML) en SQL. Explica cómo se pueden insertar, actualizar y eliminar datos en una base de datos usando las instrucciones INSERT, UPDATE y DELETE. También describe cómo se pueden consultar y filtrar datos mediante las cláusulas SELECT, WHERE, ORDER BY y JOIN.
Este documento describe un ejercicio en Microsoft Access para crear una base de datos para un colegio con tablas para alumnos, profesores, cursos y evaluaciones. Incluye instrucciones para crear los campos de cada tabla, establecer propiedades como claves principales e índices, y agregar máscaras y validaciones a los campos. También incluye datos de ejemplo para llenar las tablas.
El documento habla sobre los procedimientos almacenados en bases de datos. Explica que un procedimiento almacenado es un programa almacenado físicamente en una base de datos que generalmente está escrito en un lenguaje como PL/SQL. Luego describe algunas ventajas de usar procedimientos almacenados como la compilación, automatización, administración, seguridad y programabilidad. Finalmente resume los tipos, utilidad y sintaxis básica de los procedimientos almacenados.
Procedures in pl/sql,CREATE PROCEDURE Syntax, Compiling and Showing Errors, Parameters, Defining the IN, OUT, and IN OUT Parameter Modes, Parameter Constraint Restrictions, Example – Procedure with No Parameters,Example – Passing IN and OUT Parameters, Dropping a Procedure
El documento describe las estructuras en C. Una estructura permite agrupar múltiples variables de diferentes tipos bajo un nombre. Las estructuras se definen usando la palabra clave struct y contienen campos que almacenan los datos. Las estructuras permiten manipular conjuntos de datos relacionados como un solo objeto.
El documento describe cómo crear y administrar una base de datos y tablas en MySQL usando lenguaje SQL. Inicialmente se crea una base de datos llamada "estudianteBD", luego se crea una tabla dentro de ella y se agregan campos. También se describen cómo insertar, actualizar y eliminar datos, así como eliminar la base de datos. Finalmente, se explica phpMyAdmin como una herramienta para administrar bases de datos MySQL a través de una interfaz web.
El documento explica las reglas de normalización de bases de datos y provee ejemplos de su aplicación. Se describe la transformación de una tabla no normalizada a primera forma normal al eliminar grupos repetidos. Luego se explica cómo aplicar la segunda forma normal para eliminar columnas no llave que no dependen de la llave primaria. Finalmente, se detalla el proceso para alcanzar la tercera forma normal mediante la remoción de columnas no llave dependientes de otras no llave.
Programación II CIP200 Ejercicios resueltos en el Laboratorio de estructuras ...rasave
El programa permite al usuario introducir los nombres, edades y alturas de 10 jugadores. Luego muestra un menú con opciones para listar los nombres, alturas o edades de los jugadores. Usa una estructura para almacenar la información de cada jugador y funciones para recopilar los datos, mostrar el menú y listar la información según la opción seleccionada.
Tutorial Teorico-Practico Sql server 2000 (233 paginas)Martin Murciego
Este documento presenta información sobre la estructura de una base de datos de un hospital, incluyendo las tablas, sus campos y datos de ejemplo. Se describen las tablas de empleados, departamentos, hospitales, médicos, personal, pacientes y salas, además de proporcionar ejemplos de consultas SQL.
El documento describe las funciones básicas del lenguaje SQL y el sistema de gestión de bases de datos MySQL. Explica que SQL consta de dos partes, una para manipular datos y otra para definirlos. MySQL es un SGBD que permite acceder a bases de datos de manera sencilla mediante comandos SQL. El documento también define los lenguajes DDL y DML de SQL y muestra ejemplos básicos de comandos como crear tablas, insertar y consultar datos.
Un trigger es un procedimiento que se ejecuta automáticamente cuando ocurre un evento específico, como insertar, actualizar o eliminar datos de una tabla. Los triggers se usan comúnmente para auditar cambios, aplicar validaciones de datos y preservar la integridad referencial entre tablas.
El documento describe la creación de 7 stored procedures en SQL para realizar el mantenimiento de las tablas de una base de datos. Cada stored procedure recibe parámetros para insertar, actualizar, buscar, listar o eliminar registros de una tabla específica. Las tablas incluyen usuario, sistema, perfil, perfilxusuario, opción, opcionxperfil y opcionxusuario.
Este documento contiene ejemplos de código PL/SQL para declarar y ejecutar bloques, procedimientos y funciones. Incluye ejemplos de cómo crear y usar cursores, así como ejemplos de procedimientos que utilizan cursores para recuperar y mostrar datos de tablas.
El documento describe diferentes características de Transact SQL como identificadores de objetos de base de datos, tipos de datos definidos por el usuario, variables locales y globales, variables de tipo tabla, procedimientos almacenados, restricciones de integridad, sentencias de control de flujo como IF y WHILE, cursores, y triggers.
Este documento contiene 21 ejercicios sobre la creación de procedimientos y funciones en MySQL. Los ejercicios cubren temas como crear procedimientos que reciben y devuelven parámetros, funciones para calcular valores, y procedimientos para modificar y consultar datos en las tablas. El objetivo es familiarizarse con las herramientas de programación disponibles en MySQL.
El documento describe las características principales de los procedimientos almacenados, triggers y vistas en Microsoft SQL Server. Explica cómo crear procedimientos almacenados para insertar, actualizar y consultar datos, así como cómo crear triggers que se ejecutan automáticamente ante eventos como inserciones o actualizaciones. También describe cómo crear vistas para simplificar consultas a datos almacenados en tablas.
Este documento describe los pasos para configurar la replicación de una base de datos Oracle 10g Express Edition entre dos máquinas. Inicialmente se instala Oracle 10g EE en ambas máquinas y se conectan a través de una red. Luego, en la máquina servidora se crea un database link y una tabla de prueba, así como un trigger que replica los cambios en la tabla a la máquina cliente. Finalmente, se prueba la replicación consultando la tabla en ambas máquinas.
Unidad vi esp parte 2 procesimientos en plsql y transact sqlTitiushko Jazz
Este documento contiene ejemplos de código SQL y PL/SQL para trabajar con triggers, procedimientos, funciones y cursores. Incluye scripts para crear tablas, insertar datos, y ejemplos de cómo crear un trigger de bitácora, procedimientos para modificar salarios, una función para obtener un salario, y uso de cursores.
Unidad vi esp parte 2 procesimientos en plsql y transact sqlTitiushko Jazz
Este documento contiene ejemplos de código SQL y PL/SQL para trabajar con triggers, procedimientos, funciones y cursores. Incluye scripts para crear tablas, insertar datos, y ejemplos de cómo crear un trigger de bitácora, procedimientos para modificar salarios, una función para obtener un salario, y uso de cursores.
Este documento describe el uso de cursores en bases de datos. Explica que los cursores permiten manejar los registros devueltos por una consulta SELECT y pueden ser implícitos, cuando devuelven un solo registro, o explícitos, cuando devuelven múltiples registros. También cubre cómo declarar cursores y variables, y proporciona ejemplos de cómo utilizar cursores para actualizar tablas y ejecutar procedimientos almacenados.
El documento presenta el modelo entidad-relación de una base de datos académica que incluye entidades como asignaturas, salones, docentes, programas y más. Luego se muestran los scripts SQL para crear las tablas correspondientes a cada entidad y establecer las claves primarias y foráneas. Finalmente se incluye un código numérico.
El documento presenta el modelo entidad-relación de una base de datos académica que incluye entidades como asignaturas, salones, docentes, programas y más. Se definen las llaves primarias y foráneas de cada tabla y se incluye el código DDL para crear las tablas en una base de datos.
El documento presenta el modelo entidad-relación de una base de datos académica que incluye entidades como asignaturas, salones, docentes, programas y más. Se definen las llaves primarias y foráneas de cada tabla y se incluye el código DDL para crear las tablas en una base de datos.
El documento presenta el modelo entidad-relación de una base de datos académica que incluye entidades como asignaturas, salones, docentes, programas y más. Luego se muestran los scripts SQL para crear las tablas correspondientes a cada entidad y establecer las claves primarias y foráneas. Finalmente se incluye un código numérico.
El documento describe la creación y modificación de varias vistas en una base de datos de profesores. Se crean vistas para mostrar los nombres, códigos y salarios de profesores dentro de ciertos rangos, encontrar el salario máximo y mínimo, contar el número de profesores, y filtrar datos basados en letras en los nombres o rangos de códigos. Finalmente, se elimina una vista llamada "PROFESORX".
Este documento presenta una serie de ejercicios sobre el uso de funciones y procedimientos en PL/SQL. Los ejercicios incluyen crear funciones para realizar operaciones matemáticas usando parámetros, usar la sentencia SELECT INTO, contar préstamos con morosidad excesiva usando parámetros para el número de días, e implementar procedimientos para insertar, actualizar y eliminar registros de una tabla usando parámetros.
Este documento describe el uso de cursores en SQL. Los cursores permiten procesar tuplas de datos una por una en lugar de trabajar con conjuntos completos. Se explica la sintaxis básica para declarar, abrir, recuperar y cerrar cursores. Además, se proveen tres ejemplos detallados que ilustran cómo utilizar cursores para resolver problemas comunes como acumular créditos de un alumno, identificar los mejores estudiantes por carrera y determinar la lista de ingresantes a una carrera.
Este documento presenta las instrucciones para crear varios procedimientos almacenados y una vista en SQL Server para realizar consultas y actualizaciones de datos. Se explican los pasos para crear procedimientos para buscar empleados, obtener estadísticas de pedidos por producto y cliente, y leer datos de tablas usando cursores. También se crea una vista para unir datos de proveedores, clientes y empleados.
El documento describe el mecanismo de herencia en programación orientada a objetos. La herencia permite que una subclase herede los atributos y métodos de una superclase sin tener que reescribir el código. Un objeto de la subclase hereda todo lo de la superclase y puede incluir atributos y métodos adicionales.
El documento describe las transacciones, triggers y procedimientos almacenados en DB2/IBM. Explica que COMMIT confirma los cambios realizados en una transacción, mientras que ROLLBACK deshace cualquier cambio no confirmado. Los triggers son disparados antes o después de eventos como inserciones o actualizaciones y pueden validar o auditar datos. Los procedimientos almacenados permiten agrupar lógica de negocio reutilizable y pueden tener parámetros de entrada, salida o entrada/salida.
aqui estoy explicando un poco como son las estructuras de control de la Programacion orientada a objeto if-else, for, while,do-while,switch-case,exception
Similar a Solucion laboratorio lenguaje_transaccional (20)
Yahoo! es una compañía tecnológica fundada en 1994 que comenzó como un directorio de sitios web y se convirtió en uno de los primeros motores de búsqueda y portales en Internet. Ofrecía servicios variados como correo electrónico, noticias, finanzas y entretenimiento, siendo una parte fundamental del crecimiento inicial de la web. A lo largo de su historia, Yahoo! ha evolucionado y enfrentado desafíos significativos, pero su legado incluye su contribución pionera a la accesibilidad y organización de la información en línea.
El Observatorio ciudadano Irapuato ¿Cómo vamos?, presenta el
Reporte hemerográfico al mes de mayo de 2024
Este reporte contiene información registrada por Irapuato ¿cómo vamos? analizando los medios de comunicación tanto impresos como digitales y algunas fuentes de información como la Secretaría de Seguridad ciudadana.
1. SOLUCION LABORATORIO LENGUAJE TRANSACCIONAL
YANETH ROMERO RAMIREZ
SERVICIO NACIONAL DE APRENDIZAJE (SENA)
(ADSI) ANÁLISIS Y DE SARROLLO DE SISTEMAS DE INFORMACIÓN
BOGOTÁ
2017
SOLUCION LABORATORIO
Construya los siguiente procedimientos Almacenados para inserción de
registros:para las tablas Profesor, Curso, Estudiante,
Estudiantexcurso.
CREATE PROCEDURE InsertProfesor(pdocProf VARCHAR(11), pNomProf VARCHAR(30),
pApeProf VARCHAR(30), pCateProf INT(11), pSalProf INT(11))
INSERT INTO profesor(doc_prof, nom_prof, ape_prof, cate_prof, sal_prof)
VALUES(pdocProf, pNomProf, pApeProf , pCateProf, pSalProf);
CREATE PROCEDURE InsertCurso(pcod_curs INT(11), pnom_curs VARCHAR(100),
phoras_cur INT(11), pvalor_cur INT(11))
INSERT INTO curso(cod_curs, nom_curs, horas_cur, valor_cur)
VALUES(pcod_curs, pnom_curs, phoras_cur, pvalor_cur);
CREATE PROCEDURE InsertEstudiante(pdoc_est INT(11), pnom_est VARCHAR(30),
pap_est VARCHAR(30), pedad_est INT(11))
INSERT INTO estudiante(doc_est, nom_est, ap_est, edad_est)
VALUES(pdoc_est , pnom_est , pap_est, pedad_est);
CREATE PROCEDURE InsertEstudiantexCurso(pcod_cur_estcur INT(11), pdoc_est_estcur
INT(30), pfec_ini_estcur DATE)
INSERT INTO estudiantexcurso(cod_cur_estcur, doc_est_estcur,
fec_ini_estcur)
VALUES(pcod_cur_estcur, pdoc_est_estcur, pfec_ini_estcur
3.En MySQL construya los procedimientos almacenados para realizar los siguientes
2. procesos:
• Muestre todos los campos de la tabla curso en orden ascendente según el valor.
CREATE PROCEDURE CursoOrdenado()
SELECT *
FROM curso
ORDER BY valor_cur;
• Mostrar los pedidos con los respectivos artículos(código, nombre,valor y
cantidad pedida).
CREATE PROCEDURE GetPedidosConArticulos()
SELECT p.id_ped, p.tit_art, val_ven_art_artped Valor Artículo,
can_art_artped
FROM pedido p
INNER JOIN articuloxpedido ap
ON p.id_ped = ap.id_ped_artped
INNER JOIN articulo a
ON a.id_art = ap.id_art_artped
• Visualizar los datos de las empresas fundadas entre el año 1991 y 1998.
CREATE PROCEDURE GetEmpresasEntre9198()
SELECT *
FROM compañia
WHERE comañofun BETWEEN 1991 AND 1998;
• Visualizar todos los clientes organizados por apellido.
CREATE PROCEDURE GetClientesOrganizados()
SELECT *
FROM cliente
ORDER BY ape_cli;
• 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.
CREATE PROCEDURE GetIncidentesConUnHerido()
SELECT inciplaca, aseg.asefechainicio, aseg.asecosto, aseg.aseestado,
aseg.asevalorasegurado
FROM incidentes i
INNER JOIN automotores a
ON a.autoplaca = i.inciplaca
INNER JOIN aseguramientos aseg
ON aseg.aseplaca = a.autoplaca
WHERE incicantheridos = 1;
• 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.
CREATE PROCEDURE GetIncidentesVehiculo()
SELECT i.incifecha, i.incilugar, i.incicantheridos, aseg.asefechainicio,
aseg.asefechaexpiracion, aseg.asevalorasegurado
FROM incidentes i
3. INNER JOIN automotores a
ON a.autoplaca = i.inciplaca
INNER JOIN aseguramientos aseg
ON aseg.aseplaca = a.autoplaca
WHERE a.autoplaca = 'FLL420' ;
4. Realice las Siguientes funciones en MySQL:
• Cuente el número de estudiantes cuya edad sea mayor a 22.
DELIMITER //
CREATE FUNCTION NumeroEstudiantes()
RETURNS INT
BEGIN
DECLARE numero INT;
--
SELECT COUNT(1) INTO numero
FROM estudiante
WHERE edad_est > 22;
--
RETURN numero;
END
//
• Muestre el nombre y la edad del estudiante más joven.
DELIMITER //
CREATE FUNCTION NombreEdadEstudianteMasJoven()
RETURNS VARCHAR(30)
BEGIN
DECLARE pnombre VARCHAR(30);
DECLARE pedad VARCHAR(30);
--
SELECT nom_est, edad_est
INTO pnombre, pedad
FROM estudiante
WHERE edad_est = (SELECT MIN(edad_est)
FROM estudiante);
--
RETURN CONCAT(pnombre, " ", pedad);
END//
• Calcule el valor promedio de los cursos cuyas horas sean mayores a 40.
DELIMITER //
CREATE FUNCTION ValorPromedioCursos()
RETURNS INT
BEGIN
DECLARE pPromedio DECIMAL(11, 4);
--
SELECT AVG(valor_cur) INTO pPromedio
FROM curso
WHERE horas_cur > 40;
--
RETURN pPromedio ;
END//
4. • Obtener el sueldo promedio de los profesores de la categoría 1.
DELIMITER //
CREATE FUNCTION SueldoPromedioProfesores()
RETURNS INT
BEGIN
DECLARE pPromedio DECIMAL(11, 4);
--
SELECT AVG(sal_prof) INTO pPromedio
FROM profesor
WHERE cate_prof = 1;
--
RETURN pPromedio ;
END//
--
• Muestre el nombre del profesor con menor sueldo.
DELIMITER //
CREATE FUNCTION NombreProfesorMenorSueldo()
RETURNS VARCHAR(60)
BEGIN
DECLARE pNombre VARCHAR(60);
--
SELECT CONCAT(nom_prof, ape_prof) INTO pNombre
FROM profesor
WHERE sal_prof = (SELECT MIN(sal_prof)
FROM profesor);
--
RETURN pNombre ;
END//
6. Construya los siguiente disparadores para controlar la actualización y
borrado de registros
-- profesor
-- Creamos tabla de PROFESOR
CREATE TABLE auditoria_profesor(id_audi INT(11) AUTO_INCREMENT PRIMARY KEY,
audi_nom_prof_anterior
VARCHAR(30) NOT NULL ,
audi_ape_prof_anterior
VARCHAR(30) NOT NULL ,
audi_cate_prof_anterior INT
NOT NULL ,
audi_sal_prof_anterior INT
NOT NULL ,
audi_nom_prof_nuevo
VARCHAR(30) ,
audi_ape_prof_nuevo
VARCHAR(30) ,
audi_cate_prof_nuevo INT
,
audi_sal_prof_nuevo INT
,
5. ,
audi_fechamodificacion
DATETIME ,
audi_usuario
VARCHAR(50) ,
audi_doc_prof
VARCHAR(11) NOT NULL ,
audi_acccion
VARCHAR(45) NOT NULL
);
-- CREAMOS EL TRIGGER PARA LA ACTUALIZACIÓN
delimiter //
CREATE TRIGGER trg_profesor_update
BEFORE UPDATE ON profesor
FOR EACH ROW
BEGIN
--
INSERT INTO auditoria_profesor( audi_nom_prof_anterior ,
audi_ape_prof_anterior ,
audi_cate_prof_anterior ,
audi_sal_prof_anterior ,
audi_nom_prof_nuevo ,
audi_ape_prof_nuevo ,
audi_cate_prof_nuevo ,
audi_sal_prof_nuevo ,
audi_fechamodificacion ,
audi_usuario
,
audi_doc_prof
,
audi_acccion
)
VALUES(old.nom_prof , old.ape_prof , old.cate_prof, old.sal_prof ,
new.nom_prof , new.ape_prof , new.cate_prof ,
new.sal_prof,
now(), current_user(), new.doc_prof, 'Actualización');
END;//
-- PROBAMOS ACTUALIZANDO UN REGISTRO
UPDATE PROFESOR
SET nom_prof = 'Martha XXX',
ape_prof = 'Rojas XXX',
cate_prof = 4 ,
sal_prof = 1000000
WHERE doc_prof = '63502720';
-- CREAMOS EL TRIGGER PARA el delete
delimiter //
CREATE TRIGGER trg_profesor_delete
AFTER DELETE ON profesor
FOR EACH ROW
BEGIN
--
INSERT INTO auditoria_profesor( audi_nom_prof_anterior ,
audi_ape_prof_anterior ,
audi_cate_prof_anterior ,
audi_sal_prof_anterior ,
audi_fechamodificacion ,
audi_usuario
,
6. audi_doc_prof
,
audi_acccion
)
VALUES(old.nom_prof , old.ape_prof , old.cate_prof, old.sal_prof ,
now(), current_user(), old.doc_prof, 'Registro
Eliminado');
END;//
--PROBAMOS ELIMINANDO UN REGISTRO
DELETE FROM PROFESOR
WHERE doc_prof = '91216904';
--CURSO
-- Creamos tabla de CURSO
CREATE TABLE auditoria_curso(id_audi INT(11) AUTO_INCREMENT PRIMARY KEY,
audi_nom_curs_anterior
VARCHAR(100) NOT NULL ,
audi_horas_cur_anterior INT NOT
NULL ,
audi_valor_cur_anterior INT
NOT NULL ,
audi_nom_curs_nuevo
VARCHAR(100) ,
audi_horas_cur_nuevo INT
,
audi_valor_cur_nuevo INT
,
audi_fechamodificacion DATETIME
,
audi_usuario
VARCHAR(50) ,
audi_cod_curs
VARCHAR(11) NOT NULL ,
audi_acccion
VARCHAR(45) NOT NULL
);
-- CREAMOR EL TRIGGER PARA LA ACTUALIZACIÓN
delimiter //
CREATE TRIGGER trg_curso_update
BEFORE UPDATE ON curso
FOR EACH ROW
BEGIN
--
INSERT INTO auditoria_curso(
audi_nom_curs_anterior ,
audi_horas_cur_anterior ,
audi_valor_cur_anterior ,
audi_nom_curs_nuevo ,
audi_horas_cur_nuevo ,
audi_valor_cur_nuevo ,
audi_fechamodificacion ,
audi_usuario ,
audi_cod_curs ,
audi_acccion
7. )
VALUES(old.nom_curs , old.horas_cur , old.valor_cur,
new.nom_curs , new.horas_cur , new.valor_cur,
now(), current_user(), new.cod_curs, 'Actualización');
END;//
-- PROBAMOS ACTUALIZANDO UN REGISTRO
UPDATE curso
SET nom_curs = 'Fundamentos de SQL XXX',
horas_cur = 40,
valor_cur = 1400000
WHERE cod_curs = '250067';
-- CREAMOR EL TRIGGER PARA el delete
delimiter //
CREATE TRIGGER trg_curso_delete
AFTER DELETE ON curso
FOR EACH ROW
BEGIN
--
INSERT INTO auditoria_curso(
audi_nom_curs_anterior ,
audi_horas_cur_anterior ,
audi_valor_cur_anterior ,
audi_fechamodificacion ,
audi_usuario ,
audi_cod_curs ,
audi_acccion
)
VALUES(old.nom_curs , old.horas_cur , old.valor_cur,
now(), current_user(), old.cod_curs, 'Registro
Eliminado');
END;//
--PROBAMOS ELIMINANDO UN REGISTRO
delete from estudiantexcurso where cod_cur_estcur = 289011;
--
DELETE FROM curso
WHERE cod_curs = '289011';
-- ESTUDIANTE
-- Creamos tabla de ESTUDIANTE
CREATE TABLE auditoria_estudiante(id_audi INT(11) AUTO_INCREMENT PRIMARY KEY,
audi_nom_est_anterior VARCHAR(30)
NOT NULL ,
audi_ape_est_anterior VARCHAR(30)
NOT NULL ,
audi_edad_est_anterior INT
(11) NOT NULL ,
audi_nom_est_nuevo VARCHAR(30)
,
audi_ape_est_nuevo VARCHAR(30)
,
audi_edad_est_nuevo INT
,
audi_fechamodificacion DATETIME
,
audi_usuario
VARCHAR(50) ,
audi_doc_est
8. VARCHAR(11) NOT NULL ,
audi_accion
VARCHAR(45) NOT NULL
);
-- CREAMOS EL TRIGGER PARA LA ACTUALIZACIÓN
delimiter //
CREATE TRIGGER trg_estudiante_update
BEFORE UPDATE ON estudiante
FOR EACH ROW
BEGIN
--
INSERT INTO auditoria_estudiante( audi_nom_est_anterior ,
audi_ape_est_anterior ,
audi_edad_est_anterior ,
audi_nom_est_nuevo ,
audi_ape_est_nuevo ,
audi_edad_est_nuevo ,
audi_fechamodificacion ,
audi_usuario
,
audi_doc_est
,
audi_accion
)
VALUES(old.nom_est , old.ape_est , old.edad_est,
new.nom_est , new.ape_est , new.edad_est ,
now(), current_user(), new.doc_est, 'Actualización');
END;//
-- PROBAMOS ACTUALIZANDO UN REGISTRO
UPDATE ESTUDIANTE
SET nom_est = 'Jonatan XXX',
ape_est = 'Ardila XXX',
edad_est = 17
WHERE doc_est = '1098098097';
-- CREAMOS EL TRIGGER PARA el delete
delimiter //
CREATE TRIGGER trg_estudiante_delete
AFTER DELETE ON estudiante
FOR EACH ROW
BEGIN
--
INSERT INTO auditoria_estudiante( audi_nom_est_anterior ,
audi_ape_est_anterior ,
audi_edad_est_anterior ,
audi_fechamodificacion ,
audi_usuario
,
audi_doc_est
,
audi_accion
)
VALUES(old.nom_est , old.ape_est , old.edad_est,
now(), current_user(), old.doc_est, 'Registro
Eliminado');
END;//
9. --PROBAMOS ELIMINANDO UN REGISTRO
DELETE FROM estudiantexcurso where doc_est_estcur = 91245678;
DELETE FROM estudiante
WHERE doc_est = '91245678';
mysql>create table Estudiante(doc_est varcharalterEstudiante(11) not
null,nom_est varchar(30)
not null,ape_est varchar(30) not null,edad_est int not null,primary key(doc_est)
);
-- automotores
--Creamos tabla de AUTOMOTORES
CREATE TABLE auditoria_automotores(id_audi INT(11) AUTO_INCREMENT PRIMARY KEY,
audi_Automarca_anterior VARCHAR(30)
NOT NULL ,
audi_Autotipo_anterior INT
NOT NULL ,
audi_Automodelo_anterior INT (11)
NOT NULL ,
audi_Autonumpasajeros_anterior INT
,
audi_Autocilindraje_anterior INT
,
audi_Autonumchasis_anterior
VARCHAR(30) ,
audi_Automarca_nuevo
VARCHAR(30) ,
audi_Autotipo_nuevo INT
,
audi_Automodelo_nuevo INT
(11) ,
audi_Autonumpasajeros_nuevo INT
,
audi_Autocilindraje_nuevo INT
,
audi_Autonumchasis_nuevo
VARCHAR(30) ,
x DATETIME ,
audi_usuario
VARCHAR(50) ,
audi_autoplaca
VARCHAR(6) NOT NULL ,
audi_accion
VARCHAR(45) NOT NULL
);
-- CREAMOS EL TRIGGER PARA LA ACTUALIZACIÓN
delimiter //
CREATE TRIGGER trg_automotores_update
BEFORE UPDATE ON automotores
FOR EACH ROW
BEGIN
--
INSERT INTO auditoria_automotores( audi_Automarca_anterior ,
audi_Autotipo_anterior ,
audi_Automodelo_anterior,
11. now(), current_user(), old.autoplaca, 'Registro
Eliminado');
END;//
--PROBAMOS ELIMINANDO UN REGISTRO
DELETE FROM aseguramientos where aseplaca = 'KJQ920';
DELETE FROM automotores
WHERE autoplaca = 'KJQ920';
select * from auditoria_automotores;
-- aseguramientos
-- Creamos tabla de ASEGURAMIENTOS
CREATE TABLE auditoria_Aseguramientos(id_audi INT(11) AUTO_INCREMENT PRIMARY
KEY,
audi_asefechainicio_anterior
DATE NOT NULL ,
audi_asefechaexpiracion_anterior
DATE NOT NULL ,
audi_asevaloraegurado_anterior
INT NOT NULL ,
audi_aseestado_anterior
VARCHAR(30) NOT NULL ,
audi_asecosto_anterior
INT NOT NULL ,
audi_aseplaca_anterior
VARCHAR(20) NOT NULL ,
audi_asefechainicio_nuevo
DATE ,
audi_asefechaexpiracion_nuevo
DATE ,
audi_asevaloraegurado_nuevo
INT ,
audi_aseestado_nuevo
VARCHAR(30) ,
audi_asecosto_nuevo
INT ,
audi_aseplaca_nuevo
VARCHAR(20) ,
audi_fechamodificacion
DATETIME ,
audi_usuario
VARCHAR(50) ,
audi_asecodigo
INT NOT NULL ,
audi_accion
VARCHAR(45) NOT NULL
);
-- CREAMOS EL TRIGGER PARA LA ACTUALIZACIÓN
delimiter //
CREATE TRIGGER trg_aseguramientos_update
BEFORE UPDATE ON aseguramientos
FOR EACH ROW
12. BEGIN
--
INSERT INTO auditoria_aseguramientos( audi_asefechainicio_anterior ,
audi_asefechaexpiracion_anterior
,
audi_asevaloraegurado_anterior
,
audi_aseestado_anterior
,
audi_asecosto_anterior
,
audi_aseplaca_anterior
,
audi_asefechainicio_nuevo
,
audi_asefechaexpiracion_nuevo
,
audi_asevaloraegurado_nuevo
,
audi_aseestado_nuevo
,
audi_asecosto_nuevo
,
audi_aseplaca_nuevo
,
audi_fechamodificacion
,
audi_usuario
,
audi_asecodigo
,
audi_accion
)
VALUES(old.asefechainicio, old.asefechaexpiracion ,
old.asevalorasegurado , old.aseestado, old.asecosto, old.aseplaca,
new.asefechainicio, new.asefechaexpiracion ,
new.asevalorasegurado , new.aseestado , new.asecosto, new.aseplaca,
now(), current_user(), new.asecodigo ,
'Actualización');
END;//
-- PROBAMOS ACTUALIZANDO UN REGISTRO
UPDATE aseguramientos
SET asefechainicio = '2012-10-10',
asefechaexpiracion = '2013-10-30',
asevalorasegurado = 80000000,
aseestado = 'Vigente',
asecosto = 700000,
aseplaca ='FLL420'
WHERE asecodigo = '2';
-- CREAMOS EL TRIGGER PARA el delete
delimiter //
CREATE TRIGGER trg_aseguramientos_delete
AFTER DELETE ON aseguramientos
FOR EACH ROW
BEGIN
--
INSERT INTO auditoria_aseguramientos( audi_asefechainicio_anterior ,
audi_asefechaexpiracion_anterior
,
13. audi_asefechaexpiracion_anterior
,
audi_asevaloraegurado_anterior
,
audi_aseestado_anterior
,
audi_asecosto_anterior
,
audi_aseplaca_anterior
,
audi_fechamodificacion
,
audi_usuario
,
audi_asecodigo
,
audi_accion
)
VALUES(old.asefechainicio , old.asefechaexpiracion ,
old.asevalorasegurado, old.aseestado, old.asecosto, old.aseplaca,
now(), current_user(), old.asecodigo, 'Registro
Eliminado');
END;//
--PROBAMOS ELIMINANDO UN REGISTRO
DELETE FROM aseguramientos
WHERE asecodigo = '2';
-- incidentes
--Creamos tabla de INCIDENTES
CREATE TABLE auditoria_incidentes(id_audi INT(11) AUTO_INCREMENT PRIMARY KEY,
audi_incifecha_anterior DATE NOT
NULL ,
audi_inciplaca_anterior VARCHAR(6)
NOT NULL ,
audi_incilugar_anterior VARCHAR(40)
NOT NULL ,
audi_incicantheridos_anterior INT
NOT NULL ,
audi_incicanfatalidades_anterior INT
NOT NULL ,
audi_incicanautosinvolucrados_anterior INT NOT NULL ,
audi_incifecha_nuevo DATE
,
audi_inciplaca_nuevo VARCHAR(6)
,
audi_incilugar_nuevo VARCHAR(40)
,
audi_incicantheridos_nuevo INT
,
audi_incicanfatalidades_nuevo INT
,
audi_incicanautosinvolucrados_nuevo
INT ,
14. audi_fechamodificacion DATETIME
,
audi_usuario
VARCHAR(50) ,
audi_incicodigo INT NOT NULL
,
audi_accion
VARCHAR(45) NOT NULL
);
-- CREAMOS EL TRIGGER PARA LA ACTUALIZACIÓN
delimiter //
CREATE TRIGGER trg_incidentes_update
BEFORE UPDATE ON incidentes
FOR EACH ROW
BEGIN
--
INSERT INTO auditoria_incidentes(audi_incifecha_anterior ,
audi_inciplaca_anterior ,
audi_incilugar_anterior ,
audi_incicantheridos_anterior
,
audi_incicanfatalidades_anterior ,
audi_incicanautosinvolucrados_anterior ,
audi_incifecha_nuevo
,
audi_inciplaca_nuevo
,
audi_incilugar_nuevo
,
audi_incicantheridos_nuevo
,
audi_incicanfatalidades_nuevo
,
audi_incicanautosinvolucrados_nuevo
,
audi_fechamodificacion
,
audi_usuario
,
audi_incicodigo ,
audi_accion
)
VALUES(old.incifecha , old.inciplaca , old.incilugar,
old.incicantheridos , old.incicanfatalidades,old.incicanautosinvolucrados,
new.incifecha , new.inciplaca , new.incilugar ,
new.incicantheridos, new.incicanfatalidades,new.incicanautosinvolucrados,
now(), current_user(), new.incicodigo,
'Actualización');
END;//
-- PROBAMOS ACTUALIZANDO UN REGISTRO
UPDATE incidentes
SET incifecha = '2012-11-11',
inciplaca = 'FLL420',
incilugar = 'San Gil',
incicantheridos = 2,
incicanfatalidades = 3,
incicanautosinvolucrados = 4
WHERE incicodigo = '1';
15. -- CREAMOS EL TRIGGER PARA el delete
delimiter //
CREATE TRIGGER trg_auditoria_incidentes_delete
AFTER DELETE ON incidentes
FOR EACH ROW
BEGIN
--
INSERT INTO auditoria_incidentes(audi_incifecha_anterior ,
audi_inciplaca_anterior ,
audi_incilugar_anterior ,
audi_incicantheridos_anterior
,
audi_incicanfatalidades_anterior ,
audi_incicanautosinvolucrados_anterior ,
audi_fechamodificacion
,
audi_usuario
,
audi_incicodigo ,
audi_accion
)
VALUES(old.incifecha , old.inciplaca , old.incilugar,
old.incicantheridos , old.incicanfatalidades,old.incicanautosinvolucrados,
now(), current_user(), old.incicodigo, 'Registro
Eliminado');
END;//
--PROBAMOS ELIMINANDO UN REGISTRO
DELETE FROM INCIDENTES where incicodigo = 3;
--Solucion_Laboratorio_LenguajeTransaccional.txt