SQLite 3: Introducción e integración con Java

SQLite es un motor de base de datos que no trabaja con la arquitectura cliente-servidor, por lo cual no es necesario un servidor en el cual se almacenará la base de datos, sino que dicha base de datos se almacena de forma local en un fichero en una ruta especificada.

Este motor es muy viable para proyectos de pequeño porte de escritorio en los cuales solo se utilizará una máquina, o almacenamiento local en dispositivos móviles. SQLite tiene la desventaja que solo nos permite una conexión en simultáneo.

Itinerario

1. Instalación en Windows
2. Como crear una base de datos SQLite a partir de un script SQL
3. Como conectarnos a SQLite desde Java
4. Clase Database.java
5. Clase Conexion.java
6. SQLite Browser

Instalación en Windows

Primero que nada, debemos descargar las SQLite tools, que nos permitirán trabajar en consola, para eso vamos a este enlace y las buscamos en la sección de descargas, sería la tercera opción.

Ese enlace nos descargará un .rar con 3 archivos ejecutables.

Al descomprimirlo, dentro de la carpeta debemos pulsar SHIFT + click derecho, y seleccionamos “abrir una ventana de powershell aquí”.

Luego ejecutamos el comando ./sqlite3.exe y dentro de esa terminal de PowerShell ya podemos operar con SQLite.

Si deseamos tener estos ejecutables disponibles desde una ventana de cmd lo que debemos hacer es copiar estos 3 ficheros en un lugar donde no se toquen en el disco C.

Entonces luego debemos ir a Equipo, click derecho y propiedades, “Configuración avanzada de sistema”.

Una vez hecho esto debemos ir a variables de entorno.

En variables de usuario debemos hacer doble click en “Path”, en esa ventana que se nos abre a continuación debemos agregar la ruta a la carpeta que contiene estos 3 ejecutables.

Después de hecho este procedimiento ya podremos usar la consola de sqlite con el comando sqlite3 en un cmd.

Como crear una base de datos SQLite a partir de un script SQL

Se puede generar una base de datos desde el terminal de sqlite, pero puede resultar más cómodo generar la base a partir de un script.

Para eso nos posicionamos en el cmd en la carpeta donde está nuestro archivo .sql (sin haber ingresado al terminal de sqlite3).

Luego ejecutamos el comando:

sqlite3 mydatabase.db < estructura.sql

1. mydatabase.db es el nombre del fichero que contendrá la base de datos.
2. estructura.sql es el fichero sql que tendrá las sentencias de creación de tablas y alguna precarga si es necesario.

Como conectarnos a SQLite desde Java

A continuación, les dejo este quick start en github con maven, y una database.db de pruebas.

Ahora expongo el código de las 2 clases que nos serán útiles para conectar nuestro proyecto a la base de datos.

Clase Database.java

package Datos;

import java.sql.*;
import java.util.ArrayList;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.naming.NamingException;

public class Database {

    
    /*Atributos*/
    private static Database instancia;
    private static String url = "C:\\database\\database.db";     
    private static Conexion conexion;
    /*Atributos*/
 /*Constructores*/

 /*Constructores*/
 /*Comportamiento*/
    public static Database getInstancia() {
        if (instancia == null) {
            instancia = new Database();
        }
        return instancia;
    }
    public static Conexion getConexion(){
        if(conexion == null){
            try {
                conexion = conectar(url);
            } catch (SQLException ex) {
                Logger.getLogger(Database.class.getName()).log(Level.SEVERE, null, ex);
            } catch (NamingException ex) {
                Logger.getLogger(Database.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return conexion;
    }
    public static Conexion conectar(String url) throws SQLException, NamingException {
        try {
            Connection c = null;
            Statement s = null;
            c = DriverManager.getConnection("jdbc:sqlite:"+url);

            c.setAutoCommit(false);
            s = c.createStatement();
            return new Conexion(s, c);
        } catch (SQLException ex) {
            int codigo = ex.getErrorCode();
            String errorTexto = "Codigo de Error: " + codigo + " // Mensaje: " + ex.getMessage();
            System.out.println(errorTexto);
            if (codigo == 0) {
                throw new SQLException(errorTexto);
            }
        }
        return null;
    }
    public boolean desconectar(Conexion conexion){
        try {
            if (conexion.getConexion() != null) {
                conexion.getConexion().close();
                conexion.setConexion(null);
                conexion.setStmt(null);
                return true;
            }
        } catch (SQLException ex) {
            System.out.println(ex.getMessage());
            return false;
        }
        return false;
    }

    public int actualizar(String sql) throws SQLException, NamingException {
        try {
            Conexion DTOConexion = getConexion();
            int retorno = DTOConexion.getStmt().executeUpdate(sql);
            desconectar(DTOConexion);
            return retorno;
        } catch (SQLException ex) {
            throw ex;
        }
    }

    

    public ResultSet consultar(String sql) throws Exception, SQLException {
        try {
            Conexion DTOConexion = getConexion();
            ResultSet rs = DTOConexion.getStmt().executeQuery(sql);
            return rs;
        } catch (SQLException ex) {
            throw ex;
        }
        
    }

    /*Comportamiento*/
 /*Setters y Getters*/

    public static String getUrl() {
        return url;
    }
    /*Setters y Getters*/


}

La clase Database.java está codificada para facilitar el acceso a datos, sobre ella en resumen puedo acotar los siguientes detalles:

• En la línea 14 tenemos la ruta en la que estará el fichero .db que creamos previamente desde el CMD de Windows (dicho fichero ya debe tener la base y las tablas creadas para poder trabajar con ellas).
• Mediante el método actualizar(String sql) podemos ejecutar cualquier query en la base que nosotros pasemos por parámetro, y previamente dicho método gestiona la conexión a la base.
• Mediante el método consultar(String sql) podemos obtener un objeto ResultSet con los resultados de una consulta a la base.
• En esta clase se aplica un Singleton sobre el objeto Database y también sobre el objeto Conexion dado que SQLite nos permite utilizar una sola conexión a la base en simultaneo.

Clase Conexion.java

La clase Conexion.java simplemente tiene embebidos los objetos Connection y Statement para facilitar el manejo de la conexión, sobre la cual no tenemos ningún aspecto a resaltar.

SQLite Browser

Tenemos una interfaz gráfica que nos permite manipular bases de datos y ver datos desde un entorno más agradable, esta se encuentra en este enlace.

También se pueden ejecutar sentencias sobre ese fichero de base de datos.

Para finalizar, si tenemos dos instancias de nuestro programa abiertas posiblemente tengamos errores de acceso a la base de datos, lo mismo si tenemos el programa en ejecución y el browser.