Contenido POO IIV6

PROGRAMACIÓN ORIENTADA A OBJETOS II
SEMANA 6
Java y bases de datos
Todos los derechos de autor son de la exclusiva propiedad de IACC o de los otorgantes de sus licencias. No está
permitido copiar, reproducir, reeditar, descargar, publicar, emitir, difundir, poner a disposición del público ni 1
ESTE
utilizarDOCUMENTO
los contenidos paraCONTIENE LAdeSEMANA
fines comerciales 6
ninguna clase.
2
ESTE DOCUMENTO CONTIENE LA SEMANA 6
ÍNDICE
JAVA Y BASES DE DATOS ..................................................................................................................... 4

OBJETIVOSESPECÍFICOS ........................................................................................................................................................................4
INTRODUCCIÓN ......................................................................................................................................................................................4
1. JDBC 5
1.1. ARQUITECTURA JDBC .......................................................................................................... 5
1.2. COMPONENTES JDBC .......................................................................................................... 6
2. CONEXIONES A BASES DE DATOS ................................................................................................ 7
2.1. SQL SERVER ......................................................................................................................... 8
3. CONSULTAS SQL ........................................................................................................................ 15
3.1. SENTENCIA SELECT ............................................................................................................ 15
3.2. SENTENCIA DELETE............................................................................................................ 17
3.3. SENTENCIA INSERT ............................................................................................................ 18
3.4. SENTENCIA UPDATE .......................................................................................................... 19
4. CLASES/INTERFACES PARA EL USO DE SQL EN JAVA ................................................................. 20
4.1. LA INTERFACE CONNECTION ............................................................................................. 21
4.1.1. MÉTODOS 21
4.2. LA INTERFACE STATEMENT ............................................................................................... 22
4.2.1. MÉTODOS 22
4.3. LA INTERFACE PREPAREDSTATEMENT .............................................................................. 23
4.3.1. MÉTODOS 23
4.4. LA INTERFACE CALLABLESTATEMENT ............................................................................... 24
4.4.1. MÉTODOS 24
4.5. LA INTERFACE RESULTSET ................................................................................................. 25
4.5.1. MÉTODOS 26
5. CASO PRÁCTICO ........................................................................................................................ 28
6. DATASOURCE ............................................................................................................................ 42
7. HIBERNATE ................................................................................................................................ 44
COMENTARIOS FINALES .................................................................................................................... 49
REFERENCIAS ........................................................................................................................................................................................ 50
3
JAVA Y BASES DE DATOS
OBJETIVOS ESPECÍFICOS
 Integrar bases de datos a la Programación Orientada a Objetos con lenguaje Java.
 Comprender las formas de conexión de Java con diferentes bases de datos.
 Diseñar consultas utilizando el lenguaje SQL para aplicaciones en Java.
 Analizar herramientas de mapeo para el manejo de la relación BBDD y aplicaciones en

Java.
INTRODUCCIÓN
Durante las semanas anteriores se han revisado ejemplos y se ha trabajado con datos volátiles, es
decir, que solo existen mientras se ejecuta el programa. Terminado este, los datos se pierden.
En esta semana se estudiará la relación que se puede establecer entre Java y algunas bases de
datos existentes en el mercado, con el fin de que los datos persistan en el tiempo y puedan ser
consultados en cualquier momento.
También se verá el SQL (Structured Query Language), que es el lenguaje genérico que se utiliza
para programar consultas de bases de datos y que permitirá obtener datos para presentarlos en
pantalla, o bien para agregarlos a alguna tabla de la base. Al respecto, se estudiarán los diversos
objetos de que dispone Java para ejecutar consultas, transacciones y procedimientos
almacenados.
4
1. JDBC
Para que sea posible conectarse desde Java a alguna base de datos, se requiere JDBC, que significa
Java Database Connectivity. JDBC es una API que permite realizar las tareas comunes que implican
manejo de bases de datos, tales como (TutorialsPoint, 2015):
 Establecer una conexión a la base de datos.
 Crear sentencias SQL.
 Ejecutar sentencias SQL en la base de datos.
 Visualizar y modificar los registros resultantes de una consulta.
1.1. ARQUITECTURA JDBC
La API JDBC puede soportar modelos de procesamiento en 2 y 3 capas. Y en general, la

arquitectura JDBC se compone de 2 niveles (op. cit.):
 JDBC API: provee la conexión entre la aplicación y el JDBC Manager.
 JDBC Driver API: soporta la conexión entre el JDBC Manager y el driver correspondiente a
las bases de datos a las cuales apuntará, pudiendo ser más de una.
Gráficamente, se tiene lo siguiente:
5
Fuente: http://tallerdebasededatos15.wikispaces.com/Talle+de+Baseb+de+Datos
Cabe mencionar que cada motor de base de datos (SQL Server, Oracle, DB2, PostgreSQL, MySQL,
Sybase, etc.) implementa un driver JDBC que se puede utilizar en las aplicaciones Java.
Generalmente existe un driver (conector) por versión, pues no siempre hay compatibilidad entre
versiones.
1.2. COMPONENTES JDBC
La API JDBC, entre otros, provee las siguientes clases e interfaces (op. cit.):
 DriverManager: es una clase que administra una lista de drivers. Compara las solicitudes
de conexión de la aplicación Java con los drivers propios de base de datos que posee
usando un subprotocolo de comunicación. El primer driver que reconozca un cierto
subprotocolo bajo JDBC será el usado para establecer una conexión a la base de datos.
 Driver: es una interface que gestiona las comunicaciones con los servidores de bases de
datos. No se interactúa directamente con los drivers, sino que se utilizan objetos
DriverManager, los cuales administran los objetos de ese tipo (driver). Además, abstrae los
detalles asociados con el funcionamiento de los objetos Driver.
 Connection: es una interface con todos los métodos necesarios para conectarse a una
base de datos. El objeto connection representa el contexto de comunicación, es decir, toda
6
la comunicación con la base de datos se realiza, solamente, a través de un objeto
connection.
 Statement (sentencia): es una interface sobre la que se crean objetos para enviar las
sentencias SQL a la base de datos. Algunas interfaces derivadas aceptan parámetros para
la ejecución de procedimientos almacenados.
 ResultSet: son objetos que contienen los datos recuperados desde la base de datos luego
de la ejecución de una consulta SQL usando objetos Statement. Actúa como un iterador
que permite recorrer sus datos.
 SQLException: es la clase que gestiona cualquier error que ocurra en una aplicación de
