Jdbc

JDBC Java Database Connectivity

Bibliografía JDBC API Tutorial and Reference, Third Edition . Maydene Fisher et al. Addison-Wesley Pub Co; 3rd edition (June 11, 2003). ISBN: 0321173848 Java Programming with Oracle JDBC. Donald Bales. O'Reilly (January 2002). ISBN: 0-596-00088-X Principles of DB Systems with Internet and Java . G. Riccardi. Addison Wesley 2001. ISBN: 02-0161-247-X Java Oracle Database Development. David J. Gallardo. Prentice Hall PTR (2003). ISBN: 0-13-046218-7 JDBC: Practical Guide for Java Programmers. Gregory Speegle. Morgan Kaufmann, 1st Ed (nov, 2001). ISBN: 1558607366. Database Programming with JDBC and Java, 2 nd Edition . George Reese. O'Reilly, 2000. ISBN: 1565926161 Java Database best Practices. George Reese, O’Reilly, 2003. ISBN: 0-596-00522-9 JDBC™ Guide: Getting Started . Copyright © 1996, 1997, Sun Microsystems, Inc. Documentación sobre JDBC . http://java.sun.com/j2se/1.4.2/docs/guide/jdbc/index.html. Oracle9 i JDBC Developer’s Guide and Reference . Copyright © 1999, 2001 Oracle Corporation. Effective Oracle by design . Thomas Kyte. Oracle Press, 2003. ISBN: 0-07-223065-7   

Objetivos Profundizar en la estrategia de programación CLI, particularizando para Java Conocer la estructura habitual de las librerías CLI a través del caso particular de Java Conocer el lugar de JDBC en la arquitectura de las aplicaciones con acceso a BD Evaluar las ventajas del uso de un API estándar de acceso a BD Dominar el proceso de trabajo con JDBC Dominar en un 50% el API JDBC Ser capaz de conectar con BD remotas Ser capaz de realizar consultas y actualizaciones sobre una BD remota Ser capaz de recabar información sobre la BD remota Ser capaz de gestionar la transaccionalidad en JDBC Conocer las aportaciones de las nuevas especificaciones JDBC 2 y 3

Agenda Introducción Drivers JDBC La clase DriverManager Conexiones Ejecución de instrucciones Transacciones y SQL Cuando las cosas van mal Temas avanzados JDBC 2 Introducción Drivers JDBC La clase DriverManager Conexiones Ejecución de instrucciones Transacciones y SQL Cuando las cosas van mal Temas avanzados JDBC 2

Introducción JDBC es un conjunto de clases e interfaces Java para la ejecución de sentencias SQL ( ver JavaDoc ). Es el CLI de Java Ha sido desarrollado conjuntamente por JavaSoft, Sybase, Informix, e IBM entre otros. JDBC permite manipular cualquier base de datos SQL. No es necesario hacer un programa para manipular Oracle, otro para Sybase, etc... Un mismo programa puede manipular cualquier base de datos. Uniendo Java con JDBC tenemos programas que se pueden ejecutar en cualquier plataforma y que pueden manipular cualquier base de datos. Las clases e interfaces JDBC se encuentran en el paquete java.sql .

Proceso de trabajo con JDBC Aplicación JDBC Driver A Connection Statement Gestor de drivers Driver B ResultSet  getConnection  createStatement  executeQuery

El proceso de trabajo en JDBC consiste en: Conectarse a la base de datos ( DriverManager ). Emitir sentencias SQL ( Statement , PreparedStatement , CallableStatement ). Procesar los resultados ( ResulSet ). Ejemplo: Connection con = DriverManager.getConnection( "jdbc:odbc:misdatos", "login", "password"); Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery("SELECT d1, d2, d3 FROM Tabla1"); while (rs.next()) { int x = getInt(”d1"); String s = getString(”d2"); float f = getFloat(”d3"); } Proceso de trabajo con JDBC Connection con = DriverManager.getConnection( "jdbc:odbc:misdatos", "login", "password"); Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery("SELECT d1, d2, d3 FROM Tabla1"); while (rs.next()) { int x = rs.getInt(”d1"); String s = rs.getString(”d2"); float f = rs.getFloat(”d3"); } El proceso de trabajo en JDBC consiste en: Conectarse a la base de datos ( DriverManager ). Emitir sentencias SQL ( Statement , PreparedStatement , CallableStatement ). Procesar los resultados ( ResulSet ). Ejemplo: Connection con = DriverManager.getConnection( "jdbc:odbc:misdatos", "login", "password"); Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery("SELECT d1, d2, d3 FROM Tabla1"); while (rs.next()) { int x = getInt(”d1"); String s = getString(”d2"); float f = getFloat(”d3"); } Connection con = DriverManager.getConnection( "jdbc:odbc:misdatos", "login", "password"); Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery("SELECT d1, d2, d3 FROM Tabla1"); while (rs.next()) { int x = rs.getInt(”d1"); String s = rs.getString(”d2"); float f = rs.getFloat(”d3"); } El proceso de trabajo en JDBC consiste en: Conectarse a la base de datos ( DriverManager ). Emitir sentencias SQL ( Statement , PreparedStatement , CallableStatement ). Procesar los resultados ( ResulSet ). Ejemplo: Connection con = DriverManager.getConnection( "jdbc:odbc:misdatos", "login", "password"); Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery("SELECT d1, d2, d3 FROM Tabla1"); while (rs.next()) { int x = getInt(”d1"); String s = getString(”d2"); float f = getFloat(”d3"); } Connection con = DriverManager.getConnection( "jdbc:odbc:misdatos", "login", "password"); Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery("SELECT d1, d2, d3 FROM Tabla1"); while (rs.next()) { int x = rs.getInt(”d1"); String s = rs.getString(”d2"); float f = rs.getFloat(”d3"); } El proceso de trabajo en JDBC consiste en: Conectarse a la base de datos ( DriverManager ). Emitir sentencias SQL ( Statement , PreparedStatement , CallableStatement ). Procesar los resultados ( ResulSet ). Ejemplo: Connection con = DriverManager.getConnection( "jdbc:odbc:misdatos", "login", "password"); Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery("SELECT d1, d2, d3 FROM Tabla1"); while (rs.next()) { int x = getInt(”d1"); String s = getString(”d2"); float f = getFloat(”d3"); } Connection con = DriverManager.getConnection( "jdbc:odbc:misdatos", "login", "password"); Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery("SELECT d1, d2, d3 FROM Tabla1"); while (rs.next()) { int x = rs.getInt(”d1"); String s = rs.getString(”d2"); float f = rs.getFloat(”d3"); }

