1. JDBC

2. Introducción
Java proporciona conectividad a muchos tipos de base de datos a través de
su API de Conectividad a Base de Datos Java ( Java Data Base Connectivity -
JDBC)
Para desarrollar programas que interactuen con bases de datos en Java, se
requiere esencialmente:
 Una base de datos relacional
 Una interfaz con Java (a través del API JDBC)
 Conocimiento básico de las sentencias SQL

3. Pasos Involucrados en el Acceso
a Bases de Datos
1. Se debe cargar en memoria el controlador (driver) que habilitará la
conexión entre el programa Java y el sistema de base de datos
2. A través de este controlador, se establece una conexión a la base
de datos
3. Una vez establecida la conexión, por medio de esta se ejecutan las
sentencias SQL que sean requeridas
4. Al finalizar se debe cerrar todas las conexiones a bases de datos
que estén activas

4. El API JDBC
• Algunas de las clases e interfaces de esta api son:
– java.sql.DriverManager
– java.sql.Driver
– java.sql.Connection
– java.sql.Statement
– java.sql.ResultSet
– java.sql.ResultSetMetaData
– java.sql.DabataseMetaData
– java.sql.PreparedStatement
– java.sql.CallableStatement

5. Relación entre las Clases e
Interfaces JDBC
utiliza «interface»
DriverManager Driver
crea
«interface» genera «interface»
Connection Statement
genera retorna
«interface» «interface»
DatabaseMetaData ResultSet
genera
«interface»
ResultSetMetaData

6. Tipos de Controladores JDBC
• JDBC provee cuatro tipos de controladores:
- Controlador JDBC-ODBC (Tipo 1)
- Controlador API-Nativo (Tipo 2)
- Controlador de Protocolo de Red (Tipo 3)
- Controlador Protocolo-Nativo (Tipo 4)

7. Cargar el Controlador
• Para cargar el controlador, se debe usar el método forName en la clase
Class con el nombre del controlador como argumento
• Ejemplos del proceso de carga de un driver:
- MS Access y MS SQL Server
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
- IBM UDB DB2
Class.forName("COM.ibm.db2.jdbc.app.DB2Driver");
- MySQL
Class.forName("com.mysql.jdbc.Driver");
- PostgreSQL
Class.forName("org.postgresql.Driver");

8. Crear una Conexión
• La clase DriverManager es responsable por buscar las diferentes
implementaciones JDBC que puedan existir en un sistema y administrar
los controladores JDBC
• La clase DriverManager provee un método llamado
getConnection(), por medio de este se puede obtener una conexión
a una bases de datos
• Este método toma tres argumentos:
– El URL de la base de datos
protocol:<subprotocol>:<subname>
– Identificación del usuario
– Clave del usuario

9. Crear una Conexión
import java.sql.*;
public class PruebasJDBC {
public static void main(java.lang.String[] args) {
Connection conn = null;
try {
Class.forName("COM.ibm.db2.jdbc.app.DB2Driver");
System.out.println("Driver cargado...");
conn = DriverManager.getConnection(
"jdbc:db2:Sample", "db2admin",
"db2admin");
System.out.println("Conexión establecida...");
} catch (ClassNotFoundException e) {
System.out.println("Driver no encontrado");
} catch (SQLException e) {
System.out.println("Error DB: " + e);
} finally {
try {
if (conn != null) conn.close();
} catch (SQLException se){}
}
}
} Debemos realizar un
manejo adecuado de
las excepciones que
pueden generarse

10. Crear Objetos Statement
• Las sentencias SQL más usadas son las siguientes:
– UPDATE
– INSERT
– DELETE
– SELECT
• La interfaz Statement provee métodos para hacer estas llamadas
• El método executeUpdate() retorna el numero de registros afectados
por la sentencia SQL
• El método executeQuery() retorna el conjunto de registros
seleccionados por la consulta (ResultSet)

