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()