Slick @ Confitura 2013

Maciek Próchniak

Jak udawaćże nie mamybazy danych

Oracle view

DDD/OOP view

Uncle Bob

Repozytorium?

public interface Repository<T> {

void save(T object);

Collection<T> loadAll();

T load(Id id);

}

Repozytorium?

public interface Repository<Presentation> {

Collection<Presentation>

findByCategoryWithPopularityGreaterThan

(String name, double popularity, int limit);

...

}

Zapytania też mogą być

logiką!

Dashboard

Kolekcje - Java

Collection<Presentation> ret =

new HashSet<Presentation>();

for (Presentation presentation : presentations) {

if (presentation.getPopularity() > popularity) {

for (Author author : authors) {

if (author.getName().equals(name)

&& author.getId()

== presentation.getAuthorId() ) {

ret.add(presentation);

}

}

}

}

return ret;

Techniki

● JDBC

● i(my??)Batis

● Hibernate/JPA

● Hades

● SpringData

● jOOQ

● OneWEBSQL

Object/Relational Mapping is the Vietnam of Computer Science

- Ted Neward

ORM - OMG- Rich Hickey

SQL?

SELECT p.* from PRESENTATIONS p, AUTHORS a where p.authorId = a.id and p.popularity > :popularity and a.name = :name

SQL - kompozycja???

.Net

LINQ makes a query a first-class language construct in C# and Visual Basic.

var results = from c in Suppliers where c.size < 1 select new {c.name, c.address};

tasks

:List[Task]

convert:Task->View

tasks.map(convert) : List[View]

flatMap

tasks:List[Task]

createSubtasks:Task->List[Task]

tasks.flatMap(createSubtasks):List[Task]

Kolekcje - Scala!

presentations.flatMap(presentation =>

authors

.filter(author =>

author.id == presentation.authorId)

.filter(author => author.name == name

&& presentation.popularity > popularity)

.map(_ => presentation)

)

Kolekcje - Scala!

for {

presentation <- presentations

author <- authors

if (author.id == presentation.authorId)

if (author.name == name &&

presentation.popularity > popularity)

} yield presentation

SQL - Scala

SELECT p.* from PRESENTATIONS p

for {p <- presentations

} yield p

Filtrowanie

SELECT p.* from PRESENTATIONS pWHERE p.rank > 5

for {p <- presentationsif p.rank > 5

} yield p

Projekcja

SELECT p.name from PRESENTATIONS pWHERE p.rank > 5

for {p <- presentationsif p.rank > 5

} yield p.name

Join

SELECT p.name,a.name from PRESENTATIONS p, AUTHORS a WHERE

p.authorId = a.id

for { p <- presentations a <- authors if

(p.authorId==a.id)} yield (p.name,a.name)

InnerJoin

SELECT p.name,a.name from PRESENTATIONS p, INNER JOIN AUTHORS a ON

p.authorId = a.id

for { p <- presentations a <-

authors(p.authorId)} yield (p.name,a.name)

Order by, limit

SELECT p.* from PRESENTATIONS porder by p.namelimit 10

(for {p <- presentations

} yield p).sortBy(_.name).take(10)

Deklaratywność w Scali

tasks

.map(_.name)

.filter(_.priority > 4)

.take(3)

● Statyczne typowanie

● Deklaratywność

● Predykaty = wyrażenia Scali

● Standardowe API - (flat)Map

Logika DAO DB

findByNameOrderByTypefindByTypeGroupByCategory

...

Logika DAO DB

query

Scala

Language

Integrated

Connectivity

Kit

Play!

Akka

Slick

Scala

Typesafe

Slick

● Obsługa różnych baz

● Łatwa konfiguracja

● DML

● Ochrona przed SQL injection

● bla

● bla

● bla

zapytania ~

operacje na kolekcjachScali

SLICK - architektura

AST

H2MySQL

Lifted

Lifted - predykaty

for {

speaker <- Query(Speakers)

if (speaker.name startsWith "Maciek")

} yield (speaker.twitter)

Lifted - metadane

object Speakers extends Table[Speaker]("speakers") {

def id = column[Long]("id")

def name = column[String]("name")

def twitter = column[TwitterId]("twitterId")

def * = id ~ name ~ twitter <> (

Speaker.apply _, Speaker.unapply _)

}

Lifted - predykaty

