Adiós a las bases de datos pesadas: Cómo usar SQLite nativo en Swift para persistencia local ligera

Publicado el

En el desarrollo de aplicaciones móviles para iOS, la persistencia de datos es un pilar fundamental. Durante años, Core Data ha sido la opción predeterminada de Apple, y recientemente SwiftData ha llegado para simplificar las cosas en entornos SwiftUI. Sin embargo, estas soluciones a veces se sienten como «matar una mosca a cañonazos», especialmente cuando buscas un rendimiento bruto, un consumo mínimo de memoria y un control total sobre tus consultas. Por otro lado, dependencias externas como Realm pueden engrosar el tamaño de tu binario de forma innecesaria.

¿La alternativa? SQLite nativo.

SQLite es el motor de base de datos relacional más utilizado del mundo y viene preinstalado en todos los dispositivos Apple. En este artículo, aprenderás cómo decirle adiós a las bases de datos pesadas y cómo implementar SQLite nativo en Swift para lograr una persistencia local ultra ligera y extremadamente rápida.

¿Por qué elegir SQLite nativo en lugar de Core Data o Realm?

Antes de escribir la primera línea de código, es importante entender por qué un desarrollador de iOS querría optar por SQLite nativo directamente en lugar de usar wrappers o frameworks de alto nivel:

  • Cero dependencias externas: No necesitas CocoaPods, Swift Package Manager (SPM) ni Cartage. Tu app se mantiene ligera y libre de vulnerabilidades de terceros.
  • Consumo mínimo de recursos: SQLite está escrito en C. Es increíblemente rápido, consume una fracción de la memoria RAM que requiere Core Data y arranca de forma instantánea.
  • Portabilidad absoluta: Las bases de datos de SQLite son un único archivo en disco. Si planeas compartir tu base de datos con Android, macOS o un servidor, el archivo .sqlite funcionará exactamente igual en cualquier plataforma.
  • Control total: Tienes acceso directo al lenguaje SQL. No hay sorpresas con hilos mágicos ni «congelamientos» de objetos como ocurre a veces en Realm o Core Data.

Configuración inicial: Importando SQLite3 en Swift

La mayor sorpresa para muchos desarrolladores es que no necesitas instalar nada. Apple proporciona la biblioteca de C libsqlite3 de forma nativa. Para empezar a usarla, solo necesitas importarla en tu archivo de Swift:

import Foundation
import SQLite3

Dado que SQLite es una biblioteca escrita en C, las funciones que utilizaremos tienen una sintaxis de estilo C (con punteros y gestión manual de memoria). Para facilitar el desarrollo, lo ideal es crear una clase wrapper en Swift que encapsule esta complejidad.

Creando un Gestor de Base de Datos en Swift

Vamos a diseñar una clase llamada SQLiteManager que se encargará de abrir la conexión, crear tablas y cerrar la base de datos de manera segura.

1. Conexión a la base de datos

El primer paso es definir la ubicación del archivo de la base de datos (generalmente en el directorio Documents de la app) y abrir la conexión.

class SQLiteManager {
    private var db: OpaquePointer?
    private let dbPath: String

    init(databaseName: String = "AppDatabase.sqlite") {
        let fileManager = FileManager.default
        let documentsURL = fileManager.urls(for: .documentDirectory, in: .userDomainMask).first!
        self.dbPath = documentsURL.appendingPathComponent(databaseName).path

        openDatabase()
    }

    private func openDatabase() {
        if sqlite3_open(dbPath, &db) == SQLITE_OK {
            print("Conexión exitosa a la base de datos en: \(dbPath)")
        } else {
            print("Error al abrir la base de datos.")
        }
    }

    deinit {
        sqlite3_close(db)
    }
}

2. Creando tablas

Para ejecutar sentencias de SQL como CREATE TABLE, utilizamos la función sqlite3_exec. Añadamos un método a nuestro gestor para crear una tabla de «Usuarios».

func createTable() {
    let createTableStatementString = """
    CREATE TABLE IF NOT EXISTS User(
        Id INTEGER PRIMARY KEY AUTOINCREMENT,
        Name TEXT,
        Age INTEGER
    );
    """

    var createTableStatement: OpaquePointer?

    if sqlite3_prepare_v2(db, createTableStatementString, -1, &createTableStatement, nil) == SQLITE_OK {
        if sqlite3_step(createTableStatement) == SQLITE_DONE {
            print("Tabla 'User' creada correctamente.")
        } else {
            print("No se pudo crear la tabla 'User'.")
        }
    } else {
        print("Error en la preparación de la sentencia CREATE TABLE.")
    }
    sqlite3_finalize(createTableStatement)
}

