SPB Git

Repository Public

SQLiteDatabase.swift 5.7 KB 155 lines swift

1import Foundation2import SQLite334/// A value that can be bound to, or read from, a SQLite statement.5enum SQLValue: Equatable, Sendable {6    case int(Int64)7    case double(Double)8    case text(String)9    case null1011    var string: String? { if case .text(let s) = self { return s }; return nil }12    var int: Int64? {13        switch self {14        case .int(let i): return i15        case .double(let d): return Int64(d)16        default: return nil17        }18    }19    var double: Double? {20        switch self {21        case .double(let d): return d22        case .int(let i): return Double(i)23        default: return nil24        }25    }26}2728struct SQLiteError: Error, CustomStringConvertible, Equatable {29    let code: Int3230    let message: String31    var description: String { "SQLite error \(code): \(message)" }32}3334/// Minimal thread-safe wrapper around the system SQLite library.35/// All access is serialised with a lock; statements are prepared per call, which is36/// more than fast enough for browser metadata (history, bookmarks, notes).37final class SQLiteDatabase: @unchecked Sendable {38    private var handle: OpaquePointer?39    private let lock = NSRecursiveLock()40    private static let transient = unsafeBitCast(-1, to: sqlite3_destructor_type.self)4142    /// Opens (creating if needed) the database at `path`; `nil` opens a private in-memory database.43    init(path: String?) throws {44        let flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX45        let rc = sqlite3_open_v2(path ?? ":memory:", &handle, flags, nil)46        guard rc == SQLITE_OK else {47            let message = handle.map { String(cString: sqlite3_errmsg($0)) } ?? "cannot open database"48            sqlite3_close(handle)49            handle = nil50            throw SQLiteError(code: rc, message: message)51        }52        try execute("PRAGMA journal_mode=WAL")53        try execute("PRAGMA foreign_keys=ON")54        try execute("PRAGMA synchronous=NORMAL")55    }5657    deinit { sqlite3_close(handle) }5859    @discardableResult60    func execute(_ sql: String, _ params: [SQLValue] = []) throws -> Int {61        lock.lock(); defer { lock.unlock() }62        let stmt = try prepare(sql, params)63        defer { sqlite3_finalize(stmt) }64        var rc = sqlite3_step(stmt)65        while rc == SQLITE_ROW { rc = sqlite3_step(stmt) }66        guard rc == SQLITE_DONE else { throw lastError(rc) }67        return Int(sqlite3_changes(handle))68    }6970    func query(_ sql: String, _ params: [SQLValue] = []) throws -> [[String: SQLValue]] {71        lock.lock(); defer { lock.unlock() }72        let stmt = try prepare(sql, params)73        defer { sqlite3_finalize(stmt) }74        var rows: [[String: SQLValue]] = []75        let columns = sqlite3_column_count(stmt)76        while true {77            let rc = sqlite3_step(stmt)78            if rc == SQLITE_DONE { break }79            guard rc == SQLITE_ROW else { throw lastError(rc) }80            var row: [String: SQLValue] = [:]81            for i in 0..<columns {82                let name = String(cString: sqlite3_column_name(stmt, i))83                switch sqlite3_column_type(stmt, i) {84                case SQLITE_INTEGER: row[name] = .int(sqlite3_column_int64(stmt, i))85                case SQLITE_FLOAT: row[name] = .double(sqlite3_column_double(stmt, i))86                case SQLITE_TEXT: row[name] = .text(String(cString: sqlite3_column_text(stmt, i)))87                default: row[name] = .null88                }89            }90            rows.append(row)91        }92        return rows93    }9495    /// Runs `body` inside a transaction, rolling back if it throws.96    func transaction(_ body: () throws -> Void) throws {97        lock.lock(); defer { lock.unlock() }98        try execute("BEGIN IMMEDIATE")99        do {100            try body()101            try execute("COMMIT")102        } catch {103            _ = try? execute("ROLLBACK")104            throw error105        }106    }107108    var userVersion: Int {109        (try? query("PRAGMA user_version").first?["user_version"]?.int).flatMap { $0 }.map(Int.init) ?? 0110    }111112    /// Applies the migrations whose index is >= the stored `user_version`, each in its own transaction.113    /// Migrations are append-only: never edit a shipped entry, add a new one.114    func migrate(_ migrations: [[String]]) throws {115        let current = userVersion116        guard current < migrations.count else { return }117        for index in current..<migrations.count {118            try transaction {119                for statement in migrations[index] { try execute(statement) }120                try execute("PRAGMA user_version = \(index + 1)")121            }122        }123    }124125    private func prepare(_ sql: String, _ params: [SQLValue]) throws -> OpaquePointer? {126        var stmt: OpaquePointer?127        let rc = sqlite3_prepare_v2(handle, sql, -1, &stmt, nil)128        guard rc == SQLITE_OK else { throw lastError(rc) }129        for (offset, value) in params.enumerated() {130            let index = Int32(offset + 1)131            switch value {132            case .int(let i): sqlite3_bind_int64(stmt, index, i)133            case .double(let d): sqlite3_bind_double(stmt, index, d)134            case .text(let s): sqlite3_bind_text(stmt, index, s, -1, Self.transient)135            case .null: sqlite3_bind_null(stmt, index)136            }137        }138        return stmt139    }140141    private func lastError(_ rc: Int32) -> SQLiteError {142        SQLiteError(code: rc, message: handle.map { String(cString: sqlite3_errmsg($0)) } ?? "unknown")143    }144}145146/// Escapes `%`, `_` and `\` so user text can be used literally inside a `LIKE ... ESCAPE '\'` pattern.147func sqlLikeEscape(_ text: String) -> String {148    var out = ""149    for ch in text {150        if ch == "%" || ch == "_" || ch == "\\" { out.append("\\") }151        out.append(ch)152    }153    return out154}155
Files main
Menu

Theme