Lộ trình học Lập trình viên iOS 2025: Bắt Đầu Với SQLite

SQLite trên iOS 2026 vẫn đáng học, nhưng không còn là câu trả lời mặc định cho mọi bài toán lưu trữ. Đây là lớp thấp, cho bạn quyền kiểm soát schema, SQL, index và transaction; đổi lại, bạn phải tự chịu trách nhiệm về migration, mapping và concurrency. Với Swift 6.4 và Xcode 27.2, hãy xem SQLite là công cụ legacy/lower-level có chủ đích, không phải bản thay thế tự động cho SwiftData hay Core Data.

Cập nhật 2026

  • Ví dụ trong bài dùng Swift 6.4 và Xcode 27.2; strict concurrency khiến ranh giới truy cập database cần được thiết kế rõ ràng.
  • SwiftData (iOS 17+) là lựa chọn hiện đại cho nhiều model SwiftUI; Core Data vẫn phù hợp với object graph, caching và migration có cấu trúc.
  • SQLite vẫn được tích hợp ở tầng hệ thống, nhưng API C thô không tự giải quyết thread safety, mapping hay migration. GRDB và SQLite.swift là các wrapper Swift đáng cân nhắc; không cần khóa mình vào một wrapper nếu dự án chỉ có vài truy vấn.

SQLite nằm ở đâu trong lộ trình lưu trữ iOS?

SQLite là cơ sở dữ liệu quan hệ serverless: toàn bộ dữ liệu nằm trong một file, còn ứng dụng gọi các câu lệnh SQL thông qua một connection. Bên trong file có schema gồm bảng, cột, khóa, constraint và index. Query planner dùng schema và index để tìm hàng phù hợp; transaction bảo đảm một nhóm thay đổi được commit trọn vẹn hoặc rollback.

Điểm mạnh này hữu ích khi bạn cần dữ liệu offline có cấu trúc, query JOIN hoặc lọc/sắp xếp nhiều điều kiện, import dữ liệu lớn, hoặc cần giữ một schema SQL ổn định giữa nhiều phiên bản app. SQLite cũng phù hợp khi bạn tích hợp một database đã tồn tại, phải tương thích với một ứng dụng khác, hoặc cần kiểm soát chính xác query và kích thước lưu trữ.

Ngược lại, bạn không nên chọn direct SQLite chỉ vì “nhanh hơn”. Nếu app chỉ lưu vài cài đặt, UserDefaults, Core Data và Keychain đã có abstraction phù hợp. Secret, token và khóa mã hóa không nên để plaintext trong SQLite; dùng Keychain cho secret, còn database chỉ lưu dữ liệu mà app thực sự cần truy vấn.

Direct SQLite, SwiftData hay Core Data?

Hãy phân biệt database engine với data framework. Direct SQLite cho bạn hàng và cột; bạn tự bind tham số, đọc từng cột và biến thành model. Core Data quản lý object graph, context, faulting, relationship và có thể dùng SQLite làm persistent store phía dưới. SwiftData cung cấp model Swift, ModelContainer, ModelContext và query theo kiểu Swift cho các app mới, đặc biệt khi đi cùng SwiftUI.

Lựa chọn Chọn khi Cái giá phải trả
Direct SQLite Cần SQL rõ ràng, schema nhỏ gọn, query kiểm soát được, tích hợp dữ liệu cũ hoặc hiệu năng có thể đo. Tự làm mapping, migration, transaction, connection và kiểm thử query.
SwiftData Model Swift mới, SwiftUI, muốn giảm boilerplate CRUD và chấp nhận abstraction của framework. Ít quyền kiểm soát SQL trực tiếp; cần hiểu model container và giới hạn phiên bản hệ điều hành.
Core Data Object graph phức tạp, relationship, undo/redo, caching hoặc codebase đã dùng Core Data. Learning curve và lifecycle của context; không nên truy cập managed object tùy ý giữa các queue.

Trong dự án hỗn hợp, có thể dùng SwiftData/Core Data cho model chính và SQLite cho cache, full-text search hoặc định dạng dữ liệu cần query đặc thù. Đừng dùng hai nguồn dữ liệu cho cùng một entity nếu chưa định nghĩa nguồn sự thật, quy tắc đồng bộ và cách xử lý xung đột.