11. Crear Objetos Statement
import java.sql.*;
public class PruebasJDBC1 {
public static void main(String[] args) {
Connection conn = null;
String u = "db2admin";
String p = "db2admin";
String drv = "COM.ibm.db2.jdbc.app.DB2Driver";
try {
Class.forName(drv);
conn = DriverManager.getConnection(
"jdbc:db2:IBM",u,p);
Statement stmt = conn.createStatement();
String sql = "INSERT INTO ESTUDIANTE "+
"VALUES('Pedro','Perez',123)";
stmt.executeUpdate(sql);
System.out.println("Actualización exitosa ");
} catch (Exception e){
System.out.println("Error: "+e);
}finally {
try {if (conn != null)conn.close();}
catch (SQLException se){}
}
}
}

12. Usar ResultSet
• Al utilizar el método executeQuery() de un Statement, es necesario
utilizar una referencia a la interfaz ResultSet para manipular los datos
retornados por el Statement
• Para iterar a través de un ResultSet se utiliza el método next(), que
permite mover el cursor desde su posición actual hasta el proximo registro
• Inicialmente el cursor del ResultSet se encuentra antes del primer
registro

13. Usar ResultSet
• La interfaz ResultSet provee una serie de métodos que permiten extraer
los datos contenidos en el registro apuntado por el cursor, entre estos se
tienen:
- int getInt(String);
int getInt(int);
- String getString(String);
String getString(int);
- float getFloat(String);
float getFloat(int);
• Existe un par de métodos similares para cada tipo de dato compatible con
SQL

14. Usar ResultSet
import java.sql.*;
public class PruebasJDBC2 {
public static void main(String[] args) {
...
try {
...
Statement stmt = conn.createStatement();
String sql = "SELECT * FROM ESTUDIANTE";
ResultSet r = stmt.executeQuery(sql);
while(r.next())
System.out.println(r.getString("nombre")+
" "+ r.getInt("ci"));
} catch (Exception e){
System.out.println("Error: "+e);
}finally {
try {if (conn != null)conn.close();}
catch (SQLException se){}
}
}
}

15. Interfaces MetaData
• La palabra Metadata implica información acerca de información
• La interfaz ResultSetMetaData provee información acerca de los
objetos ResultSet
• La clase DatabaseMetaData está relacionado con el objeto
Connection. Por medio de esta se puede obtener información de la
base de datos a la cual se está conectado por medio de Connection

16. ResultSetMetaData
• Algunos de los métodos contenidos en esta interfaz son los siguientes:
- int getColumnCount()
- String getColumnLabel(int column)
- String getColumnName(int column)
- String getTableName(int column)
- int isNullable(int column)
- boolean isReadOnly(int column)

17. DatabaseSetMetaData
• Alguno de los métodos contenidos en esta interfaz son los siguientes:
- String getDriverName()
- String getURL()
- String getUserName()
- boolean isReadOnly()

18. Extensiones de la Interfaz Statement
• La especificación JDBC provee dos clases adicionales, provenientes de la
interfaz Statement para permitir al programador realizar programación
sofisticada de base de datos
• Estas interfaces son:
– PreparedStatement
– CallableStatement

19. PreparedStatement
• Existe una manera de crear sentencias SQL una vez y usarla cada vez
que quiera correrla
• Esto se logra a través de PreparedStatement de JDBC
• Esta interfaz permite construir las sentencias SQL requeridas una vez y
ejecutarlas cualquier número de veces en la aplicación
• Cuando un objeto PreparedStatement es creado, la sentencia SQL se
da como argumento
• La sentencia SQL debe ser enviada al DBMS inmediatamente donde es
compilada una vez