base de datos.
2. CONEXIONES A BASES DE DATOS
A continuación se dará a conocer la forma en que se debe establecer, vía código, la conexión con
una base de datos. Se asume que el driver correspondiente ya fue descargado, y que al proyecto
se le agregó la librería .jar correspondiente. Esto último se explicará con un ejemplo más adelante.
Para MySQL:
Class.forName("com.mysql.jdbc.Driver");
String servidorBD = "jdbc:mysql://localhost/"+NombreBD;
String usuarioBD = " ... ";
String passwordBD = " ... ";
conexion= DriverManager.getConnection(servidorBD, usuarioBD, passwordBD);
Para Oracle:
Class.forName("oracle.jdbc.driver.OracleDriver")
String servidorBD = "jdbc:oracle:thin:@localhost:1521:XE";
conexion= DriverManager.getConnection(servidorBD,usuarioBD, passwordBD);
XE es un SID que Oracle asigna por defecto.
7
Para PostgreSQL:
Class.forName("org.postgresql.Driver");
String servidorBD = "jdbc:postgresql://localhost/"+NombreBD;
conexion= DriverManager.getConnection(servidorBD,usuarioBD, passwordBD);
Para SQL Server:
Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
String servidorBD = "jdbc:sqlserver://localhost;"+NombreBD;
String urlConexion = servidorBD+";user="+usuarioBD+";password="+passwordBD;
conexion= DriverManager.getConnection(urlConexion);
Básicamente lo que cambia es el nombre del driver. Localhost indica que la base de datos está
instalada en forma local en la estación de trabajo. Si se tratara de un servidor remoto que forma
parte de la red, entonces se debiera indicar el nombre del servidor en vez de localhost.
2.1. SQL SERVER
A continuación se mostrará un ejemplo de conexión a una BD SQL Server 2008 R2, con los pasos a
seguir para lograr una conexión exitosa.
Paso 1 Lo primero que se debe hacer es descargar el driver desde el siguiente link:
http://www.microsoft.com/es-es/download/details.aspx?id=11774
En el link existen archivos .exe y .tar.gz. Para Windows, se descarga al archivo .exe.
Paso 2 Posteriormente se descomprime el archivo en alguna carpeta a elección del usuario. Se

sugiere, por ejemplo: C:\Archivos de programa\Microsoft SQL Server\
Por defecto, se creará la carpeta sqljdbc_4.1\esn cuyo contenido es:
8
Paso 3 En BlueJ, se escoge la opción “Herramientas” y luego “Preferencias”.
Posteriormente se selecciona la pestaña “Librerías”
9
Se mostrará la siguiente pantalla:
Se deba presionar “Agregar” para avanzar.
10
Paso 4 Aparecerá la pantalla “Select directory or jar/zip file”. A través de “Buscar en” se debe
seleccionar la carpeta mencionada en el paso 2.
Posteriormente se debe seleccionar el archivo “sqljdbc4.jar”, y presionar el botón

“Abrir”.
Y se verá lo siguiente:
11
Paso 5 Se presiona el botón “Aceptar”, y se mostrará el siguiente mensaje:
Por lo tanto, se debe reiniciar BlueJ.
Una vez reiniciado, se ingresa nuevamente a la pestaña “Librerías” de “Herramientas” >

“Preferencias”, y el estado de la librería queda en Loaded.
12
Se debe habilitar la dll sqljdbc_auth que se encuentra en la carpeta “auth\x86” o
“auth\x64”, según corresponda. Esas carpetas están dentro de la carpeta esn, como se
mostró en el paso 2. Dicha dll se debe copiar en la carpeta del proyecto.
Paso 6 La forma de conectarse es siempre la misma. El extracto del código que permite
verificar la conexión es el siguiente:
En este caso, se definen todos los parámetros para establecer una conexión al servidor
nombre_del_servidor, en el cual existe una base de datos de nombre
nombre_de_la_base_de_datos, con usuario login_de_usuario y pasword clave_del_usuario.
13
A continuación se muestra un programa que permite verificar si se pudo establecer la conexión
con los datos indicados anteriormente, con el correspondiente manejo de excepciones. La
interface Connection se explicará más adelante en este documento.
Y la salida obtenida es:
14
Y también muestra el mensaje
3. CONSULTAS SQL
Para efectuar consultas y transacciones a la base de datos, es necesario hacer uso del lenguaje
SQL, que es muy similar para todas las bases de datos antes mencionadas.
A continuación se explicitan las sentencias más usadas.
3.1. SENTENCIA SELECT
La sentencia SELECT permite obtener datos desde una o más tablas. Generalmente va
acompañada de las palabras clave FROM, WHERE y ORDER BY.
 FROM indica las tablas (separadas por comas) desde donde se obtendrán los datos.
 WHERE indica las condiciones que se deben cumplir.
 ORDER BY indica la o las columnas que serán consideradas para ordenar los registros de
salida, pudiendo ser en orden ascendente o descendente.
La sintaxis genérica es:
SELECT columna_1, columna_2, ...., columna_n

FROM tabla_1, tabla_2, ...., tabla_m
WHERE condicion_1
AND/OR condicion_2
...
AND/OR condicion_x
ORDER BY columna_a, columna_b, ... ASC/DESC
Cuando se desea obtener todas las columnas de una tabla, se puede usar *, y queda de la
siguiente manera:
15
SELECT *
FROM tabla_1
EJEMPLO 1: Se desea obtener datos de la tabla EMPLEADOS.
Si se quisiera obtener todas las columnas, la sentencia queda así:
SELECT *
FROM EMPLEADOS
Ahora bien, si se desean solo algunas columnas, y ordenadas por la columna apellido, se podría
tener:
SELECT nombre, apellido, cargo, renta

FROM EMPLEADOS
ORDER BY apellido
Si se desea obtener los empleados con renta mayor a 200.000, se agrega la condición en el
WHERE.
SELECT nombre, apellido, cargo, renta

FROM EMPLEADOS
WHERE renta > 200000
ORDER BY apellido
EJEMPLO 2: Considerar la existencia de una tabla de EMPRESAS y otra de EMPLEADOS. Se desea

