SQLite

簡介

• 是一款輕型的資料庫
• 設計目標是嵌入式的
• 佔用資源少
• 處理速度快
• 當前版本 3.8.10.2，MAC 內建已經安裝了 SQLite

什麼是 SQLite？

• SQLite 是一個程序內的庫，本質上就是一個檔案，是一個 SQL 資料庫引擎，具有：

  • 自給自足
    • 不需要任何外部的依賴
  • 無伺服器
    • 不需要一個單獨的伺服器程序或操作的系統
  • 零配置
    • 不需要安裝或管理
    • 一個完整的 SQLite 資料庫就是一個單一的磁碟檔案
  • 輕量級
    • 完全配置時小於 400K，省略可選功能配置時小於250K
  • 事務性支援

• 而服務端使用的資料庫，如：Orcal, SQL Server, MySQL...則需要獨立的伺服器，安裝，配置，維護……

關係型資料庫的特點

• 一個 欄位(COL) 儲存一個值，類似於物件的一個屬性
• 一 行(ROW) 儲存一條記錄，類似於一個物件
• 一個 表(TABLE) 儲存一系列資料，類似於物件陣列
• 多個 表 之間存在一定 關係，類似於物件之間的關係，例如：一條微博資料中包含使用者記錄

術語

• 欄位(Field/Col)：一個欄位儲存一個值，可以儲存 INTEGER, REAL, TEXT, BLOB, NULL 五種型別的資料
  • SQLite 在儲存時，本質上並不區分準確的資料型別
• 主鍵：Primary Key，唯一標示一條記錄的欄位，具有以下特點：
  • 名字：xxx_id
  • 型別：Integer
  • 自動增長
  • 準確數值由資料庫決定，程式設計師不用關心
• 外來鍵：Foreign Key，對應其他關係表的標示，利用外來鍵 可以和另外一個表建立起"關係"
  • 方便資料維護
  • 節約儲存空間

開發資料庫的步驟

1. 建立資料庫 -> 有儲存資料的檔案
2. 建立資料表 -> 每一張資料表儲存一類資料
3. 利用 SQL 命令 實現增/刪/查/改，並在 UI 中顯示

移動應用中使用資料庫的好處

1. 將網路資料儲存在本地，不用每次都載入，減少使用者網路流量開銷
2. 對本地資料進行查詢

SQLite 命令

DDL - 資料定義語言

• 不需要記憶，可以直接從客戶端軟體複製/貼上

DML - 資料操作語言

• 需要掌握，語法固定，簡單

DQL - 資料查詢語言

• 需要掌握一些簡單的查詢指令

常用 SQL

建立表

/*
    建立資料表

    CREATE TABLE '表名' (
        '欄位名' 型別(INTEGER, REAL, TEXT, BLOB)
                NOT NULL    不允許為空
                PRIMARY KEY    主鍵
                AUTOINCREMENT 自增長,
        '欄位名2' 型別,
        ...
    )

    注意：在開發中，如果是從 Navicat 貼上的 SQL，需要自己新增一個指令
    IF NOT EXISTS 加在表名前，如果資料表已經存在，就什麼也不做
*/

CREATE TABLE IF NOT EXISTS "T_Person" (
     "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
     "name" TEXT,
     "age" INTEGER,
     "heigth" REAL
)

/* 簡單約束 */
CREATE TABLE IF NOT EXISTS t_student
(
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT,
    age INTEGER
);

CREATE TABLE IF NOT EXISTS t_student
(
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT UNIQUE,
    age INTEGER
);

/* 新增主鍵 */
CREATE TABLE IF NOT EXISTS t_student
(
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT,
    age INTEGER,
    score REAL
);

/* 新增主鍵 */
CREATE TABLE IF NOT EXISTS t_student
(
    id INTEGER,
    name TEXT,
    age INTEGER,
    score REAL,
    PRIMARY KEY(id)
);

插入

 INSERT INTO t_student
    (age, score, name)
    VALUES
    ('28', 100, 'zhangsan');

 INSERT INTO t_student
    (name, age)
    VALUES
    ('lisi', '28');

INSERT INTO t_student
    (score)
    VALUES
    (100);

修改

UPDATE t_student
    SET name = 'MM'
    WHERE age = 10;

