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'

或者指定具体版本

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

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数据类型的对照图

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结果代码列表详情),产生错误的语句的一个可选的引用。