Thiết kế schema trước khi viết CRUD

Ví dụ dưới đây là schema tối thiểu cho danh sách công việc. Khóa chính là INTEGER; cờ boolean được lưu dưới dạng 0/1. Constraint NOT NULL và CHECK ngăn dữ liệu hỏng lọt vào database. Index đặt trên cột thường xuất hiện trong WHERE, JOIN hoặc ORDER BY; index thừa làm ghi chậm và tốn dung lượng.

CREATE TABLE tasks (
    id INTEGER PRIMARY KEY,
    title TEXT NOT NULL,
    is_completed INTEGER NOT NULL DEFAULT 0 CHECK (is_completed IN (0, 1)),
    created_at TEXT NOT NULL
);

CREATE INDEX tasks_completed_created_idx
    ON tasks(is_completed, created_at DESC);

Đặt database ở thư mục phù hợp với vòng đời dữ liệu. Dữ liệu người dùng cần backup có thể nằm trong Application Support; cache có thể nằm trong Caches và chấp nhận bị hệ thống xóa. Đừng mặc định Documents cho mọi file. Nếu database chứa dữ liệu nhạy cảm, thêm lớp bảo vệ file của iOS và đánh giá yêu cầu mã hóa ở cấp ứng dụng; SQLite tự nó không biến plaintext thành secret.

Prepared statement và parameter binding

Không nối chuỗi input vào SQL. Cách sai là tạo câu lệnh như "SELECT ... WHERE title = '\(title)'"; một dấu nháy trong dữ liệu đã có thể làm query sai, còn input độc hại có thể mở đường cho SQL injection. Cách đúng là chuẩn bị statement một lần, bind giá trị vào placeholder, thực thi, đọc kết quả rồi finalize statement.

import SQLite3

func insertTask(db: OpaquePointer, title: String) throws {
    let sql = "INSERT INTO tasks (title, is_completed, created_at) VALUES (?, 0, ?);"
    var statement: OpaquePointer?
    guard sqlite3_prepare_v2(db, sql, -1, &statement, nil) == SQLITE_OK else {
        throw DatabaseError.prepare(String(cString: sqlite3_errmsg(db)))
    }
    defer { sqlite3_finalize(statement) }
    let transient = unsafeBitCast(-1, to: sqlite3_destructor_type.self)

    guard sqlite3_bind_text(statement, 1, title, -1, transient) == SQLITE_OK,
          sqlite3_bind_text(statement, 2, ISO8601DateFormatter().string(from: Date()), -1, transient) == SQLITE_OK else {
        throw DatabaseError.bind(String(cString: sqlite3_errmsg(db)))
    }
    guard sqlite3_step(statement) == SQLITE_DONE else {
        throw DatabaseError.step(String(cString: sqlite3_errmsg(db)))
    }
}

enum DatabaseError: Error {
    case prepare(String)
    case bind(String)
    case step(String)
}

Đoạn code minh họa trực tiếp libsqlite3, vì vậy cần kiểm tra module import và khai báo SQLITE_TRANSIENT phù hợp target khi đưa vào project thật. Wrapper như GRDB hoặc SQLite.swift thường làm phần pointer/error handling dễ đọc hơn, nhưng không miễn cho bạn khỏi việc bind tham số và thiết kế transaction. Tên bảng hoặc tên cột không thể bind như value; nếu cần dynamic identifier, chỉ cho phép một danh sách cố định do code kiểm soát.

Transaction, WAL và hiệu năng có thể đo

Mỗi lệnh ghi riêng lẻ đều có chi phí commit. Khi import nhiều bản ghi hoặc cập nhật nhiều bảng liên quan, hãy gom chúng vào transaction: bắt đầu, thực hiện mọi statement, commit nếu thành công; rollback nếu có lỗi. Không nuốt lỗi giữa transaction vì database có thể ở trạng thái nửa hoàn tất theo logic của ứng dụng.

PRAGMA journal_mode = WAL;

