Repository Public
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