obtener los empleados de la empresa SoftPaper. Para esto, se cuenta con una columna en la tabla
de EMPLEADOS que indica el código de la empresa a la que pertenece. Mientras que la tabla
EMPRESAS tiene un código único que identifica a cada empresa.
16
SELECT EMPLEADOS.nombre,
EMPLEADOS.apellido,
EMPLEADOS.cargo,
EMPLEADOS.renta
FROM EMPLEADOS, EMPRESAS
WHERE EMPLEADOS.codigo_empresa = EMPRESAS.codigo_empresa
AND EMPRESAS.nombre = ‘SoftPaper’
Eventualmente se pueden usar alias para abreviar los nombres de las tablas. Esto es muy útil
cuando existen columnas con el mismo nombre en tablas distintas.
SELECT e.nombre,
e.apellido,
e.cargo,
e.renta
FROM EMPLEADOS e, EMPRESAS m
WHERE e.codigo_empresa = m.codigo_empresa
AND m.nombre = ‘SoftPaper’
3.2. SENTENCIA DELETE
La sentencia DELETE permite eliminar/borrar uno o más registros de una tabla. Generalmente se
acompaña de la palabra clave WHERE (explicada anteriormente), que indica las condiciones que
deben cumplir los registros para ser eliminados.
La sintaxis genérica es:
DELETE tabla
WHERE condicion_1
AND/OR condicion_2
...
AND/OR condicion_n
EJEMPLO 1: Se desea eliminar completa la tabla CLIENTES. La instrucción es muy simple:
DELETE CLIENTES
17
EJEMPLO 2: Se desea eliminar los clientes cuyo apellido es Soto. La instrucción queda de la
siguiente manera:
DELETE CLIENTES
WHERE apellido = ‘Soto’
EJEMPLO 3: Se desea eliminar los clientes cuyo apellido es Soto, o bien, cuya fecha de nacimiento
es menor al 01 de enero de 2015. La instrucción queda de la siguiente manera:
DELETE CLIENTES
OR fecha_nacimiento < ‘2015-01-01’
EJEMPLO 4: Se cambia el ejemplo 3 queriendo eliminar los CLIENTES cuyo apellido es Soto y cuya
fecha de nacimiento es menor al 01 de enero de 2015. La instrucción queda de la siguiente
manera:
DELETE CLIENTES
AND fecha_nacimiento < ‘2015-01-01’
3.3. SENTENCIA INSERT
La sentencia INSERT permite agregar uno o más registros a una tabla. Se acompaña de las palabras
clave INTO y VALUES, y los datos a ingresar van separados por comas. La sintaxis genérica es:
INSERT INTO tabla

VALUES (valor_columna_1, valor_columna_2,..., valor_columna_2)
Existen situaciones en que la una tabla acepta valores nulos por defecto en algunos de sus
campos, entonces se puede forzar a que se ingresen los datos solo en las columnas necesarias.
18
INSERT INTO tabla (nombre_columna_1, nombre_columna_3, nombre_columna_7)
VALUES (valor_columna_1, valor_columna_3, valor_columna_7)
Lo anterior supone que las columnas 2, 4, 5, y 6 queden con valor nulo, o alguno por defecto con
el que haya sido configurado al momento de crear la tabla.
EJEMPLO 1: Se desea agregar un nuevo país a la tabla de PAISES, cuyas columnas son codigo_pais
y nombre_pais. Entonces se tiene:
INSERT INTO PAISES

VALUES (‘030’, ‘Senegal’)
EJEMPLO 2: Existe una forma de realizar un INSERT masivo a una tabla. Por ejemplo, si se tuviera
una tabla histórica de comunas HIST_COMUNAS, y se quisieran pasar las columnas
codigo_comuna y nombre_comuna a una nueva tabla llamada COMUNAS, entonces se puede
hacer uso de la sentencia SELECT.
INSERT INTO COMUNAS

SELECT codigo_comuna,
nombre_comuna
FROM HIST_COMUNAS
3.4. SENTENCIA UPDATE
La sentencia UPDATE permite actualizar/modificar uno o más datos de una tabla. Va acompañada
de la palabra SET, y generalmente también se acompaña de la palabra clave WHERE. La sentencia
genérica es:
UPDATE tabla
SET nombre_columna_1 = valor_columna_1,
nombre_columna_2 = valor_columna_2,
...
nombre_columna_n = valor_columna_n
WHERE condicion_1
AND/OR condicion_2
...
AND/OR condicion_m
19
EJEMPLO 1: Se desea actualizar la tabla de FACTURAS, para dejar todos los registros en estado
pagada.
UPDATE FACTURAS
SET estado = ‘pagada’
EJEMPLO 2: Se desea subir el precio en $100 a los productos de la tabla PRODUCTOS, cuyo
proveedor sea 1-9.
UPDATE PRODUCTOS
SET precio = precio + 100
WHERE rut_proveedor = ‘1-9’
EJEMPLO 3: Se desea cambiar los puntajes de las pruebas de lenguaje y matemáticas, del año
2013, de la persona cuyo rut es 2-7.
UPDATE PUNTAJES_PSU
SET prueba_lenguaje = 750,
prueba_matematicas = 720
WHERE anno_prueba = 2013
AND rut_persona = ‘2-7’
4. CLASES/INTERFACES PARA EL USO DE SQL EN JAVA
Luego de haber establecido la conexión con la base de datos desde la aplicación, se está en
condiciones de hacer consultas para mostrar resultados por pantalla.
En las conexiones a distintas bases de datos se mencionó Connection (interface), que es sin duda
el objeto más importante para efecto de trabajar desde una aplicación Java hacia una base de
datos. A continuación se detalla esta interface y otras importantes a considerar.
20
4.1. LA INTERFACECONNECTION
Es una interface que permite establecer una conexión con una base de datos específica. Las
sentencias SQL y sus resultados se obtienen en el contexto de una conexión.
4.1.1. MÉTODOS
De acuerdo a lo indicado en Oracle (2014.b), los métodos más importantes de la interface

Connection son:
TIPO MÉTODO DESCRIPCIÓN
void close() Libera inmediatamente los objetos de la conexión

de la base de datos y los recursos JDBC.
void commit() Graba todos los cambios que se hayan efectuado en

la base de datos.
statement createStatement() Crea un objeto statement para enviar la sentencia

SQL a la base de datos.
boolean getAutoCommit() Devuelve el modo auto-commit de la conexión.
DatabaseMetaData getMetaData() Devuelve un objeto DatabaseMetaData que

contiene metadata acerca de la base de datos a la
cual apunta la conexión.
Boolean isClosed() Devuelve true si es que la conexión está cerrada.
boolean isReadOnly() Devuelve true si es que la conexión está en modo

