SQLite con Java

2013-03-07 - Categorías: General

Hoy les dejo un acceso a una base de datos SQLite, que últimamente está tan de moda. SQLite se usa en todo tipo de programas, es de dominio público, se puede incluir en tu programa añadiendo alguna librería muy ligera, y te da casi todas las funcionalidades que te puede dar cualquier otra BD relacional (de las que usan SQL).

Materiales

  1. Una vez más, mi entorno de desarrollo favorito, el Eclipse que supongo ya instalado. También se puede seguir el post usando otro entorno http://www.eclipse.org/
  2. Una librería hecha por completo en Java para usar SQLite, un tal Taro L. Saito, de Xerial nos deja en su repositorio para descargar en https://bitbucket.org/xerial/sqlite-jdbc/downloads
  3. El JDK instalado http://www.oracle.com/technetwork/java/javase/downloads/index.html 

 Un poco de teoría

Lo que he averiguado en mis investigaciones, más que nada con lo que me han explicado amigos, es que SQLite lo que no tiene son claves ajenas, con lo que la integridad referencial no está implementada dentro de su llamemosle «motor de la BD» es que tenemos integridad referencial, claves ajenas. Se pueden usar disparadores (triggers), cuando se hagan inserciones, modificaciones o borrados. Podemos usar BLOBs, definir los tipos de datos de las tablas, y un largo etcétera…

Según pone en la Wikipedia http://es.wikipedia.org/wiki/SQLite, la versión 3 de SQLite admite archivos de 2 Terabytes con incluso tipos de datos BLOB, con lo que podemos almacenar ficheros dentro de la base de dato. Con ésto creo que tenemos bastante, por lo menos para empezar a trastear las BD sin tener que instalar todo un señor motor de BD como los de Oracle o MS SQL Server, o los que más me gustan a mi como PostgreSQL o Firebird. En Java funcionan todas éstas BD de manera parecida, la idea principal es usar el JDBC que proporciona un estándar de conexión para conexión a bases de datos desde Java.

Manos a la obra

Al grano, después de un poco de teoría, antes de empezar con el código, hay que preparar el proyecto en Eclipse:

  1. Creo un nuevo proyecto de Java.
  2. Copio la librería de SQLite, en el proyecto, Eclipse te deja coger y arrastrar el fichero al Explodor de Proyectos con lo que te proguntará si quieres copiar o hacer un enlace externo al fichero. Prefiero copiarlo dentro del proyecto porqué así siempre estará incluido si es que creamos un ejecutable o nos llevamos el proyecto a otro ordenador.
  3. No basta con copiar la librería, tenemos que agregarla al Build Path del proyecto. Con el botón derecho del ratón en el explorador de proyectos, le damos a Build Path > Configure Build Path… Le damos a Add JAR… y elegimos el fichero que ya está dentro del proyecto. Debes ver una ventana parecida a ésta:

Hecho ésto ya podemos usar la librería desde cualquier clase que creemos dentro de éste proyecto. Entonces ya sí que sí, que empezamos creando una nueva clase, con un main. Yo he usado el generador de código de Eclipse y me ahorro tiempo. Entonces el código de ejemplo con el que se crea un fichero bdpruebas.db, luego dentro crea una tabla llamada tablapruebas, y va insertando valores aleatorios del 1 al 100 con un índice. Queda así:

package SqlitePack;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class ProbandoSqlite {

public static void main(String[] args) throws ClassNotFoundException {

Class.forName("org.sqlite.JDBC");

try {

// ESTABLECER LA CONEXIÓN
Connection conexion;
conexion = DriverManager.getConnection("jdbc:sqlite:bdpruebas.db");

// CREAR ENUNCIADO
Statement enunciado;
enunciado = conexion.createStatement();

// CREAR UNA TABLA NUEVA, LA BORRA SI EXISTE
enunciado.execute("DROP TABLE IF EXISTS tablapruebas;");
enunciado.execute("CREATE TABLE tablapruebas (id int primary key, aleatorio int);");

// INSERTAR DATOS
for (int i = 1; i <= 100; i++) {
enunciado.execute("INSERT INTO tablapruebas (id, aleatorio) values ("
+ i
+ ", "
+ Math.floor(Math.random() * 100 + 1) + ");");
}

// CONSULTA DATOS
ResultSet resultados;
resultados = enunciado.executeQuery("SELECT * FROM tablapruebas;");

// PROCESAR EL RESULTADO
while (resultados.next()) {
System.out.println("id " + resultados.getString(1)
+ ": aleatorio " + resultados.getString(2));
}

// CERRAR
resultados.close();
enunciado.close();
conexion.close();

} catch (Exception e) {
System.out.println("ERROR: " + e.getMessage());
}

}

}

