slick小白入门

Slick 简介

Slick（Scala Language-Integrated Connection Kit，Scala 语言集成连接工具包）是 Lightbend 面向 Scala 推出的函数式关系映射（FRM，Functional Relational Mapping）库，让你轻松使用关系数据库。它让你操作数据库里的数据就像操作 Scala 集合一样自然，同时让你完全掌控数据库访问发生的时机与传输的内容。必要时你也可以直接使用 SQL。数据库操作以异步方式执行，这让 Slick 非常契合基于 Play 与 Akka 的响应式应用。

Slick 的 FRM 范式把映射工作放在 Scala 中完成，具备松耦合、最小配置等核心优势，将关系数据库的复杂性抽象掉。

Slick 并没有试图去弥合对象模型与数据库模型之间的鸿沟，而是把数据库模型直接引入 Scala，因此开发者无需手写 SQL。

Slick 把数据库直接集成进 Scala，让你用普通的 Scala 类与集合，以处理内存数据同样的方式来查询和处理存储的、乃至远端的数据。

Slick 这种函数式 FRM 方案的主要优点包括：

预优化效率：FRM 是一种更高效的连接方式。与 ORM 不同，它能在编译期预先优化与数据库的通信，开箱即用。用 FRM 比用 ORM 更快地把应用做出来。
类型安全的免繁琐排错：FRM 为构建数据库查询带来类型安全。编译器会自动发现错误，开发者效率更高，不必再像在普通字符串里那样做繁琐的手动排查。
更高效、可组合的查询模型：FRM 支持可组合的查询模型，可以像搭积木一样把各部分组合成查询，并在代码库中复用这些片段。

支持的数据库

DB2
Derby / JavaDB
H2
HSQLDB (HyperSQL)
Microsoft SQL Server
MySQL
Oracle
PostgreSQL
SQLite

通过代码生成器生成实体类

Slick的代码生成器附带一个默认运行器，可以从命令行或Java / Scala中使用。你可以简单地执行

slick.codegen.SourceCodeGenerator.main(
  Array(profile, jdbcDriver, url, outputFolder, pkg, user, password)
)

uri：在类型安全配置中配置路径的URL和/或片段，例如 url#slick.db.default
profile：配置文件类的完全限定名称，例如 slick.jdbc.H2Profile
jdbcDriver：JDBC驱动程序类的完全限定名称，例如 org.h2.Driver
url：JDBC url，例如 jdbc:postgresql://localhost/test
outputFolder：应放置包文件夹结构的位置
pkg：Scala包生成的代码应该放在哪里
user：数据库连接用户名
password：数据库连接密码

数据库配置

Using Typesafe Config

mydb = {
  dataSourceClass = "org.postgresql.ds.PGSimpleDataSource"
  properties = {
    databaseName = "mydb"
    user = "myuser"
    password = "secret"
  }
  numThreads = 10
}

val db = Database.forConfig("mydb")

Using a JDBC URL

val db = Database.forURL("jdbc:h2:mem:test1;DB_CLOSE_DELAY=-1",
  driver="org.h2.Driver")

Using a DataSource(常用)

val db = Database.forDataSource(dataSource: javax.sql.DataSource,
  Some(size: Int))

Using a JNDI Name

val db = Database.forName(jndiName: String, Some(size: Int))

常规操作

SELECT *

sql"select * from PERSON".as[Person]

people.result

SELECT

sql"""
  select AGE
  from PERSON
""".as[(Int,String)]

people.map(_.age).result

WHERE

sql"select * from PERSON where AGE >= 18 AND NAME = 'C. Vogt'".as[Person]

people.filter(p => p.age >= 18 && p.name === "C. Vogt").result

ORDER BY

sql"select * from PERSON order by AGE asc, NAME".as[Person]

people.sortBy(p => (p.age.asc, p.name)).result

Aggregations

sql"select max(AGE) from PERSON".as[Option[Int]].head

people.map(_.age).max.result

GROUP BY

sql"""
  select ADDRESS_ID, AVG(AGE)
  from PERSON
  group by ADDRESS_ID
""".as[(Int,Option[Int])]

people.groupBy(p => p.addressId)
       .map{ case (addressId, group) => (addressId, group.map(_.age).avg) }
       .result

HAVING

sql"""
  select ADDRESS_ID
  from PERSON
  group by ADDRESS_ID
  having avg(AGE) > 50
""".as[Int]

people.groupBy(p => p.addressId)
       .map{ case (addressId, group) => (addressId, group.map(_.age).avg) }
       .filter{ case (addressId, avgAge) => avgAge > 50 }
       .map(_._1)
       .result