BEGIN IMMEDIATE;
-- Các INSERT/UPDATE liên quan nằm trong cùng transaction.
COMMIT;

WAL (write-ahead logging) thường cho phép reader tiếp tục đọc snapshot trong khi writer ghi log, nhưng không phải “bật lên là nhanh”. Theo dõi kích thước WAL và hiểu rằng writer vẫn có giới hạn. Chọn WAL sau khi đo workload, đồng thời kiểm tra behavior khi app bị suspend hoặc terminate.

Index chỉ giúp query đúng mẫu. Dùng EXPLAIN QUERY PLAN trong test hoặc công cụ đo để xem SQLite có dùng index không. Tránh SELECT * khi chỉ cần vài cột, phân trang bằng khóa ổn định thay vì tải toàn bộ bảng, và đặt timeout/busy handling hợp lý thay vì retry vô hạn.

Migration là một phần của sản phẩm

CREATE TABLE IF NOT EXISTS chỉ giúp lần cài mới; nó không nâng schema của người đã cài app từ phiên bản trước. Hãy lưu version trong PRAGMA user_version hoặc bảng migration riêng, rồi chạy các migration tuần tự trong transaction. Migration cần idempotent ở mức thiết kế và phải được test trên database thật của các phiên bản cũ.

Version Thay đổi Cách triển khai
1 Tạo bảng tasks CREATE TABLE và index ban đầu.
2 Thêm nhãn ưu tiên ALTER TABLE tasks ADD COLUMN priority INTEGER NOT NULL DEFAULT 0.
3 Tăng tốc màn hình chưa hoàn tất Tạo index trên (is_completed, created_at DESC), sau đó cập nhật version.

Đừng sửa migration cũ sau khi đã phát hành. Khi schema cần thay đổi khó bằng ALTER TABLE, tạo bảng mới, copy dữ liệu có mapping rõ ràng, kiểm tra row count, đổi tên trong cùng transaction rồi xóa bảng cũ ở migration tiếp theo nếu cần. Giữ một fixture database đại diện cho từng schema cũ để test nâng cấp và rollback khi migration thất bại.

Codable mapping và ranh giới repository

SQL row không tự biến thành một struct Swift. Tạo model domain ổn định, đọc từng cột và chuyển đổi kiểu ở một nơi. Với JSON từ API, Codable trong Swift xử lý decode/encode; repository chịu trách nhiệm map model đó sang cột SQLite, không để ViewController biết tên bảng.

struct Task: Codable, Sendable, Equatable {
    let id: Int64
    var title: String
    var isCompleted: Bool
    let createdAt: Date
}

func task(from statement: OpaquePointer) -> Task {
    Task(
        id: sqlite3_column_int64(statement, 0),
        title: String(cString: sqlite3_column_text(statement, 1)),
        isCompleted: sqlite3_column_int(statement, 2) != 0,
        createdAt: Date(timeIntervalSince1970: sqlite3_column_double(statement, 3))
    )
}

Trong code thật, cần xử lý cột NULL, text/blob có thể nil và định dạng ngày nhất quán. Nếu database lưu JSON blob, vẫn nên version payload và kiểm thử decode khi field được thêm hoặc đổi tên; đừng dùng blob để né một quan hệ mà bạn thường xuyên cần query.

Concurrency: actor hoặc queue, không phải một connection dùng chung

Query SQLite trên main thread sẽ làm scroll, input và animation đứng lại khi file lớn, query thiếu index hoặc migration chạy lâu. Boundary an toàn là repository bất đồng bộ: UI gọi await, còn mọi thao tác file và SQL chạy ngoài MainActor. Swift 6.4 giúp compiler phát hiện nhiều lỗi truyền dữ liệu, nhưng bạn vẫn phải chọn ownership của connection.

actor TaskStore {
    private let db: OpaquePointer

    init(path: String) throws {
        var openedDB: OpaquePointer?
        guard sqlite3_open_v2(path, &openedDB, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX, nil) == SQLITE_OK,
              let openedDB else {
            throw StoreError.open
        }
        self.db = openedDB
    }

    deinit { sqlite3_close(db) }

    func add(_ task: Task) throws {
        // Prepare, bind, step và finalize đều chạy trong actor này.
    }
}