UPDATE t_student
    SET name = 'WW'
    WHERE age is 7;

UPDATE t_student
    SET name = 'XXOO'
    WHERE age < 20;

UPDATE t_student
    SET name = 'NNMM'
    WHERE age < 50 and score > 10;

/*更新記錄的name*/
UPDATE t_student SET name = 'zhangsan';

刪除

DELETE FROM t_student;

DELETE FROM t_student WHERE age < 50;

查詢

/* 分頁 */
SELECT * FROM t_student
ORDER BY id ASC LIMIT 30, 10;

/* 排序 */
SELECT * FROM t_student
WHERE score > 50
ORDER BY age DESC;

SELECT * FROM t_student
WHERE score < 50
ORDER BY age ASC , score DESC;

/* 計量 */
SELECT COUNT(*)
FROM t_student
WHERE age > 50;

/* 別名 */
SELECT name as myName, age as myAge, score as myScore
FROM t_student;

SELECT name myName, age myAge, score myScore
FROM t_student;

SELECT s.name myName, s.age myAge, s.score myScore
FROM t_student s
WHERE s.age > 50;

/* 查詢 */
SELECT name, age, score FROM t_student;
SELECT * FROM t_student;

刪除表

/*刪除表*/
DROP TABLE IF EXISTS t_student;

SQLite核心物件

核心物件 & 核心介面

核心物件

1. database_connection

   • 由 sqlite3_open 函式建立並返回
   • 在使用其他 SQLite 介面函式之前，必須先獲得 database_connnection 物件

2. prepared_statement

   • 可以簡單的將它視為編譯後的SQL語句

核心介面

1. sqlite3_open

   • 可以開啟已經存在的資料庫檔案
   • 如果資料庫不存在，可以建立新的資料庫檔案
   • 返回的 database_connection 物件是其他 SQLite APIs 的控制代碼引數
   • 可以在多個執行緒之間共享該物件指標

2. sqlite3_prepare

   • 將 SQL 文字轉換為 prepared_statement 物件
   • 不會執行指定的 SQL 語句
   • 只是將 SQL 文字初始化為待執行的狀態

3. sqlite3_step

   • 執行一次 sqlite3_prepare 函式返回的 prepared_statement 物件
   • 執行完該函式後，prepared_statement 物件的內部指標將指向其返回結果集的第一行
   • 如果要獲得後續的資料行，則需要不斷地呼叫該函式，直到所有的資料行遍歷完畢
   • 對於 INSERT、UPDATE 和 DELETE 等 DML 語句，執行一次即可完成

4. sqlite3_column

   • 用於獲取當前行指定列的資料
   • 以下函式分別對應不同的資料型別
     • sqlite3_column_blob
     • sqlite3_column_bytes
     • sqlite3_column_bytes16
     • sqlite3_column_double
     • sqlite3_column_int
     • sqlite3_column_int64
     • sqlite3_column_text
     • sqlite3_column_text16
     • sqlite3_column_type
     • sqlite3_column_value
     • sqlite3_column_count
       • 用於獲取當前結果集中的欄位數量

5. sqlite3_finalize

   • 銷燬 prepared_statement 物件，否則會造成記憶體洩露

6. sqlite3_close

   • 關閉之前開啟的 database_connection 物件
   • 所有和該物件相關的 prepared_statements 物件都必須在此之前被銷燬

Swift 中使用 SQLite

準備工作

• 新增 libsqlite3.tbd
• 建立 SQLite-Bridge.h
  • SQLite3 框架是一套 C 語言的框架，因此需要新增橋接檔案
• 選擇 專案-TARGETS-Build Settings，搜尋 Bridg
• 在 Objective-C Bridging Header 中輸入 專案名/SQLite-Bridge.h
  • 如果之前設定過橋接檔案，可以直接使用

編譯測試

SQLiteManager

與網路介面的獨立類似，資料庫的底層操作，也應該有一個獨立的物件單獨負責

SQLiteManager 單例

• 新建 SQLiteManager.swift，並且實現以下程式碼：

/// SQLite 管理器
class SQLiteManager {

    /// 單例
    static let sharedManager = SQLiteManager()
}

資料庫訪問操作需求