Implicit inner joins

sql"""
  select P.NAME, A.CITY
  from PERSON P, ADDRESS A
  where P.ADDRESS_ID = a.id
""".as[(String,String)]

people.flatMap(p =>
  addresses.filter(a => p.addressId === a.id)
           .map(a => (p.name, a.city))
).result

// or equivalent for-expression:
(for(p <- people;
     a <- addresses if p.addressId === a.id
 ) yield (p.name, a.city)
).result

Explicit inner joins

sql"""
  select P.NAME, A.CITY
  from PERSON P
  join ADDRESS A on P.ADDRESS_ID = a.id
""".as[(String,String)]

(people join addresses on (_.addressId === _.id))
  .map{ case (p, a) => (p.name, a.city) }.result

Outer joins (left/right/full)

sql"""
  select P.NAME,A.CITY
  from ADDRESS A
  left join PERSON P on P.ADDRESS_ID = a.id
""".as[(Option[String],String)]

(addresses joinLeft people on (_.id === _.addressId))
  .map{ case (a, p) => (p.map(_.name), a.city) }.result

Subquery

sql"""
  select *
  from PERSON P
  where P.ID in (select ID
                 from ADDRESS
                 where CITY = 'New York City')
""".as[Person]

val address_ids = addresses.filter(_.city === "New York City").map(_.id)
people.filter(_.id in address_ids).result // <- run as one query

insert

sqlu"""
  insert into PERSON (NAME, AGE, ADDRESS_ID) values ('M Odersky', 12345, 1)
"""

people.map(p => (p.name, p.age, p.addressId)) += ("M Odersky",12345,1)

update

sqlu"""
  update PERSON set NAME='M. Odersky', AGE=54321 where NAME='M Odersky'
"""

people.filter(_.name === "M Odersky")
       .map(p => (p.name,p.age))
       .update(("M. Odersky",54321))

delete

sqlu"""
  delete PERSON where NAME='M. Odersky'
"""

people.filter(p => p.name === "M. Odersky")
       .delete

CASE

sql"""
  select
    case
      when ADDRESS_ID = 1 then 'A'
      when ADDRESS_ID = 2 then 'B'
    end
  from PERSON P
""".as[Option[String]]

import slick.ast.ScalaBaseType.stringType
people.map(p =>
  Case
    If(p.addressId === 1) Then "A"
    If(p.addressId === 2) Then "B"
).result

Slick 的局限

缺少部分查询运算符（Slick 在一定程度上是可扩展的，你可以自行补充缺失的操作符）。
生成的 SQL 并非总是最优（某些情况下，生成的查询比手写更复杂，例如 Slick 偶尔会生成不必要的子查询；在 MySQL ≤ 5.5 中，这容易导致多余的表扫描或索引未被使用）。

Slick 纯 SQL 查询

普通 SQL 通过 sql、sqlu 与 tsql 插值器使用。sqlu 用于产生“受影响行数”而非结果集的 DML 语句，因此它们的类型是 DBIO[Int]。

注入查询的任意变量或表达式，在最终生成的查询字符串里都会变成绑定变量，而不会直接拼进字符串，因此不存在 SQL 注入的风险。

def insert(c: Coffee): DBIO[Int] =
  sqlu"insert into coffees values (${c.name}, ${c.supID}, ${c.price}, ${c.sales}, ${c.total})"

此方法生成的SQL语句始终相同：

insert into coffees values (?, ?, ?, ?, ?)

以下代码使用 sql 插值器返回语句生成的结果集。插值器本身不产生 DBIO 值，需要紧跟 .as 调用以定义行类型：

sql"""select c.name, s.name
      from coffees c, suppliers s
      where c.price < $price and s.id = c.sup_id""".as[(String, String)]

这将得到 DBIO[Seq[(String, String)]]。.as 接收一个隐式的 GetResult 参数，它负责从结果集中取出目标类型的数据。标准 JDBC 类型都有预定义的 GetResult；对于表示可空列的情况，则对应 Option 类型的 GetResult，以及元组类型的 GetResult。对于非标准类型，你需要自定义转换器：

case class Coffee(name: String, supID: Int, price: Double, sales: Int, total: Int)

implicit val getCoffeeResult = GetResult(r => Coffee(r.<<, r.<<, r.<<, r.<<, r.<<))

这里用了快捷方法 <<，它会返回在当前上下文中预期类型的取值。（当然，只有当这个构造调用里实际能推断出类型时才能使用它。）