SQLite Java: Conéctese a la base de datos

SQLite con el controlador SQLite JDBC

Resumen: en este tutorial, le mostraremos cómo descargar el controlador SQLite JDBC y
conectarse a la base de datos SQLite a través de JDBC.

Descargar SQLite JDBC Driver

Para descargar la última versión del Controlador SQLite JDBC, vaya a la página de descarga en
bitbucket. Debe descargar la última versión del controlador. Al escribir estas líneas, la última
versión es 3.8.11.2.
El archivo JAR incluye archivos de clase Java y binarios SQLite para Mac OX S, Linux y
Windows, tanto de 32 bits como de 64 bits.

Agregue el archivo JAR del controlador SQL JDBC a un proyecto Java

Utilizaremos NetBean IDE para desarrollar aplicaciones Java SQLite.
Primero, cree un nuevo proyecto desde NetBean haciendo clic en el botón Nuevo proyecto ... en la
barra de herramientas.
A continuación, elija la aplicación Java y haga clic en el botón Siguiente.

Luego, ingrese el nombre del proyecto, su ubicación y la clase principal. Haga clic en el botón
Finalizar para crear el nuevo proyecto
Después de eso, para agregar el archivo SQLite JDBC Driver Jar al proyecto, haga clic con el botón
derecho del mouse en el nombre del proyecto y elija Propiedades.
Finalmente, seleccione Bibliotecas (1) en las Categorías de las ventanas de Propiedades del
Proyecto. A continuación, haga clic en el botón Agregar JAR / Carpeta (2), elija el archivo SQLite
JDBC JAR (3) y haga clic en el botón Abrir (4).

Cadena de conexión SQLite

El controlador SQLite JDBC le permite cargar una base de datos SQLite desde el sistema de
archivos utilizando la siguiente cadena de conexión.
jdbc: sqlite: sqlite_database_file_path

Sqlite_data_file_path es la ruta al archivo de base de datos SQLite, que es una ruta relativa o
absoluta de la siguiente manera:
jdbc: sqlite: sample.db
O
jdbc: sqlite: C: /sqlite/db/chinook.db
Para conectarse a una base de datos en memoria, use la siguiente cadena de conexión:
jdbc: sqlite :: memoria
Conéctese a una base de datos SQLite a través de JDBC
El siguiente programa se conecta a la base de datos de muestra de SQLite chinook.

package net.sqlitetutorial;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

/**
*
* @author sqlitetutorial.net
*/
public class SQLiteJDBCDriverConnection {
/**
* Connect to a sample database
*/
public static void connect() {
Connection conn = null;
try {
// db parameters
String url = "jdbc:sqlite:C:/sqlite/db/chinook.db";
// create a connection to the database
conn = DriverManager.getConnection(url);

System.out.println("Connection to SQLite has been established.");

} catch (SQLException e) {
System.out.println(e.getMessage());
} finally {
try {
if (conn != null) {
 conn.close();
}
} catch (SQLException ex) {
System.out.println(ex.getMessage());
}
}
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
connect();
}
}
Vamos a ejecutarlo.
La conexión a SQLite se ha establecido.

Funciona como se esperaba.

En este tutorial, le mostramos cómo usar el controlador SQLite JDBC para conectarse a una base de
datos SQLite.
SQLite Java: crea una nueva base de datos
SQLite
Resumen: en este tutorial, le mostraremos cómo crear una nueva base de datos SQLite utilizando
Java SQLite JDBC.
Para crear una nueva base de datos SQLite desde la aplicación Java, use los siguientes pasos:
1. Primero, especifique el nombre de la base de datos y su ubicación, por ejemplo, c: \
sqlite \ db \ test.db
2. Segundo, conéctese a la base de datos a través del controlador SQLite JDBC.
Cuando se conecta a una base de datos SQLite inexistente, SQLite crea automáticamente una nueva
base de datos. Por lo tanto, para crear una nueva base de datos, solo necesita especificar el nombre
de la base de datos y conectarse a ella.
El siguiente programa crea una nueva base de datos SQLite denominada test.db en la carpeta c: \
sqlite \ db.

package net.sqlitetutorial;

import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.SQLException;