1. 建立資料庫 -> 有儲存資料的檔案
2. 建立資料表 -> 每一張資料表儲存一類資料
3. 利用 SQL 命令 實現增/刪/查/改，並在 UI 中顯示

建立&開啟資料庫

/// 資料庫控制代碼
private var db: COpaquePointer = nil

/// 開啟資料庫
///
/// - parameter dbname: 資料庫檔名
func openDB(dbname: String) {
    let path = (NSSearchPathForDirectoriesInDomains(NSSearchPathDirectory.DocumentDirectory, NSSearchPathDomainMask.UserDomainMask, true).last! as NSString).stringByAppendingPathComponent(dbname)
    print(path)

    if sqlite3_open(path, &db) != SQLITE_OK {
        print("開啟資料庫失敗")
        return
    }

    print("開啟資料庫成功")
}

程式碼小結

• 建立資料庫需要給定完整的資料庫路徑
• sqlite3_open 函式會開啟資料庫，如果資料庫不存在，會新建一個空的資料庫，並且返回資料庫指標(控制代碼)
• 後續的所有資料庫操作，都基於此 資料庫控制代碼 進行

開啟資料庫

• 在 AppDelegate 中新增以下程式碼

func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {

    SQLiteManager.sharedManager.openDB("my.db")

    return true
}

程式碼小結

• SQLite 資料庫是直接儲存在沙盒中的一個檔案，只有當前應用程式可以使用
• 在移動端開發時，資料庫通常是以 持久式 連線方式使用的
• 所謂 持久式連線 指的是隻做一次 開啟資料庫 的操作，永遠不做 關閉 資料庫的操作，從而可以提高資料庫的訪問效率

建立資料表

• 如果是第一次執行，開啟資料庫之後，只能得到一個空的資料，沒有任何的資料表
• 為了讓資料庫正常使用，在第一次開啟資料庫後，需要執行 創表 操作

注意：創表操作本質上是通過執行 SQL 語句實現的

• 執行 SQL 語句函式

/// 執行 SQL
///
/// - parameter sql: SQL
///
/// - returns: 是否成功
func execSQL(sql: String) -> Bool {
    /**
        引數
        1. 資料庫控制代碼
        2. 要執行的 SQL 語句
        3. 執行完成後的回撥，通常為 nil
        4. 回撥函式第一個引數的地址，通常為 nil
        5. 錯誤資訊地址，通常為 nil
    */
    return sqlite3_exec(db, sql, nil, nil, nil) == SQLITE_OK
}

• 建立資料表

/// 建立資料表
///
/// - returns: 是否成功
private func createTable() -> Bool {
    let sql = "CREATE TABLE IF NOT EXISTS T_Person \n" +
        "('id' INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, \n" +
        "'name' TEXT, \n" +
        "'age' INTEGER);"
    print(sql)

    return execSQL(sql)
}

• 調整 openDB 函式

if createTable() {
    print("創表成功")
} else {
    print("創表失敗")
    db = nil
}

程式碼小結

• 創表 SQL 可以從 Navicat 中貼上，然後做一些處理
  • 將 " 替換成 '
  • 在每一行後面增加一個 \n 防止字串拼接因為缺少空格造成 SQL 語句錯誤
  • 在 表名 前新增 IF NOT EXISTS防止因為資料表存在出現錯誤

資料模型

• 建立 Person 模型

class Person: NSObject {

    /// id
    var id: Int = 0
    /// 姓名
    var name: String?
    /// 年齡
    var age: Int = 0

    /// 使用字典建立 Person 物件
    init(dict: [String: AnyObject]) {
        super.init()

        setValuesForKeysWithDictionary(dict)
    }
}

• 新增資料

/// 將當前物件插入到資料庫
///
/// - returns: 是否成功
func insertPerson() -> Bool {
    assert(name != nil, "姓名不能為空")

    let sql = "INSERT INTO T_Person (name, age) VALUES ('\(name!)', \(age));"

    return SQLiteManager.sharedManager.execSQL(sql)
}

• 在檢視控制器新增如下程式碼，測試新增資料

/// 測試插入資料
func demoInsert() {
    print(Person(dict: ["name": "zhangsan", "age": 18]).insertPerson())
}

• 更新記錄