20. PreparedStatement
• En tiempo de construcción el PreparedStatement no conoce los
valores que determinan el resultado de su ejecución
• Solo las posiciones de dichos valores son conocidas en el momento de su
creación, las mismas son indicadas con el símbolo “?”
PreparedStatement ps;
ps = conn.preparedStatement("select * from
tabla "+ "where c1=? ")

21. PreparedStatement
import java.sql.*;
public class PruebasJDBCPrepared {
static String db="jdbc:db2:IBM";
static String drv="COM.ibm.db2.jdbc.app.DB2Driver";
public static void main(String []args){
Connection conn = null;
PreparedStatement ps = null;
try{
Class.forName(drv);
conn = DriverManager.
getConnection(db,"db2admin","db2admin");
String sql = "select * from estudiante where
ci=?";
ps = conn.prepareCall(sql);
ps.setInt(1,123);
ResultSet rs = ps.executeQuery();
//Continúa...

22. PreparedStatement
if(rs.next())
System.out.println("Encontrado");
else
System.out.println("No Encontrado");
}catch(Exception e){
System.out.println("Error: "+e);
}finally{
try{
if(conn!=null)
conn.close();
}catch(Exception e){}
}
}
}//Fin de la clase PruebasJDBCPrepared

23. Procedimientos Almacenados
• Un procedimiento almacenado (stored procedure) permite asociar un
conjunto de sentencias SQL a un único nombre, para luego ejecutarlas
haciendo uso de ese nombre en cualquier momento
• Los procedimientos almacenados son muy rápidos, ya que se ejecutan
dentro de la base de datos y están previamente compilados
• Por medio de los objetos de la interfaz CallableStatement se pueden
ejecutar dentro del código Java

24. Administración de Transacciones
• Una transacción puede ser definida como un conjunto de operaciones que
deben ser ejecutadas como una unidad
• De fallar una de las operaciones, falla en su totalidad la transacción
• Una transacción es una “unidad de trabajo”
• Cuando se realiza cualquier operación de INSERT, UPDATE o DELETE ésta
se ejecuta con auto-commit explícito por omisión
• Para habilitar control sobre las transacciones de la base de datos se usa el
método setAutoCommit(boolean autoCommit)

25. Administración de Transacciones
...
try{
// Auto commit deshabilitado
conn.setAutoCommit(false);
// Insertamos en la primera tabla
stmt = conn.createStatement();
stmt.executeUpdate("INSERT INTO table1 ...");
stmt.close();
// Insertamos en la segunda tabla
stmt = conn.createStatement();
stmt.executeUpdate("INSERT INTO table2 ...");
stmt.close();
// Compromete los cambios en la base de datos
conn.commit();
}catch(SQLException e){
try {
conn.rollback();
}catch( SQLException sqle2 ){}
}...

26. Soporte de Cursores
• JDBC provee soporte limitado de cursores.
• Permite a una aplicación obtener un cursor asociado con el resultado a
través del método de ResultSet.getCursorName()
• El desplazamiento dentro del cursor es provisto recientemente en las
implementaciones de JDBC, algunos controladores pueden no permitirlo
• Para hacer uso de cursores desplazables se debe activar esta
característica

27. Soporte de Cursores
Uso típico de cursores:
stmt = conn.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
rs = stmt.executeQuery("SELECT * FROM tableName”);
rs.absolute(7);
System.out.println(rs.getString(1));
while (rs.next(){
// ...
}
rs.beforeFirst();
while (rs.next()) {
// ...
}

28. Múltiples Resultados
• Especialmente con procedimientos almacenados, se puede estar interesados
en una aplicación que retorne múltiples resultados
• Para obtenerlos, se debe hacer uso de los siguientes métodos:
boolean getMoreResults();
ResulSet getResultSet();

29. Múltiples Resultados
• Un uso típico de esta característica es el siguiente:
...
while(stmt.getMoreResults()) {
rs = stmt.getResultSet();
while (rs.next()) {
// algunas tareas
}
}
...

30. Clases de Soporte JDBC
• Algunas de las clases de soporte son las siguientes:
 SQLException
 SQLWarning
 DataTruncation
 Date, Time y Timestamp
 Types

31. Resumen
• Se entendió como usar clases heredadas de Statement
• Se aprendió acerca de procedimientos almacenados
• Se discutió acerca de otras funcionalidades JDBC:
- como administración de transacciones,
- soporte de cursores y
- procesamiento de resultados múltiples.
• Se listaron algunas de las clases de soporte JDBC en Java