slick小白入门

slick 介绍

Slick（“Scala语言集成连接工具包”）是Lightbend用于Scala的功能关系映射（FRM）库，可以轻松使用关系数据库。它允许您使用存储的数据，就像使用Scala集合一样，同时让您完全控制数据库访问何时发生以及传输哪些数据。您也可以直接使用SQL。数据库操作的执行是异步完成的，这使得Slick非常适合基于Play和Akka的被动应用程序。

Slick的新功能关系映射（FRM）范例允许在Scala中完成映射，具有松散耦合，最小配置要求以及许多其他主要优势，这些优势从连接关系数据库中抽象出复杂性。

Slick没有尝试弥合对象模型和数据库模型之间的差距，而是将数据库模型引入Scala，因此开发人员不需要编写SQL代码。

Slick将数据库直接集成到Scala中，允许使用普通的Scala类和集合以与内存数据相同的方式查询和处理存储和远程数据。

Slick用于函数式编程的FRM方法的一些主要优点包括：
- 预优化效率
FRM是一种更有效的连接方式; 与ORM不同，它能够预先优化与数据库的通信 - 而使用FRM，您可以开箱即用。使用FRM比使用ORM更快地制作应用程序的道路要短得多。
- 没有类型安全的繁琐故障排除
FRM为构建数据库查询带来了类型安全性。开发人员的工作效率更高，因为编译器会自动发现错误，而不是在非类型化字符串中查找错误所需的典型繁琐故障排除。
- 用于构建查询的更高效，可组合的模型
FRM支持用于构建查询的可组合模型。这是一个非常自然的模型，可以将各个部分组合在一起构建查询，然后在代码库中重用各个部分。

支持的数据库

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

slick 如何通过代码生成器生成实体类

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：数据库连接密码

slick 数据库配置

1. Using Typesafe Config

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

val db = Database.forConfig("mydb")

2. Using a JDBC URL

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

3. Using a DataSource(常用)

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

4. Using a JNDI Name

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

slick 常规操作

1. SELECT *

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

people.result

2. SELECT

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

people.map(_.age).result

3. 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

4. ORDER BY

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

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

5. Aggregations

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

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

6. 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

7. 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

8. 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

9. 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

10. 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

11. 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

12. 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)

13. 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))

14. delete

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

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

15. 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 限制

1. 缺少查询运算符（Slick在某种程度上是可扩展的，这意味着您可以自己添加一些缺少的操作符）
2. 非最佳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参数，该参数从结果集中提取所请求类型的数据。GetResult标准JDBC类型有预定义的含义，对于那些（表示可为空的列）的选项和有类型的类型的元组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.<<))

使用快捷方法<<，该方法 返回在此处预期的任何类型的值。（当然，只有在这个构造函数调用中实际知道类型时才能使用它。）