iOS Swift 4.0:第三方SQLite框架 SQLite.swift 使用（一）

最近在看Swift 4.0,看到SQLite部分，回想起之前在Swift下使用SQLite很是麻烦（当然OC下也是挺麻烦的），苹果官方文档中，要使用原生的SQLite，要先导入framwork，然后建一个.h文件，还要做一次Swift与C语言的桥接（SQLite是基于C语言的），使用的时候还要写SQL语句，反正就是烦！！！
然后Swift下的SQLite.swift应运而生，我自己也用了一下，也是挺好用，所以特地在此总结一下这个框架的使用。

一、使用cocoaPods导入
不会使用cocoaPods请自行解决啦嘻嘻。在Podfile里面加上一句

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

然后 pod install 一下就好了

二、开始使用
（一）导入：在要使用SQLite的地方导入头文件，当然一般会将数据库操作封装到一个类中

import SQLite

（二）创建/连接数据库
比如在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() 

如果要在temporary创建临时磁盘备份数据库,使用如下格式，数据库会在连接关闭后自动删除

let db = try Connection(.temporary)

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

db.busyTimeout = 5

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

（三）基本表达式
下图是Swift和SQLite数据类型的对照图

类型对照图.jpeg

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

let id = Expression("id")
let email = Expression("email")
let balance = Expression("balance")
let verified = Expression("verified")

以上表达式分别表示表的字段，第一个字段名是id，类型是Int64,第二个字段名是email,类型是String...以此类推，以上创建的是不为空的，要创建可以为空的字段，如下：

let name = Expression("name")

（四）创建表
声明一个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

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

try db.run(users.insert(email <- "[email protected]", name <- "Alice"))
// INSERT INTO "users" ("email", "name") VALUES ('[email protected]', 'Alice')

try db.run(users.insert(or: .replace, email <- "[email protected]", name <- "Alice B."))
// INSERT OR REPLACE INTO "users" ("email", "name") VALUES ('[email protected]', 'Alice B.')

do {
    let rowid = try db.run(users.insert(email <- "[email protected]"))
    print("inserted id: \(rowid)")
} catch {
    print("insertion failed: \(error)")
}

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

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

do {
    try db.run(users.insert(email <- "[email protected]"))
    try db.run(users.insert(email <- "[email protected]"))
} 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结果代码列表详情），产生错误的语句的一个可选的引用。

（七）赋值方法
在SQLite.swift中，可以直接使用 '<-' 为字段赋值，由上文表达式一节可见端倪，同样，我们也可以在update,delete等语句中使用同样格式进行操作。比如，在更新语句中：

try db.run(users.update(balance-=10))

以上语句是指对表中全部数据的balance字段进行 -10 操作

（八）查询操作
在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: [email protected]
}
// 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"

（八）更新操作
使用update()方法进行更新操作：

try db.run(users.update(email <- "[email protected]"))
// UPDATE "users" SET "email" = '[email protected]'    

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

let alice = users.filter(id == 1)
try db.run(alice.update(email <- "[email protected]"))
// UPDATE "users" SET "email" = '[email protected]' WHERE ("id" = 1)

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

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

（九）删除操作
使用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)")
}

好了，今天就先到此为止吧，有点累了哈哈，还有一些内容会后续补上的。
之前我的笔记都是记在印象笔记上面的，这是我第二次写博客，如果有什么错漏的，欢迎交流指正哈~~
后续也会将印象笔记里面的发上来的，谢谢大家O(∩_∩)O~~