iOS中的数据库

// 基础类型
UserDefaults.standard.set(42, forKey: "launchCount")
UserDefaults.standard.set("zh-Hans", forKey: "language")
UserDefaults.standard.set(true, forKey: "hasOnboarded")

// Codable对象
let encoder = JSONEncoder()
if let data = try? encoder.encode(userProfile) {
    UserDefaults.standard.set(data, forKey: "userProfile")
}

// 存储密码
func savePassword(_ password: String, for account: String) throws {
    let data = password.data(using: .utf8)!
    let query: [String: Any] = [
        kSecClass as String: kSecClassGenericPassword,
        kSecAttrAccount as String: account,
        kSecValueData as String: data,
        kSecAttrAccessible as String: kSecAttrAccessibleAfterFirstUnlock
    ]
    
    let status = SecItemAdd(query as CFDictionary, nil)
    if status == errSecDuplicateItem {
        let updateQuery: [String: Any] = [
            kSecClass as String: kSecClassGenericPassword,
            kSecAttrAccount as String: account
        ]
        let attributes: [String: Any] = [kSecValueData as String: data]
        SecItemUpdate(updateQuery as CFDictionary, attributes as CFDictionary)
    } else if status != errSecSuccess {
        throw KeychainError.saveFailed(status)
    }
}

import MMKV

// 初始化
MMKV.initialize(rootDir: nil)
let mmkv = MMKV.default()!

// 基础类型
mmkv.set(42, forKey: "count")
mmkv.set("hello", forKey: "greeting")
mmkv.set(true, forKey: "flag")

// 读取
let count = mmkv.int32(forKey: "count")
let greeting = mmkv.string(forKey: "greeting")

// Codable对象
if let data = try? JSONEncoder().encode(user) {
    mmkv.set(data, forKey: "user")
}

数据库文件结构:
┌──────────┐
│  Page 1  │  ← 文件头 + sqlite_master表的根页面
├──────────┤
│  Page 2  │  ← 某个表的B-Tree内部节点
├──────────┤
│  Page 3  │  ← 某个表的B-Tree叶子节点（存储实际数据行）
├──────────┤
│  Page 4  │  ← 某个索引的B-Tree节点
├──────────┤
│   ...    │
└──────────┘

查找 rowid = 42:

        [10, 30, 50]          ← 内部节点（只存键）
       /     |      \
  [1..9]  [11..29] [31..49] [51..60]  ← 叶子节点（存键+数据行）
                      ↑
                  42在这个范围，找到！

sqlite3_exec(db, "PRAGMA journal_mode=WAL;", nil, nil, nil)

import SQLite3

class SQLiteManager {
    private var db: OpaquePointer?
    
    func open(path: String) throws {
        guard sqlite3_open(path, &db) == SQLITE_OK else {
            let error = String(cString: sqlite3_errmsg(db))
            throw DatabaseError.openFailed(error)
        }
        sqlite3_exec(db, "PRAGMA journal_mode=WAL;", nil, nil, nil)
        sqlite3_exec(db, "PRAGMA foreign_keys=ON;", nil, nil, nil)
    }
    
    func createTable() throws {
        let sql = """
            CREATE TABLE IF NOT EXISTS users (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                name TEXT NOT NULL,
                email TEXT UNIQUE,
                created_at REAL DEFAULT (julianday('now'))
            );
            """
        var errMsg: UnsafeMutablePointer<CChar>?
        guard sqlite3_exec(db, sql, nil, nil, &errMsg) == SQLITE_OK else {
            let error = String(cString: errMsg!)
            sqlite3_free(errMsg)
            throw DatabaseError.executionFailed(error)
        }
    }
    
    // 使用预编译语句（Prepared Statement）防止SQL注入并提升性能
    func insertUser(name: String, email: String) throws {
        let sql = "INSERT INTO users (name, email) VALUES (?, ?);"
        var stmt: OpaquePointer?
        
        guard sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK else {
            throw DatabaseError.prepareFailed
        }
        defer { sqlite3_finalize(stmt) }
        
        sqlite3_bind_text(stmt, 1, (name as NSString).utf8String, -1, nil)
        sqlite3_bind_text(stmt, 2, (email as NSString).utf8String, -1, nil)
        
        guard sqlite3_step(stmt) == SQLITE_DONE else {
            throw DatabaseError.stepFailed
        }
    }
    
    func queryUsers() throws -> [(id: Int, name: String, email: String)] {
        let sql = "SELECT id, name, email FROM users ORDER BY id;"
        var stmt: OpaquePointer?
        
        guard sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK else {
            throw DatabaseError.prepareFailed
        }
        defer { sqlite3_finalize(stmt) }
        
        var results: [(id: Int, name: String, email: String)] = []
        while sqlite3_step(stmt) == SQLITE_ROW {
            let id = Int(sqlite3_column_int(stmt, 0))
            let name = String(cString: sqlite3_column_text(stmt, 1))
            let email = String(cString: sqlite3_column_text(stmt, 2))
            results.append((id, name, email))
        }
        return results
    }
    