/// 更新當前物件在資料庫中的記錄
///
/// - returns: 是否成功
func updatePerson() -> Bool {
    assert(name != nil, "姓名不能為空")
    assert(id > 0, "ID 不正確")

    let sql = "UPDATE T_Person SET name = '\(name!)', age = \(age) WHERE id = \(id);"

    return SQLiteManager.sharedManager.execSQL(sql)
}

• 在檢視控制器新增如下程式碼，測試更新資料

/// 測試更新記錄
func demoUpdate() {
    print(Person(dict: ["id": 1, "name": "lisi", "age": 20]).updatePerson())
}

• 刪除資料

/// 刪除當前物件在資料庫中的記錄
///
/// - returns: 是否成功
func deletePerson() -> Bool {
    assert(id > 0, "ID 不正確")

    let sql = "DELETE FROM T_Person WHERE ID = \(id);"

    return SQLiteManager.sharedManager.execSQL(sql)
}

• 在檢視控制器新增如下程式碼，測試刪除資料

/// 測試刪除記錄
func demoDelete() {
    print(Person(dict: ["id": 1, "name": "lisi", "age": 20]).deletePerson())
}

• 測試批量插入

/// 測試批量插入資料
func insertManyPerson() {
    print("開始")
    let start = CFAbsoluteTimeGetCurrent()
    for i in 0..<100000 {
        Person(dict: ["name": "lisi-\(i)", "age": Int(arc4random_uniform(10)) + 20]).insertPerson()
    }
    print(CFAbsoluteTimeGetCurrent() - start)
}

非常耗時，大概需要1分鐘左右

查詢資料

• 準備虛擬碼

/// 載入 Person 物件陣列
class func loadPersons() -> [Person]? {
    // 1. 從資料庫獲取字典陣列
    SQLiteManager.sharedManager.execRecordSet("SELECT id, name, age FROM T_Person;")

    // 2. 遍歷陣列，字典轉模型

    return nil
}

• 在 SQLiteManager 中新增查詢語句，準備結果集

/// 執行 SQL 返回結果集
///
/// - parameter sql: SQL
///
/// - returns: 字典陣列
func execRecordSet(sql: String) -> [[String: AnyObject]]? {

    // 1. 準備(預編譯) SQL
    var stmt: COpaquePointer = nil
    /**
        1. 已經開啟的資料庫控制代碼
        2. 要執行的 SQL
        3. 以位元組為單位的 SQL 最大長度，傳入 -1 會自動計算
        4. SQL 語句地址
        5. 未使用的指標地址，通常傳入 nil
    */
    if sqlite3_prepare_v2(db, sql, -1, &stmt, nil) != SQLITE_OK {
        print("準備 SQL 失敗")
        return nil
    }

    print("OK")

    // 釋放語句
    sqlite3_finalize(stmt)

    return nil
}

• 程式碼小結

  • 這一部分的工作可以看作是對字串的 SQL 語句進行編譯，並且檢查是否存在語法問題
  • 編譯成功後通過 sqlite3_step 執行 SQL，每執行一次，獲取一條記錄
  • 通過 while 迴圈直至執行完畢
  • 注意，指令執行完畢後需要釋放

• 單步執行

// 2. 單步執行獲取結果集內容
var index = 0
while sqlite3_step(stmt) == SQLITE_ROW {
    print(index++)
}

• 遍歷 stmt 中的列數以及每列的列名 & 資料型別

// 2. 單步執行獲取結果集內容
while sqlite3_step(stmt) == SQLITE_ROW {
    // 1> 結果集列數
    let colCount = sqlite3_column_count(stmt)

    // 2> 遍歷每一列
    for col in 0..<colCount {
        let cName = sqlite3_column_name(stmt, col)
        let name = String(CString: cName, encoding: NSUTF8StringEncoding)!

        print(name + "\t", appendNewline: false)
    }
    print("\n", appendNewline: false)
}

• 根據 資料型別 獲取資料