solo lectura.
CallableStatement prepareCall(String sql) Crea un objeto CallableStatement para llamar a un

procedimiento almacenado de la base de datos.
PreparedStatement prepareStatement(String Crea un objeto prepareStatement para enviar una

sql) sentencia SQL parametrizada a la base de datos.
void rollback() Deshace todos los cambios realizados en la

transacción y libera cualquier bloqueo que tenga la
base de datos sostenido por el objeto Connection.
void setAutoCommit(boolean Setea la conexión en modo auto-commit.

autoCommit)
void setReadOnly(boolean Deja la conexión en modo de solo lectura.

readOnly)
21
4.2. LA INTERFACESTATEMENT
Este objeto es usado para ejecutar sentencias SQL estáticas y para obtener los resultados producto
de la ejecución.
4.2.1. MÉTODOS
En base a lo especificado en la página de Oracle (2014.e), los métodos más importantes de la

interface Statement son:
void addBatch(String sql) Agrega la sentencia SQL a la lista actual de comandos del
objeto Statement.
void cancel() Cancela el objeto Statement.
void clearBatch() Vacía la lista actual de comandos del objeto Statement.
void close() Libera los objetos de la base de datos relacionados al

Statement y los recursos JDBC.
boolean execute(String sql) Ejecuta la sentencia SQL dada, que podría retornar múltiples
resultados.
int[] executeBatch() Envía un batch de comandos a la base de datos para su

ejecución y, si todas las ejecuciones son correctas, devuelve un
arreglo de conteos de actualización.
ResultSet executeQuery(String Ejecuta la sentencia SQL dada, la cual devuelve un objeto

sql) ResultSet.
int executeUpdate(String Ejecuta la sentencia SQL dada, la cual pudiera ser un INSERT,
sql) UPDATE o DELETE, o alguna sentencia SQL que no devuelva
valores.
Connection getConnection() Devuelve el objeto Connection que contiene el objeto

Statement.
ResultSet getResultSet() Devuelve el resultado actual como un objeto ResultSet.
boolean isClosed() Devuelve true si es que el objeto Statement ha sido cerrado.
void setMaxRows(int max) Setea el número máximo de filas que puede contener cualquier
objeto ResultSet generado por el objeto Statement.
void setQueryTimeout(int Setea el número de segundos que el driver esperará por el

seconds) resultado de la ejecución de un objeto Statement.
22
4.3. LA INTERFACEPREPAREDSTATEMENT
Este objeto representa una sentencia SQL pre-compilada, lo cual permite que el objeto pueda ser
usado para ejecutar eficientemente la sentencia múltiples veces. Se debe tener presente el hecho
de que se debe especificar el tipo de variable correspondiente a cada parámetro con los métodos
setShort, setString, setInt, etc.
4.3.1. MÉTODOS
Hereda los métodos de la interfaz Statement, y además posee métodos propios. Según Oracle
(2014.c), los métodos más importantes de la interface PreparedStatement son:
void addBatch() Agrega un conjunto de parámetros al batch de

comandos.
void clearParameters() Limpia (deja en blanco) el valor actual de los

parámetros.
boolean execute() Ejecuta la sentencia SQL, pudiendo tratarse de

cualquier tipo de sentencia.
ResultSet executeQuery() Ejecuta la query SQL y devuelve un objeto

ResultSet con el resultado.
int executeUpdate() Ejecuta la sentencia SQL dada, la cual pudiera ser

un INSERT, UPDATE o DELETE, o alguna sentencia
SQL que no devuelva valores.
ResultSetMetaData getMetaData() Devuelve un objeto ResultSetMetaData que

contiene información sobre las columnas del
objeto ResultSet que será retornado cuando se
ejecute la sentencia SQL.
ParameterMetaData getParameterMetaData() Devuelve el número, tipos y propiedades de los

parámetros del objeto PreparedStatement.
void setBoolean(int Setea el parámetro indicado con el valor

paramIndex, boolean x) booleando dado.
void setDate(int paramIndex, Setea el parámetro indicado con el valor de fecha

Date x) dado.
23
void setDouble(int Setea el parámetro indicado con el valor double
paramIndex, double x) dado.
void setFloat(int paramIndex, Setea el parámetro indicado con el valor float

float x) dado.
void setInt(int paramIndex, Setea el parámetro indicado con el valor int dado.
int x)
void setLong(int paramIndex, Setea el parámetro indicado con el valor long

long x) dado.
void setNull(int paramIndex, Setea el parámetro indicado a valor NULL de SQL.

int sqlType)
void setString(int Setea el parámetro indicado con el valor String

paramIndex, String x) dado.
4.4. LA INTERFACECALLABLESTATEMENT
Este objeto es usado para ejecutar procedimientos almacenados existentes en la base de datos.
4.4.1. MÉTODOS
Hereda los métodos de la interfaz PreparedStatement y además posee métodos propios. Según se
indica en Oracle (2014.a), los métodos más importantes de la interface CallableStatement son:
boolean getBoolean(int Devuelve el valor de un parámetro de tipo boolean o

paramIndex) bit como boolean.
boolean getBoolean(String Devuelve el valor de un parámetro de tipo boolean o

paramName) bit como boolean.
Date getDate(int paramIndex) Devuelve el valor de un parámetro de tipo date

como un objeto de tipo Date.
Date getDate(String Devuelve el valor de un parámetro de tipo date

paramName) como un objeto de tipo Date.
void setBoolean(String Setea el parámetro indicado con el valor booleando

paramName, boolean x) dado.
24
void setDate(String Setea el parámetro indicado con el valor de fecha
paramName, Date x) dado.
void setDouble(String Setea el parámetro indicado con el valor double

paramName, double x) dado.
void setFloat(String Setea el parámetro indicado con el valor float dado.

paramName, float x)
void setInt(String Setea el parámetro indicado con el valor int dado.

paramName, int x)
void setLong(String Setea el parámetro indicado con el valor long dado.

paramName, long x)
void setNull(String Setea el parámetro indicado a valor NULL de SQL.

paramName, int sqlType)
void setString(String Setea el parámetro indicado con el valor String dado.

paramName, String x)
4.5. LA INTERFACERESULTSET
Este objeto es una tabla que representa el resultado de la ejecución de una sentencia SQL sobre
una base de datos. Este objeto mantiene un cursor apuntando a su fila actual. Inicialmente el
cursor se posiciona antes de la primera fila. Con el método next() el cursor se puede mover a la fila
siguiente, y devuelve false cuando se llega al final. De esta forma se puede recorrer (o iterar) el
objeto mediante un while loop. Cabe mencionar que el cursor solo se “mueve” hacia adelante.
Dispone de métodos para obtener los valores de cada fila, ya sea indicando el nombre de la
columna (considerar que es case sensitive) o el número que le corresponde (posición), partiendo
desde el 1.
25
4.5.1. MÉTODOS
Según lo indicado en Oracle (2014.d), los métodos más importantes de la interface ResultSet son:
boolean absolute(int row) Mueve el cursor a la fila dada.
void afterLast() Mueve el cursor al final del ResultSet, y queda