    deinit {
        sqlite3_close(db)
    }
}

FMDatabaseQueue *queue = [FMDatabaseQueue databaseQueueWithPath:dbPath];

// 线程安全的写入
[queue inTransaction:^(FMDatabase *db, BOOL *rollback) {
    BOOL success = [db executeUpdate:@"INSERT INTO users (name, email) VALUES (?, ?)",
                    @"张三", @"zhangsan@example.com"];
    if (!success) {
        *rollback = YES;
        return;
    }
    
    success = [db executeUpdate:@"INSERT INTO orders (user_id, amount) VALUES (?, ?)",
               @(db.lastInsertRowId), @(99.9)];
    if (!success) {
        *rollback = YES;
    }
}];

// 线程安全的查询
[queue inDatabase:^(FMDatabase *db) {
    FMResultSet *rs = [db executeQuery:@"SELECT * FROM users WHERE name = ?", @"张三"];
    while ([rs next]) {
        NSString *name = [rs stringForColumn:@"name"];
        NSString *email = [rs stringForColumn:@"email"];
        NSLog(@"%@ - %@", name, email);
    }
    [rs close];
}];

import WCDBSwift

class User: TableCodable {
    var id: Int = 0
    var name: String = ""
    var email: String?
    var createdAt: Date = Date()
    
    enum CodingKeys: String, CodingTableKey {
        typealias Root = User
        
        case id
        case name
        case email
        case createdAt
        
        static let objectRelationalMapping = TableBinding(CodingKeys.self) {
            BindColumnConstraint(id, isPrimary: true, isAutoIncrement: true)
            BindColumnConstraint(name, isNotNull: true)
            BindIndex(email, namedWith: "idx_email", isUnique: true)
        }
    }
}

let database = Database(at: dbPath)

// 建表
try database.create(table: "users", of: User.self)

// 插入
let user = User()
user.name = "张三"
user.email = "zhangsan@example.com"
try database.insert(user, intoTable: "users")

// 查询
let users: [User] = try database.getObjects(
    fromTable: "users",
    where: User.Properties.name == "张三",
    orderBy: [User.Properties.createdAt.order(.descending)],
    limit: 10
)

// 更新
try database.update(table: "users",
                    on: User.Properties.email,
                    with: "new@example.com",
                    where: User.Properties.id == 1)

// 删除
try database.delete(fromTable: "users",
                    where: User.Properties.id == 1)

let database = Database(at: dbPath)
database.setCipher(key: "encryption_key".data(using: .utf8)!)

// 备份修复所需的元数据
database.backup()

// 数据库损坏时执行修复
database.retrieve { fraction in
    // fraction: 修复进度 (0.0 ~ 1.0)
}

class CoreDataStack {
    static let shared = CoreDataStack()
    
    lazy var persistentContainer: NSPersistentContainer = {
        let container = NSPersistentContainer(name: "DataModel")
        container.loadPersistentStores { description, error in
            if let error = error {
                fatalError("Core Data加载失败: \(error)")
            }
        }
        container.viewContext.automaticallyMergesChangesFromParent = true
        return container
    }()
    
    var viewContext: NSManagedObjectContext {
        persistentContainer.viewContext
    }
    
    func newBackgroundContext() -> NSManagedObjectContext {
        persistentContainer.newBackgroundContext()
    }
}

// 后台写入
let context = CoreDataStack.shared.newBackgroundContext()
context.perform {
    let user = NSEntityDescription.insertNewObject(forEntityName: "User", into: context) as! UserEntity
    user.name = "张三"
    user.email = "zhangsan@example.com"
    
    do {
        try context.save()
    } catch {
        context.rollback()
    }
}

// 主线程读取（UI绑定）
let fetchRequest: NSFetchRequest<UserEntity> = UserEntity.fetchRequest()
fetchRequest.predicate = NSPredicate(format: "name CONTAINS[cd] %@", "张")
fetchRequest.sortDescriptors = [NSSortDescriptor(key: "createdAt", ascending: false)]
fetchRequest.fetchBatchSize = 20

let results = try CoreDataStack.shared.viewContext.fetch(fetchRequest)

let users = try context.fetch(fetchRequest)
// users中的对象此时可能是fault状态
// 访问 users[0].name 时才触发实际的数据加载

// 批量删除
let deleteRequest = NSBatchDeleteRequest(fetchRequest: UserEntity.fetchRequest())
deleteRequest.resultType = .resultTypeObjectIDs
let result = try context.execute(deleteRequest) as? NSBatchDeleteResult
let objectIDs = result?.result as? [NSManagedObjectID] ?? []
NSManagedObjectContext.mergeChanges(
    fromRemoteContextSave: [NSDeletedObjectsKey: objectIDs],
    into: [context]
)

// 批量更新
let updateRequest = NSBatchUpdateRequest(entityName: "User")
updateRequest.predicate = NSPredicate(format: "isActive == NO")
updateRequest.propertiesToUpdate = ["isArchived": true]
try context.execute(updateRequest)

