Desarrollo de Bases de Datos

Transcripción

1 SQLJ Motivación Utilización de variables compartidas Compatibilidad de tipos Recuperación de datos Tratamiento de excepciones Contexto de ejecución Contexto de conexión Ejecución de una aplicación SQLJ Motivación Dos tipos de usuario: ocasionales: utilizan SQL interactivo para recuperar datos desarrolladores: utilizan SQL embebido para tratamiento de datos Requisitos del tratamiento de datos modificar/recuperar tuplas? SQL capacidad de cálculo + instrucciones de control? COBOL, C Por tanto, el tratamiento de datos requiere utilizar SQL dentro de un lenguaje de programación SQL embebido Estándar para la inclusión de instrucción SQL dentro de un lenguaje de programación Se extiende el leng. prog. mediante la pre-compilación SQLJ Interfaz de alto nivel: consultas directamente en SQL Análisis sintáctico y semántico en tiempo de (pre)compilación Interoperabilidad: estándar ANSI (diciembre, 1998) Toda instrucción SQL aparece precedida por una palabra clave reconocida durante la pre-compilación Para el caso de JAVA estándar SQLJ Pasos para la ejecución de una aplicación.sqlj Pre-compilador SQLJ comprobación de sintaxis comprobación de tipos comprobación de esquema Compilador Java Código fuente: Java + SQLJ.. #sql [contexto conexión] {select }; Código fuente: Java + JDBC >>sqlj mifichero.sqlj >>javac mifichero.java Código byte: Java + llamadas al controlador JDBC >>java mifichero.class Controlador JDBC Sistema Base de Datos