después de la última fila.
void beforeFirst() Mueve el cursor al principio del ResultSet, y queda

antes de la primera fila.
void cancelRowUpdates() Cancela las actualizaciones hechas a la fila actual.
voud close() Libera los objetos de la BD relacionados al ResultSet

y los recursos JDBC.
void deleteRow() Elimina la fila actual del ResultSet y de la base de

datos asociada.
boolean first() Mueve el cursor a la primera fila.
boolean getBoolean(int Devuelve el valor de la columna indicada como un

columnIndex) valor de tipo boolean.
boolean getBoolean(String Devuelve el valor de la columna indicada como un

columnLabel) valor de tipo boolean.
String getCursorName() Devuelve el nombre del cursor SQL usado en el

ResultSet.
Date getDate(int Devuelve el valor de la columna indicada como

columnIndex) objeto de tipo Date.
Date getDate(String Devuelve el valor de la columna indicada como

columnLabel) objeto de tipo Date.
double getDouble(int Devuelve el valor de la columna indicada como un

columnIndex) valor de tipo double.
double getDouble(String Devuelve el valor de la columna indicada como un

columnLabel) valor de tipo double.
float getFloat(int Devuelve el valor de la columna indicada como un

columnIndex) valor de tipo float.
float getFloat(String Devuelve el valor de la columna indicada como un

columnLabel) valor de tipo float.
26
Int getInt(int columnIndex) Devuelve el valor de la columna indicada como un
valor de tipo integer.
Int getInt(String Devuelve el valor de la columna indicada como un

columnLabel) valor de tipo integer.
long getLong(int Devuelve el valor de la columna indicada como un

columnIndex) valor de tipo long.
long getLong(String Devuelve el valor de la columna indicada como un

columnLabel) valor de tipo long.
ResultSetMetaData getMetaData() Devuelve el número, los tipos y propiedades de las

columnas del objeto ResultSet.
int getRow() Devuelve el número de la fila actual.
Statement getStatement() Devuelve el objeto Statement que produjo el

ResultSet.
String getString(int Devuelve el valor de la columna indicada como un

columnIndex) valor de tipo String.
String getString(String Devuelve el valor de la columna indicada como un

columnLabel) valor de tipo String.
void insertRow() Inserta el contenido de insertRow del ResultSet en

la base de datos.
boolean isClosed() Indica si el ResultSet está cerrado.
boolean isFirst() Indica si el cursor está en la primera fila.
boolean isLast() Indica si el cursor está en la última fila.
boolean last() Mueve el cursor a la última fila.
boolean next() Avanza el cursor a la fila siguiente desde la posición

actual.
boolean previous() Devuelve el cursor a la fila anterior de la posición

actual.
void refreshRow() Actualiza la fila actual con el valor más reciente que
tenga en la base de datos.
boolean relative(int rows) Mueve el cursor un número relativo de filas,

pudiendo ser negativo o positivo.
27
También existen los métodos del tipo UpdateType(...), cuyo comportamiento es similar a los
métodos SetType(...).
5. CASO PRÁCTICO
Ya se tienen nociones de los principales objetos involucrados en el tratamiento de consultas SQL a

la base de datos, y además en semanas anteriores se estudiaron algunos componentes gráficos de
intefaz de usuario, por lo tanto es momento de presentar un ejemplo basado en un modelo de
datos simple, el cual se muestra a continuación:
EJEMPLO 1: Se desean obtener los datos de una determinada factura:
Al código de conexión mostrado anteriormente, se le agregará un método llamado

datosDeFactura(), y al método main se le agregará la llamada al método mencionado. Para este
ejemplo es necesario importar las siguientes librerías:
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Scanner;
28
Y en el método main se tiene:
La salida obtenida es la siguiente: (cabe destacar que el mismo programa solicita el ingreso del
número de factura)
29
EJEMPLO 2: Se desea obtener el detalle de una determinada factura. Cabe destacar que el detalle
puede contener más de un registro. Además, en este caso, es necesario efectuar un JOIN con la
tabla de Producto para obtener la descripción del producto.
Se agregará el método detalleDeFactura(), y al método main se le agregará la llamada al método

mencionado:
30
31
La salida obtenida es la siguiente: (cabe destacar que el mismo programa solicita el ingreso del
número de factura)
En este caso, por un tema de ordenamiento, se prefirió dejar la descripción de los productos al
final.
EJEMPLO 3: Se desea obtener las facturas emitidas entre un rango de fechas y cuyo monto total
supera una cierta cantidad.
Se agregará el método facturasPorFechayTotal(), y al método main se le agregará la llamada al

método mencionado. Nótese que en la sentencia SQL hay una conversión de la fecha a un formato
predeterminado, ya que en la base de datos los campos tipo datetime se almacenan de la forma
YYYYMMDD HH:MM:SS.mmm, y la idea es que la salida presente el formato DD-MM-YYYY.
32
33
Y la salida obtenida es: (cabe destacar que se ingresa la fecha desde y la fecha hasta, con el monto
mínimo)
34
EJEMPLO 4: Se desea agregar un nuevo cliente.
Se agregará el método agregarNuevoClientel(), y al método main se le agregará la llamada al

método mencionado. Además, como se trata de una sentencia transaccional, se utiliza
executeUpdate(), y por tratarse de datos que pueden tener más de dos palabras conviene utilizar
el método nextLine de la clase Scanner y definir una instancia para cada ingreso.
35
Y la salida obtenida es: (cabe destacar que se ingresan el rut, el nombre y la ciudad del nuevo
cliente):
EJEMPLO 5: Se desea eliminar una factura. Esto implica eliminar el encabezado y su detalle.
Se agregará el método eliminarFactura(), y al método main se le agregará la llamada al método