enum StoreError: Error { case open }

Đây là ranh giới minh họa, không phải lời khuyên dùng FULLMUTEX để chữa mọi lỗi. Một connection nên có một owner rõ ràng; actor có thể serialize truy cập, còn wrapper có thể cung cấp database queue hoặc pool phù hợp. Nếu cần nhiều reader và writer, thiết kế các connection theo vai trò, bật WAL khi đã hiểu workload, và không truyền statement hoặc pointer ra ngoài boundary. Đóng connection khi store bị hủy, nhưng đừng mở/đóng file cho từng nút bấm.

Kiểm thử và các bẫy thường gặp

  • String-concatenated SQL: bind mọi value và test input có dấu nháy, Unicode, newline. Kiểm tra query vẫn trả đúng dữ liệu và không thực thi phần input như SQL.
  • Không có migration strategy: tạo database từ schema v1, nâng tuần tự lên v2/v3, rồi kiểm tra dữ liệu cũ và index. Migration lỗi phải rollback hoặc báo lỗi rõ ràng, không âm thầm xóa database.
  • Một connection dùng chung giữa actors: giữ connection trong một actor/queue hoặc dùng abstraction có quy tắc concurrency. Không đánh dấu bừa kiểu C là Sendable để né compiler.
  • Query trên main thread: đo thời gian query và chuyển work sang repository bất đồng bộ. Chỉ trả model value về UI.
  • Không có index: tạo dữ liệu đủ lớn trong performance test, xem query plan và thêm index theo truy vấn thực tế, không theo cảm tính.
  • Lưu secret/plaintext: token, mật khẩu và khóa không thuộc bảng SQLite thông thường. Dùng Keychain và hạn chế log SQL hoặc dữ liệu nhạy cảm.
  • Quên finalize hoặc đọc NULL như non-optional: dùng defer, kiểm tra mọi mã trả về và viết test cho nullability, duplicate key, busy database và lỗi disk.

Unit test nên dùng database tạm trong thư mục temporary, chạy migration từ đầu và kiểm tra CRUD, constraint, transaction rollback, binding và mapping. Xcode 27.2 hỗ trợ Swift Testing với @Test và #expect; XCTest vẫn cần cho UI test. Test integration với file SQLite thật quan trọng hơn việc chỉ mock repository, vì mock không phát hiện lỗi SQL syntax, index hay migration.

Quyết định nhanh và bước tiếp theo

Chọn direct SQLite khi schema và query là một phần quan trọng của sản phẩm, đội ngũ sẵn sàng review SQL, và bạn cần kiểm soát thấp hơn SwiftData/Core Data. Chọn SwiftData cho model Swift mới cần CRUD và tích hợp SwiftUI nhanh. Chọn Core Data khi object graph, context, relationship hoặc codebase hiện hữu là lợi thế. Với dự án legacy, có thể giữ SQLite nhưng bọc nó sau repository để đường thay thế sau này không lan vào UI.

  1. Viết schema tối thiểu, constraint và index dựa trên query thật.
  2. Chọn một owner cho connection, tạo repository async và cấm database work trên MainActor.
  3. Dùng prepared statement, parameter binding và transaction cho nhóm thay đổi.
  4. Tạo bảng migration, fixture cho schema cũ và test nâng cấp trước khi phát hành.
  5. Đo query plan, kích thước WAL, thời gian đọc/ghi và behavior khi app vào background.

Nhìn sang 2027

Trong 2027, abstraction hiện đại như SwiftData và concurrency an toàn sẽ tiếp tục giảm nhu cầu viết SQL trực tiếp cho app mới. SQLite vẫn có chỗ đứng ở lớp persistence thấp, cache, search và hệ thống cần schema kiểm soát được.

SQLite là kỹ năng nền tảng đáng giữ trong roadmap iOS, miễn là bạn dùng có chủ đích. Sau khi hoàn tất storage, hãy nối repository với networking bằng URLSession async/await, thay vì dồn mọi thứ vào một file SQL.