for col in 0..<colCount {
    // 1) 欄位名
    let cName = sqlite3_column_name(stmt, col)
    let name = String(CString: cName, encoding: NSUTF8StringEncoding)!

    // 2) 欄位型別
    let type = sqlite3_column_type(stmt, col)

    // 3) 根據型別獲取欄位內容
    var v: AnyObject? = nil
    switch type {
    case SQLITE_INTEGER:
        v = Int(sqlite3_column_int64(stmt, col))
    case SQLITE_FLOAT:
        v = sqlite3_column_double(stmt, col)
    case SQLITE3_TEXT:
        let cText = UnsafePointer<Int8>(sqlite3_column_text(stmt, col))
        v = String(CString: cText, encoding: NSUTF8StringEncoding)
    case SQLITE_NULL:
        v = NSNull()
    default:
        print("不支援的格式")
    }

    print(name + "\t" + String(type) + "\t \(v) \t", appendNewline: false)
}
print("\n", appendNewline: false)

• 抽取建立結果集程式碼

/// 從 stmt 獲取記錄字典
///
/// - parameter stmt: stmt
///
/// - returns: 返回記錄集字典
private func recordDict(stmt: COpaquePointer) -> [String: AnyObject] {
    // 1> 結果集列數
    let colCount = sqlite3_column_count(stmt)

    // 2> 遍歷每一列 - 建立字典
    var record = [String: AnyObject]()

    for col in 0..<colCount {
        // 1) 欄位名
        let cName = sqlite3_column_name(stmt, col)
        let name = String(CString: cName, encoding: NSUTF8StringEncoding)!

        // 2) 欄位型別
        let type = sqlite3_column_type(stmt, col)

        // 3) 根據型別獲取欄位內容
        var v: AnyObject? = nil
        switch type {
        case SQLITE_INTEGER:
            v = Int(sqlite3_column_int64(stmt, col))
        case SQLITE_FLOAT:
            v = sqlite3_column_double(stmt, col)
        case SQLITE3_TEXT:
            let cText = UnsafePointer<Int8>(sqlite3_column_text(stmt, col))
            v = String(CString: cText, encoding: NSUTF8StringEncoding)
        case SQLITE_NULL:
            v = NSNull()
        default:
            print("不支援的格式")
        }

        record[name] = v
    }

    return record
}

• 重構後的程式碼

/// 執行 SQL 返回結果集
///
/// - parameter sql: SQL
///
/// - returns: 字典陣列
func execRecordSet(sql: String) -> [[String: AnyObject]]? {

    // 1. 準備(預編譯) SQL
    var stmt: COpaquePointer = nil
    if sqlite3_prepare_v2(db, sql, -1, &stmt, nil) != SQLITE_OK {
        print("準備 SQL 失敗")
        return nil
    }

    // 2. 單步執行獲取結果集內容
    // 2.1 結果集
    var recordset = [[String: AnyObject]]()
    // 2.2 遍歷結果集
    while sqlite3_step(stmt) == SQLITE_ROW {
        recordset.append(recordDict(stmt))
    }

    // 3. 釋放語句
    sqlite3_finalize(stmt)

    return recordset
}

• 在 Person 模型中載入 Person 列表

/// 載入 Person 物件陣列
class func loadPersons() -> [Person]? {
    // 1. 從資料庫獲取字典陣列
    guard let array = SQLiteManager.sharedManager.execRecordSet("SELECT id, name, age FROM T_Person;") else {
        return nil
    }

    // 2. 遍歷陣列，字典轉模型
    var persons = [Person]()
    for dict in array {
        persons.append(Person(dict: dict))
    }

    return persons
}

批量插入

在 SQLite 中如果要批量插入資料，通常需要引入 事務的概念

事務

• 在準備做大規模資料操作前，首先開啟一個事務，儲存操作前的資料庫的狀態
• 開始資料操作
• 如果資料操作成功，提交事務，讓資料庫更新到資料操作後的狀態
• 如果資料操作失敗，回滾事務，讓資料庫還原到操作前的狀態

• 事務處理函式

///  開啟事務
func beginTransaction() -> Bool {
    return execSQL("BEGIN TRANSACTION;")
}

///  提交事務
func commitTransaction() -> Bool {
    return execSQL("COMMIT TRANSACTION;")
}

///  回滾事務
func rollBackTransaction() -> Bool {
    return execSQL("ROLLBACK TRANSACTION;")
}

• 修改插入多人記錄函式