Lo que hace el código es crear tres objetos: conexión, enunciado y resultados. Con conexión como su nombre indica, nos conectamos a la base de datos, si el fichero no existe lo crea, ésto es un comportamiento propio de SQLite. Con el enunciado lo que venimos a tener es una especie de «mesa de trabajo» con lo que vamos a atacar la base de datos con todo tipo de consultas o sentencias SQL. Es interesante el PreparedStatement para mejorar el funcionamiento interno de nuestro programa pero eso es otro tema. Luego con el objeto resultados en éste ejemplo lo que se hace es almacenar los resultados de la consulta.

Las sentencias SQL que se han usado lo que hacen es borrar la tabla si existe, la crean y llenan la tabla con los INSERT INTO. La última consulta con el SELECT lo que hace simplemente es listar todos los resultados de la tabla.

Dejo el proyecto en descarga como viene siendo costumbre xD

Descargar

Terminando

Para terminar, si pulsamos F11 en la ventana de consola debemos ver en los resultados algo tal que así:

id 1: aleatorio 4
id 2: aleatorio 70
id 3: aleatorio 94
id 4: aleatorio 40
id 5: aleatorio 86
id 6: aleatorio 40
id 7: aleatorio 89
id 8: aleatorio 80
id 9: aleatorio 79
id 10: aleatorio 14
id 11: aleatorio 69
id 12: aleatorio 2
id 13: aleatorio 12
id 14: aleatorio 62
id 15: aleatorio 74
id 16: aleatorio 53
id 17: aleatorio 45
id 18: aleatorio 44
id 19: aleatorio 56
id 20: aleatorio 40
id 21: aleatorio 81
id 22: aleatorio 75
id 23: aleatorio 97
id 24: aleatorio 78
id 25: aleatorio 63
id 26: aleatorio 30
id 27: aleatorio 13
id 28: aleatorio 21
id 29: aleatorio 68
id 30: aleatorio 58
id 31: aleatorio 25
id 32: aleatorio 92
id 33: aleatorio 88
id 34: aleatorio 77
id 35: aleatorio 38
id 36: aleatorio 45
id 37: aleatorio 18
id 38: aleatorio 47
id 39: aleatorio 60
id 40: aleatorio 51
id 41: aleatorio 90
id 42: aleatorio 90
id 43: aleatorio 96
id 44: aleatorio 34
id 45: aleatorio 47
id 46: aleatorio 89
id 47: aleatorio 97
id 48: aleatorio 58
id 49: aleatorio 78
id 50: aleatorio 49
id 51: aleatorio 23
id 52: aleatorio 82
id 53: aleatorio 12
id 54: aleatorio 92
id 55: aleatorio 51
id 56: aleatorio 99
id 57: aleatorio 56
id 58: aleatorio 9
id 59: aleatorio 14
id 60: aleatorio 1
id 61: aleatorio 4
id 62: aleatorio 80
id 63: aleatorio 80
id 64: aleatorio 97
id 65: aleatorio 89
id 66: aleatorio 47
id 67: aleatorio 3
id 68: aleatorio 73
id 69: aleatorio 34
id 70: aleatorio 99
id 71: aleatorio 22
id 72: aleatorio 38
id 73: aleatorio 69
id 74: aleatorio 22
id 75: aleatorio 6
id 76: aleatorio 97
id 77: aleatorio 28
id 78: aleatorio 47
id 79: aleatorio 21
id 80: aleatorio 50
id 81: aleatorio 89
id 82: aleatorio 22
id 83: aleatorio 71
id 84: aleatorio 98
id 85: aleatorio 45
id 86: aleatorio 20
id 87: aleatorio 12
id 88: aleatorio 29
id 89: aleatorio 75
id 90: aleatorio 11
id 91: aleatorio 54
id 92: aleatorio 24
id 93: aleatorio 86
id 94: aleatorio 89
id 95: aleatorio 90
id 96: aleatorio 39
id 97: aleatorio 34
id 98: aleatorio 1
id 99: aleatorio 37
id 100: aleatorio 66

Ya les dejo con ésto, espero que a alguien le sirva, un saludo.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

 

© 2021 JnjSite.com - MIT license

Sitio hecho con WordPress, diseño y programación del tema por Jnj.