Scala持久层框架Slick介绍

FRM介绍

最近看到了一个FRM的框架Slick。 FRM的意思是Functional Relational Mapping， 一种基于函数式的ORM。

举一个最简单的例子：

val queryResult = db.query(queryStr)

queryResult.onSuccess { result =>
result.doSomething ...
}

数据库db查询一条sql语句。查询成功的时候使用闭包完成处理。 看到这段代码的第一反应就是js的ajax处理，代码几乎是一样的，也发现之前在学校里写nodejs的时候查询db也是这样的语法。

var jqxhr = $.ajax( {
url: 'url',
method: 'GET',
data: [user: 'format']
});

jqxhr.success(function() {
...
});

FRM相比ORM最明显的优势就是FRM基于多线程的Future的数据查询，而ORM是单线程的线性执行。

FRM构造sql查询也是相当简单的：

// 构造查询
val newQuery = students.filter(_.age > 24).sortBy(_.name)
// 执行查询
db.run(newQuery)

FRM其他的优势可以参考官方文档。

Slick实例

下面以一个Students和Classrooms的实例来说明一下Slick的使用。

首先是创建对应的domain，学生与教室的关系是1对多。

Students domain(使用Option类型说明该列是可为空的)：

class Student(tag: Tag) extends Table[(Int, String, Int, Int, Option[Date])](tag, "Students") {

def id: Rep[Int] = column[Int]("id", O.PrimaryKey, O.AutoInc)
def name: Rep[String] = column[String]("name")
def age: Rep[Int] = column[Int]("age")
def birthDate: Rep[Option[Date]] = column[Option[Date]]("birth_date")
def classroomId = column[Int]("classroom_id")

def * : ProvenShape[(Int, String, Int, Int, Option[Date])] = (id, name, age, classroomId, birthDate)

def classroom: ForeignKeyQuery[Classroom, (Int, String)] = foreignKey("FK_CLASSROOM", classroomId, TableQuery[Classroom])(_.id)
}

Classrooms domain：

class Classroom(tag: Tag) extends Table[(Int, String)](tag, "Classrooms") {
def id = column[Int]("id", O.PrimaryKey, O.AutoInc)
def name = column[String]("name")

def * = (id, name)
}

各个db操作，schema创建，sql插入，sql查询等操作如下，加了几句备注，具体的代码就不分析了：

object SampleSlickDemo extends App {

val db = Database.forConfig("h2mem1")

try {

val classrooms = TableQuery[Classroom]
val students = TableQuery[Student]

val setupAction: DBIO[Unit] = DBIO.seq(
// create student and classroom table in database
(classrooms.schema ++ students.schema).create,
// insert some rows in classroom
classrooms += (1, "classroom1"),
classrooms += (2, "classroom2"),
classrooms += (3, "classroom2")
)

val setupFuture = db.run(setupAction)

val f = setupFuture.flatMap { _ =>

val insertAction: DBIO[Option[Int]] = students ++= Seq (
(1, "format1", 11, 1, new Date(System.currentTimeMillis())),
(2, "format2", 22, 2, new Date((System.currentTimeMillis()))),
(3, "format3", 33, 3, new Date((System.currentTimeMillis())))
)

val insertAndPrintAction = insertAction.map { studentResult =>
studentResult.foreach { numRows =>
println(s"inserted $numRows students")
}
}

db.run(insertAndPrintAction)
}.flatMap { _ =>

// print All Classrooms
db.run(classrooms.result).map { classroom =>
classroom.foreach(println);
}

// print All Students
db.run(students.result).map { studnet =>
studnet.foreach(println);
}

// condition search
val studentQuery = students.filter(_.age > 20).sortBy(_.name)
db.run(studentQuery.result).map { student =>
student.foreach(println)
}
}
Await.result(f, Duration.Inf)
} finally db.close()
}

数据库配置

在配置文件application.conf里配置数据库配置信息：

h2mem1 = {
url = "jdbc:h2:mem:test1"
driver = org.h2.Driver
connectionPool = disabled
keepAliveConnection = true
}

然后就可使用Database初始化数据库，参数就是配置文件里对应的数据库name：

val db = Database.forConfig("h2mem1")

DBIOAction介绍

DBIOAction就是数据库的一个操作，比如Insert，Update，Delete，Query等操作。

可以使用上面分析的数据库配置变量db进行操作。

db有个run方法使用DBIOAction作为参数，返回Future类型的返回值。