mencionado. En este caso, se debe eliminar primero el detalle de la factura y luego el encabezado.
36
37
Y la salida obtenida es: (nótese que se ingresa el número de la factura):
EJEMPLO 6: Se desea actualizar la descripción y el precio unitario de un producto.
Se agregará el método actualizarProducto(), y al método main se le agregará la llamada al método

mencionado.
38
39
Y la salida obtenida es: (nótese que se ingresa el código del producto, la nueva descripción y el
nuevo precio unitario)
Efectuando una consulta a la base de datos, efectivamente se cambiaron los datos del producto:
EJEMPLO 7: Usando un procedimiento almacenado, obtener el monto total y cantidad de facturas

de un determinado cliente por año. Evidentemente se consideran solo las facturas vigentes.
Se tiene creado el procedimiento almacenado sp_total_facturado_anual_por_cliente
CREATE proc sp_total_facturado_anual_por_cliente

@cli_rut varchar(15)
AS
BEGIN
select anno = datepart(yyyy, fct_fec),
fct_qty = COUNT(fct_num),
fct_ttl = SUM(fct_tot)
from Factura
WHERE cli_rut = @cli_rut
AND fct_est = 'VIGENTE'
group by cli_rut, datepart(yyyy, fct_fec)
END
40
Se agregará el método totalFacturadoAnualCliente(), y al método main se le agregará la llamada al
método mencionado.
Primero, se debe importar la librería CallableStatement.
import java.sql.CallableStatement;
41
Y la salida obtenida es: (Cabe destacar que se ingresa rut del cliente):
6. DATASOURCE
Hasta el momento se ha podido ver que la conexión a la base de datos se puede hacer mediante
DriverManager, sin embargo existe una limitante con respecto al uso de ese objeto y se refiere a
que varios hilos (threads) no pueden utilizar la misma conexión simultáneamente, ya que los datos
usados por cada uno se podrían entremezclar, lo cual dificulta enormemente la lectura y escritura
desde y hacia la base de datos. Para evitar esto, se podría pensar en algunas alternativas:
42
 Abrir y cerrar una conexión de acuerdo a si se necesita o no, así cada hilo podrá tener su
propia conexión, pero el gran problema que se presenta es que abrir y cerrar conexiones
produce un costo de tiempo importante y la performance de la aplicación se vería muy
afectada.
 Utilizar una única conexión y sincronizar los hilos para que puedan acceder a ella. La
solución es válida, pero implica que los hilos deben estar sincronizados (synchronized)
antes de efectuar cualquier transacción a la base de datos. Esto implica que debe terminar
un hilo para que empiece otro y se pierda la concurrencia.
 Tener varias conexiones abiertas, de tal forma que si un hilo requiere usar una, siempre
existirá una disponible, y evidentemente cuando la termina de usar la libera para dejarla
disponible para que otro hilo la use. A esto se le conoce como “pool de conexiones”.
Un pool de conexiones corresponde a una clase de Java que tiene abiertas varias conexiones a la
base de datos. Entonces, cuando algún usuario requiere de una conexión, sencillamente se la pide
al pool invocando al método pool.getConnection(). Entonces, el pool “marca” la conexión para
dejarla reservada y que nadie más la use. Luego, se ejecuta el método pool.close() para “cerrarla”,
aunque realmente no se cierra, sino que se libera quedando nuevamente disponible.
Y, como se vio en los ejemplos, el “paso a paso” sería muy similar:
// Se solicita al pool una conexión

Connection miConexion = miPool.getConnection();
// Se ejecutan las sentencias SQL (select, update, insert, delete)
// Se libera la conexión para dejarla disponible

miConexion.close();
Para utilizar un pool de conexiones, cada fabricante de base de datos usa su propia interface, la
cual viene incorporada en el .jar que se debe agregar al proyecto.
Siguiendo con el ejemplo de SQL Server, la conexión al pool se establece de la siguiente manera:
(nótese la librería que se debe importar, correspondiente a la que contiene la interface para
administrar el pool de conexiones de SQL Server)
43
Y la respuesta obtenida es:
Y ahora, todos los ejemplos detallados en el punto 5 se pueden realizar utilizando una conexión al
pool de conexiones.
7. HIBERNATE
Hibernate es una herramienta Open Source de mapeo objeto-relacional (ORM) que permite
mapear los componentes de una base de datos relacional y el modelo de objetos de una aplicación
mediante archivos XML, y además facilita la creación de sentencias SQL (www.cartagena99.com, s.
f.).
44
Por lo general, las bases de datos relacionales son la mejor opción para guardar datos y el enlace
hacia la base de datos se realiza con JDBC. Pero Hibernate nace como una necesidad de
persistencia de los datos. La persistencia se define como la capacidad que tienen los objetos de
conservar su estado e identidad entre distintas ejecuciones del programa que los creó o de otros
programas que accedan a ellos (op. cit.).
El problema se presenta en los paradigmas sobre los que se apoyan las bases de datos relacionales
y la programación orientada a objetos. Las primeras tratan con relaciones y conjuntos, y la
segunda trata con objetos, sus atributos y las asociaciones que existen entre ellos. Y es ahí donde
entra el uso de un ORM, con el fin de definir la forma en que las tablas de la base de datos se
asocian a los objetos (clases) de la aplicación. A esto último se le conoce como “mapeo”.
Lo interesante de Hibernate es que puede utilizar los objetos definidos por el usuario sin tener que
generar código anexo o manipularlos en tiempo de compilación ni tampoco obligarlos a que
hereden de alguna superclase.
Algunas razones que hacen de Hibernate una herramienta muy importante hoy en día son (op. cit.,
pp. 14-3):
 Simplicidad y flexibilidad: solo se requiere de un archivo de configuración en tiempo de

ejecución y de un documento de mapeo por aplicación. El primero puede ser el estándar
de Java (el que tiene extensión .properties) o bien un archivo XML. Además, no crea
dependencias del framework, y los objetos persistentes de la aplicación no requieren
heredar alguna clase Hibernate ni regirse por alguna semántica específica o pertenecer a
un contenedor.
 Completo: dispone de todas las características de orientación a objetos, tales como
herencia, colecciones, etc. Y pone a disposición una capa de abstracción SQL llamada HQL,
y las sentencias HSL son compiladas en el mismo framework de Hibernate, quedando
además en caché para ser reutilizadas.
Un concepto importante a definir es el concepto de “sesión”. Se trata de un objeto especial de la

