Repository Public
1import Foundation2import SQLite334public enum SQLiteValue: Sendable, Equatable {5 case null6 case int(Int64)7 case real(Double)8 case text(String)9 case blob(Data)1011 public init(_ s: String?) { self = s.map { .text($0) } ?? .null }12 public init(_ i: Int?) { self = i.map { .int(Int64($0)) } ?? .null }13 public init(_ d: Double?) { self = d.map { .real($0) } ?? .null }14 public init(_ b: Bool) { self = .int(b ? 1 : 0) }15 public init(_ date: Date?) { self = date.map { .real($0.timeIntervalSince1970) } ?? .null }16}1718public struct SQLiteRow: Sendable {19 public let columns: [String: SQLiteValue]2021 public func string(_ name: String) -> String? {22 if case .text(let s) = columns[name] ?? .null { return s }23 return nil24 }25 public func int(_ name: String) -> Int? {26 switch columns[name] ?? .null {27 case .int(let i): return Int(i)28 case .real(let d): return Int(d)29 default: return nil30 }31 }32 public func double(_ name: String) -> Double? {33 switch columns[name] ?? .null {34 case .real(let d): return d35 case .int(let i): return Double(i)36 default: return nil37 }38 }39 public func bool(_ name: String) -> Bool { (int(name) ?? 0) != 0 }40 public func date(_ name: String) -> Date? { double(name).map { Date(timeIntervalSince1970: $0) } }41 public func data(_ name: String) -> Data? {42 if case .blob(let d) = columns[name] ?? .null { return d }43 return nil44 }45}4647public struct SQLiteError: Error, CustomStringConvertible, Sendable {48 public let code: Int3249 public let message: String50 public var description: String { "SQLite error \(code): \(message)" }51}5253/// Minimal, lock-protected wrapper over the system SQLite. All statements are prepared with bound54/// parameters — never string-interpolated — and the connection runs in WAL mode with foreign keys on.55public final class SQLiteDatabase: @unchecked Sendable {56 private var db: OpaquePointer?57 private let lock = NSLock()58 public let path: String5960 public init(path: String) throws {61 self.path = path62 if path != ":memory:" {63 try FileManager.default.createDirectory(at: URL(fileURLWithPath: path).deletingLastPathComponent(), withIntermediateDirectories: true)64 }65 var handle: OpaquePointer?66 let flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX67 guard sqlite3_open_v2(path, &handle, flags, nil) == SQLITE_OK, let handle else {68 let msg = handle.map { String(cString: sqlite3_errmsg($0)) } ?? "cannot open"69 throw SQLiteError(code: -1, message: msg)70 }71 db = handle72 try execute("PRAGMA journal_mode=WAL")73 try execute("PRAGMA foreign_keys=ON")74 try execute("PRAGMA busy_timeout=2000")75 }7677 deinit {78 if let db { sqlite3_close_v2(db) }79 }8081 public var userVersion: Int {82 get { (try? query("PRAGMA user_version").first?.int("user_version")) ?? 0 }83 }8485 public func setUserVersion(_ v: Int) throws {86 try execute("PRAGMA user_version=\(Int32(v))") // PRAGMA cannot be parameterised; value is an integer we control87 }8889 public func execute(_ sql: String, _ params: [SQLiteValue] = []) throws {90 try lock.withLock {91 try withStatement(sql, params) { stmt in92 let rc = sqlite3_step(stmt)93 guard rc == SQLITE_DONE || rc == SQLITE_ROW else { throw error(rc) }94 }95 }96 }9798 public func query(_ sql: String, _ params: [SQLiteValue] = []) throws -> [SQLiteRow] {99 try lock.withLock {100 var rows: [SQLiteRow] = []101 try withStatement(sql, params) { stmt in102 let count = Int(sqlite3_column_count(stmt))103 let names = (0..<count).map { String(cString: sqlite3_column_name(stmt, Int32($0))) }104 while true {105 let rc = sqlite3_step(stmt)106 if rc == SQLITE_DONE { break }107 guard rc == SQLITE_ROW else { throw error(rc) }108 var columns: [String: SQLiteValue] = [:]109 for i in 0..<count {110 let col = Int32(i)111 switch sqlite3_column_type(stmt, col) {112 case SQLITE_INTEGER: columns[names[i]] = .int(sqlite3_column_int64(stmt, col))113 case SQLITE_FLOAT: columns[names[i]] = .real(sqlite3_column_double(stmt, col))114 case SQLITE_TEXT: columns[names[i]] = .text(String(cString: sqlite3_column_text(stmt, col)))115 case SQLITE_BLOB:116 let bytes = sqlite3_column_blob(stmt, col)117 let len = Int(sqlite3_column_bytes(stmt, col))118 columns[names[i]] = .blob(bytes.map { Data(bytes: $0, count: len) } ?? Data())119 default: columns[names[i]] = .null120 }121 }122 rows.append(SQLiteRow(columns: columns))123 }124 }125 return rows126 }127 }128129 /// Runs `body` inside a transaction; rolls back on throw. Re-entrant calls are not supported.130 public func transaction<T>(_ body: () throws -> T) throws -> T {131 try execute("BEGIN IMMEDIATE")132 do {133 let result = try body()134 try execute("COMMIT")135 return result136 } catch {137 try? execute("ROLLBACK")138 throw error139 }140 }141142 // MARK: - Internals143144 private func withStatement(_ sql: String, _ params: [SQLiteValue], _ body: (OpaquePointer) throws -> Void) throws {145 guard let db else { throw SQLiteError(code: -1, message: "database closed") }146 var stmt: OpaquePointer?147 guard sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK, let stmt else {148 throw SQLiteError(code: sqlite3_errcode(db), message: String(cString: sqlite3_errmsg(db)) + " in: \(sql)")149 }150 defer { sqlite3_finalize(stmt) }151 let transient = unsafeBitCast(-1, to: sqlite3_destructor_type.self)152 for (i, p) in params.enumerated() {153 let idx = Int32(i + 1)154 switch p {155 case .null: sqlite3_bind_null(stmt, idx)156 case .int(let v): sqlite3_bind_int64(stmt, idx, v)157 case .real(let v): sqlite3_bind_double(stmt, idx, v)158 case .text(let v): sqlite3_bind_text(stmt, idx, v, -1, transient)159 case .blob(let v): v.withUnsafeBytes { sqlite3_bind_blob(stmt, idx, $0.baseAddress, Int32(v.count), transient) }160 }161 }162 try body(stmt)163 }164165 private func error(_ rc: Int32) -> SQLiteError {166 SQLiteError(code: rc, message: db.map { String(cString: sqlite3_errmsg($0)) } ?? "unknown")167 }168}169