/**
*
* @author sqlitetutorial.net
*/
public class Main {

/**
* Connect to a sample database
*
* @param fileName the database file name
*/
public static void createNewDatabase(String fileName) {

String url = "jdbc:sqlite:C:/sqlite/db/" + fileName;

try (Connection conn = DriverManager.getConnection(url)) {

if (conn != null) {
DatabaseMetaData meta = conn.getMetaData();
System.out.println("The driver name is " + meta.getDriverName());
System.out.println("A new database has been created.");
}

} catch (SQLException e) {
System.out.println(e.getMessage());
}
}
 /**
* @param args the command line arguments
*/
public static void main(String[] args) {
createNewDatabase("test.db");
}
Ahora ejecutamos el programa y vemos el siguiente resultado:

correr:
El nombre del controlador es SQLiteJDBC
Se ha creado una nueva base de datos.
CONSTRUIR ÉXITO (tiempo total: 0 segundos)

El test.db debe crearse en la carpeta c: \ sqlite \ db \. Puede verificarlo para asegurarse de que se
haya creado la base de datos.
SQLite Java: crea una nueva tabla

Resumen: en este tutorial, aprenderá a crear una nueva tabla desde el programa Java utilizando el
Controlador SQLite JDBC.

Para crear una nueva tabla en una base de datos específica, use los siguientes pasos:
1. Primero, prepare la instrucción CREATE TABLE.
2. Segundo, conéctese a la base de datos que contiene la tabla.
3. En tercer lugar, cree una nueva instancia de la clase Statement desde el objeto Connection.
4. Cuarto, ejecute la instrucción CREATE TABLE llamando al método executeUpdate () del objeto
Statement.
El siguiente programa ilustra los pasos para crear una tabla.

package net.sqlitetutorial;

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

/**
*
* @author sqlitetutorial.net
*/
public class Main {

/**
* Create a new table in the test database
*
*/
public static void createNewTable() {
// SQLite connection string
String url = "jdbc:sqlite:C://sqlite/db/tests.db";

// SQL statement for creating a new table

String sql = "CREATE TABLE IF NOT EXISTS warehouses (\n"
+ " id integer PRIMARY KEY,\n"
+ " name text NOT NULL,\n"
+ " capacity real\n"
+ ");";

try (Connection conn = DriverManager.getConnection(url);

Statement stmt = conn.createStatement()) {
// create a new table
stmt.execute(sql);
} catch (SQLException e) {
System.out.println(e.getMessage());
}
}
 /**
* @param args the command line arguments
*/
public static void main(String[] args) {
createNewTable();
}

}
In this tutorial, we have shown you how to create a new table in SQLite from a Java program using
the SQLite JDBC driver.

SQLite Java: inserción de datos

Resumen: en este tutorial, le mostraremos cómo insertar datos en una tabla usando el JDBC.
Para insertar datos en una tabla utilizando la instrucción INSERT, use los siguientes pasos:
1. Primero, conéctese a la base de datos SQLite.
2. Luego, prepare la instrucción INSERT. Si usa parámetros para la declaración, use un
signo de interrogación (?) Para cada parámetro.
3. Luego, cree una instancia de PreparedStatement desde el objeto Connection.
4. Después de eso, establezca los valores correspondientes para cada marcador de posición
utilizando el método set del objeto PreparedStatement como setInt (), setString (), etc.
5. Finalmente, llame al método executeUpdate () del objeto PreparedStatement para ejecutar
la instrucción.
El siguiente programa inserta tres filas en la tabla de almacenes que creamos en la tabla de creación
de tutoriales.

package net.sqlitetutorial;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

/**
*
* @author sqlitetutorial.net
*/
public class InsertApp {

/**
* Connect to the test.db database
*
* @return the Connection object
*/
private Connection connect() {
// SQLite connection string
String url = "jdbc:sqlite:C://sqlite/db/test.db";
Connection conn = null;
try {
conn = DriverManager.getConnection(url);
} catch (SQLException e) {
 System.out.println(e.getMessage());
}
return conn;
}

/**
* Insert a new row into the warehouses table
*
* @param name
* @param capacity
*/
public void insert(String name, double capacity) {
String sql = "INSERT INTO warehouses(name,capacity) VALUES(?,?)";

try (Connection conn = this.connect();

PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, name);
pstmt.setDouble(2, capacity);
pstmt.executeUpdate();
} catch (SQLException e) {
System.out.println(e.getMessage());
}
}

/**
* @param args the command line arguments
*/
public static void main(String[] args) {

InsertApp app = new InsertApp();

// insert three new rows
app.insert("Raw Materials", 3000);
app.insert("Semifinished Goods", 4000);
app.insert("Finished Goods", 5000);
}

Después de ejecutar el programa, puede consultar la tabla de almacenes en la base de datos test.db
utilizando la siguiente instrucción SELECT:

SELECT
id,
name,
capacity
FROM
warehouses;

En este tutorial, ha aprendido cómo insertar datos en una tabla en la base de datos SQLite del
programa Java.
SQLite Java: seleccionar datos
Resumen: en este tutorial, aprenderá a consultar datos de una tabla utilizando Java JDBC.
Para consultar datos de una tabla, use los siguientes pasos:
1. Primero, cree un objeto Connection para conectarse a la base de datos SQLite.
2. Luego, cree una instancia de la clase Statement desde el objeto Connection.
3. Luego, cree una instancia de la clase ResultSet llamando al método executeQuery del
objeto Statement. El método executeQuery () acepta una instrucción SELECT.
4. Después de eso, recorra el conjunto de resultados utilizando el método next () del objeto
ResultSet.
5. Finalmente, use el método get * del objeto ResultSet, como getInt (), getString (),
getDouble (), etc., para obtener los datos en cada iteración.
El siguiente programa selecciona todas las filas de la tabla de almacenes.

package net.sqlitetutorial;

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

/**
*
* @author sqlitetutorial.net
*/
public class SelectApp {

/**
* Connect to the test.db database
* @return the Connection object
*/
private Connection connect() {
// SQLite connection string
String url = "jdbc:sqlite:C://sqlite/db/test.db";
Connection conn = null;
try {
conn = DriverManager.getConnection(url);
} catch (SQLException e) {
System.out.println(e.getMessage());
}
return conn;
}

/**
* select all rows in the warehouses table
*/
public void selectAll(){
 String sql = "SELECT id, name, capacity FROM warehouses";

try (Connection conn = this.connect();

Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery(sql)){

// loop through the result set

while (rs.next()) {
System.out.println(rs.getInt("id") + "\t" +
rs.getString("name") + "\t" +
rs.getDouble("capacity"));
}
} catch (SQLException e) {
System.out.println(e.getMessage());
}
}

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
SelectApp app = new SelectApp();
app.selectAll();
}

Lo siguiente ilustra el resultado del programa:

Consultar datos con parámetros

Para usar parámetros en la consulta, use el objeto PreparedStatement en su lugar. Por ejemplo, el
siguiente método selecciona el almacén cuya capacidad es mayor que una capacidad especificada

/**
* Get the warehouse whose capacity greater than a specified capacity
* @param capacity
*/
public void getCapacityGreaterThan(double capacity){
String sql = "SELECT id, name, capacity "
+ "FROM warehouses WHERE capacity > ?";

try (Connection conn = this.connect();

PreparedStatement pstmt = conn.prepareStatement(sql)){
 // set the value
pstmt.setDouble(1,capacity);
//
ResultSet rs = pstmt.executeQuery();

// loop through the result set

while (rs.next()) {
System.out.println(rs.getInt("id") + "\t" +
rs.getString("name") + "\t" +
rs.getDouble("capacity"));
}
} catch (SQLException e) {
System.out.println(e.getMessage());
}
}
Para encontrar los almacenes cuyas capacidades son mayores que 3600, use el método
getCapacityGreaterThan () de la siguiente manera:

SelectApp app = new SelectApp();

app.getCapacityGreaterThan(3600);

El siguiente es el resultado:

En este tutorial, ha aprendido cómo consultar datos de la tabla en la base de datos SQLite desde un
programa Java.
SQLite Java: actualización de datos
Resumen: este tutorial le muestra cómo actualizar datos en una tabla desde un programa Java
usando JDBC.
Para actualizar los datos existentes de una tabla, siga los pasos a continuación:
Primero, conéctese a la base de datos SQLite.
1. Luego, prepare la instrucción UPDATE. Para la instrucción UPDATE que usa parámetros,
usa el marcador de posición de interrogación (?) En las cláusulas SET y WHERE.
2. Luego, instale un objeto en la clase PreparedStatement llamando al método
prepareStatement () del objeto Connection.
3. Después de eso, establezca un valor para cada marcador de posición utilizando el método
set * del objeto PreparedStatement, por ejemplo, setString (), setInt (), etc.
4. Finalmente, ejecute la instrucción UPDATE llamando al método executeUpdate () del
objeto PreparedStatement.
El siguiente programa inserta tres filas en la tabla de almacenes que creamos en la tabla de creación
de tutoriales.

package net.sqlitetutorial;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

/**
*
* @author sqlitetutorial.net
*/
public class UpdateApp {

/**
* Connect to the test.db database
*
* @return the Connection object
*/
private Connection connect() {
// SQLite connection string
String url = "jdbc:sqlite:C://sqlite/db/test.db";
Connection conn = null;
try {
conn = DriverManager.getConnection(url);
} catch (SQLException e) {
System.out.println(e.getMessage());
}
return conn;
}

/**
* Update data of a warehouse specified by the id
*
 * @param id
* @param name name of the warehouse
* @param capacity capacity of the warehouse
*/
public void update(int id, String name, double capacity) {
String sql = "UPDATE warehouses SET name = ? , "
+ "capacity = ? "
+ "WHERE id = ?";

try (Connection conn = this.connect();

PreparedStatement pstmt = conn.prepareStatement(sql)) {

// set the corresponding param

pstmt.setString(1, name);
pstmt.setDouble(2, capacity);
pstmt.setInt(3, id);
// update
pstmt.executeUpdate();
} catch (SQLException e) {
System.out.println(e.getMessage());
}
}

/**
* @param args the command line arguments
*/
public static void main(String[] args) {

UpdateApp app = new UpdateApp();

// update the warehouse with id 3
app.update(3, "Finished Products", 5500);
}

Primero, verifica la tabla de almacenamiento antes de ejecutar el programa de actualización

utilizando la siguiente instrucción SELECT.

SELECT
id,
name,
capacity
FROM
warehouses;
Segundo, ejecuta el programa UpdateApp.
En tercer lugar, consulte nuevamente los datos de la tabla de almacenes utilizando la misma
instrucción SELECT anterior.

En este tutorial, ha aprendido cómo actualizar los datos en la base de datos SQLite del programa
Java.
SQLite Java: eliminación de datos
Resumen: este tutorial lo guía por los pasos para eliminar datos en una tabla de un programa Java
utilizando JDBC.
Para eliminar una o más filas de una tabla de base de datos de un programa Java, utilice los
siguientes pasos:
1. Primero, cree una conexión de base de datos a la base de datos SQLite.
2. Luego, prepare la declaración DELETE. En caso de que quiera que la declaración tome
parámetros, use el marcador de posición de interrogación (?) Dentro de la declaración.
3. Luego, cree una nueva instancia de la clase PreparedStatement llamando al método
prepareStatement () del objeto Connection.
4. Después de eso, proporcione valores en lugar del marcador de posición del signo de
interrogación utilizando el método set * del objeto PreparedStatement, por ejemplo, setInt (),
setString (), etc.
5. Finalmente, ejecute la instrucción DELETE llamando al método executeUpdate () del
objeto PreparedStatement.
El siguiente programa elimina la fila con id 3 en la tabla de almacenes de la base de datos test.db
que creamos en el tutorial de la tabla de creación.

package net.sqlitetutorial;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

/**
*
* @author sqlitetutorial.net
*/
public class DeleteApp {

/**
* Connect to the test.db database
*
* @return the Connection object
*/
private Connection connect() {
// SQLite connection string
String url = "jdbc:sqlite:C://sqlite/db/test.db";
Connection conn = null;
try {
conn = DriverManager.getConnection(url);
} catch (SQLException e) {
System.out.println(e.getMessage());
}
return conn;
}

/**
 * Delete a warehouse specified by the id
*
* @param id
*/
public void delete(int id) {
String sql = "DELETE FROM warehouses WHERE id = ?";

try (Connection conn = this.connect();

PreparedStatement pstmt = conn.prepareStatement(sql)) {

// set the corresponding param

pstmt.setInt(1, id);
// execute the delete statement
pstmt.executeUpdate();

} catch (SQLException e) {
System.out.println(e.getMessage());
}
}

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
DeleteApp app = new DeleteApp();
// delete the row with id 3
app.delete(3);
}

}
Primero, usa la siguiente instrucción SELECT para verificar la tabla de almacenes antes de ejecutar
el programa de eliminación.

SELECT
id,
name,
capacity
FROM
warehouses;

Segundo, ejecute el programa Eliminar aplicación.

En tercer lugar, utilice la misma instrucción SELECT anterior para consultar los datos de la tabla de
almacenes.

En este tutorial, ha aprendido cómo eliminar datos en la base de datos SQLite del programa Java.
SQLite Java: transacción
Resumen: en este tutorial, le mostraremos cómo usar la transacción JDBC para administrar
transacciones en la base de datos SQLite.
Base de datos de muestra para demostración de transacción
Antes de comenzar con Java, crearemos dos nuevas tablas en la base de datos test.db.
1. La tabla de materiales almacena el maestro de materiales.
2. La tabla de inventario almacena la relación entre los almacenes y la tabla de materiales.
Además, la tabla de inventario tiene la columna qty que almacena los datos de stock.
Las siguientes declaraciones crean los materiales y las tablas de inventario.

CREATE TABLE IF NOT EXISTS materials (

id integer PRIMARY KEY,
description text NOT NULL
);

CREATE TABLE IF NOT EXISTS inventory (

warehouse_id integer,
material_id integer,
qty real,
PRIMARY KEY (warehouse_id, material_id),
FOREIGN KEY (warehouse_id) REFERENCES warehouses (id),
FOREIGN KEY (material_id) REFERENCES materials (id)
);

El siguiente diagrama ilustra las tablas y su relación.

¿Qué es una transacción de base de datos?

Una transacción representa un conjunto de operaciones realizadas como una sola unidad de trabajo.
Significa que si cualquier operación en el conjunto falla, SQLite aborta otras operaciones y retrotrae
los datos a su estado inicial.
Una transacción tiene cuatro atributos principales, que se conocen como ACID.
La letra A representa la atomicidad. Significa que cada transacción debe ser todo o nada. Si
cualquier operación en la transacción falla, el estado de la base de datos permanece sin cambios.
La letra C significa coherencia. Se asegura de que cualquier transacción lleve los datos en la base de
datos de un estado válido a otro.
La letra I significa aislamiento. Esto es para el control de concurrencia. Asegura que la ejecución
concurrente de todas las transacciones produzca el mismo resultado que si se ejecutaran
secuencialmente.
La letra D representa durabilidad. Significa que cuando se compromete la transacción, permanecerá
intacta independientemente de cualquier error, como la pérdida de energía.

Ejemplo de transacción Java SQLite

Cuando se conecta a una base de datos SQLite, el modo predeterminado es autocompromiso.

Significa que cada consulta que envíes a la base de datos SQLite se confirma automáticamente.
Para deshabilitar el modo de confirmación automática, use el método setAutoCommit () del objeto
Connection de la siguiente manera:
conn.setAutoCommit (falso);

Para comprometer el trabajo, utiliza el método de confirmación del objeto Connection.

conn.commit ();

En caso de que ocurra una falla en el medio de la transacción, siempre puede usar el método
rollback () para deshacer la transacción.

conn.rollback ();

El siguiente programa agrega un nuevo material a la tabla de materiales y también publica el

inventario. Ponemos ambas operaciones en la misma transacción.

package net.sqlitetutorial;

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

/**
 *
* @author sqlitetutorial.net
*/
public class TransactionApp {

/**
* Connect to the test.db database
*
* @return the Connection object
*/
private Connection connect() {
// SQLite connection string
String url = "jdbc:sqlite:C://sqlite/db/test.db";
Connection conn = null;
try {
conn = DriverManager.getConnection(url);
} catch (SQLException e) {
System.out.println(e.getMessage());
}
return conn;
}

/**
* Create a new material and add initial quantity to the warehouse
*
* @param material
* @param warehouseId
* @param qty
*/
public void addInventory(String material, int warehouseId, double qty) {
// SQL for creating a new material
String sqlMaterial = "INSERT INTO materials(description) VALUES(?)";

// SQL for posting inventory

String sqlInventory = "INSERT INTO inventory(warehouse_id,material_id,qty)"
+ "VALUES(?,?,?)";

ResultSet rs = null;
Connection conn = null;
PreparedStatement pstmt1 = null, pstmt2 = null;

try {
// connect to the database
conn = this.connect();
if(conn == null)
return;

// set auto-commit mode to false

conn.setAutoCommit(false);

// 1. insert a new material

pstmt1 = conn.prepareStatement(sqlMaterial,
 Statement.RETURN_GENERATED_KEYS);

pstmt1.setString(1, material);
int rowAffected = pstmt1.executeUpdate();

// get the material id

rs = pstmt1.getGeneratedKeys();
int materialId = 0;
if (rs.next()) {
materialId = rs.getInt(1);
}

if (rowAffected != 1) {
conn.rollback();
}
// 2. insert the inventory
pstmt2 = conn.prepareStatement(sqlInventory);
pstmt2.setInt(1, warehouseId);
pstmt2.setInt(2, materialId);
pstmt2.setDouble(3, qty);
//
pstmt2.executeUpdate();
// commit work
conn.commit();

} catch (SQLException e1) {

try {
if (conn != null) {
conn.rollback();
}
} catch (SQLException e2) {
System.out.println(e2.getMessage());
}
System.out.println(e1.getMessage());
} finally {
try {
if (rs != null) {
rs.close();
}
if (pstmt1 != null) {
pstmt1.close();
}
if (pstmt2 != null) {
pstmt2.close();
}
if (conn != null) {
conn.close();
}
} catch (SQLException e3) {
System.out.println(e3.getMessage());
}
}
 }

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
TransactionApp app = new TransactionApp();
app.addInventory("HP Laptop", 3, 100);
}

Para verificar el resultado, puede consultar los datos de los materiales y la tabla de inventario
utilizando la cláusula de unión interna de la siguiente manera:

SELECT
name,
description,
qty
FROM
materials
INNER JOIN inventory ON inventory.material_id = materials.id
INNER JOIN warehouses ON warehouses.id = inventory.warehouse_id;

En este tutorial, ha aprendido cómo administrar transacciones en SQLite usando Java JDBC.
SQLite Java: escribir y leer BLOB
Resumen: este tutorial muestra paso a paso cómo actualizar y seleccionar el BLOB de una base de
datos SQLite.
Para la demostración, utilizaremos la tabla de materiales que creamos en el tutorial de la tabla de
creación.
Supongamos que tenemos que almacenar una imagen para cada material en la tabla de materiales.
Para hacer esto, agregamos una columna cuyo tipo de datos es BLOB a la tabla de materiales.
La siguiente instrucción ALTER TABLE agrega la columna de imagen a la tabla de materiales.
ALTER TABLE materiales ADD COLUMN imagen blob;

Insertar datos BLOB en la base de datos SQLite

Primero, consultamos los datos de la tabla de materiales para ver su contenido:
SELECT
id,
description,
picture
FROM
materials;

La columna de la imagen es NULL.

En segundo lugar, preparamos un archivo de imagen y lo colocamos en una carpeta, por ejemplo, C:
\ temp de la siguiente manera:

Para actualizar la columna de imagen con los datos del archivo de imagen:
1. Primero, prepare una declaración ACTUALIZADA.
2. Luego, conéctese a la base de datos SQLite para obtener el objeto Connection.
3. Luego, cree un objeto PreparedStatement desde el objeto Connection.
4. Después de eso, proporcione los valores a los parámetros correspondientes utilizando los
métodos set * del objeto PreparedStatement.
5. Finalmente, ejecute la instrucción UPDATE llamando al método executeUpdate () del
objeto PreparedStatement.

Observe que el controlador SQLiteJDBC no implementa el método setBinaryStream, por lo tanto,

debe usar el método setBytes en su lugar.
El siguiente método readFile lee un archivo y devuelve una matriz de bytes que podemos pasar al
método setBytes.
/**
* Read the file and returns the byte array
* @param file
* @return the bytes of the file
*/
private byte[] readFile(String file) {
ByteArrayOutputStream bos = null;
try {
File f = new File(file);
FileInputStream fis = new FileInputStream(f);
byte[] buffer = new byte[1024];
bos = new ByteArrayOutputStream();
for (int len; (len = fis.read(buffer)) != -1;) {
bos.write(buffer, 0, len);
}
} catch (FileNotFoundException e) {
System.err.println(e.getMessage());
} catch (IOException e2) {
System.err.println(e2.getMessage());
}
return bos != null ? bos.toByteArray() : null;
}

Para conectarse a la base de datos test.db, use el método connect () de la siguiente manera:

/**
* Connect to the test.db database
*
* @return the Connection object
*/
private Connection connect() {
// SQLite connection string
String url = "jdbc:sqlite:C://sqlite/db/test.db";
Connection conn = null;
try {
conn = DriverManager.getConnection(url);
} catch (SQLException e) {
System.out.println(e.getMessage());
}
return conn;
}

El siguiente método updatePicture () actualiza una imagen especificada por el nombre del archivo
para un material en particular.

/**
* Update picture for a specific material
 *
* @param materialId
* @param filename
*/
public void updatePicture(int materialId, String filename) {
// update sql
String updateSQL = "UPDATE materials "
+ "SET picture = ? "
+ "WHERE id=?";

try (Connection conn = connect();

PreparedStatement pstmt = conn.prepareStatement(updateSQL)) {

// set parameters
pstmt.setBytes(1, readFile(filename));
pstmt.setInt(2, materialId);

pstmt.executeUpdate();
System.out.println("Stored the file in the BLOB column.");

} catch (SQLException e) {
System.out.println(e.getMessage());
}
}

Para actualizar la imagen para la Id. De material 1, usa el siguiente código:

package net.sqlitetutorial;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

/**
*
* @author sqlitetutorial.net
*/
public class BLOBApp {
private Connection connect() {
//...
}

private byte[] readFile(String file) {

 //...
}

public void updatePicture(int materialId, String filename) {

//...
}

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
BLOBApp app = new BLOBApp();
app.updatePicture(1, "c:\\temp\\HP_Laptop.jpg");
}
}
Tenga en cuenta que no repetimos el cuerpo de los métodos que ya mencionamos.
Ejecutamos el programa y revisemos la tabla de materiales nuevamente.

