iOS SQLite.swift 使用

1. iOS SQLite.swift 简介

• 之前使用SQLite苹果官方框架的痛点

之前在Swift下使用SQLite很是麻烦（当然OC下也是挺麻烦的），苹果官方文档中，要使用原生的SQLite，要先导入framwork，然后建一个.h文件，还要做一次Swift与C语言的桥接（SQLite是基于C语言的），使用的时候还要写SQL语句，反正就是很麻烦，需要写很多胶水代码。

• Swift下的SQLite.swift就是为了解决上面痛点而产生的。不过只支持swift4.0以上版本。

2. iOS SQLite.swift 安装

• 这里只介绍pod安装：

pod 'SQLite.swift', '~> 0.11.4'

3. iOS SQLite.swift 使用

3.1 导入

• 在要使用SQLite的地方导入头文件，当然一般会将数据库操作封装到一个类中import SQLite

3.2 创建/连接数据库

• 比如在iOS下，要在Document文件夹下创建一个名为db.sqlite3的数据库，并且要连接数据库。

//获取doc路径
let path = NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true).first!
//如果不存在的话，创建一个名为db.sqlite3的数据库，并且连接数据库
let db = try Connection("\(path)/db.sqlite3")

• 如果你把一个数据库应用程序（例如，复制数据库文件到你的Xcode项目并将其添加到你的应用程序的target），你可以建立一个只读连接。

let path = Bundle.main.pathForResource("db", ofType: "sqlite3")
let db = try Connection(path, readonly: true)

• 如果省略路径，sqlite.swift将提供一个内存数据库。

//创建一个内存数据库
let db = try Connection() 

• 有时候多个数据库连接使用同一个数据库的时候，可能会出现线程安全的问题，这时候访问数据库可能会出错，这时候就有类似于网络访问超时的机制，如果为单个数据库维护多个连接，可以设置超时时间（以秒为单位）以及繁忙处理程序。

db.busyTimeout = 5

db.busyHandler({ tries in
    if tries >= 3 {
        return false
    }
    return true
})

3.3 Expression基本表达式

• Swift和SQLite数据类型的对照图

• 表达式是与类型（内置或自定义）、原始SQL和（可选）值绑定到该SQL的通用结构。通常，您只需显式地创建表达式来描述列，通常每列只有一次。

let id = Expression<Int64>("id")
let email = Expression<String>("email")
let balance = Expression<Double>("balance")
let verified = Expression<Bool>("verified")

• 以上表达式分别表示表的字段，第一个字段名是id，类型是Int64,第二个字段名是email,类型是String…以此类推，以上创建的是不为空的，要创建可以为空的字段，可以这样创建：let name = Expression<String?>("name")

3.4 创建表

• 声明一个Table常量

let users = Table("users")

• 使用上文表达式创建的字段，如果表不存在，就创建表

try db.run(users.create(ifNotExists: true) { t in     // CREATE TABLE "users" (
    t.column(id, primaryKey: true) //     "id" INTEGER PRIMARY KEY NOT NULL,
    t.column(email, unique: true)  //     "email" TEXT UNIQUE NOT NULL,
    t.column(name)                 //     "name" TEXT
}) 

• 我们也可以对字段进行约束。设置字段为主键/自增/唯一/检查/设置默认值/校对/设置外键等等

t.column(id, primaryKey: true)
// "id" INTEGER PRIMARY KEY NOT NULL

t.column(id, primaryKey: .autoincrement)
// "id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL

t.column(email, unique: true)
// "email" TEXT UNIQUE NOT NULL

t.column(email, check: email.like("%@%"))
// "email" TEXT NOT NULL CHECK ("email" LIKE '%@%')

t.column(name, defaultValue: "Anonymous")
// "name" TEXT DEFAULT 'Anonymous'

t.column(email, collate: .nocase)
// "email" TEXT NOT NULL COLLATE "NOCASE"
t.column(name, collate: .rtrim)
// "name" TEXT COLLATE "RTRIM"

t.column(user_id, references: users, id)
// "user_id" INTEGER REFERENCES "users" ("id")

• 表之间的约束