Agenda Introducción Drivers JDBC La clase DriverManager Conexiones Ejecución de instrucciones Transacciones y SQL Cuando las cosas van mal Temas avanzados JDBC 2

El driver JDBC JDBC es básicamente una colección de interfaces Java (paquete java.sql ). P.ej. Connection Statement ResultSet Cada BD concreta implementará los interfaces de una manera particular La conexión ( Connection ) con Oracle no se hace igual que la conexión con Access Para una BD concreta, el conjunto de clases implementación, clases auxiliares y clases de utilidad componen el driver JDBC para esa BD Una misma aplicación puede conectar con distintas BD con sólo cambiar el driver

Tipos de drivers Tipo 1: Puente JDBC-ODBC Traduce JDBC a ODBC y lo retransmite al driver ODBC de la máquina Es el driver ODBC el que realmente comunica con la BD Se suministra con la JDK pero no incluye JDBC2 Pegas Puede ser útil para pruebas pero es lento en producción Necesita del driver ODBC en cliente (menor portabilidad) Tipo 2: Driver JDBC sobre driver nativo de la BD Retransmite JDBC al driver nativo instalado en la máquina Es el driver nativo el que realmente se comunica con la BD Precisa de instalación de driver nativo (menor portabilidad)

Tipos de drivers (II) Tipo 3: Driver Java sobre red Traduce las llamadas JDBC a un protocolo de red independiente de la plataforma que contacta con el servidor El servidor traduce esas peticiones al protocolo concreto de cada BD Usa middleware en el servidor de red que es capaz de conectar a los clientes puros Java a muchas bases de datos diferentes Rápido, independiente de la plataforma y no requiere de instalación en el cliente Tipo 4: Driver puro Java con protocolo nativo Traduce las JDBC al protocolo específico de la BD Y contacta directamente con ella

Tipos de drivers (III) Driver ODBC

El interface Driver y la clase DriverManager El interface Driver especifica los métodos que todo driver JDBC debe implementar. Será necesario un driver por cada tipo de base de datos que se desee utilizar (un driver para Oracle, otro para MySQL, etc...) y será el encargado de abrir conexiones con las mismas ( Connection ). Ejemplos de drivers sun.jdbc.odbc.JdbcOdbcDriver oracle.jdbc.driver.OracleDriver com.microsoft.jdbc.sqlserver.SQLServerDriver com.mysql.jdbc.Driver No se suele trabajar directamente con la clase concreta. El DriverManager agrupa los drivers y es el encargado de entregar el Driver adecuado para cada base de datos.

Clase DriverManager Es la capa de gestión de JDBC Se sitúa entre la aplicación que usará JDBC y los drivers JDBC de la BD Guarda una lista de los drivers disponibles y … … establece la conexión entre la BD y el driver apropiado para cada aplicación Es la primera clase JDBC con la que las aplicaciones contactan para comenzar una conexión JDBC DriverManager.getConnection(...)

Mantenimiento de la lista de drivers ¿Cómo se forma la lista de drivers disponibles? Toda clase Driver debe auto-registrarse en el Drivermanager nada más cargarse Una clase Driver se carga, y por tanto se registra, de dos formas diferentes: Cuando se inicia, el DriverManager consulta la propiedad jdbc.drivers . Dicha propiedad contiene una lista de drivers (las clases) que se desea cargar. Si se desea introducir un nuevo driver después de que el DriverManager se haya inicializado se utilizará el método forName de la clase Class > java -Djdbc.drivers= sun.jdbc.odbc.JdbcOdbcDriver aplicación Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");

Dónde poner el forName El driver se debe registrar una única vez durante la vida de la aplicación Se debe registrar al iniciar la aplicación (antes de pedir una conexión) Se debe elegir una clase que se inicialice al arrancar la aplicación y … … usar un bloque static para cargar el driver public class GestorBD { static { try { Class.forName("oracle.jdbc.driver.OracleDriver"); } catch (ClassNotFoundException e) { System.out.println("No se ha podido cargar el driver de laBD"); } } ... Resto de la clase }

