SQLite es una base de datos integrada en el lenguaje de programación PHP desde la versión 5, así como en muchos otros sistemas informáticos. Como podemos deducir de su nombre, es un motor de base de datos relacional en el que usamos SQL para poder realizar las consultas, igual que otras bases de datos populares. Además es un motor de reducidas dimensiones, que resulta bastante ligero.

Para explicar los mecanismos de trabajo con SQLite en PHP hemos dividido el contenido en estos apartados.

• Cuándo usar SQLite
• Almacenamiento de SQLite
• Abrir una conexión con SQLite en PHP
• Cerrar las conexiones con SQLite
• Ejecutar consultas de SQLite que no producen resultados
• Métodos que producen conjuntos de resultados
• Preparar consultas con SQLite y PHP
• Ejemplo completo de SQLite y PHP

Cuándo usar SQLite

SQLite es un modelo de bases de datos simplificado al máximo, que permite las operaciones básicas de SQL pero que no está pensado para aplicaciones grandes, con requisitos corrientes.

Es ideal cuando no tenemos otro sistema gestor de base de datos a mano. Por ejemplo podríamos tener un alojamiento que soporta PHP pero que no ofrece bases de datos, por lo que podríamos usar SQLite para compensar esas carencias.

También es útil cuando estamos desarrollando en local, para realizar todas las tareas de desarrollo de un sitio web sin necesidad de instalar un sistema gestor de base de datos en local.

Sin embargo, SQLite no es una base de datos que aporte seguridad, con una gestión de usuarios y permisos necesaria para proteger la información. Tampoco es una base de datos pensada para grandes volúmenes de información ni para un acceso veloz a los datos. Por tanto, podemos pesar en este motor para salir del paso en aplicaciones pequeñas, donde no necesitemos preservar la integridad de la información y donde no se vayan a almacenar datos sensibles.

Pese a todo ello SQLite es una de las bases de datos más usada y muy probablemente la que más instalaciones tenga en el mundo, no en PHP en particular sino en modo general, ya que está soportada por cantidad de sistemas, entre ellos multitud de lenguajes y sistemas operativos como Android.

Almacenamiento de SQLite

Para el almacenamiento de las bases de datos SQLite se usa el sistema de archivos del servidor. Es por ello que no se necesita instalar nada en especial: con el acceso a las carpetas y archivos del servidor, algo que nos ofrece PHP de casa, y el soporte a esta base de datos, que también viene de casa, tenemos todo lo suficiente para trabajar con una base de datos relacional.

Por tanto, para poder hacer un ejemplo de uso de SQLite simplemente necesitamos contar con un archivo donde se van a almacenar los datos. De hecho, no hace falta ni crear el archivo manualmente, puesto que, al crear una conexión con SQLite ese archivo se generará automáticamente, si es que no estaba creado anteriormente.

Abrir una conexión con SQLite en PHP

Vamos a comenzar con el código necesario para conectarnos con SQLite en PHP. Para ello creamos un objeto de la clase SQLite3, indicando al menos el parámetro con el nombre del archivo de la base de datos que queremos usar.

$bd = new SQLite3('db1.db');

La sentencia de conexión creará el archivo de la base de datos, en este caso llamado 'db1.db', si es que no estaba creado anteriormente.

La sentencia de apertura de la base de datos también permite indicarle otros datos como las constantes de configuración del comportamiento de SQLite así como una clave de encriptación si queremos guardar los datos con un grado de protección extra. Puedes consultar la documentación de PHP para ver cómo hacerlo.

Cerrar las conexiones de SQLite con PHP

Preferiblemente debemos cerrar las conexiones con SQLite en el momento en el que ya no vayamos a usarla, o al terminar el script. Para ello tenemos el método close de las conexiones:

$bd->close();

El método close no recibe ningún parámetro y devuelve un boleano que será true si ha ido todo bien y false en caso de error.

Ejecutar consultas de SQLite que no producen resultados

Una vez tenemos una base de datos abierta, existe un método de la clase SQLite3 que permite ejecutar sentencias SQL que no producen conjuntos de registros, que es el método exec().

Este método sería adecuado para producir llamadas a sentencias como "CREATE TABLE", "INSERT", "UPDATE" o "DELETE".