DBIO是一个单例对象，它的seq方法可以传入多个DBIOAction，然后返回一个新的DBIOAction。 += 方法返回的也是DBIOAction。

val setupAction: DBIO[Unit] = DBIO.seq(
(classrooms.schema ++ students.schema).create,
classrooms += (1, "classroom1"),
classrooms += (2, "classroom2"),
classrooms += (3, "classroom2")
)

++=方法跟+=方法一样会返回DBIOAction，只不过它的参数是个Iterable：

val insertAction: DBIO[Option[Int]] = students ++= Seq (
(1, "format1", 11, 1, new Date(System.currentTimeMillis())),
(2, "format2", 22, 2, new Date((System.currentTimeMillis()))),
(3, "format3", 33, 3, new Date((System.currentTimeMillis())))
)

DBIOAction提供许多好用的方法：

map方法：参数是个函数，这个函数可以返回任意类型的值，返回是个DBIOAction。 所以可以使用map关联起来多个DBIOAction。

flatMap方法：参数是个函数，这个函数的返回值必须是个DBIOAction，返回值是个DBIOAction。作用跟map类似，只不过函数参数的返回值不一样。

filter方法：参数是个函数，这个函数的返回值必须是个Boolean，返回值是个DBIOAction。过滤作用。

andThen方法：参数是个DBIOAction，返回值是个DBIOAction。在Action完成后执行另外一个Action。

增删改查操作

查询

Slick的查询可以直接通过TableQuery操作，使用TableQuery提供的filter可以实现过滤操作，使用drop和take完成分页操作，使用sortBy完成排序操作。

students.filter(_.classroomId === 1)
students.drop(1).take(2)
students.sortBy(_.age.desc)

可以使用map方法找出需要的列。

多列：

students.map { student =>
(student.name, student.age)
}

一列：

students.map(_.name)

Join方法：

cross join操作：

val crossJoin = for {
(s, c) <- students join classrooms
} yield (s.name, c.name)

inner Join操作：

val innerJoin = for {
(s, c) <- students join classrooms on (_.classroomId === _.id)
} yield (s.name, c.name)

另外一个inner join：

val innerJoin = for {
s <- students
c <- classrooms if c.id === s.classroomId
} yield (s.name, c.name)

left join操作：

val leftJoin = for {
(s, c) <- students joinLeft classrooms on (_.classroomId === _.id)
} yield (s.name, c.map(_.name))

right join操作：

val rightJoin = for {
(s, c) <- students joinRight classrooms on (_.classroomId === _.id)
} yield (s.map(_.name), c.name)

新增

所有列都有值：

val insertAction = DBIO.seq(
students += (4, "format4", 44, 3, new Date(System.currentTimeMillis())),
students += (5, "format5", 55, 3, new Date(System.currentTimeMillis())),

students ++= Seq (
(6, "format6", 66, 3, new Date(System.currentTimeMillis())),
(7, "format7", 77, 3, new Date(System.currentTimeMillis()))
)
)

部分列有值：

students.map(s => (s.name, s.age, s.classroomId)) += ("format8", 88, 3)

删除

删除classroomId为3的所有数据：

val q = students.filter(_.classroomId === 3)
val affectedRowsCountFuture = db.run(q.delete)
affectedRowsCountFuture.map { rows =>
println(rows)
}

修改

修改单列：

val q = students.filter(_.id === 2).map(_.name)
val updateSql = q.update("format2222")
db.run(updateSql)

修改多列：

val q = students.filter(_.id === 2).map(s => (s.name, s.age))
val updateSql = q.update(("format2222", 222))
db.run(updateSql)

CaseClass的使用

之前的例子都是使用Tuple构造domain。 还有一种更方便的方式，那就是使用CaseClass。

case class People(id: Long, name: String, age: Int)

例子：

private class PeopleTable(tag: Tag) extends Table[People](tag, "people") {
val id = column[Long]("id", O.PrimaryKey, O.AutoInc)
val name = column[String]("name")
val age = column[Int]("age")

def * = (id, name, age) <> ((People.apply _).tupled, People.unapply)
}

val db = Database.forConfig("h2mem1")
try {

val people = TableQuery[PeopleTable]

val setupAction = DBIO.seq(
people.schema.create,
people += People(1, "format1", 11)
)

val setupFuture = db.run(setupAction);

val f = setupFuture.flatMap { _ =>
db.run(people.result).map { p =>
p.foreach(println)
}
}

Await.result(f, Duration.Inf)

} finally db.close()