clase Session que permite mantener un enlace con el motor Hibernate para recuperar o almacenar
objetos de la base de datos (op. cit.). Además, es un concepto ligado a un proceso de negocio, por
lo tanto una sesión siempre pertenecerá a un mismo thread de ejecución.
Por lo anterior, se infiere que para un entorno multiusuario, y por ende multithread, habrán
múltiples sesiones corriendo en forma simultánea, y cada una pertenecerá a un thread distinto. De
esto se desprende que debe existir una clase superior que permita crear sesiones y efectuar
operaciones entre los threads; esta clase es SessionFactory, que expone el metodo openSession()
(op. cit.).
En Hibernate se tienen 2 tipos de objetos (op. cit.,pp. 14-4):
45
 Transient:
o Solo existen en memoria y no en un repositorio de datos. Incluso, se podría dar
que jamás sean almacenados en una base de datos.
o Son instanciados por el programador sin haberlos almacenado mediante una
sesión.
 Persistent:
o Ya fueron almacenados, por ende pasan a ser objetos persistentes.
o Fueron creados y almacenados en una sesión, o bien fueron obtenidos mediante
una consulta dentro de una sesión. Por lo tanto, un objeto está persistido cuando
está en la sesión de Hibernate.
Otro concepto clave es el de transacción, que controla todos los pasos que hay que dar con los
objetos y, en caso de que exista una falla en el proceso, realiza un rollback para evitar que queden
inconsistencias. La transacción debe estar dentro de la sesión de Hibernate.
El siguiente diagrama muestra dónde se ubica Hibernate dentro de la arquitectura de la aplicación:
Fuente: https://docs.jboss.org/hibernate/orm/3.5/reference/es-ES/html_single/
En el diagrama se puede ver que Hibernate hace uso de la base de datos y de la configuración de
los datos para proveer servicios y objetos persistentes a la aplicación.
Dado que Hibernate fue creado para poder trabajar en distintos ambientes, se tiene una gran
cantidad y variedad de parámetros de configuración. Por lo tanto, para configurar Hibernate es
necesario (op. cit., pp. 14-15):
 Realizar la configuración del servicio Hibernate.
46
 Entregar toda la información correspondiente a las clases que se requiere sean
persistentes.
Esta configuración se puede realizar bajo 2 opciones:
 Archivo de propiedades estándar de Java (hibernate.properties)

 Archivo XML, comúnmente llamado hibernate.cfg.xml
A continuación se muestra un ejemplo de cada archivo (op. cit.):
Hibernate.properties (muestra los detalles de la conexión a la base de datos)
hibernate.connection.username=username
hibernate.connection.password=password
hibernate.connection.driver_class=com.mysql.jdbc.Driver
hibernate.connection.url=jdbc:mysql://localhost/events_calendar
hibernate.dialect=org.hibernate.dialect.MySQLDialect
hibernate.cfg.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 2.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-2.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="show_sql">true</property>
<mapping resource="com/manning/hq/ch03/Event.hbm.xml"/>
<mapping resource="com/manning/hq/ch03/Attendee.hbm.xml"/>
<mapping resource="com/manning/hq/ch03/Speaker.hbm.xml"/>
<mapping resource="com/manning/hq/ch03/Location.hbm.xml"/>
</session-factory>
</hibernate-configuration>
Eventualmente se podría tener una combinación de ambos archivos, dentro del archivo
hibernate.cfg.xml
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration- 3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="connection.username">uid</property>
<property name="connection.password">pwd</property>
<property name="connection.url">jdbc:mysql://localhost/db</property>
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
<mapping resource="com/manning/hq/ch03/Event.hbm.xml"/>
<mapping resource="com/manning/hq/ch03/Location.hbm.xml"/>
<mapping resource="com/manning/hq/ch03/Speaker.hbm.xml"/>
47
<mapping resource="com/manning/hq/ch03/Attendee.hbm.xml"/>
</session-factory>
</hibernate-configuration>
También se tienen los archivos de mapeo, que proveen la información necesaria para asociar los
objetos con las tablas que se va a trabajar. El mapeo para todas las tablas se puede realizar
completo en un solo archivo, o bien existiendo un archivo de mapeo para cada objeto. Esta última
opción es la más recomendada. La extensión de estos archivos es .hbm.xml, por ejemplo:
Cliente.hbm.xml, que se muestra a continuación:
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
<hibernate-mapping>
<class name="entidades.Cliente" table="Cliente">
<id name="id" type="int" column="ClienteId">
<generator class="native"/>
</id>
<property name="nombre" type="string"/>
<property name="apellidoPaterno" column="apellido1" type="string"/>
<property name="apellidoMaterno" column="apellido2" type="string"/>
<property name="direccion" type="string"/>
<property name="telefono" type="int"/>
</class>
</hibernate-mapping>
Con respecto a este último archivo, se puede decir (op. cit., pp. 14-18):
 Inmediatamente después de la etiqueta <hibernate-mapping> va la etiqueta <class...> que

indica el inicio de la definición del mapeo de una clase específica. En este caso, la clase
Cliente.
 El atributo table indica el nombre de la tabla de la base de datos donde se almacenarán
los objetos. En este caso, Cliente.
 La etiqueta <id> indica la clave primaria para la clase persistente. Al respecto, toda clase
persistente debe tener un id acorde con la clave primaria de la tabla. A su vez, el atributo
name define el valor de la clase que almacenará el valor de la clave primaria. En este caso,
la clave primaria de la clase es id, y la de la tabla es ClienteId.
 Cada etiqueta <property> indica una propiedad del objeto.
