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. } }