Funciona como se esperaba.

Consultar datos BLOB de la base de datos SQLite

Los siguientes pasos le muestran cómo consultar datos BLOB desde la base de datos SQLite:
1. Primero, prepare una declaración SELECT.
2. Luego, cree un objeto Connection conectándose a la base de datos SQLite.
3. Luego, cree una instancia de la clase PreparedStatement desde el objeto Connection. Use
el método set * del objeto PreparedStatement para suministrar valores para los parámetros.
4. Después de eso, llame al método executeQuery del objeto PreparedStatement para obtener
el objeto ResultSet.
5. Finalmente, recorra el conjunto de resultados, use el método getBinaryStream () para
obtener datos y use el objeto FileOutputStream para guardar datos en un archivo.
El siguiente método readPicture selecciona los datos BLOB de un material específico y los guarda
en un archivo.

/**
* read the picture file and insert into the material master table
*
* @param materialId
* @param filename
*/
public void readPicture(int materialId, String filename) {
// update sql
String selectSQL = "SELECT picture FROM materials WHERE id=?";
ResultSet rs = null;
FileOutputStream fos = null;
Connection conn = null;
PreparedStatement pstmt = null;
 try {
conn = connect();
pstmt = conn.prepareStatement(selectSQL);
pstmt.setInt(1, materialId);
rs = pstmt.executeQuery();

// write binary stream into file

File file = new File(filename);
fos = new FileOutputStream(file);

System.out.println("Writing BLOB to file " + file.getAbsolutePath());

while (rs.next()) {
InputStream input = rs.getBinaryStream("picture");
byte[] buffer = new byte[1024];
while (input.read(buffer) > 0) {
fos.write(buffer);
}
}
} catch (SQLException | IOException e) {
System.out.println(e.getMessage());
} finally {
try {
if (rs != null) {
rs.close();
}
if (pstmt != null) {
pstmt.close();
}

if (conn != null) {
conn.close();
}
if (fos != null) {
fos.close();
}

} catch (SQLException | IOException e) {

System.out.println(e.getMessage());
}
}
}

Por ejemplo, podemos usar el método readPicture () para obtener los datos BLOB que actualizamos
para el id. De material 1 y guardarlos en un archivo llamado archivo HP_Laptop_From_BLOB.jpg.

app.readPicture (1, "c: \\ temp \\ HP_Laptop_BLOB.jpg");

Ejecutamos el programa y verificamos la carpeta c: \\ temp:

En este tutorial, ha aprendido cómo actualizar y seleccionar datos BLOB en la base de datos SQLite
usando el controlador SQLite JDBC.