La idea de este punto fue conocer la existencia de Hibernate y entregar solo un barniz respecto de
cómo funciona la herramienta.
48
COMENTARIO FINAL
Afortunadamente Java no presenta problemas para conectarse con diversas bases de datos,
incluso con aquellas más complejas como DB2, puesto que es cuestión de descargar el driver
(controlador) correcto. Entonces, es fácil crear una aplicación para que interactúe con alguna base
de datos ya creada. Esto se da mucho cuando se trata de migraciones, es decir, programas que
están obsoletos y requieren ser migrados a una tecnología que sea compatible con cualquier
sistema operativo.
Muy importante es saber que al lenguaje SQL, que es prácticamente universal para cualquier base
de datos, cada fabricante le agrega ciertas sentencias y funciones propias que enriquecen y
marcan la diferencia. Lo trascendental es que las sentencias SELECT, INSERT, DELETE y UPDATE son
universales y aplicables a cualquier base de datos.
Hibernate es una herramienta muy poderosa para trabajo web. La gran mayoría de los “carritos de
compra” están basados en él. Se requiere de un curso más avanzado para poder abordarlo en su
totalidad, sin embargo se deja hecha la invitación para que el alumno indague e investigue más al
respecto.
Es momento entonces de comenzar a pensar en grande. Llevar a cabo esa aplicación que siempre
se quiso hacer, pero no se tenían las herramientas necesarias. Quizás ese software para llevar un
inventario, o un software de ventas de algún negocio, etc. Conocer el manejo de una base de
datos abre un mundo de posibilidades, y más aun si se opta por Java para las capas de negocio y
de presentación.
49
REFERENCIAS
Barnes, D. & Kölling, M. (2007). Programación orientada a objetos con Java. 3.ª edición. México:
Editorial Prentice Hall.
Cartagena99.com (s. f.). Hibernate. Recuperado de:
http://www.cartagena99.com/recursos/programacion/apuntes/ManualHibernate.pdf
Dean, J. & Dean, R. (2009). Introducción a la programación en Java. México: Editorial McGraw-Hill.
Joyanes, L. & Zahonero, I. (2011). Programación en Java 6. Primera edición. México: McGraw-Hill.
Oracle (2014.a). Interface CallableStatement. Recuperado de:
https://docs.oracle.com/javase/7/docs/api/java/sql/CallableStatement.html
Oracle (2014.b). Interface Connection. Recuperado de:
https://docs.oracle.com/javase/6/docs/api/java/sql/Connection.html
Oracle (2014.c). Interface PreparedStatement. Recuperado de:
http://docs.oracle.com/javase/7/docs/api/java/sql/PreparedStatement.html
Oracle (2014.d). Interface ResultSet. Recuperado de:
http://docs.oracle.com/javase/7/docs/api/java/sql/ResultSet.html
Oracle (2014.e). Interface Statement. Recuperado de:
http://docs.oracle.com/javase/7/docs/api/java/sql/Statement.html
TutorialsPoint (2015). What is JDBC? Recuperado de: http://www.tutorialspoint.com/jdbc/jdbc-
introduction.htm
50
PARA REFERENCIAR ESTE DOCUMENTO, CONSIDERE:
IACC (2015). Java y bases de datos. Programación Orientada a Objetos II. Semana 6.
51
52

Contenido POO IIV6

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Contenido POO IIV6

Cargado por

Copyright:

Formatos disponibles

PROGRAMACIÓN ORIENTADA A OBJETOS II

JAVA Y BASES DE DATOS ..................................................................................................................... 4

 Comprender las formas de conexión de Java con diferentes bases de datos.

 Diseñar consultas utilizando el lenguaje SQL para aplicaciones en Java.

 Analizar herramientas de mapeo para el manejo de la relación BBDD y aplicaciones en

 Establecer una conexión a la base de datos.

 Crear sentencias SQL.

 Ejecutar sentencias SQL en la base de datos.

 Visualizar y modificar los registros resultantes de una consulta.

1.1. ARQUITECTURA JDBC

La API JDBC puede soportar modelos de procesamiento en 2 y 3 capas. Y en general, la

 JDBC API: provee la conexión entre la aplicación y el JDBC Manager.

Gráficamente, se tiene lo siguiente:

1.2. COMPONENTES JDBC

2. CONEXIONES A BASES DE DATOS

XE es un SID que Oracle asigna por defecto.

Para SQL Server:

2.1. SQL SERVER

Paso 2 Posteriormente se descomprime el archivo en alguna carpeta a elección del usuario. Se

Por defecto, se creará la carpeta sqljdbc_4.1\esn cuyo contenido es:

Posteriormente se selecciona la pestaña “Librerías”

Se deba presionar “Agregar” para avanzar.

Posteriormente se debe seleccionar el archivo “sqljdbc4.jar”, y presionar el botón

Por lo tanto, se debe reiniciar BlueJ.

Una vez reiniciado, se ingresa nuevamente a la pestaña “Librerías” de “Herramientas” >

Y la salida obtenida es:

A continuación se explicitan las sentencias más usadas.

3.1. SENTENCIA SELECT

 WHERE indica las condiciones que se deben cumplir.

La sintaxis genérica es:

SELECT columna_1, columna_2, ...., columna_n

EJEMPLO 1: Se desea obtener datos de la tabla EMPLEADOS.

Si se quisiera obtener todas las columnas, la sentencia queda así:

SELECT nombre, apellido, cargo, renta

SELECT nombre, apellido, cargo, renta

EJEMPLO 2: Considerar la existencia de una tabla de EMPRESAS y otra de EMPLEADOS. Se desea

3.2. SENTENCIA DELETE

La sintaxis genérica es:

EJEMPLO 1: Se desea eliminar completa la tabla CLIENTES. La instrucción es muy simple:

3.3. SENTENCIA INSERT

INSERT INTO tabla

INSERT INTO PAISES

INSERT INTO COMUNAS

3.4. SENTENCIA UPDATE

4. CLASES/INTERFACES PARA EL USO DE SQL EN JAVA

De acuerdo a lo indicado en Oracle (2014.b), los métodos más importantes de la interface

TIPO MÉTODO DESCRIPCIÓN

void close() Libera inmediatamente los objetos de la conexión

void commit() Graba todos los cambios que se hayan efectuado en

statement createStatement() Crea un objeto statement para enviar la sentencia

boolean getAutoCommit() Devuelve el modo auto-commit de la conexión.

DatabaseMetaData getMetaData() Devuelve un objeto DatabaseMetaData que

Boolean isClosed() Devuelve true si es que la conexión está cerrada.

boolean isReadOnly() Devuelve true si es que la conexión está en modo

CallableStatement prepareCall(String sql) Crea un objeto CallableStatement para llamar a un

PreparedStatement prepareStatement(String Crea un objeto prepareStatement para enviar una

void rollback() Deshace todos los cambios realizados en la

void setAutoCommit(boolean Setea la conexión en modo auto-commit.

void setReadOnly(boolean Deja la conexión en modo de solo lectura.

En base a lo especificado en la página de Oracle (2014.e), los métodos más importantes de la

TIPO MÉTODO DESCRIPCIÓN

void cancel() Cancela el objeto Statement.