let controller = NSFetchedResultsController(
    fetchRequest: fetchRequest,
    managedObjectContext: viewContext,
    sectionNameKeyPath: nil,
    cacheName: "users"
)
controller.delegate = self
try controller.performFetch()

let description = NSPersistentStoreDescription()
description.shouldMigrateStoreAutomatically = true
description.shouldInferMappingModelAutomatically = true
container.persistentStoreDescriptions = [description]

import SwiftData

@Model
class User {
    var name: String
    @Attribute(.unique) var email: String
    var createdAt: Date
    
    @Relationship(deleteRule: .cascade)
    var posts: [Post] = []
    
    init(name: String, email: String) {
        self.name = name
        self.email = email
        self.createdAt = Date()
    }
}

@Model
class Post {
    var title: String
    var content: String
    var user: User?
    
    init(title: String, content: String) {
        self.title = title
        self.content = content
    }
}

// App入口配置
@main
struct MyApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
        .modelContainer(for: [User.self, Post.self])
    }
}

// SwiftUI View中使用
struct UserListView: View {
    @Environment(\.modelContext) private var context
    @Query(sort: \User.createdAt, order: .reverse) private var users: [User]
    
    var body: some View {
        List(users) { user in
            VStack(alignment: .leading) {
                Text(user.name)
                Text(user.email)
                    .foregroundStyle(.secondary)
            }
        }
    }
    
    func addUser() {
        let user = User(name: "新用户", email: "new@example.com")
        context.insert(user)
        // SwiftData自动保存，无需手动调用save()
    }
    
    func deleteUsers(at offsets: IndexSet) {
        for index in offsets {
            context.delete(users[index])
        }
    }
}

// 类型安全的查询——拼写错误或类型不匹配会在编译期报错
let predicate = #Predicate<User> { user in
    user.name.contains("张") && user.createdAt > someDate
}

let descriptor = FetchDescriptor<User>(
    predicate: predicate,
    sortBy: [SortDescriptor(\.createdAt, order: .reverse)]
)
descriptor.fetchLimit = 20

let users = try context.fetch(descriptor)

// NSPredicate——字符串拼接，运行时才能发现错误
let predicate = NSPredicate(format: "name CONTAINS[cd] %@ AND createdAt > %@", "张", someDate as NSDate)

import RealmSwift

class Dog: Object {
    @Persisted(primaryKey: true) var id: ObjectId
    @Persisted var name: String = ""
    @Persisted var age: Int = 0
    @Persisted var owner: User?
}

class User: Object {
    @Persisted(primaryKey: true) var id: ObjectId
    @Persisted var name: String = ""
    @Persisted var dogs: List<Dog>
}

// 写入
let realm = try! Realm()
try! realm.write {
    let user = User()
    user.name = "张三"
    
    let dog = Dog()
    dog.name = "旺财"
    dog.age = 3
    dog.owner = user
    user.dogs.append(dog)
    
    realm.add(user)
}

// 查询——惰性求值，不会立即加载所有结果
let puppies = realm.objects(Dog.self)
    .where { $0.age < 2 }
    .sorted(byKeyPath: "name")

// 实时通知
let token = puppies.observe { changes in
    switch changes {
    case .initial(let results):
        // 初始数据加载完成
        print("当前有\(results.count)只小狗")
    case .update(let results, let deletions, let insertions, let modifications):
        // 数据发生变化
        print("新增: \(insertions), 删除: \(deletions), 修改: \(modifications)")
    case .error(let error):
        print("观察错误: \(error)")
    }
}

// 在后台线程操作
DispatchQueue.global().async {
    autoreleasepool {
        let realm = try! Realm()
        
        try! realm.write {
            let user = User()
            user.name = "后台创建的用户"
            realm.add(user)
        }
    }
}

let user = realm.objects(User.self).first!
let reference = ThreadSafeReference(to: user)

DispatchQueue.global().async {
    let realm = try! Realm()
    guard let user = realm.resolve(reference) else { return }
    try! realm.write {
        user.name = "更新后的名字"
    }
}

let frozenUser = user.freeze()
DispatchQueue.global().async {
    print(frozenUser.name)  // 安全访问
}

表数据（按rowid顺序存储）:
rowid=1: {name:"张三", age:25, city:"北京"}
rowid=2: {name:"李四", age:30, city:"上海"}
rowid=3: {name:"王五", age:22, city:"北京"}
rowid=4: {name:"赵六", age:28, city:"广州"}
rowid=5: {name:"钱七", age:35, city:"深圳"}
rowid=6: {name:"孙八", age:22, city:"杭州"}
rowid=7: {name:"周九", age:31, city:"成都"}
rowid=8: {name:"吴十", age:28, city:"武汉"}

CREATE INDEX idx_city_age ON users(city, age);

("北京", 25) → rowid=1
("北京", 25) → rowid=3
("广州", 28) → rowid=4
("上海", 30) → rowid=2