2 Utilización de variables compartidas Variables de Java que aparecen en sentencias SQL void ejemplo() throws Exception { String cuentaa = null; String cuentab = null; Integer elsaldo = null; DefaultContext contexto1 = new DefaultContext ( jdbc:oracle:oci8:@midb, unusuario, secreto, false ); Cont. OJO: Identificadores de SQL no son sensibles. Identificadores de Java sí son sensibles #sql [ctx] {update Alumno set nota= :la_nota where dni = :el_dni} #sql [contexto1] {select saldo INTO :elsaldo from cuentacorriente where codigo = :cuentaa}; instrucción SQLJ contexto en el que se ejecuta la sentencia SQL Las variables compartidas precedidas por : #sql [contexto1] {update cuentacorriente set saldo = saldo + :elsaldo where codigo = :cuentab}; #sql [ctx1] {select nombre into :el_nombre from Alumno where dni = :el_dni} Compatibilidad de tipo SQL? Tipos Java (escalares) boolean byte short int long float double Tipos SQL BIT TINYINT SMALLINT INTEGER BIGINT REAL FLOAT, DOUBLE Java #sql [ctx] {update Alumno set nota= :la_nota where dni = :el_dni} A la variable de SQL nota se le asigna la variable JAVA la_nota sus tipos tienen que ser compatibles El valor null Los tipos de datos de Java NO soportan el valor null. SQLJ define para cada clase escalar de Java, una clase wrapper donde se soporta el valor null existe un método xxxvalue que permite la conversión al tipo primitivo (p.ej intvalue pasa a int) otros métodos: tostring(int), valueof(string), shortvalue() Nótese que si el tipo es wrapper empieza por mayúscula Tipos Java Tipos SQL (clases wrapper) java.lang.boolean BIT java.lang.byte TINYINT java.lang.short SMALLINT java.lang.integer INTEGER java.lang.long BIGINT java.lang.float REAL java.lang.double FLOAT, DOUBLE java.lang.string CHAR, VARCHAR, LONGVARCHAR java.math.bigdecimal NUMERIC, DECIMAL byte[ ] BINARY, VARBINARY, LONGBINARY java.sql.date DATE java.sql.time TIME java.sql.timestamp TIMESTAMP cont. Pasar null de Java a SQL String elnombre = null; Short laedad = null; #sql {insert into Alumno (dni, nombre, edad) values (444, :elnombre, :laedad)}; Recuperar null de SQL en Java Short eldni; Short laedad; #sql {select edad into :laedad from Alumno where dni = :eldni} short auxedad = laedad.shortvalue(); error Si una variable de tipo primitivo recibe null se genera el error SQLNullException Recuperación de datos Si SELECT devuelve un solo valor. El resultado se guarda en una variable del lenguaje anfitrión #sql {SELECT edad INTO :laedad FROM Alumno where dni = :eldni} Si SELECT devuelve un conjunto de valores. El resultado se guarda en un CURSOR

3 Cursores identificados por posición Un cursor es un objeto de la clase iterator El nº de columnas es igual al de la pregunta Se especifica el tipo de los atributos de la pregunta #sql publiciterator itealumno (Integer, String); // 1.- define el tipo itealumno itealumno uncursor; // 2.- se introduce variable de este tipo Integer eldni; String elnombre; #sql uncursor = {select dni, nombre from Alumno}; // 3.- se abre el cursor while (true) { // 4.- se itera sobre el cursor #sql {fetch :uncursor into :eldni, :elnombre}; if(un_cursor.endfetch()) break; // true si no hay más tuplas System.out.println (eldni, elnombre); } un_cursor.close(); // 4.- se cierra el cursor Cursores identificados por el nombre (recomendado) Un iterador especifica el nombre y tipo de los atributos de la pregunta Los valores de los atributos del registro se obtienen con métodos con nombre el del atributo #sql publiciterator itealumno (Integer el_dni, String el_nombre); itealumno uncursor; // variable de tipo la clase anterior Integer eldni; String elnombre; #sql uncursor = {select nombre as el_nombre, dni as el_dni from Alumno}; // asignación cjto. tuplas while (uncursor.next()) { // avanza a la sgte. tupla. (false, si no hay más) eldni = uncursor.el_dni(); // obtiene el valor del atributo de la tupla elnombre = uncursor.el_nombre(); System.out.println (eldni, elnombre);} uncursor.close(); // liberación del recurso Tratamiento de excepciones Excepción es un objeto de tipo SQLException se crea cuando se produce una excepción métodos: getmessage, geterrorcode, getsqlstate try{ #sql {select nombre into :elnombre from Alumno where dni = :eldni};} catch( SQLNullException ne ){ System.out.println( Seha encontrado un valor null: + ne. geterrorcode());} catch( SQLException e ){ System.out.println( Error: + e.getmessage() + e.geterrorcode());} Contexto de conexión Una instrucción SQL se ejecuta en un contexto de conexión #sql [contexto] {update Alumno set nota= :la_notawhere dni = :el_dni} Este contexto indica el SGBD, la base de datos usuario y password modo autocommit con el que se ejecutará la instrucción SQL Este contexto se define como una instancia de la clase sqlj.runtime.defaultcontext Clase DefaultContext static DefaultContext DefaultContext(java.lang.String url, java.lang.string user, java.lang.string password, boolean autocommit) Crea el contexto por defecto static DefaultContext getdefaultcontext() Devuelve el contexto por defecto static void setdefaultcontext(defaultcontext ctx) Establece el contexto por defecto Ejemplo DefaultContext miejemplo = new DefaultContext ( jdbc:oracle:oci8:@midb, unusuario, secreto, false ); DefaultContext.setDefaultContext ( miejemplo ); #sql [miejemplo] {update }; //no sería necesario poner el contexto miejemplo.close(); public void close() Cierra el actual contexto

4 Varios contextos de conexión simultáneos Necesidad de usar en la aplicación SGBDs distintos Necesidad de usar BD diferentes Necesidad de añadir más funcionalidades a la clase contexto de conexión DefaultContext miejemplo = newdefaultcontext ( jdbc:oracle:oci8:@midb, unusuario, secreto, false ); DefaultContext otroejemplo = newdefaultcontext ( jdbc:oracle:oci8:@midb, otrousuario, misecreto, false ); DefaultContext.setDefaultContext ( miejemplo ); #sql {select }; #sql [otroejemplo] {update }; // utiliza el contexto por defecto miejemplo.close(); otroejemplo.close( ); Contexto de ejecución Una instrucción SQL se ejecuta en un contexto de ejecución: #sql [unctxcon, unctxeje] {update Alumno set nota = nota + 1 where curso = 5}; Este contexto es una zona compartida por el runtime del SGBD y el programa, para intercambiar información sobre MaxRows: máximo nº de tuplas que puede guardar un cursor MaxFieldSize: máximo nº de bytes de un atributo QueryTimeout: segundos de espera a una sentencia SQL UpdateCount: nº tuplas afectadas con última sentencia SQL SQLWarnings : texto error generado en la ejecución Estos atributos se guardan como una instancia de la clase sqlj.runtime.executioncontext Ejemplo // Crea un contexto de ejecución donde guarda las incidencias ExecutionContext unctxeje = new ExecutionContext(); #sql [unctxcon, unctxeje] {delete from Alumno where curso = 5}; System.out.println( Se han borrado + unctxeje.getupdatecount() + alumnos ); // Espera 3 segundos a que se ejecute la sentencia SQL unctxeje.setquerytimeout(3); Tratamiento fichero.sqlj Pre-compilador SQLJ comprobación de sintaxis comprobación de tipos comprobación de esquema Compilador Java Código fuente: Java + SQLJ.. #sql [contexto conexión] {select }; Código fuente: Java + JDBC >>sqlj mifichero.sqlj >>javac Código byte: Java + llamadas al controlador JDBC Controlador JDBC mifichero.java >>java mifichero.class #sql [unctxcon, unctxeje] {update Alumno set curso = 5}; Sistema Base de Datos Configuración de la pre-compilación Algunos parámetros de configuración dir : directorio de los ficheros.java generados user y password : nombre de usuario, y su clave, para conectarse a la bd. (si no es null, el sistema realiza comprobación online) url: indica dónde establecer la conexión driver: controladores JDBC offline/online: comprobación sin/con conexión a la bd. Pueden indicarse explícitamente: >> sqlj -user=unusuario -password=secreto mifichero.sqlj en el fichero sqlj.properties, consultado al invocar a sqlj sqlj.user=unusuario sqlj.password=secreto Conexión durante la pre-compilación mifichero.sqlj SQLJ mifichero.java Conexiones en la compilación Compilador Java miejemplo mifichero.class otroejemplo Conexiones en la ejecución

5 public class top5 { #sql static iterator top5it (String unalumno, Integer notamedia); void listartop5() throws Exception { top5it lostop5; String elalumno = null; Integer lanotamedia = null; int contador = 0; #sql lostop5 = { SELECT elalumno AS unalumno, avg(nota) AS notamedia FROM AluAsi GROUP BY elalumno ORDER BY 2 DESC}; System.out.println("ALUMNO " + "SU NOTA MEDIA"); while (lostop5.next() && contador < 5) { elalumno = lostop5.unalumno(); lanotamedia = lostop5.notamedia(); System.out.println(elAlumno + " " + lanotamedia); contador = contador + 1; } lostop5.close();} Ejercicio La casa discográfica VIRGIN desea crear una base de datos sobre las canciones, los autores y los cantantes que hacen distintas versiones de dichas canciones. Un autor puede componer distintas canciones y una canción puede tener distintos compositores (tabla Aut_Can). Por otro lado, los cantantes pueden realizar distintas versiones de una determinada canción. Las canciones están agrupadas en álbumes (tabla Can_Can_Al). En un álbum una misma canción puede ser cantada por distintos cantantes, pero un cantante no puede tener diferentes versiones de la misma canción en el mismo álbum. El diagrama E/R y las tablas correspondientes son estas: top5() {ConnectionManager.initContext();}} Esquema Esquema Autor M AUT_CAN N M CAN_CAN_AL N P Cantante Fecha Duración AUTOR (NomAut, Tfno, Cuota) CANCION (Título, Estilo) CANTANTE (NomCan, Tfno, País) ALBUM (Código, DiscosPlatino) AUT_CAN (ElAutor, LaCanción) CAN_CAN_AL (LaCanción, ElCantante, ElAlbum, Fecha, Duración) Canción Álbum Ejercicio 1 Ejercicio 1 Expresar en SQLJ un programa que cree un nuevo album recopilatorio con las canciones 1º) de cualquier estilo 2º) existan más de dos versiones de las mismas, y 3º) cuyos autores hayan compuesto alguna canción de estilo Jazz. Expresar en SQLJ un programa que cree el album XXX The BEST que contenga para cada autor sus 5 canciones de más éxito, es decir, aquellas que aparezcan en más álbumes. Conseguir todas las canciones Para cada canción Comprobar que si es de algún autor de Jazz Comprobar número de versiones Si se cumplen las dos anteriores Insertar en la BD (número de álbum y cantante fijos que deberíamos saber)

6 Ejercicio 1 Conseguir todas las canciones Select titulo from cancion Comprobar que si es de algún autor de Jazz Select 2 FROM AUT_CAN AS AC1 NJ Autor NJ AUT_CAN AS AC2 NJ Canción WHERE AC1.título=:título AND C2.Estilo= Jazz (si devuelve tuplas es que sí tiene autor de Jazz) Comprobar número de versiones Select COUNT (Distinct Album) INTO :numversiones from CAN-CAN-AL WHERE título=:titulo (si >2, entonces insertar en la BD) Otras opciones del lenguaje Borrar o modificar la tupla actual #sql [ctx] {delete from tabla WHERE CURRENT OF :variableiteradoranfitrión}; #sql [ctx] {update tabla set atributo = valor WHERE CURRENT OF : variableiteradoranfitrión}; #sql iterator UnIterador(String, String); UnIterador iter; #sql iter = {select nombre, dir from cliente where ciudad= Donostia }; while (true) { #sql {fetch :iter into:nombre, :dir}; if (iter.endfetch()) break; System.out.println (nombre+ " " + dir + " Borrar (S/N)?"); entrada= new BufferedReader (new InputStreamReader (System.in)); tecla= entrada.readline(); if (tecla.equals( S")) #sql{deletefrom cliente wherecurrentof:iter}; } Procedimientos almacenados Los definen los usuarios. Son objetos del esquema Se ejecutan en el SGBD La sintaxis de las llamadas depende del SGBD. Por ejemplo, en Oracle #sql [ctx] { CALL procedimiento(:arg1, :arg2) }; #sql [ctx] var= { VALUES funcion(:arg1, :arg2) }; Transacción Comienzo de la transacción: Al realizar una operación SQL sobre tuplas de la BD El control de concurrencia se basa en reservas A nivel de tupla Reserva de tupla: lo hace el sistema al escribir Para leer no se hace reserva Liberar la reserva: Automáticamente AutoCommit Manualmente #sql {rollback}; AutoCommit Se puede definir cuando se crea el contexto de conexión: Autocommit=false DefaultContext ctx1= new DefaultContext ( jdbc:oracle:oci8:@mibd, Jon, secreto, false); Las transacciones se deben terminar manualmente Autocommit=true DefaultContext ctx2= new DefaultContext ( jdbc:oracle:oci8:@mibd, Nerea, asaber, true); Las transacciones se terminan automáticamente en cuanto terminan sus operaciones NO hay posibilidad de hacer ROLLBACK Autocommit También se puede cambiar a través del contexto de conexión: ctx.getconnection().setautocommit(true); Tiene que ser la primera operación de la transacción

7 Recomendaciones para el diseño de transacciones #sql public iterator IteBDNotas(int nota); IteBDNotas bdnotas; #sql bdnotas = {select nota from Matricula where codalum = 787}; #sql media = {select avg(nota) from Matricula where codalum = 787}; while (bdnotas.next()) { nota = bdnotas.nota(); if (nota > media) {System.out.println( );} } #sql public iterator itebdnotas (int nota); itebdnotas bdnotas; // Solo se obtienen las notas que son superiores a la media #sql bdnotas = {select nota from Matricula where codalum = 787 and nota > (select avg(nota) from Matricula where codalum = 787 )}; while (bdnotas.next()) { nota = bdnotas.nota(); System.out.println( ); }. Row Prefetching El estándar JDBC trae las tuplas del resultado de una consulta de una en una Para cada tupla hace falta un acceso a la BD Con la opción DefaultRowPrefetch las tuplas traidas se pueden agrupar Se ahorran accesos a la BD El valor por defecto es 10 (Oracle) Se debe indicar el valor a cada instancia del contexto de conexión Row prefetching Cambiar el valor por defecto a 20 tuplas en un contexto concreto (ctx) ((OracleConnection)ctx.getConnection()).getDefaultRowPrefetch() ((OracleConnection)ctx.getConnection()).setDefaultRowPrefetch(20) Cambiarlo en el contexto por defecto ((OracleConnection)DefaultContext.getDefaultContext().getConnection()).get DefaultRowPrefetch() ((OracleConnection)DefaultContext.getDefaultContext().getConnection()).set DefaultRowPrefetch(20) Update batching Las operaciones UPDATE, DELETE, INSERT se pueden agrupar (en un proceso batch) para que la ejecución sea más rápida (ahorrando accesos a la BD) Las instrucciones en modo batch deben ser del mismo tipo Esta característica se aplica a cada contexto de ejecución Update batching ExecutionContext ctxeje = new ExecutionContext(); ctxeje.setbatching(true); ctxeje.setbatchlimit(limite); for (int j=1; i<=limite; i++) { } // meter las instrucciones en un lote #sql [ctxeje ] { INSERT INTO Tabla VALUES(:i) }; //Ejecución explícita de todas las inserciones a la vez int[ ] kop = ctxeje.executebatch();

8 Update batching las instrucciones de un lote se ejecutan de manera implícita: Antes de ejecutar una instrucción de otro tipo Cuando se ejecuta commit Cuando se llega al límite de instrucciones batch Otras instrucciones ctxeje.isbatching() ctxeje.getbatchlimit() ctxeje.getbatchupdatecounts() ctxeje.cancel() Update batching ExecutionContext ctxeje = new ExecutionContext(); ctxeje.setbatching(true); ctxeje.setbatchlimit(3); #sql [ctxeje] {update Empleado set sueldo=sueldo+100 where dni=1}; #sql [ctxeje] {update Empleado set sueldo=sueldo+100 where dni=2}; #sql [ctxeje] {update Empleado set sueldo=sueldo+100 where dni=3}; #sql [ctxeje] {update Empleado set sueldo=sueldo+100 where dni=4}; #sql [ctxeje] {update Empleado set sueldo=sueldo+100 where dni=5}; #sql [ctxeje] {update Empleado set sueldo=sueldo+100 where categoria=10}; #sql [ctxeje] {update Empleado set sueldo=sueldo+100 where categoria=20}; #sql [ctxeje] {commit}; #sql [ctxeje] {update Empleado set sueldo=sueldo+100 where categoria=20}; ctxeje.executebatch Cuántos lotes hay y cuándo se ejecutan? Update batching ExecutionContext ctxeje = new ExecutionContext(); ctxeje.setbatching(true); ctxeje.setbatchlimit(3); #sql [ctxeje] {update Empleado set sueldo=sueldo+100 where na=1}; #sql [ctxeje] {update Empleado set sueldo=sueldo+100 where na=2}; #sql [ctxeje] {update Empleado set sueldo=sueldo+100 where na=3}; // llegado al límite #sql [ctxeje] {update Empleado set sueldo=sueldo+100 where na=4}; #sql [ctxeje] {update Empleado set sueldo=sueldo+100 where na=5}; #sql [ctxeje] {update Empleado set sueldo=sueldo+100 where categoria=10}; // límite =3 #sql [ctxeje] {update Empleado set sueldo=sueldo+100 where categoria=20}; #sql [ctxeje] {commit}; // se ha llegadoha terminado la transacción #sql [ctxeje] {update Empleado set sueldo=sueldo+100 where categoria=20}; ctxeje.executebatch(); // petición de ejecución explícita Niveles de aislamiento en transac. Priorizar transacciones Es posible hacer operaciones de lectura y escritura Cuando se compromete una transacción se liberan las reservas (protocolo estricto de dos fases) Garantizar la serialización empeora el nivel de concurrencia Para mejorar la concurrencia se propone relajar las reglas definiendo niveles de aislamiento Se pueden ejecutar concurrentemente las transacciones que tienen distintos niveles de aislamiento Niveles de aislamiento en transac. Para definir las características de la transacción se debe utilizar como primera instrucción: set transaction [read only read write] [isolation level [read uncommitted read committed [diagnostics size <valor>] repeatable read serializable]] Read uncommited Solo operaciones de lectura Recomendable solo para transacciones que tienen funciones estadísticas Las transacciones (Tj) pueden leer datos sin comprometer Puede aparecer el problema de la lectura sucia (dirty read)

9 Read uncommitted (dirty read) Read commited Transacción T1 #sql {update cuenta set saldo= saldo- :cant where numcta= :ctax}; Transacción T2 #sql {update cuenta set saldo = saldo+ :cant where numcta= :ctay}; if () #sql {rollback}; Transacción T2 #sql iterator MiIter(int numcta); #sql {set transaction isolation level read uncommitted}; MiIter iter; #sql iter = {select numctafrom cuenta where saldo<0}; while (iter.next( )) { ctax = iter.numcta( ); mandar_carta(ctax);} La transacción (Tj) no puede leer ni escribir un dato modificado por otra transacción (Ti) hasta que éste se comprometa Evita la lectura sucia (dirty read) La transacción Tk puede leer o modificar un dato leido antes por Tj antes de comprometerlo Puede ocurrir el problema de la lectura irrepetible (unrepeatable read) Read committed (unrepeatable read) Transacción T1 #sql iterator MiIter(int dni); #sql {set transaction isolation level read committed}; MiIter iter; #sql iter = {select dni from cuenta where saldo> }; a = iter.dni( ); Transacción T2 #sql iter = {select dni from cuenta where saldo> }; Transacción T2 #sql {update cuenta set saldo= saldo - :cant where numcta= A2345}; Repeatable read Se aplica el protocolo de reserva de dos fases con todo Se evita la lectura sucia (dirty read) Se evita la lectura irrepetible (unrepeatable read) Puede aparecer el problema de la modificación fantasma cuando hay transacciones que introducen nuevas tuplas. El predicado no se tiene en cuenta Repeatable read (ghost update) Serializable Transacción T1 #sql iterator MiIter(int dni); #sql {set transaction isolation level repeatable read}; MiIter iter; #sql iter = {select dni from cuenta where saldo> }; a = iter.dni( ); Transacción T2 #sql iter = {select dni from cuenta where saldo> }; Transacción T2 #sql {insert intocuentavalues (A2565, 37, , , 2, Matia )}; Se evita la lectura sucia Se evita la lectura irrepetible Se evita la modificación fantasma En el grafo de prioridad, también se almacena información acerca de los predicados utilizados En oracle se usan rollback segments y marcas de tiempo Consistencia a nivel de transacción: los datos utilizados a lo largo de la transacción, son los comprometidos al comienzo de la misma.

10 Serializable Transacción T1 update cuentaset saldo= saldo * 2 where numcta= 2 Transacción T2 set transaction isolation level serializable update cuentaset saldo = saldo + 20 where numcta= 1 insert intocuentavalues (4, ) select * from cuenta commit update cuentaset saldo = saldo + 30 where numcta= 3 select * from cuenta update cuentaset saldo = saldo + 30 where numcta= 2 Error de pérdidade la serialización: ORA Niveles de aislamiento. Resumen Reserva de exclusión larga sobre las tuplas Reserva compartida larga sobre las tuplas Reservas de exc., compart. y sobre predicados largas Read uncommited NO NO Read commited SI NO NO Repeatable read SI SI NO Serializable SI SI NO Reservalarga = al comprometerse la transacción se libera la reserva(vsse libera la reservanada más terminar de usar el dato) No todos los SGBD ofrecen todos los niveles de aislamiento Oracle: Read committed, Serializable DB2: Read uncommited, Read commited, repeatable read & serializable Reservas explícitas LOCK TABLE Sintaxis: LOCK TABLE Tabla/Vista IN modo -reserva MODE [NOWAIT] Reserva explícita de una tabla completa Sin NOWAIT la transacción se queda en espera hasta lograr la reserva Modos de reserva Clave Otras reservas compatibles Consistencia nivel de transacción ROW SHARE IS IS, IX, S, SIX ROW EXCLUSIVE IX IS, IX SHARE S IS, S SHARE ROW EXCLUSIVE SIX IS EXCLUSIVE X -- Reservas explícitas SELECT FOR UPDATE Sintaxis: SELECT FOR UPDATE [OF tabla] [NOWAIT] Nivel de consistencia de transacciones Las tuplas encontradas se reservan una a una, pero todas a la vez y en modo exclusivo Si una tupla ya está reservada Con NOWAIT Se envía un mensaje de error al momento Sin NOWAIT La transacción se queda en espera hasta que se libera la reserva Si es en un iterador al llenarlo se reservan las tuplas (y no cuando se hace next) Para liberar la reserva, se espera al commit o al rollback (y no cuando se acaba de trabajar con el iterador) No se pueden utilizar: funciones agregadas, la cláusula group by, ni distinct Se pueden reservar varias tablas de una consulta con Join SELECT FOR UPDATE. Ejemplo for update Definición y verificación de restricciones #sql libres = {select asientos from espectaculo where cod = 34 } System.out.println (libres + asientos disponibles. + Cuántas entradas quiere? ); cant = entrada.readline( ); if (cant<= libres) #sql {update espectáculo set asientos = asientos - :cant where cod = 34}; else { } select nombre, saldo from cuenta natural join cliente where ciudad= Durango for update of Cuenta CONSTRAINT nombre-restricción [NOT] DEFERRABLE [INITIALLY [DEFERRED IMMEDIATE] ] Not Deferrable (No diferible) La comprobación de la restricción se realiza cada vez que se ejecuta una sentencia SQL en la transacción. Deferrable (Diferible) La comprobación de la restricción se puede diferir hasta el punto en el que se compromete la transacción initially deferred, initially immediate: Se indica cuándo se realizará la comprobación de las restricciones diferibles Initially immediate Se comprueba cada vezque se ejecutauna sentenciasql Reserva las cuentasde los clientes de Durango

11 Cambio de las definiciones de restricciones SET CONSTRAINTS [ALL murriztapen_izena {, urriztapen_izena}] [DEFERRED IMMEDIATE] En general las restricciones serán diferibles La comprobación de las restricciones diferidas se retrasa hasta que se haga explícito #sql {set immediate} o hasta comprometer la transacción. Al comprometer una transacción que tiene las restricciones diferidas, el sistema las pasa al estado immediate y se hacela comprobación. Si se viola una restricción, se termina la transacción (rollback) y se envía un mensaje de error Restricciones. Ejemplos #sql {insert into alumno values (23, )}; create table alumno( constraint matriculado check dni in (select dni from matricula) not deferrable) insert commit create table alumno( constraint matriculado check dni in (select dni from matricula) deferrableinitially immediate ) insert commit Restricciones. Ejemplos #sql {insert into alumno values (23, )}; create table alumno( constraint matriculado check dni in (select dni from matricula) deferrableinitially deferred ) insert commit insert set constraint immediate commit