for {


if (speaker.name startsWith "Maciek")


abstract class Query[+E, U] {

def flatMap[F, T](f: E => Query[F, T]): Query[F, T] = ...

def map[F, G, T](f: E => F)

(implicit shape: Shape[F, T, G]): Query[G, T] = ...

def filter[T](f: E => T)

(implicit wt: CanBeQueryCondition[T]): Query[E, U]

}

trait UnitInvoker[+R] extends Invoker[Unit, R] {

final def list()(implicit session: JdbcBackend#Session): List[R]

final def first()(implicit session: JdbcBackend#Session) : R

final def foreach(f: R => Unit, maxRows: Int)

(implicit session: JdbcBackend#Session): Unit

....

}

Lifted - predykaty

for {


if (speaker.name startsWith "Mac")


====!=

notNull

Lifted - predykaty

for {


if (speaker.name startsWith "Mac")


Rep[String]

Rep[TwitterId]

Rep[String]

Lifted - Join

for {

(s,p) <- Query(Speakers)

innerJoin Presentations

on (_.id === _.authorId)

} yield (s.twitter,p.abstr)

Lifted - własne typy

case class TwitterId(id:String) extends AnyVal

implicit val twitterId = MappedJdbcType.base[TwitterId,String]

(_.id,TwitterId.apply)

object Speakers extends Table[Speaker]("speakers") {

def twitter = column[TwitterId]("twitterId")

}

Lifted - kompozycja

def filter(pred

:Presentations=>Column[Boolean]) = {

for {

p <- Query(Presentations)

if (pred(p))

} yield (p.id)

}

Lifted - kompozycja

for {

presentation <- Query(Presentations)

author <- presentation.author

if author.name startsWith "Mac"

} yield presentation.title

Lifted - kompozycja

object Presentations

extends Table[Presentation] {

...

def author = foreignKey("author_fk",

authorId, Speakers)(_.id)

}

Lifted - podsumowanie

Czego brakuje lifted?

for {


if (speaker.name === "Mac")


WIP - direct

Makra

● C - syntaktyczne

● Lisp - higieniczne

● Scala 2.10 - typowane

def filter(filter:T => Boolean)

: Queryable[T] =

macro QueryableMacros.filter[T]

def filter[T:c.WeakTypeTag]

(c: scala.reflect.macros.Context)

(projection: c.Expr[T => Boolean]) : c.Expr

[scala.slick.direct.Queryable[T]] = ...

Makro - przykład

.filter(s => s.name == "Henry")

("filter", Supplier, Function( List("s"), Apply( Select("s", "name"), "==",

List(Literal(Constant("Henry"))))))

("filter", Supplier, Function( List("s"), Apply( Select("s", "name"), "==",

List(Literal(Constant("Henry"))))))

Slick Query AST


AST

H2MySQL

Lifted Direct

Direct - metadane

@table("presentation")

case class Presentation(@column("id") id:Long,

@column("authorId") authorId:Long,

@column("title") title:String,

@column("abstract")abstr:String)

Direct - przykład

val query = for {

speaker <- Queryable[Speaker]

if speaker.name == "Kuba Nabrdalik"

} yield speaker.bio

Direct - przykładval backend = new SlickBackend(profile,

AnnotationMapper)

def list[H](query:BaseQueryable[H])

: Iterable[H]

= backend.result(query, session)

dao.list(query) : List[Speaker]

Direct - typesafety :|

for {

presentation <- Queryable[Presentation]

if (presentation.title.contains("scala"))

} yield (presentation.id)

Direct - kompozycja??

def filter(pred:Presentation=>Boolean) = {

for {

p <- Queryable[Presentation]

if (pred(p))

} yield (presentation.id)

}

Slick - architektura

AST

H2MySQL

Lifted Direct

OrientDB

Slick OrientDB

@table("presentation")

case class Presentation(@column("id") id:Long,

@column("title") title:String,

@column("comments") comments:List[Comment])

case class Comment(@column("number") author:String,

@column("rate") rate:Integer,

@column("content") content:String)

Slick OrientDB

for {

presentation <- Queryable[Presentation]

if (presentation.comments

.filter(_.ratio > 5).size > 0)

} yield (presentation.title)


AST

H2MySQL

Lifted Direct

OrientDBMemory


AST

H2MySQL

Lifted

18 faz kompilacji...

OrientDBMemory

Direct

there is no valid translation of arbitrary monadic Query expressions to SQL (whose semantics are stuck half-way between applicative functors and monads)

- Stefan Zeiger

czy to się opłaca?● Deklaratywne zapytania

● Znane API

● Brak magii

● ... oprócz odrobiny makr

● Skomplikowane :(

http://slick.typesafe.com

https://github.com/slick/slick

https://github.com/mproch/slick-orientdb









Takk/Tänan/Dzięki

* we're hiring :)

Slick @ Confitura 2013

Software

Transcript of Slick @ Confitura 2013