Viernes, 07 de noviembre de 2014

Parecería que cada día se encuentra uno con uno nuevo reto o enigma por descifrar jejeje, ayer en lo que los chicos trabajaban en su proyecto uno de ellos se acerco a preguntar sobre como se hacía el borrado en tablas SQLite, las respuestas vinieron rápidas y expontáneas, pero carecieron de verdad, el increible y sabelotodo Google arrojó resultandos no convincentes para los dos que estaban ahi consultando.

Sin embargo no quiero perder mi estado inspiracional y me quedé en el aula, hasta que quedó, tenemos que usar efectivamente un Statement, pero no su método executeUpdate() sino simplemente execute().

Aquí, aprovechando este estado de exitación les dejo un ABC en Java con una interfaz de consola y en Windows 8, con NetBeans 7.4 y como dice la categoría Java SE8.

Como mis piezas de "lego" son los objetos empecé por crear una clase que hace "menus" en modo texto, conforme la escribía se me ocurrían más cosas pero para el ejemplo con lo que escribí es suficiente. Vamos a empezar por el diagrama de clases.

Inspirados en la reciente "arrepentida" del gobierno federal sobre la licitación de la construcción de los trenes de alta velocidad la tabla que construi le llamé Ruta.

La clase menú me recordó a aquella "unidad" de pascal para hacer ventanas, menus, y algunos controles en modo texto, en nuestros días la consola es solo para hacer pruebas o ejecutar rútinas a muy bajo nivel, en este caso es para probar que nuestro programa de altas y bajas haga lo que tiene que hacer.

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
 
package inegi.dgreyra.utils.consola;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Scanner;
/**
 *
 * @author MIGUEL.ARAUJO
 */
public class MenuConsola {
    private int numeroOpciones;
 
    public int getNumeroOpciones() {
        return numeroOpciones;
    }
 
    public void setNumeroOpciones(int numeroOpciones) {
        this.numeroOpciones = numeroOpciones;
    }
 
    private ArrayList<String> menu;
 
    public MenuConsola() {
        numeroOpciones = 0;
        menu = new ArrayList<>();
    }
     
    public void mostrar(){
        Integer i=1;
        Iterator it = menu.iterator();
        while(it.hasNext() ){
            System.out.println("<"+i.toString()+ ">......." + it.next());
            i++;
        }
    }
     
    public void adicionarOpcion(String opcion){
        setNumeroOpciones(getNumeroOpciones()+1);
        menu.add(opcion);
    }
     
    public int regresaOpcionElegida(){
        int regreso = 0;  
        System.out.println("Introduce la opción deseada y confirma con [Enter]");
        Scanner sc = new Scanner(System.in);
        regreso = sc.nextInt();
        while(regreso<=0 || regreso>getNumeroOpciones()){
            System.out.println("¡Opción erronea");
            regreso = sc.nextInt();
        }
        return regreso;
    }
}



La tabla tiene simplemente 4 campos que listamos aquí (por cierto que aquí descubrí un comando para ver y especificamente los comandos de creación y llenado de las tablas .dump)


Ahora escribimos el código para conectar la tabla y sus operaciones, vamos con conectar:

package jappabcsqlite;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Scanner;
import java.sql.ResultSet;
 
/**
 *
 * @author MIGUEL.ARAUJO
 */
public class JAppABCSQLite {
    private final String URL = "C:\\bdUt\\bdTransporte.db";
 
     
    private Connection conn;
 
    public JAppABCSQLite(){
       conn = null;  
    }
     
    private void conectar(){
        try {
            Class.forName("org.sqlite.JDBC");
            try{
                conn = DriverManager.getConnection("jdbc:sqlite:"+URL);
                System.out.println("Conectado");
            }catch(SQLException ex){
                System.out.println(ex.getMessage());
            }
 
        } catch (ClassNotFoundException e) {
            System.out.println(e.getMessage());
        }
             
    }

La primer acción es la inserción de datos, este ejercicio como la mayoría que se hacen para internet son muy especificos para solucionar un solo problema, una idea es usar el mismo método pedirDatos() que captura la información para altas y modificaciones, además creamos una clase que representa el registro de la tabla que queremos afectar, por eso hacemos la clase Ruta.

    public void altas(){
        conectar();
        Ruta rutaInsertar=pedirDatos(" a insertar");
        System.out.println(rutaInsertar);
        String sql = "insert into ruta values (" +
                String.valueOf(rutaInsertar.getId()) + ",'" +
                rutaInsertar.getNombre() + "','" +
                rutaInsertar.getCiudad1() + "','" +
                rutaInsertar.getCiudad2() + "')";
        System.out.println(sql);
        try{
            Statement st = conn.createStatement();
            st.executeUpdate(sql);
            System.out.println("Registro insertado");
        }catch(SQLException ex){
            System.out.println("Error"+ex.getMessage());
        }finally{
            cerrar();
        }
    }

Podemos ver que se usa como menciono al principio el método executeUpdate() y se construye el comando insert después de obtener los valores que brinda el usuario. Aquí el método que recupera los datos.

    private Ruta pedirDatos(String aviso)
    {
       Ruta miRuta = new Ruta();
       Scanner teclado = new Scanner(System.in);
       System.out.println("Dame el id de la ruta" + aviso);
       teclado = new Scanner(System.in);
       miRuta.setId(teclado.nextInt());
       System.out.println("Dame el nombre de la ruta");
       teclado = new Scanner(System.in);
       String dato = teclado.next();
       miRuta.setNombre(dato);
       System.out.println("Dame la ciudad 1 de la ruta");
       teclado = new Scanner(System.in);
       dato = teclado.next();
       miRuta.setCiudad1(dato);
       System.out.println("Dame la ciudad 2 de la ruta");
       teclado = new Scanner(System.in);
       dato = teclado.next();
       miRuta.setCiudad2(dato);
       return miRuta;
    }

Podemos observar que este método regresa un objeto de la clase Ruta...con el fin de ver si estamos haciendo las cosas bien implemento la consulta de datos.