//不像上面的字段约束，它支持所有的数据库类型，升序和降序命令，和复合（多字段）键。
 t.primaryKey(email.asc, name)
// PRIMARY KEY("email" ASC, "name")

//不像上面的字段约束，它支持复合（多字段）键。
t.unique(local, domain)
// UNIQUE("local", "domain")

t.check(balance >= 0)
// CHECK ("balance" >= 0.0)

//可以使用过滤器运算符和函数轻松地构造布尔表达式。
t.check(balance >= 0)
// CHECK ("balance" >= 0.0)

//和上面的引用约束不同的是，它支持SQLite的全部类型，比如更新、删除操作以及复合（多字段）键。
t.foreignKey(user_id, references: users, id, delete: .setNull)
// FOREIGN KEY("user_id") REFERENCES "users"("id") ON DELETE SET NULL

3.5 增，删，改，查

3.5.1 插入操作（增）

• 通过insert()方法进行插入操作，操作成功会返回一个类型为Int64的ROWID

try db.run(users.insert(email <- "alice@mac.com", name <- "Alice"))
// INSERT INTO "users" ("email", "name") VALUES ('alice@mac.com', 'Alice')

try db.run(users.insert(or: .replace, email <- "alice@mac.com", name <- "Alice B."))
// INSERT OR REPLACE INTO "users" ("email", "name") VALUES ('alice@mac.com', 'Alice B.')

do {
    let rowid = try db.run(users.insert(email <- "alice@mac.com"))
    print("inserted id: \(rowid)")
} catch {
    print("insertion failed: \(error)")
}

• 如果insert()方法没有任何参数，全部字段都会以默认值录入数据库表，字段没有默认值的，会报错。

3.5.2 删除操作（删）

• 使用delete()方法进行删除操作：

try db.run(users.delete())
// DELETE FROM "users"

• 可以先使用filter()方法进行过滤操作，指定范围进行删除操作

let alice = users.filter(id == 1)
try db.run(alice.delete())
// DELETE FROM "users" WHERE ("id" = 1)    

• 删除操作会返回被删除数据的行号

do {
    if try db.run(alice.delete()) > 0 {
        print("deleted alice")
    } else {
       print("alice not found")
    }
} catch {
    print("delete failed: \(error)")
}

3.5.3 更新操作（改）

• 赋值方法:

在SQLite.swift中，可以直接使用 ‘<-’ 为字段赋值，由上文表达式一节可见端倪，同样，我们也可以在update,delete等语句中使用同样格式进行操作。比如，在更新语句中：try db.run(users.update(balance-=10)) 这条语句是指对表中全部数据的balance字段进行 -10 操作。

• 使用update()方法进行更新操作：

try db.run(users.update(email <- "alice@me.com"))
// UPDATE "users" SET "email" = 'alice@me.com'    

• 可以先使用filter()方法进行过滤操作，指定范围进行更新操作

let alice = users.filter(id == 1)
try db.run(alice.update(email <- "alice@me.com"))
// UPDATE "users" SET "email" = 'alice@me.com' WHERE ("id" = 1)

• 更新操作会返回被更新数据的行号

do {
    if try db.run(alice.update(email <- "alice@me.com")) > 0 {
        print("updated alice")
    } else {
        print("alice not found")
    }    
} catch {
    print("update failed: \(error)")
}

3.5.4 查询操作（查）

• 在SQLite.swift中，使用prepare()方法表示SELECT操作。此方法返回的是一组数据，我们可以使用forin循环从里面取出数据.

for user in try db.prepare(users) {
    print("id: \(user[id]), email: \(user[email]), name: \(user[name])")
}
// SELECT * FROM "users"

• 在一条数据中的列下标将尝试中止错误的情况下执行，如果想处理这种情况，可以使用Row.get(_ column: Expression)

for user in try db.prepare(users) {
    do {
        print("name: \(try user.get(name))")
    } catch {
        // handle
    }
}    

• 我们可以通过对数据库连接上的pluck方法的查询来获取第一行。

if let user = try db.pluck(users) { /* ... */ } // Row
// SELECT * FROM "users" LIMIT 1