Operaciones CRUD con SQLite Nativo

Ahora que tenemos nuestra base de datos lista y nuestra tabla creada, veamos cómo realizar las operaciones básicas de persistencia: Crear, Leer, Actualizar y Borrar (CRUD).

Insertar Datos (Create)

Para insertar datos de forma segura y evitar ataques de inyección SQL, debemos usar sentencias preparadas (prepared statements) y enlazar (bind) los parámetros.

func insert(name: String, age: Int32) {
    let insertStatementString = "INSERT INTO User (Name, Age) VALUES (?, ?);"
    var insertStatement: OpaquePointer?

    if sqlite3_prepare_v2(db, insertStatementString, -1, &insertStatement, nil) == SQLITE_OK {
        // Enlazar los valores a los signos de interrogación '?'
        sqlite3_bind_text(insertStatement, 1, (name as NSString).utf8String, -1, nil)
        sqlite3_bind_int(insertStatement, 2, age)

        if sqlite3_step(insertStatement) == SQLITE_DONE {
            print("Fila insertada con éxito.")
        } else {
            print("Error al insertar la fila.")
        }
    } else {
        print("Error en la preparación de la sentencia INSERT.")
    }
    sqlite3_finalize(insertStatement)
}

Leer Datos (Read)

Para recuperar datos, ejecutamos una consulta SELECT y recorremos las filas devueltas por el puntero de SQLite.

struct User {
    let id: Int32
    let name: String
    let age: Int32
}

func readUsers() -> [User] {
    let queryStatementString = "SELECT Id, Name, Age FROM User;"
    var queryStatement: OpaquePointer?
    var users: [User] = []

    if sqlite3_prepare_v2(db, queryStatementString, -1, &queryStatement, nil) == SQLITE_OK {
        while sqlite3_step(queryStatement) == SQLITE_ROW {
            let id = sqlite3_column_int(queryStatement, 0)

            guard let queryResultCol1 = sqlite3_column_text(queryStatement, 1) else {
                continue
            }
            let name = String(cString: queryResultCol1)
            let age = sqlite3_column_int(queryStatement, 2)

            let user = User(id: id, name: name, age: age)
            users.append(user)
        }
    } else {
        print("Error en la preparación de la sentencia SELECT.")
    }
    sqlite3_finalize(queryStatement)
    return users
}

Actualizar y Eliminar (Update & Delete)

El proceso para actualizar y eliminar es muy similar al de inserción. Preparamos la sentencia, enlazamos los valores (como el ID del usuario) y ejecutamos.

func deleteUser(id: Int32) {
    let deleteStatementString = "DELETE FROM User WHERE Id = ?;"
    var deleteStatement: OpaquePointer?

    if sqlite3_prepare_v2(db, deleteStatementString, -1, &deleteStatement, nil) == SQLITE_OK {
        sqlite3_bind_int(deleteStatement, 1, id)

        if sqlite3_step(deleteStatement) == SQLITE_DONE {
            print("Usuario eliminado con éxito.")
        } else {
            print("No se pudo eliminar el usuario.")
        }
    }
    sqlite3_finalize(deleteStatement)
}

Buenas prácticas al usar SQLite nativo en Swift

Trabajar directamente con las APIs de C requiere cierta disciplina para evitar fugas de memoria (memory leaks) o corrupción de datos. Sigue estas pautas esenciales:

  1. Libera siempre los Statements: Cada vez que uses sqlite3_prepare_v2, debes llamar a sqlite3_finalize al final de la función para liberar la memoria del puntero de C.
  2. Usa transacciones para inserciones masivas: Si vas a insertar cientos de registros de una sola vez, envuélvelos en una transacción (BEGIN TRANSACTION y COMMIT). Esto reduce el tiempo de escritura en disco de minutos a milisegundos.
  3. Seguridad de hilos (Thread Safety): SQLite soporta acceso multi-hilo si se configura correctamente, pero la forma más segura en iOS es realizar todas las operaciones de lectura/escritura en una cola serial de Dispatch (DispatchQueue dedicada).

Conclusión

Optar por SQLite nativo en Swift es una decisión inteligente para proyectos donde la eficiencia, el tamaño del binario y el control de datos son prioritarios. Aunque requiere escribir un poco más de código de infraestructura que SwiftData o Realm, el resultado es una aplicación increíblemente rápida, independiente de librerías de terceros y con un consumo de batería y memoria mínimo.

Si tu aplicación móvil necesita almacenar configuraciones, caché de red o bases de datos relacionales medianas, dale una oportunidad a SQLite nativo. Te sorprenderá lo potente que puede llegar a ser el software que ya viene integrado en el sistema operativo.

Deja una respuesta