Así podríamos crear una tabla dentro de nuestra base de datos recién conectada:

$bd->exec('CREATE TABLE cervezas (id INT unsigned auto_increment, nombre STRING, graduacion STRING, CONSTRAINT `PRIMARY` PRIMARY KEY (id))');

Ahora vamos a ver cómo realizar el insert de unas cervezas, también con el método exec():

$bd->exec("INSERT INTO cervezas (nombre, graduacion) VALUES ('Alhambra', '5.5%')");
$bd->exec("INSERT INTO cervezas (nombre, graduacion) VALUES ('Mahou Clásica ', '5.4%')");

Métodos que producen conjuntos de resultados

Para las consultas SELECT, que producen un conjunto de resultados se usa el método query(). Funciona de manera similar a exec(), solamente que devuelve un objeto de la clase SQLite3Result, que es el que nos permite, entre otras cosas, iterar por los resultados.

Este código permitiría acceder a las cervezas almacenadas en la tabla que acabamos de crear.

$result = $bd->query('SELECT * FROM cervezas');
while ($cerveza = $result->fetchArray()) {
  var_dump($cerveza);
}

Preparar consultas con SQLite y PHP

A la hora de realizar consultas con datos que han sido obtenidos desde la entrada de datos del usuario, por ejemplo datos que vienen de un formulario, es muy recomendable preparar las consultas. Esto permitirá escapar los caracteres de las consultas haciendo un software más robusto y seguro.

Vamos a suponer que los datos nos llegan por un formulario:

$nombreCerveza = $_POST['nombre']';
$graduacion = $_POST['graduacion'];

Ahora preparamos la sentencia SQL, con el método prepare(). Este método no ejecuta la sentencia SQL, sino que la prepara para luego bindear las variables.

$sentencia = $bd->prepare("INSERT INTO cervezas (nombre, graduacion) VALUES (:nombre, :graduacion)");

Observarás que las variables se colocan con ":" seguido del nombre de la variable. No hacen falta las comillas aunque sean variables de texto.

El método prepare() nos devuelve un objeto de la clase SQLite3Stmt, es decir, un "SQLite Statement". Ese objeto no contiene los resultados, ya que antes de ejecutar las sentencias debemos asignarle valores al statement. Esto lo conseguimos con el método bindValue(), como sigue:

$sentencia->bindValue(':nombre', $nombreCerveza, SQLITE3_TEXT);
$sentencia->bindValue(':graduacion', $graduacion, SQLITE3_TEXT);

Una vez que tenemos bindeadas las sentencias podemos ejecutar la consulta preparada.

$sentencia->execute();

Este método nos devuelve un objeto de la clase SQLite3Result o false en caso de fallo.

Ejemplo completo de SQLite y PHP

Veamos ahora todo el código completo de uso de una base de datos SQLite con PHP, que hemos ido explicando por partes en este artículo.

<?php
$bd = new SQLite3('db1.db');

$bd->exec('CREATE TABLE IF NOT EXISTS cervezas (id INT unsigned auto_increment, nombre STRING, graduacion STRING, CONSTRAINT `PRIMARY` PRIMARY KEY (id))');
$bd->exec("INSERT INTO cervezas (nombre, graduacion) VALUES ('Alhambra', '5.5%')");
$bd->exec("INSERT INTO cervezas (nombre, graduacion) VALUES ('Mahou Clásica ', '5.4%')");

$nombreCerveza = 'Corona';
$graduacion = '5%';
$sentencia = $bd->prepare("INSERT INTO cervezas (nombre, graduacion) VALUES (:nombre, :graduacion)");
$sentencia->bindValue(':nombre', $nombreCerveza, SQLITE3_TEXT);
$sentencia->bindValue(':graduacion', $graduacion, SQLITE3_TEXT);
$sentencia->execute();

$result = $bd->query('SELECT * FROM cervezas');
while ($cerveza = $result->fetchArray()) {
  echo '<pre>';
  var_dump($cerveza);
  echo '</pre>';
}
$bd->close();

Espero que te haya resultado de utilidad y tengas un recurso más a tu mano para trabajar con bases de datos en PHP, sin necesidad de tener ningún sistema gestor de base de datos a mano, simplemente con lo que el lenguaje nos aporta y gracias a SQLite.