///  插入許多人
private func insertManyPerson() {
    print("開始")
    let start = CFAbsoluteTimeGetCurrent()
    SQLiteManager.sharedSQLiteManager.beginTransaction()
    for i in 0..<100000 {
        let person = Person(dict: ["name": "lisi-" + String(i), "age": 18, "height": 1.8])
        person.insertPerson()
    }
    SQLiteManager.sharedSQLiteManager.commitTransaction()
    print("結束 " + String(CFAbsoluteTimeGetCurrent() - start))
}

測試結果不到 4s

• 測試回滾

///  插入許多人
private func insertManyPerson() {
    print("開始")
    let start = CFAbsoluteTimeGetCurrent()

    SQLiteManager.sharedSQLiteManager.beginTransaction()
    for i in 0..<100000 {
        let person = Person(dict: ["name": "lisi-" + String(i), "age": 18, "height": 1.8])
        person.insertPerson()

        if i == 10000 {
            SQLiteManager.sharedSQLiteManager.rollBackTransaction()
            break
        }
    }
    SQLiteManager.sharedSQLiteManager.commitTransaction()

    print("結束 " + String(CFAbsoluteTimeGetCurrent() - start))
}

批量更新

• 批量更新函式 - 繫結引數

func batchUpdate(sql: String, params: CVarArgType...) -> Bool {

    let cSQL = sql.cStringUsingEncoding(NSUTF8StringEncoding)!
    var stmt: COpaquePointer = nil

    if sqlite3_prepare_v2(db, cSQL, -1, &stmt, nil) == SQLITE_OK {
        // 繫結引數
        var col: Int32 = 1
        for arg in params {
            if arg is Int {
                sqlite3_bind_int64(stmt, col, sqlite3_int64(arg as! Int))
            } else if arg is Double {
                sqlite3_bind_double(stmt, col, (arg as! Double))
            } else if arg is String {
                let cStr = (arg as! String).cStringUsingEncoding(NSUTF8StringEncoding)
                sqlite3_bind_text(stmt, col, cStr!, -1, SQLITE_TRANSIENT)
            } else if arg is NSNull {
                sqlite3_bind_null(stmt, col)
            }
            col++
        }
    }

    sqlite3_finalize(stmt)

    return true
}

繫結字串

• 如果第5個引數傳遞 NULL 或者 SQLITE_STATIC 常量，SQlite 會假定這塊 buffer 是靜態記憶體，或者客戶應用程式會小心的管理和釋放這塊 buffer，所以SQlite放手不管

• 如果第5個引數傳遞的是 SQLITE_TRANSIENT 常量，則SQlite會在內部複製這塊buffer的內容。這就允許客戶應用程式在呼叫完 bind 函式之後，立刻釋放這塊 buffer（或者是一塊棧上的 buffer 在離開作用域之後自動銷燬）。SQlite會自動在合適的時機釋放它內部複製的這塊 buffer

• 由於在 SQLite.h 中 SQLITE_TRANSIENT 是以巨集的形式定義的，而在 swift 中無法直接利用巨集傳遞函式指標，因此需要使用以下程式碼轉換一下

swift 1.2

private let SQLITE_TRANSIENT = sqlite3_destructor_type(COpaquePointer(bitPattern: -1))

swift 2.0

private let SQLITE_TRANSIENT = unsafeBitCast(-1, sqlite3_destructor_type.self)

• 而繫結字串的函式必須寫成(OC中可以使用 NULL，是因為 OC 中以 @"" 定義的函式都是儲存在靜態區的)

sqlite3_bind_text(stmt, index, cStr, -1, SQLITE_TRANSIENT)

• 單步執行

var result = true
if sqlite3_step(stmt) != SQLITE_DONE {
    print("插入錯誤")
    result = false
}

// 語句復位
if sqlite3_reset(stmt) != SQLITE_OK {
    print("語句復位錯誤")
    result = false
}

sqlite3_finalize(stmt)

return result

注意：執行結束後，一定要對語句進行復位，以便後續查詢語句能夠繼續執行

函式小結

• 列數的計數從 1 開始
• 對於資料更新操作，單步執行正確的結果是 SQLITE_DONE
• 每單步執行之後，需要做一次 reset 操作

使用預編譯 SQL 批量插入資料

• 批量插入資料

