Ejemplo excepciones(2)

Ejemplo de excepciones en jarra de bases de datos
package Uv;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class ConexiónS {
/*
* Esta clase es parte de un ejemplo de uso de bases de datos en Java
* Autor: Juan Manuel Fernández Peña
* Fecha: octubre de 2010
* Se buscó usar un patrón Singleton para evitar conflictos en acceso a BD
* Historia:
*
versión 1.1: se aprovechó experiencia en conexionSSQL y otras
*/
private static Connection conexion;
private static String quemanejador, queurl, queclave, quepass;
private static ConexiónS unica=new ConexiónS();
private static Statement sta;
private static String ultfalla=" ";
private final String versión = "Versión 1.1 10/2010";
private ConexiónS(){
// Constructor interno para evitar duplicidades
}
/*
* Parte interna. Note que la conexión física se maneja de modo privado, para evitar dobles aperturas
*/
private static boolean Conecta(){
// Conexión física a la base de datos
boolean resp=false;
if (conexion == null)
try{
Class.forName(quemanejador).newInstance();
conexion = DriverManager.getConnection(queurl,queclave,quepass);
resp=true;
} catch (InstantiationException e) {
// TODO Auto-generated catch block
System.out.println("Falla al crear conexión. "+e);
e.printStackTrace();
ultfalla="Falla al crear conexión. "+e;
}
catch (IllegalAccessException e) {
// TODO Auto-generated catch block
System.out.println("No deja acceder a la bd: "+queurl+". "+e);
e.printStackTrace();
ultfalla="No deja acceder a la bd: "+queurl+". "+e;
}
catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
System.out.println("No reconoce el manejador: "+quemanejador+". "+e);
e.printStackTrace();
ultfalla="No reconoce el manejador: "+quemanejador+". "+e;
}
catch(SQLException ex1){
System.out.println("Mensaje: "+ex1.getMessage());
System.out.println("Estado: "+ex1.getSQLState());
System.out.println("Codigo de Error: "+ex1.getErrorCode());
}
return resp;
}
private static boolean prepara(String manejador, String url,String clave, String pass){
// Método intermediario para dar acceso al público
// Manejador: cualquiera tipo sql
// Url: asociado al manejador, podría ser ODBC
// Clave y password si lo pide el manejador; Derby no las usa
boolean ret = false;
if (conexion == null){
quemanejador=manejador; queurl=url; queclave=clave; quepass=pass;
ret = Conecta();
}else{ret=true;}
return ret;
}
public static String getUltfalla(){
return ultfalla;
}
/*
* Para crear una instancia del objeto de tipo ConexiónS
*/
public static ConexiónS getConexiónS(){
// Al ser estática, es la forma de obtener un acceso a la conexión, sin duplicar
return unica;
}
/*
* Aquí comienza la API que se ofrece al público
*/
//crear base de datos y conectarse
public static boolean creabd(String manejador, String url, String basedat,String clave, String pass){
boolean resp=false;
//Note la parte que indica crear: create=true
resp=prepara(manejador,url+basedat+";create=true",clave,pass);
return resp;
}
//abrir base de datos ya existente
public static boolean abrirbd(String manejador, String url, String basedat,String clave, String pass){
boolean resp=false;
resp=prepara(manejador,url+basedat,clave,pass);
return resp;
}
//abrir base de datos ya existente sin clave y password
public static boolean abrirbd(String manejador, String url, String basedat){
boolean resp=false;
resp=prepara(manejador,url+basedat,"","");
return resp;
}
//Crear una tabla
public void creaTabla(String ta) throws ExcepciónBD {
// ta debe contener el nombre de la tabla y la definición de las columnas
//ResultSet r = null;
if (conexion==null)
throw new ExcepciónBD("No hay conexión activa.");
else
try {
sta = conexion.createStatement();
//System.out.println("Creamos statement");
sta.execute("CREATE TABLE " + ta);
} catch (SQLException se) {
System.out.println("Problema con la creación de tabla. " + ta
+ "| " + se);
}
}
//lectura de datos con un select estándar sólo lectura
public ResultSet getDatos(String que) throws ExcepciónBD{
//sólo usable para consultas
//el parámetro que contiene un query en SQL
//Antes abrebd(manejador,url+basedat,clave,pass);
ResultSet r = null;
if (conexion==null) throw new ExcepciónBD("Aún no existe conexión.");
else {
try {
sta = conexion.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);
r = sta.executeQuery(que);
//System.out.println("Se ejecutó query:"+que);
} catch (SQLException se) {
System.out.println("Problema con la query. " + que + "| " + se);
}
}
return r;
}
//lectura de datos actualizables
public ResultSet ensalDatos(String que) throws ExcepciónBD{
//sólo usable para consultas
//el parámetro que contiene un query en SQL
//Antes abrebd(manejador,url+basedat,clave,pass);
System.out.println("Conexion Ensal recibe query: "+que+"|");
ResultSet r = null;
if (conexion==null) throw new ExcepciónBD("Aún no existe conexión.");
else {
try {
sta = conexion.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
System.out.println("Conexion Ensal creo statement");
r = sta.executeQuery(que);
//System.out.println("Se ejecutó query:"+que);
} catch (SQLException se) {
System.out.println("Problema con la query. " + que + "| " + se);
}
}
return r;
}
//inserción de datos
public void insertaDatos(String ta, String va)throws ExcepciónBD {
// ta indica la tabla donde se insertará
// va los valores a insertar, suponiendo que es todo el registro
// antes debe hacer abredb
if (conexion==null) throw new ExcepciónBD("Aún no existe conexión.");
else {
try {
sta = conexion.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta.execute("INSERT INTO "+ta+" VALUES "+va);
//sta.execute("INSERT INTO "+ta+" "+cab+" VALUES "+va);
//System.out.println("Se ejecutó insert:"+ta+" "+cab+" VALUES "+va);
//System.out.println("Se ejecutó insert:"+ta+" VALUES "+va);
} catch (SQLException se) {
System.out.println("Problema con la inserción. INSERT INTO " + ta+" VALUES "+va + "| " + se);
}
}
}
//actualización de datos
public int actualizaDatos(String ta, String va)throws ExcepciónBD {
int regact=0;
if (conexion==null) throw new ExcepciónBD("Aún no existe conexión.");
else {
try {
sta = conexion.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
regact=sta.executeUpdate("UPDATE "+ta+" SET "+va);
//System.out.println("Se ejecutó insert:"+ta+" "+va);
} catch (SQLException se) {
System.out.println("Problema con la actualización. " + ta+" "+va + "| " + se);
}
}
return regact;
}
//eliminación de datos
public int eliminaDatos(String ta, String va)throws ExcepciónBD {
int regact=0;
if (conexion==null) throw new ExcepciónBD("Aún no existe conexión.");
else {
try {
sta = conexion.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
regact=sta.executeUpdate("DELETE FROM "+ta+" "+va);
//System.out.println("Se ejecutó delete:"+ta+" "+va);
} catch (SQLException se) {
System.out.println("Problema con la eliminación. " + ta+" "+va + "| " + se);
}
}
return regact;
}
// Terminar la conexión, cerrando la base de datos
public void cierra() {
if (conexion != null)
try {
conexion.commit();
conexion.close();
} catch (SQLException se) {
System.out.println("Falla al cerrar. " + se);
}finally {boolean edo=(conexion==null);
System.out.println("Despues de cerrar: conexion nula: "+edo);
}
conexion = null;
}
// Aplicación de una query arbitraria
public boolean aplicaQuery(String que){
boolean res=false;
ResultSet r = null;
if (conexion==null) throw new ExcepciónBD("Aún no existe conexión.");
else {
try {
sta = conexion.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
r=sta.executeQuery(que);
res=true;
//System.out.println("Se ejecutó query"+que);
} catch (SQLException se) {
System.out.println("Problema con la acción. " + que + "| " + se);
}
}
return res;
}
// Uso local para conocer la versión
public String getVersión(){
return versión;
}
// Obtiene metadatos de una tabla
public DatabaseMetaData dameMetadatos(){
DatabaseMetaData dbmd=null;
try{
dbmd=conexion.getMetaData();
}catch (SQLException ex) {
System.out.println("Problema al traeer metadatos");
}
return dbmd;
}
}
package Uv;
public class ExcepciónBD extends RuntimeException {
//Auxiliar para manejo de bases de datos
// JM Fernández, 2009
public ExcepciónBD(String mens){
super(mens);
}
}
package Uv;
import java.beans.Statement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.Vector;
import javax.swing.JOptionPane;
import javax.swing.table.AbstractTableModel;
/*
* Clase que representa los elementos Control y Modelo de datos para
* el manejo de tablas en conexión a una interfaz (parte "Vista")
* Supone que se le pasa una conexión en forma de referencia a ConexiónS
* y también una consulta de SQL
* El modelo se pasa a un JTable, que le pasa avisos cuando se acciona sobre la vista
*/
public class ModeloConsulta extends AbstractTableModel {
// Parte transitoria del modelo de datos
// (la parte persistente es la base de datos que se abre)
Vector cache;
private int colCount;
String[] headers;
private Statement statement;
private ConexiónS kone = null;
private ResultSet rs;
ResultSetMetaData meta;
private static final String versión = "1.1";
// Los métodos que dicen override deben sobreescribirse obligatoriamente
// Otros son opcionales.
@Override
public int getColumnCount() {
return colCount;
}
@Override
public int getRowCount() {
return cache.size();
}
@Override
public Object getValueAt(int row, int col) {
return ((String[])cache.elementAt(row))[col];
}
// Para obtener los encabezados
public String getColumnName(int i) {
return headers[i];
}
// Para permitir edición de todas las celdas.
// se puede limitar a ciertas filas y columnas
public boolean isCellEditable(int fila, int col){
return true;
}
// Actualiza el modelo de datos
public void setValueAt(Object algo, int fila, int col){
System.out.println("Se pidió actualizar ("+fila+","+col+") con "+algo);
try{
String []temp = (String[])cache.elementAt(fila);
temp[col] = (String) algo;
cache.setElementAt(temp, fila);
rs.absolute(fila+1);
rs.updateString(col+1,(String) algo);
rs.updateRow();
//this.fireTableCellUpdated(fila+1, col+1);
}catch (SQLException se){
System.err.println("Problema al actualizar ("+fila+","+col+") con "+algo+"| "+se);
}
}
// Constructor (muy simple)
public ModeloConsulta(){
// la conexión se establece en la interfaz, pero se puede cambiar
//System.out.println("construyendo modelo");
cache = new Vector();
}
// Le pasa la conexión
public void setKone(ConexiónS con){
kone = con;
}
// Parte principal: recibe una consulta
public void cargaConsulta(String consu){
//System.out.println("Se traerán datos");
cache = new Vector();
try {
// Execute the query and store the result set and its metadata
rs = kone.ensalDatos(consu);
meta = rs.getMetaData();
colCount = meta.getColumnCount();
// Now we must rebuild the headers array with the new column names
headers = new String[colCount];
for (int h=1; h <= colCount; h++) {
headers[h-1] = meta.getColumnName(h);
//System.out.println("Col "+h+" llamada "+meta.getColumnName(h));
}
// El uso de cache para los registros se limita a cantidades pequeñas de registros
// No es bueno para grandes volúmenes
// También está hecho para datos genéricos, puede necesitarse algo mejor
while (rs.next()) {
String[] record = new String[colCount];
for (int i=0; i < colCount; i++) {
record[i] = rs.getString(i + 1);
}
cache.addElement(record);
}
fireTableChanged(null); // notify everyone that we have a new table.
}
catch(Exception e) {
cache = new Vector(); // blank it out and keep going.
System.err.println("Problema al ejecutar la consulta:"+consu+"|");
JOptionPane.showMessageDialog(null,"No pudo cargarse la consulta pedida");
e.printStackTrace();
}
System.out.println("Se hallaron registros= "+colCount);
}
// Agrega registros; es invocada por la JTable
public void addRow(int ref){
String[] s= new String[colCount];
int kua = getRowCount();
//System.out.println("se inserta con ref= "+ref);
cache.addElement(s);
try{
rs.moveToInsertRow();
//System.out.println("Posicionado");
rs.insertRow();
fireTableRowsInserted(kua,kua+1);
}catch (SQLException se){
System.out.println("No se pudo agregar elemento. "+se);
}
}
// Elimina un registro
public void deleteRow(int ref){
//System.out.println("Eliminando reg "+ref+" Hay ahora "+getRowCount());
cache.remove(ref);
try{
rs.absolute(ref+1);
rs.deleteRow();
//System.out.println("Registro eliminado"+ref+" Hay ahora "+getRowCount());
fireTableRowsInserted(ref,ref);
}catch (SQLException se){
System.out.println("No se pudo eliminar elemento. "+se);
}
}
public void cierra(){
cache = new Vector();
fireTableChanged(null); // notify everyone that we have a new table.
}
}