    public void consultar(){
        conectar();
        try{
            Statement st = conn.createStatement();
            ResultSet rs = st.executeQuery("select * from ruta");
            while(rs.next()){
                System.out.print("id="+String.valueOf(rs.getInt(1))+ "|");
                System.out.print("Ruta="+rs.getString(2)+ "|");
                System.out.print("Ciudad 1="+rs.getString(3)+ "|");
                System.out.println("Ciudad 2="+rs.getString(4)+ "|");
            }
        }catch(SQLException ex){
            System.out.println(ex.getMessage());
        }finally{
            cerrar();
        }
    }


Aquí podemos observar ahora vamos con el método executeQuery() que devuelve un ResultSet que muestra los datos en la terminal. Aquí el método que motivo este artículo, el borrado de un registro de la tabla.

    public void borrar(){
        Scanner teclado = new Scanner(System.in);
        System.out.println("Dame el número del registro a borrar");
        Integer reg=teclado.nextInt();
        conectar();
        try{
            Statement st = conn.createStatement();
            st.execute("delete from ruta where id="+reg.toString());
            System.out.println("Registro borrado!");
        }catch(SQLException ex){
            System.out.println(ex.getMessage());
        }finally{
            cerrar();
        }
    }

Aquí la solución que comenté al principio, usamos simplemente execute() de la clase Statement, eso era todo, para este caso el dato que nos sirve para determinar que borrar es el id de la tabla. Solo para completar el ejercicio completamos con el método de actualizar que pide los datos para actualizar y el id se usa para que registro de cambiaran sus datos.

    public void actualizar(){
        conectar();
        try{
            Statement st = conn.createStatement();
            Ruta rutaActualiza = pedirDatos(" a actualizar");
            String sql = "update ruta set nombre='" + rutaActualiza.getNombre() +
                    "',ciudad1='" + rutaActualiza.getCiudad1() + "',ciudad2='" + rutaActualiza.getCiudad2() +
                    "' where id=" + String.valueOf(rutaActualiza.getId());
            System.out.println(sql);
            st.executeUpdate(sql);
            System.out.println("Registro actualizado");
        }catch(SQLException ex){
             
        }finally{
            cerrar();
        }
    }


Solo para completar el ejercicio dejamos el método cerrar() que se encargar de precisamente cerrar la conexión creada.

    public void cerrar(){
        try{
        if(conn!=null || conn.isClosed()==false)
            conn.close();
        }catch(SQLException ex){
            System.out.println(ex.getMessage());
        }
    }


Ahora detallar la clase de Ruta que es quien guarda los valores que dan los usuarios.

public class Ruta {
    private int id;
    private String nombre;
    private String ciudad1;
    private String ciudad2;
 
    public int getId() {
        return id;
    }
 
    public void setId(int id) {
        this.id = id;
    }
 
    public String getNombre() {
        return nombre;
    }
 
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
 
    public String getCiudad1() {
        return ciudad1;
    }
 
    public void setCiudad1(String ciudad1) {
        this.ciudad1 = ciudad1;
    }
 
    public String getCiudad2() {
        return ciudad2;
    }
 
    public void setCiudad2(String ciudad2) {
        this.ciudad2 = ciudad2;
    }
 
    public Ruta(int id, String nombre, String ciudad1, String ciudad2) {
        this.id = id;
        this.nombre = nombre;
        this.ciudad1 = ciudad1;
        this.ciudad2 = ciudad2;
    }
 
    public Ruta() {
        this.id = 0;
        this.nombre = "";
        this.ciudad1 = "";
        this.ciudad2 = "";
    }
 
    @Override
    public String toString() {
        return "Ruta{" + "id=" + id + ", nombre=" + nombre + ", ciudad1=" + ciudad1 + ", ciudad2=" + ciudad2 + '}';
    }
     
     
}

Tenemos ahora la clase que prueba nuestro ABC de SQLite, un aspecto importante y que me llevo tiempo recordar para resolver es que tenemos que agregar en la clase que prueba y usa las clases descritas arriba, la clase que este caso es el JDBC de SQLite.

public class JAppTestABCSQLite {
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        int resp=0;
        MenuConsola menuPrincipal = new MenuConsola();
        JAppABCSQLite app = new JAppABCSQLite();
        menuPrincipal.adicionarOpcion("Altas");
        menuPrincipal.adicionarOpcion("Bajas");
        menuPrincipal.adicionarOpcion("Cambios");
        menuPrincipal.adicionarOpcion("Consultar");
        menuPrincipal.adicionarOpcion("Salir");
        while (resp!=5){
            menuPrincipal.mostrar();
            resp = menuPrincipal.regresaOpcionElegida();
            switch(resp){
                case 1:{app.altas();break;}
                case 2:{app.borrar();break;}
                case 3:{app.actualizar();break;}
                case 4:{app.consultar();break;}     
            }
        }
    }
     
}


Por ejemplo tenemos que la tabla tiene tres rutas, como se muestra en la siguiente salida:

Vamos a borrar la ruta 3...

Y listo, el registro se fue...

Una cosa importante hablando de mi clase, este ejemplo NO RESUELVE LA SITUACIÓN DEL MINIPROYECTO PLANTEADO ya que resuelve solo para una sola base de datos y una tabla y la idea es que se use una interface y que la clase que la implemente sea genérica y nos sirva para cualquier situación.

Profesor Enrique Nash.


Publicado por neofito69 @ 15:26  | Java SE8
Comentarios (0)  | Enviar
Comentarios