///  批量插入
private func batchInsert() {
    print("開始")
    let start = CFAbsoluteTimeGetCurrent()

    let manager = SQLiteManager.sharedSQLiteManager
    let sql = "INSERT INTO T_Person (name, age, height) VALUES (?, ?, ?);"

    // 開啟事務
    manager.beginTransaction()

    for _ in 0..<10000 {

        if !manager.batchUpdate(sql, params: "zhangsan", 18, 1.8) {
            manager.rollBackTransaction()
            break
        }
    }
    manager.commitTransaction()

    print("結束 " + String(CFAbsoluteTimeGetCurrent() - start))
}

執行測試，執行結果只需要 0.1s

多執行緒

• 定義佇列

/// 操作佇列
private let queue = dispatch_queue_create("com.itheima.sqlite", DISPATCH_QUEUE_SERIAL)

• 佇列執行

///  佇列更新
///
///  :param: action 在後臺執行的任務
func queueUpdate(action: (manager: SQLiteManager) -> ()) {

    dispatch_async(queue) { [unowned self] in
        // 1. 開啟事務
        self.beginTransaction()

        action(manager: self)

        // 2. 提交事務
        self.commitTransaction()
    }
}

• 測試後臺更新

private func queueUpdate() {
    print("開始")
    let start = CFAbsoluteTimeGetCurrent()

    SQLiteManager.sharedSQLiteManager.queueUpdate { (manager) -> () in

        let sql = "INSERT INTO T_Person (name, age, height) VALUES (?, ?, ?);"

        for i in 0..<10000 {
            if !manager.batchUpdate(sql, params: "zhangsan", 18, 1.8) {
                manager.rollBackTransaction()
                break
            }

            if i == 1000 {
                manager.rollBackTransaction()
                break
            }
        }

        print(NSThread.currentThread())
        print("結束 " + String(CFAbsoluteTimeGetCurrent() - start))
    }
}

注意：SQLite 資料庫不允許同時併發寫入輸入，如果用多執行緒，也必須使用序列佇列進行操作

FMDB

使用框架

官網地址

直接拖拽

• 將 fmdb 資料夾拖入專案
• 建立橋接檔案
• 將 Swift extensions 拖入專案

Podfile

• 不推薦

use_frameworks!
pod 'FMDB', :git => 'https://github.com/robertmryan/fmdb.git'

程式碼演練

• 除了查詢都使用 executeUpdate
• 查詢使用 executeQuery

let documentsFolder = NSSearchPathForDirectoriesInDomains(.DocumentDirectory, .UserDomainMask, true)[0] as String
let path = documentsFolder.stringByAppendingPathComponent("test.sqlite")

let database = FMDatabase(path: path)

if !database.open() {
    println("Unable to open database")
    return
}

if !database.executeUpdate("create table test(x text, y text, z text)", withArgumentsInArray: nil) {
    println("create table failed: \(database.lastErrorMessage())")
}

if !database.executeUpdate("insert into test (x, y, z) values (?, ?, ?)", withArgumentsInArray: ["a", "b", "c"]) {
    println("insert 1 table failed: \(database.lastErrorMessage())")
}

if !database.executeUpdate("insert into test (x, y, z) values (?, ?, ?)", withArgumentsInArray: ["e", "f", "g"]) {
    println("insert 2 table failed: \(database.lastErrorMessage())")
}

if let rs = database.executeQuery("select x, y, z from test", withArgumentsInArray: nil) {
    while rs.next() {
        let x = rs.stringForColumn("x")
        let y = rs.stringForColumn("y")
        let z = rs.stringForColumn("z")
        println("x = \(x); y = \(y); z = \(z)")
    }
} else {
    println("select failed: \(database.lastErrorMessage())")
}

database.close()

• 佇列演練

let queue = FMDatabaseQueue(path: "/Users/liufan/Desktop/my.db")

let sql = "insert into t_person (name, age) VALUES (?, ?);"
queue.inTransaction { (db, rollBack) -> Void in
    db.executeUpdate(sql, "lisi", 28)
    db.executeUpdate(sql, "wangwu", 48)

    rollBack.memory = true
}

queue.inDatabase { (db) -> Void in
    if let result = db.executeQuery("select * from t_person") {

        while result.next() {
            let name = result.objectForColumnName("name")
            let age = result.intForColumn("age")

            print("\(name) \(age)")
        }
    }
}

要設定 rollBack 可以使用 rollBack.memory = true