• 将查询结果封装成一个数组也很简单，我们可以这样处理：

let all = Array(try db.prepare(users))
// SELECT * FROM "users"

• 上面的是指一些很简单的查询操作，实际操作中这些肯定满足不了我们的需求的，所以要用到复合查询操作。

let query = users.select(email)           // SELECT "email" FROM "users"
                 .filter(name != nil)                // WHERE "name" IS NOT NULL
                 .order(email.desc, name)   // ORDER BY "email" DESC, "name"
                 .limit(5, offset: 1)                 // LIMIT 5 OFFSET 1

• 选择指定的字段

for user in try db.prepare(users.select(id, email)) {
   print("id: \(user[id]), email: \(user[email])")
    // id: 1, email: alice@mac.com
}
// SELECT "id", "email" FROM "users"

• 数据表内联接，比如将posts表的user_id和users表的id作为连接条件，内联两个表

users.join(posts, on: user_id == users[id])
// SELECT * FROM "users" INNER JOIN "posts" ON ("user_id" = "users"."id")

• 以上是表之间的连接，有时候涉及到表内自联，这时候就要用到数据表别名alias

let managers = users.alias("managers")
let query = users.join(managers, on: managers[id] == users[managerId])
// SELECT * FROM "users"
// INNER JOIN ("users") AS "managers" ON ("managers"."id" = "users"."manager_id")

• 选择的条件：

users.filter(id == 1)
// SELECT * FROM "users" WHERE ("id" = 1)

users.filter([1, 2, 3, 4, 5].contains(id))
// SELECT * FROM "users" WHERE ("id" IN (1, 2, 3, 4, 5))

users.filter(email.like("%@mac.com"))
// SELECT * FROM "users" WHERE ("email" LIKE '%@mac.com')

users.filter(verified && name.lowercaseString == "alice")
// SELECT * FROM "users" WHERE ("verified" AND (lower("name") == 'alice'))

users.filter(verified || balance >= 10_000)
// SELECT * FROM "users" WHERE ("verified" OR ("balance" >= 10000.0))

• 排序操作（ASC：升序，DESC：降序），根据email和name字段排序

users.order(email, name)
// SELECT * FROM "users" ORDER BY "email", "name"

• email字段降序，name字段升序

users.order(email.desc, name.asc)
// SELECT * FROM "users" ORDER BY "email" DESC, "name" ASC

• 分页操作,取前面5条数据

users.limit(5)
// SELECT * FROM "users" LIMIT 5

• 分页操作, 偏移量为5，取偏移量后面5条数据

users.limit(5, offset: 5)
// SELECT * FROM "users" LIMIT 5 OFFSET 5

• 聚合操作

let count = try db.scalar(users.count)
  // SELECT count(*) FROM "users"
let count = try db.scalar(users.filter(name != nil).count)
// SELECT count(*) FROM "users" WHERE "name" IS NOT NULL
let count = try db.scalar(users.select(name.count)) // -> Int
// SELECT count("name") FROM "users"
let max = try db.scalar(users.select(id.max)) // -> Int64?
// SELECT max("id") FROM "users"
let min = try db.scalar(users.select(id.min)) // -> Int64?
// SELECT min("id") FROM "users"
let average = try db.scalar(users.select(balance.average)) // -> Double?
// SELECT avg("balance") FROM "users"
let sum = try db.scalar(users.select(balance.sum)) // -> Double?
// SELECT sum("balance") FROM "users"
let total = try db.scalar(users.select(balance.total)) // -> Double
// SELECT total("balance") FROM "users"

3.6 错误处理

• 你可以匹配上选择性地抓住SQLite的错误错误。例如，专门处理约束错误

do {
    try db.run(users.insert(email <- "alice@mac.com"))
    try db.run(users.insert(email <- "alice@mac.com"))
} catch let Result.error(message, code, statement) where code == SQLITE_CONSTRAINT {
    print("constraint failed: \(message), in \(statement)")
} catch let error {
    print("insertion failed: \(error)")
}

• Result.error类型包含描述错误的英语文本（信息），错误代码（参见SQLite结果代码列表详情），产生错误的语句的一个可选的引用。

3.7

3.8