SPB Git

Repository Public

SQLiteDatabase.swift 6.7 KB 169 lines swift

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
Files main
Menu

Theme