Obtención de conexiones Es el Driver concreto el que realiza las conexiones, pero las solicitudes de conexión se realizan al DriverManager Una vez que la clase Driver ha sido cargada y registrada en DriverManager , se pueden establecer conexiones con la BD. Llamada al método DriverManager.getConnection(…) el DriverManager prueba los drivers registrados para ver si puede establecer la conexión. Para ello usa la URL de conexión Ejemplo (para Oracle) Class.forName(" oracle.jdbc.driver.OracleDriver "); String url = "jdbc:oracle:thin:@localhost:1521:PBD"; Connection con = DriverManager.getConnection(url, "PBD", "pbdpbd");

El interface Connection Un objeto de tipo Connection representa una sesión abierta con una base de datos. Provee de un contexto en el que emitir sentencias SQL y obtener resultados. Una aplicación puede tener varias conexiones a una misma base de datos y/o varias conexiones a distintas bases de datos. A partir de una conexión se puede: Obtener objetos Statement , PreparedStatement o CallableStatement para ejecutar sentencias SQL. Establecer el modo de las transacciones. Obtener información sobre la base de datos ( DatabaseMetadata ). Las conexiones se obtienen del DriverManager mediante el método getConnection.

URLs en JDBC Uno de los parámetros del método getConnection indica la URL (con protocolo jdbc ) que permite localizar la BD. La forma general de esta URL es: jdbc:<subprotocolo>:<subnombre> Por ejemplo: jdbc:oracle:thin:@172.77.77.77:1521:MIBD jdbc:odbc:MiBD El subprotocolo es particular de cada SGBD y lo utiliza el DriverManager para buscar el Driver adecuado para manipular la base de datos El formato subnombre depende de cada subprotocolo concreto. El Driver será el encargado de interpretarlo y le ayudará a localizar de alguna manera la base de datos. Los otros parámetros de getConnection son el nombre de usuario y la contraseña

Ejemplo de código de conexión a Oracle try { Class.forName("oracle.jdbc.driver.OracleDriver"); } catch (ClassNotFoundException e) { System.err.println("No se ha podido cargar el driver de la BD"); } ... Connection con = null ; try { String url = "jdbc:oracle:thin:@localhost:1521:PBD"; con = DriverManager.getConnection(url, "PBD", "pbdpbd"); ... Trabajo con la conexión } catch (SQLException e) { e.printStackTrace(); } finally { try { if (con != null ) con.close(); } catch (SQLException e2) { e2.printStackTrace(); } }

Importante La aplicación no suele trabajar directamente con el Driver concreto. Le pide al DriverManager conexiones a la BD concreta Busca por su lista de drivers alguno que sepa tratar el tipo de URL especificada y devuelve un objeto Connection (genérico) De esta manera las aplicaciones trabajan con Connection s sin preocuparse del tipo de base de datos con la que trabajan. El mismo código sirve para cualquier BD. Sólo hay que cambiar la URL. IMPORTANTÍSIMO: cerrar la conexión . Usar el bloque finally

El interface Statement Los objetos Statement permiten la ejecución de sentencias SQL y obtener los resultados. Es la propia conexión la que actúa como factoría de Statements: Connection.createStatement() Básicamente hay dos formas de lanzar sentencias SQL: Método executeQuery(<sql>) para comandos SQL que producen tuplas como resultado (consultas SELECT) ResultSet rs = stmt.executeQuery("SELECT a, b, c FROM Table2"); Método executeUpdate(<sql>) en sentencias INSERT, DELETE, UPDATE, comandos DDL (CREATE, DROP, etc...) y bloques PL/SQL (entre begin y end;). stmt.executeUpdate(”DROP TABLE Table2"); Connection con = DriverManager.getConnection(url, usr, pwd); Statement stmt = con. createStatement() ; ResultSet rs = stmt.executeQuery("SELECT a, b, c FROM Table2"); stmt.executeUpdate("DROP TABLE Table2"); int n = stmt.executeUpdate("UPDATE Table2 SET a = a + 1");

El interface Statement (II) El Método executeQuery devuelve un objeto de tipo ResultSet Es como una tabla que almacena el resultado de la consulta Tiene una serie de métodos de consulta Es como un cursor (en terminología PL/SQL) El método executeUpdate devuelve un entero que indica el número de filas modificadas por el comando Y en comandos DDL (CREATE, DROP, etc...) devuelve 0 Hay un método execute( <sql> ) que ejecuta cualquier tipo de sentencia Si es un SELECT devolverá true El ResultSet se deberá conseguir con getResultSet() Si es un UPDATE, …, devolverá false Las filas modificadas se consiguen con getUpdateCount()

El interface Statement (III) Una vez que el resultado haya sido procesado se debe cerrar el Statement mediante el método close() . Esto cierra también el ResultSet asociado Aun así Sun recomienda CERRAR EL ResultSet EXPLICITAMENTE Un mismo Statement puede reutilizarse en una misma conexión para ejecutar distintas sentencias. Al reejecutar un Statement se cierran los ResultSet anteriores Aun así Sun recomienda CERRAR EL ResultSet EXPLICITAMENTE

Ejemplo de código para Oracle // Carga del driver (Class.forName ... Connection con = null ; try { String url = "jdbc:oracle:thin:@localhost:1521:PBD"; con = DriverManager.getConnection(url, "PBD", "pbdpbd"); Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery(“SELECT a, b, c FROM Table2"); ... Procesamiento del resultado rs.close(); stmt.close(); } catch (SQLException e) { e.printStackTrace(); } finally { try { if (con != null ) con.close(); } catch (SQLException e2) { e2.printStackTrace(); } } OJO QUE NO ACABE EN ;

Composición del SQL El SQL que aceptan los métodos executeXxx es un String (JDBC es CLI) Puede componerse dinámicamente en función de valores de variables Para componer el String del SQL habrá que concatenar los distintos trozos del SQL (los estáticos y los variables). String id = "xx67yw8“; String sql = " SELECT a, b, c FROM Table2 WHERE id =' " + id + " ' " ; ResultSet rs = stmt.executeQuery(sql);

El interface ResultSet Los objetos de tipo ResultSet ofrecen métodos para recorrer el resultado de una consulta. Mantiene un puntero a la fila actual. Cada vez que se invoca el método next() se pasa a la siguiente fila. Inicialmente el puntero se sitúa antes de la primera fila  hay que llamar a next para situarlo en la primera fila (¡si la hay!) next() devuelve true , si el puntero ha avanzado a la siguiente fila false , si no quedan más filas que procesar ResultSet rs = stmt.executeQuery("SELECT a, b, c FROM Table2"); while (rs.next()) { ... Tratamiento de cada fila }

El interface ResultSet (II) Se obtienen los valores de la fila actual utilizando las distintas versiones del método get <tipo>(<columna>) pudiendo indicar la columna mediante su nombre o mediante su posición ( comienza por la 1 ). Ejemplo: devolverá N filas, con la columna 1 como un int, la 2 como un String y la 3 como una fecha Conviene cerrar el ResultSet aunque se cierra implícitamente al cerrar o reutilizar el Statement que lo creó. ResultSet rs = stmt.executeQuery("SELECT a, b, c FROM Table1"); while (rs.next()) { int i = rs.getInt("a"); // rs.getInt(1) String s = rs.getString("b"); // rs.getString(2) java.sql.Date f = rs.getDate("c"); // rs.getDate (3) System.out.println(“FILA = " + i + " " + s + " " + f); }

ResultSet y valores nulos Cuando se ha leído un null de SQL usando uno de los métodos get<tipo> , éste devuelve algo de lo siguiente: Un valor null de Java para aquellos métodos get<tipo> que devuelven objetos Java ( getString , getBigDecimal , getBytes , getDate , getTime , getTimestamp , …). Un valor cero para getByte , getShort , getInt , getLong , getFloat y getDouble . Un valor false para getBoolean. Para determinar si un valor resultado dado es null , primero debe intentarse leer la columna y usar el método de ResultSet wasNull() para ver si lo que acabamos de leer era null int i = rs.getInt("a"); // si el valor es null, i vale 0 if (rs.wasNull() { ... }

Navegación por el ResultSet En principio sólo se puede avanzar por las filas de datos ( next() ) No se puede retroceder, ni volver a procesar un ResultSet . A partir de JDBC2, se incluyen métodos para ir hacia detrás, al principio, al final, a una fila determinada … … pero tienen implicaciones en el rendimiento de la aplicación

Tipos de datos y get<Tipo> Una “x” indica que el método get <tipo> puede legalmente usarse para recuperar el tipo JDBC dado. Una “ X ” indica que el método get <tipo> es el recomendado para recuperar el tipo de dato dado.

Tipos de datos y get<Tipo> 

Ejemplo completo try { Class.forName("oracle.jdbc.driver.OracleDriver"); } catch (ClassNotFoundException e) { System.err.println("No se ha podido cargar el driver de la BD"); } Connection con = null ; try { String url = "jdbc:oracle:thin:@localhost:1521:PBD"; con = DriverManager.getConnection(url, "PBD", "pbdpbd"); Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery("SELECT a, b, c FROM Table1"); while (rs.next()) { int i = rs.getInt("a"); // rs.getInt(1) String s = rs.getString("b"); // rs.getString(2) java.sql.Date f = rs.getDate("c"); // rs.getDate (3) System.out.println(“FILA = " + i + " " + s + " " + f); } try { Class.forName("oracle.jdbc.driver.OracleDriver"); } catch (ClassNotFoundException e) { System.err.println("No se ha podido cargar el driver de la BD"); } Connection con = null ; try { String url = "jdbc:oracle:thin:@localhost:1521:PBD"; con = DriverManager.getConnection(url, "PBD", "pbdpbd"); Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery("SELECT a, b, c FROM Table1"); while (rs.next()) { int i = rs.getInt("a"); // rs.getInt(1) String s = rs.getString("b"); // rs.getString(2) java.sql.Date f = rs.getDate("c"); // rs.getDate (3) System.out.println(“FILA = " + i + " " + s + " " + f); } Carga del driver try { Class.forName("oracle.jdbc.driver.OracleDriver"); } catch (ClassNotFoundException e) { System.err.println("No se ha podido cargar el driver de la BD"); } Connection con = null ; try { String url = "jdbc:oracle:thin:@localhost:1521:PBD"; con = DriverManager.getConnection(url, "PBD", "pbdpbd"); Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery("SELECT a, b, c FROM Table1"); while (rs.next()) { int i = rs.getInt("a"); // rs.getInt(1) String s = rs.getString("b"); // rs.getString(2) java.sql.Date f = rs.getDate("c"); // rs.getDate (3) System.out.println(“FILA = " + i + " " + s + " " + f); } Conexión try { Class.forName("oracle.jdbc.driver.OracleDriver"); } catch (ClassNotFoundException e) { System.err.println("No se ha podido cargar el driver de la BD"); } Connection con = null ; try { String url = "jdbc:oracle:thin:@localhost:1521:PBD"; con = DriverManager.getConnection(url, "PBD", "pbdpbd"); Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery("SELECT a, b, c FROM Table1"); while (rs.next()) { int i = rs.getInt("a"); // rs.getInt(1) String s = rs.getString("b"); // rs.getString(2) java.sql.Date f = rs.getDate("c"); // rs.getDate (3) System.out.println(“FILA = " + i + " " + s + " " + f); } Consulta try { Class.forName("oracle.jdbc.driver.OracleDriver"); } catch (ClassNotFoundException e) { System.err.println("No se ha podido cargar el driver de la BD"); } Connection con = null ; try { String url = "jdbc:oracle:thin:@localhost:1521:PBD"; con = DriverManager.getConnection(url, "PBD", "pbdpbd"); Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery("SELECT a, b, c FROM Table1"); while (rs.next()) { int i = rs.getInt("a"); // rs.getInt(1) String s = rs.getString("b"); // rs.getString(2) java.sql.Date f = rs.getDate("c"); // rs.getDate (3) System.out.println(“FILA = " + i + " " + s + " " + f); } Procesar resultado

Ejemplo completo (II) ... rs.close(); stmt.close(); } catch (SQLException e) { e.printStackTrace(); } finally { try { if (con != null ) con.close(); } catch (SQLException e) { e.printStackTrace(); } } ... rs.close(); stmt.close(); } catch (SQLException e) { e.printStackTrace(); } finally { try { if (con != null ) con.close(); } catch (SQLException e2) { e2.printStackTrace(); } } Cerrar TODO

Ejemplo de prácticas package sol; import bd.AbstractDBManager; import java.sql.*; import model.*; public class GestorBD extends AbstractDBManager { // Registro del driver apropiado para la BD a utilizar static { try { Class.forName("oracle.jdbc.driver.OracleDriver"); } catch (ClassNotFoundException e) { System.out.println("No puedo cargar el driver JDBC de la BD"); } } public Articulo getArticulo(String codigo) { } }

public Articulo getArticulo(String codigo) { Articulo articulo = null ; Connection con = null ; try { con = DriverManager.getConnection ("jdbc:oracle:thin:@localhost:1521:pbd", "prbd", "prbdprbd"); Statement stm = con.createStatement (); String sql = " SELECT nombre, PVP FROM Articulo WHERE codigo =' " +codigo+ " ' "; ResultSet res = stm.executeQuery(sql); if ( res.next() ) { articulo = new Articulo(codigo, res.getString("nombre") , res.getDouble("PVP") ); } res.close(); stm.close(); } catch (SQLException e) { e.printStackTrace(); } finally { if (con != null ) try { con.close(); } catch (SQLException ex) { ex.printStackTrace(); } } return articulo; }

El interface PreparedStatement Cada vez que se lanza un Statement el SGBD debe interpretarla y calcular un plan de consulta La clase PreparedStatement permite lanzar comandos SQL precompilados. En sentencias que van a ser ejecutadas múltiples veces se obtiene un aumento de rendimiento al tener la consulta ya analizada y optimizada. Los objetos PreparedStatement se obtienen de la conexión, mediante el método prepareStatement(<sql>) Connection con = DriverManager.getConnection(url, usr, pwd); PreparedStatement stmt = con. prepareStatement(... SQL ...) ;

El interface PreparedStatement Otro uso de PreparedStatement es la posibilidad de parametrizar las consultas La sentencia SQL puede contiene uno o más parámetros de entrada (indicados por ‘?’) los cuales podrán ser modificados en distintas ejecuciones de la sentencia. Esta funcionalidad puede ser útil cuando no se sabe cómo escribir los valores de ciertos tipos de datos en el SQL del SGBD destino (ejemplo, los valores DATE, boolean). También puede evitar “inyecciones de SQL” PreparedStatement ps = con.prepareStatement("UPDATE table SET sueldo= ? WHERE nombre= ? ");

Inyección de SQL Detrás de un formulario de autenticación habrá una consulta como: SELECT * FROM users WHERE usr=‘Bob’ and pwd=‘2kjlu’ Si la consulta devuelve resultado, el usuario puede entrar; si no, adiós muy buenas. El código de la aplicación concatena la consulta basándose en el contenido de los campos del formulario: "SELECT * FROM users WHERE usr='"+ elUsuario +"' and pwd='"+ laContraseña +"'" Ej: SELECT * FROM users WHERE usr=' fco ' and pwd=' xx ' Si el usuario mete Como usuario: admin Como contraseña: MeDaIgual' OR '1'='1 La cosa queda: SELECT * FROM users WHERE usr=' admin ' and pwd=' MeDaIgual' OR '1'='1 '

El interface PreparedStatement Antes de que la sentencia SQL pueda ser ejecutada deberemos asignar algún valor a los parámetros de entrada La asignación se realiza mediante el método set<tipo>() siendo el tipo compatible con el del parámetro. El método set<tipo> lleva dos argumentos: La posición del parámetro a asignar dentro de la sentencia (el primero es el 1). El valor a asignar al parámetro. Finalmente se ejecuta la sentencia: ps.executeUpdate(); PreparedStatement ps = con.prepareStatement("UPDATE table SET sueldo= ? WHERE nombre= ? "); ps.setFloat(1, 1500.0); ps.setString(2, “Pepe"); ps.executeUpdate();

Ejemplo try { Class.forName("oracle.jdbc.driver.OracleDriver"); } catch (ClassNotFoundException e) { System.err.println("No se ha podido cargar el driver de la BD"); } Connection con = null ; try { String url = "jdbc:oracle:thin:@localhost:1521:PBD"; con = DriverManager.getConnection(url, "PBD", "pbdpbd"); float sueldos [] = {1500, 2000, 1205.75f}; String nombres [] = {"Juan","Ana","Maria"}; PreparedStatement ps = con.prepareStatement("UPDATE table SET sueldo=? WHERE nombre=?"); for ( int i=0;i<sueldos.length;i++) { ps.setFloat(1,sueldos[i]); ps.setString(2,nombres[i]); ps.executeUpdate(); } ps.close();

Ejemplo (II) } catch (SQLException e) { e.printStackTrace(); } finally { try { if (con != null ) con.close(); } catch (SQLException e2) { e2.printStackTrace(); } }

Parámetros con valores null Cuando se pasa un valor null Java en alguno de los métodos set<tipo>() , se almacena un valor SQL null en la BD. Si son valores de tipos primitivos ( int , float , boolean , …) El método a utilizar es setNull() Hay que indicar el tipo PreparedStatement ps = con.prepareStatement(“INSERT INTO Persona(nombre, casado) VALUES (?,?)"); ps.setString (1, "Juan"); ps.setNull(2, java.sql.Types.BOOLEAN);

Notas sobre fechas (Oracle) Al almacenar fechas en Oracle podemos perder precisión Oracle tiene dos (tres) tipos para fechas: DATE: que almacena fechas con hora,minutos y segundos TIMESTAMP: que almacena fechas con hora,minutos, segundos y fracciones de segundo Cualquiera de los dos tipos de campos puede consultarse / almacenarse con setDate / getDate o setTimestamp / getTimestamp Pero: setDate no almacena datos sobre la hora, sólo la fecha (la hora la pone a 00:00:00) getDate no recupera datos sobre la hora (aunque sí esté en la BD) setTimestamp / getTimestamp sí almacenan y recuperan datos sobre la hora. Si el campo es de tipo TIMESTAMP (en Oracle) incluso recuperan los datos sobre fracciones de segundo

El interface CallableStatement Los objetos CallableStatement proporcionan un mecanismo para invocación de stored procedures de la base de datos. Se obtienen de Connection mediante el método prepareCall(...) La sintaxis de la invocación es: {[? = ]call <procedure_name>[(?, ?, ...)]} Los procedimientos almacenados pueden tener parámetros de tres tipos Los parámetros IN se tratan como en PreparedStatement . Los parámetros OUT hay que registrarlos mediante: registerOutParameter(<indice>, <tipo>); Los parámetros INOUT se le da valor como a los IN y se registran como los OUT Finalmente se ejecuta la sentencia y se recogen los valores OUT con la familia de métodos get<tipo>(<indice>)

Ejemplo Supongamos una función llamada PrecioArticulo que devuelve el precio de una cantidad de artículos // Carga del driver ... Connection con = null ; try { String url = "jdbc:oracle:thin:@localhost:1521:PBD"; con = DriverManager.getConnection(url, "PBD", "pbdpbd"); CallableStatement call=con.prepareCall("{?=call PrecioArticulo(?,?)}"); call.registerOutParameter(1, Types.DOUBLE); call.setString(2, "D786SCO"); call.setInt(3, 10); call.executeQuery(); precioLinea = call.getDouble(1); call.close(); } ... cerrar la conexión

Ejemplo (II) Un procedimiento ( swap ) de intercambio de valores (dos parámetros INOUT) // Carga del driver ... Connection con = null ; try { // ... Establecimiento de la conexión CallableStatement call = con.prepareCall(“{call swap(?, ?)}"); call.registerOutParameter(1, Types.INTEGER); call.registerOutParameter(2, Types.INTEGER); call.setInt(1, 1); call.setInt(2, 2); call.execute(); int r1 = call.getInt(1); int r2 = call.getInt(2); call.close(); System.out.println("Los valores ahora son "+r1+" y "+r2); } ... cerrar la conexión

Transacciones en JDBC Una transacción es un conjunto de sentencias que se deben completar o anular en su totalidad. Cuando se inicia una transacción la forma de hacerla definitiva es mediante el método commit() del interface Connection . Si se desean deshacer todas las sentencias de la transacción hay que invocar al método rollback() del interface Connection . Las conexiones están por defecto en modo autoCommit, es decir, las sentencias se auto-confirman sin necesidad de llamar a commit() cuando finalizan (luego cada sentencia es una transacción).

Transacciones en JDBC El modo autoCommit se activa/desactiva con el método setAutoCommit(boolean on) del interface Connection . Si el modo autoCommit está desactivado las transacciones no finalizarán hasta que se llame a commit() o rollback() explícitamente. A su vez dichos métodos inician una nueva transacción, por lo que una transacción serán todas aquellas sentencias ejecutadas entre dos commit y/o rollback consecutivos. También se puede establecer un punto de recuperación con el método setSavePoint() del interface Connection (desde JDBC 3.0).

Ejemplo ... Carga del driver ... String URL = "jdbc:oracle:thin:@localhost:1521:PBD"; Connection con = null ; try { con = DriverManager.getConnection(URL, "PBD", "pbdpbd"); con.setAutoCommit( false ); float sueldos [] = {1500, 2000, 1205.75f}; String nombres [] = {"Juan","Ana","Maria"}; PreparedStatement ps =con.prepareStatement("UPDATE table SET sueldo=?"+ "WHERE nombre=?"); for ( int i=0;i<sueldos.length;i++) { ps.setFloat(1,sueldos[i]); ps.setString(2,nombres[i]); ps.executeUpdate(); } ps.close(); con.commit();

Ejemplo (II) } catch (SQLException e) { e.printStackTrace(); try { if (con != null ) con.rollback(); } catch (SQLException e2) { e2.printStackTrace(); } } finally { try { if (con != null ) con.close(); } catch (SQLException e2) { e2.printStackTrace(); } }

Control de la concurrencia ¿Que ocurre cuando un proceso está realizando una transacción (no se sabe si la confirmará o no) y otro intenta acceder a filas afectadas por la transacción? El programador debe decidir como debe comportarse la conexión en ese caso mediante el método setTransactionIsolation(<tipo>) . TRANSACTION_READ_UNCOMMITTED (dirty reads): Se lee siempre la última versión de los datos aunque se encuentren sin confirmar (si luego se hace un rollback los datos son erróneos). TRANSACTION_READ_COMMITTED : Solo se leen datos confirmados. No se consideran los datos modificados en otra transacción hasta que no los confirme (con commit ).

Control de la concurrencia (II) TRANSACTION_REPEATABLE_READ : Solo se leen datos cofirmados. Además mantiene un lock sobre la fila actual de manera que otros procesos no pueden modificarla (aunque sí leerla). Cuando se cambia la fila actual el lock cambia de registro. TRANSACTION_SERIALIZABLE : Solo se leen datos confirmados. Además mantiene un lock sobre todas las filas seleccionadas durante la transacción. Otros procesos no podrán modificar ninguna de ellas (aunque sí leerlas).

SQLException La mayoría de los métodos de las clases e interfaces JDBC lanzan la excepción java.sql.SQLException cuando se produce algún error con relación a la BD: No se puede conectar La sentencia está mal construida … SQLException es una exception explícita y proporciona Un mensaje explicativo sobre la causa del error - getMessage() Un código (entero) que identifica al error - getErrorCode() Un enlace a la siguiente excepción anidada - getNextException()

DatabaseMetaData La conexión proporciona información sobre la BD a la que se conecta Para ello dispone del método getMetaData() que devuelve un objeto DatabaseMetaData al que se puede preguntar por: Información sobre la versión de BD y de driver Propiedades sobre lo que puede hacer la BD y el driver: procedimientos almacenados, outer joins, … Límites de la BD: nº máximo de conexiones concurrentes, máximo de columnas en tabla, … Funciones que incluye la BD y tipos que soporta Esquema de la BD: tablas, campos de cada tabla, claves primarias, foráneas, índices, privilegios

ResultSetMetaData ResultSet proporciona información, además de sobre el contenido, sobre la estructura de los datos obtenidos en un SELECT. Para ello dispone del método getMetaData() que devuelve un objeto ResultSetMetaData al que se puede preguntar por: El número de columnas que incluye Las características de cada columna: nombre, tipo, precisión, escala Si la columna puede contener valores nulos

Secuencias de escape Los Statement pueden contener SQL con sintaxis de escape SQL. La sintaxis de escape señala al driver que el código que lleva debe ser tratado diferentemente. El driver traducirá la sintaxis de escape en código que entiende la BD en particular. Ejemplos: escape para caracteres LIKE d , t y ts para literales de fecha y tiempo una fecha se especifica en SQL JDBC mediante la sintaxis: {d 'yyyy-mm-dd'} st.executeQuery("SELECT * FROM Articulo WHERE Id LIKE '\_%' {escape '\'};

Sobre conexiones Las conexiones son un recurso limitado: hay que cerrarlas Pero cuando? ¿Tras cada transacción? Regla general: si no es necesario usar la misma conexión a lo largo de varias interacciones, debe cerrarse Se pueden conservar Si hay pocos usuarios concurrentes Si hay que mantener las propiedades transaccionales en varias interacciones Pero hay que comprobar que la conexión está viva (y no siempre funciona el isClosed() y hay que hacer queries como SELECT 7 FROM DUAL) Hay que cerrarla Si puede haber muchos usuarios conectados concurrentemente, por ejemplo en aplicaciones web. En estos casos tras cada servicio hay que cerrar la conexión. Se suelen usar Pool de conexiones

Pool de Conexiones Aplicación DriverManager new Connection( con.close() Pool de Conexiones getConnection( getConnection(

Cuando usar PreparedStatement No todos los SGBDs lo soportan En principio mejoran el rendimiento, aunque este no es el único método de mejora: Los SGBDs suelen cachear las queries (Oracle lo hace): ofrecen mucho rendimiento si se repite la misma query Pero si la query se diferencia en el valor de algún parámetro, … la caché no actúa En este caso puede ser mejor usar PreparedStatement . Los PreparedStatement están asociados a la conexión que los creó: viven mientras no se cierre la conexión Es necesario combinar la reutilización de PreparedStatement con pooling de conexiones. Los servidores de aplicaciones suelen hacerlo.

“ The use of a Statement in JDBC should be 100% localized to being used for DDL (ALTER, CREATE, GRANT, etc) as these are the only statement types that cannot accept BIND VARIABLES. PreparedStatements or CallableStatements should be used for EVERY OTHER type of statement (DML, Queries). As these are the statement types that accept bind variables. This is a fact, a rule, a law -- use prepared statements EVERYWHERE ” Tom Kyte, Oracle's VP

Actualizaciones por lotes Ejecutar un conjunto de actualizaciones de “una tacada”. No se pueden ejecutar SELECTs. Para ejecutar un lote primero crear un Statement e ir añadiéndole updates SQL (con addBatch() ) Se debería tratar al lote como una transacción poniendo el autocommit en falso, para luego hacer un commit() . Statement stmt = con.createStatement(); stmt.addBatch( "... un INSERT, algo que no sea SELECT ..."); stmt.addBatch( "... ... stmt.executeBatch();

ResultSet recorrible y actualizable Con el ResultSet tradicional sólo se puede avanzar por los datos Con JDBC2 es posible ir hacia delante y hacia atrás en un ResultSet . El ResultSet debe ser configurado para tal cosa poniendo unos settings apropiados. Los settings indican si se permite navegar por el ResultSet y si se deja editar su contenido. ResultSet.CONCUR_READ_ONLY , no se puede editar el contenido ResultSet.CONCUR_UPDATABLE , sí se puede editar ResultSet.TYPE_FORWARD_ONLY , solo se puede ir hacia adelante ResultSet.TYPE_SCROLL_INSENSITIVE , se puede navegar; una vez consultados los datos si estos son cambiados por terceros no veremos los cambios ResultSet.TYPE_SCROLL_SENSITIVE Estos settings se indican cuando se crea el Statement , debiéndose dar un valor para definir las características de navegabilidad y de modificafilidad. Ej: los resultSets de la siguiente statement serán navegables pero no se podrán modificar: con.createStatement( ResultSet.TYPE_SCROLL_INSENSITIVE , ResultSet.CONCUR_READ_ONLY );

ResultSet recorrible y actualizable (II) Los movimientos se realizan con los métodos next() , previous() , relative(n) , absolute(n) , last() , first() , beforeFirst() , afterLast() , pudiendo saber en que fila se está con el getRow() . Los drivers de BD pueden no dar soporte a estas características. Incluso en drivers que si las soportan, determinadas queries complejas pueden devolver resultados que por ejemplo no sean modificables. Como norma es preciso comprobar las características del ResultSet devuelto para ver cual es el modo en el que trabaja (con los métodos getType() y getConcurency() ). Estas características tienen su impacto en el rendimiento de la aplicación

Nuevos tipos de datos Se pueden recuperar/almacenar en una base de datos objetos de tipo BLOB (Binary Large Objects) CLOB (Character Large Objects). Se recuperan con los métodos getBlob() y getClob() de ResultSet , que devuelven objetos de tipo java.sql.Blob y java.sql.Clob , los cuales incorporan métodos para navegar por los contenidos de los objetos. También se pueden recuperar ARRAYs con el método getArray() , que devuelve un objeto de tipo java.sql.Array .

javax.sql Incluye las extensiones JDBC para J2EE Destinado a su empleo en servidores de aplicaciones (Weblogic, WebSphere, Oracle9iAS, JRun, JBoss, …) Proporciona: Otro mecanismo de obtención de conexiones: Basado en DataSource Que hay que desplegar previamente Pueden ser pooled Gestión de transacciones distribuidas Rowsets, como el CachedRowset

Novedades JDBC 4.0 Carga automática de drives JDBC Usando el mecanismo de Proveedores de Servicio de Java SE Tipo de dato ROWID Mejora en el soporte para CLOB y BLOB Soporte para SQL/XML Posibilidad de “des-envolver” las clases que implementan JDBC para acceder a funcionalidad propietaria de un SGBD concreto Mejoras en la gestión de Connection y Statement en pool Nuevas funciones escalares Nuevos métodos en varios interfaces

Cosas que se quedan en el tintero La configuración y obtención de conexiones vía DataSources JDBC El empleo de pools de conexiones Empleo de datos de tipos CLOB y BLOB

} finally { try { if (presentacion != null ) presentacion.close(); } catch (SQLException e) { e.printStackTrace(); } }

Jdbc

Más contenido relacionado

La actualidad más candente (19)

Similar a Jdbc (20)

Último (20)

Jdbc

Notas del editor