Добрый день!
Решил написать небольшой обзор с примерами на легковесный ORM для Scala — Squeryl 0.9.5
Начнем с основных достоинств данного фреймворка
1) Squeryl предоставляет DSL для SQL запросов. К примеру
def songs = from(MusicDb.songs)(s => where(s.artistId === id) select(s))
def fixArtistName = update(songs)(s =>
where(s.title === "Prodigy")
set(
s.title := "The Prodigy",
)
)
Синтаксис напоминает C# LINQ. Как вы могли заметить в запросах используются лямбда выражения, что значительно сокращает объем кода.
В данном примере метод songs возвращает объект Query[Song] который реализует интерфейс Iterable, что позволяет работать с ним как с обычной коллекцией.
Также стоит отметить, что запросы можно будет использовать в качестве подзапросов, для этого достаточно указать запрос в конструкции from вместо таблицы.
2) Простейшее описание моделей
class User(var id:Long, var username:String) extends KeyedEntity[Long]
object MySchema extends Schema{
val userTable = table[User]
}
В данном примере вы описываем модель с первичным ключом id типа Long и полем username типа String, какие-то дополнительные конфиги не требуются. После того как мы описали модель необходимо зарегистрировать ее в схеме.
По умолчанию Squeryl использует для имен таблиц имена классов и для имен полей имена свойств класса.
Для явного указания названия таблицы можно использовать:
val userTable = table[User]("USER_TABLE")
а для колонок можно использовать атрибут @Column
class User(var id:Long, @Column("USER_NAME") var username:String) extends KeyedEntity[Long]
Для составных ключей используется типы CompositeKey2[K1,K2], CompositeKey3[K1,K2,K3] и тд, в соответствии количеству полей в составном ключе.
Для того чтобы поле не сохранялось в БД достаточно пометить его аннотацией Transient.
3) Кастомные функции.
Squeryl содержит в себе необходимый минимум функций для работы с БД, этот набор можно легко дополнить.
К примеру реализуем функцию date_trunc для PostgreSQL
class DateTrunc(span: String, e: DateExpression[Timestamp], m: OutMapper[Timestamp])
extends FunctionNode[Timestamp](
"date_trunc", Some(m), Seq(new TokenExpressionNode("'" + span + "'"), e)
) with DateExpression[Timestamp]
def dateTrunc(span: String, e: DateExpression[Timestamp])(implicit m: OutMapper[Timestamp]) = new DateTrunc(span, e, m)
Более подробное описание вы можете найти на официальном сайте squeryl.org/getting-started.html
Ну что же ближе к практике
Задача
Для демонстрации работы ORM напишем небольшое приложение на Play Framework 2, которое будет предоставлять универсальный API для получения объекта, сохранения/создания объекта и удаления, по названию класса и его идентификатору
В качестве БД будем использовать PostgreSQL 9.3.
Интеграция
Добавляем в build.sbt
"org.squeryl" %% "squeryl" % "0.9.5-7",
"org.postgresql" % "postgresql" % "9.3-1101-jdbc41"
Добавим в conf/application.conf
db.default.driver = org.postgresql.Driver
db.default.url = "postgres://postgres:password@localhost/database"
db.default.logStatements = true
evolutionplugin = disabled
Создадим Global.scala в директории app
import org.squeryl.adapters.PostgreSqlAdapter
import org.squeryl.{Session, SessionFactory}
import play.api.db.DB
import play.api.mvc.WithFilters
import play.api.{Application, GlobalSettings}
object Global extends GlobalSettings {
override def onStart(app: Application) {
SessionFactory.concreteFactory = Some(() => Session.create(DB.getConnection()(app), new PostgreSqlAdapter))
}
}
Таким при запуске приложения у нас инициализируется фабрика сессий с дефолтовым соединением.
Модели
Реализуем базовый трейт для моделей, который будет содержать в себе поля id типа Long, created — время создания модели в БД, updated — время последнего изменения, (возможно я вызову холливар, но все же) поле deleted типа Boolean, которое будет являться флагом удален объект или нет, и при необходимости данный объект можно будет восстановить.
Также сразу реализуем функционал для преобразования объекта в json, для этого воспользуемся библиотекой Gson, чтобы добавить ее пропишете в build.sbt:
"com.google.code.gson" % "gson" % "2.2.4"
Конечно у Play Framework есть уже встроенные механизмы для работы с json, но на мой взгляд они имеют недостатки, поэтому мы будем комбинировать их вместе с Gson.
Для этого создадим app/models/Entity.scala
package models
import com.google.gson.Gson
import org.joda.time.DateTime
import org.squeryl.KeyedEntity
import play.api.libs.json.JsValue
trait EntityBase[K] extends KeyedEntity[K] {
def table = findTablesFor(this).head
def json(implicit gson: Gson): JsValue = play.api.libs.json.Json.parse(gson.toJson(this))
def isNew: Boolean
def save(): this.type = transaction {
if (isNew) table.insert(this)
else table.update(this)
this
}
}
trait EntityC[K] extends EntityBase[K] {
var created: TimeStamp = null
override def save(): this.type = {
if (isNew) created = DateTime.now()
super.save()
}
}
trait EntityCUD[K] extends EntityC[K] {
var updated: TimeStamp = null
var deleted = false
override def save(): this.type = {
updated = DateTime.now()
super.save()
}
def delete(): this.type = {
deleted = true
save()
}
}
class Entity extends EntityCUD[Long] {
var id = 0L
override def isNew = id == 0L
}
В данном коде реализованы несколько трейтов, которые наследуется друг от друга добавляя новую функциональность.
Основной концепт: метод save(), проверяет сохранен ли данный объект в БД или нет и в зависимости от этого вызывается у соответствующей ему таблицы вызывается метод create или update.
Для хранения времени Squeryl использует тип java.sql.Timestamp, который для меня (и многие со мной согласятся) очень не удобен в использовании. Для работы со временем я предпочитаю использовать joda.DateTime. Благо Scala предоставляет удобный механизм для неявных преобразований типов.
Создадим схему данных и набор полезных утилит, для удобства создадим package object, для этого создаем файл app/models/package.scala со следующем кодом:
import java.sql.Timestamp
import com.google.gson.Gson
import org.joda.time.DateTime
import org.squeryl.customtypes._
import org.squeryl.{Schema, Table}
import play.api.libs.json.{JsObject, JsValue, Json}
import scala.language.implicitConversions
package object models extends Schema with CustomTypesMode {
val logins = table[Login]
def getTable[E <: Entity]()(implicit manifestT: Manifest[E]): Table[E]
= tables.find(_.posoMetaData.clasz == manifestT.runtimeClass).get.asInstanceOf[Table[E]]
def getTable(name: String): Table[_ <: Entity] = tables.find(_.posoMetaData.clasz.getSimpleName.toLowerCase == name)
.get.asInstanceOf[Table[_ <: Entity]]
def get[T <: Entity](id: Long)(implicit manifestT: Manifest[T]): Option[T] = getTable[T]().lookup(id).map(e => {
if (e.deleted) None
else Some(e)
}).getOrElse(None)
def get(table: String, id: Long): Option[Entity] = getTable(table).lookup(id).map(e => {
if (e.deleted) None
else Some(e)
}).getOrElse(None)
def getAll(table: String): Seq[Entity] = from(getTable(table))(e => select(e)).toSeq
def save(table: String, json: String)(implicit gson: Gson) = gson.fromJson(
json, getTable(table).posoMetaData.clasz
).save()
def delete(table: String, id: Long) = get(table, id).map(_.delete())
class TimeStamp(t: Timestamp) extends TimestampField(t)
implicit def jodaToTimeStamp(dateTime: DateTime): TimeStamp = new TimeStamp(new Timestamp(dateTime.getMillis))
implicit def timeStampToJoda(timeStamp: TimeStamp): DateTime = new DateTime(timeStamp.value.getTime)
class Json(s: String) extends StringField(s)
implicit def stringToJson(s: String): Json = new Json(s)
implicit def jsonToString(json: Json): String = json.value
implicit def jsValueToJson(jsValue: JsValue): Json = new Json(jsValue.toString())
implicit def jsonToJsObject(json: Json): JsObject = Json.parse(json.value).asInstanceOf[JsObject]
class ForeignKey[E <: Entity](l: Long) extends LongField(l) {
private var _entity = Option.empty[E]
def entity(implicit manifestT: Manifest[E]): E = _entity.getOrElse({
val res = get[E](value).get
_entity = Some(res)
res
})
def entity_=(value: E) {
_entity = Some(value)
}
}
implicit def entityToForeignKey[E <: Entity](entity: E): ForeignKey[E] = {
val fk = new ForeignKey[E](entity.id)
fk.entity = entity
fk
}
implicit def foreignKeyToEntity[T <: Entity](fk: ForeignKey[T])(implicit manifestT: Manifest[T]): T = fk.entity
implicit def longToForeignKey[T <: Entity](l: Long)(implicit manifestT: Manifest[T]) = new ForeignKey[T](l)
}
Здесь реализованы основные методы для работы с БД, создан свой класс для времени TimeStamp, свой класс для хранения json в БД и свой класс для внешних ключей со всеми необходимыми неявными преобразованиями. Многие посчитают код оверкилом, но сразу скажу в большинстве задач на практике подобный код вовсе ни к чему, я стремился продемонстрировать вам какой функциональностью обладает Squeryl.
И наконец то напишем модель Login с полем login, password и внешним ключем на пригласившего его Login и не забудем создать соответствующую таблицу в БД с тестовыми данными.
package models
class Login extends Entity {
var login = ""
var password = ""
var parent: ForeignKey[Login] = null
}
Actions
Для того чтобы выполнить запрос, необходимо помещать код в inTransaction{ } либо transaction{ }.
inTransaction{ } добавляет запрос к текущей транзакции.
transaction{ } выполняет код в рамках одной транзакции.
Будем считать что один action соответствуют одной транзакции и для того чтобы не писать в каждом action блок transaction создадим DbAction в файле app/controller/BaseController.scala
package controllers
import models._
import play.api.mvc._
import utils.Jsons
import scala.concurrent.Future
import scala.language.implicitConversions
trait BaseController extends Controller {
implicit val gson = new Gson
object DbAction extends ActionBuilder[Request] {
override def invokeBlock[A](request: Request[A],
block: (Request[A]) => Future[Result]): Future[Result] = transaction {
block(request)
}
}
}
Здесь же мы указали объект gson, который будет использоваться преобразования модели в формат json/
Ну и наконец, напишем контроллер для API, app/controllers/Api.scala
package controllers
import play.api.libs.json.Json
import play.api.mvc.Action
object Api extends BaseController {
def get(cls: String, id: Long) = Get {
Ok(models.get(cls, id).map(_.json).getOrElse(Json.obj()))
}
def save(cls: String) = Post {
request => Ok(models.save(cls, request.form.getOrElse("data", "{}")).json)
}
def delete(cls: String, id: Long) = Post {
Ok(models.delete(cls, id).map(_.json).getOrElse(Json.obj()))
}
}
Добавим actions в роуты conf/routes
# Api
GET /api/:cls/:id controllers.Api.get(cls:String,id:Long)
POST /api/save/:cls controllers.Api.save(cls:String)
POST /api/delete/:cls/:id controllers.Api.delete(cls:String,id:Long)
И наконец-то запускаем:
При том вы можете прописать в url любой id, любой класс вместо login и получите в ответ необходимый вам Json. При необходимости в моделях можно перегрузить метод json, для добавления/скрытия каких-либо данных. Стоит отметить, что Gson не сериализует коллекции Scala, так что для этого придется воспользоваться преобразованиями в Java-коллекции, либо воспользоваться встроенным в Play Framework механизмом для работы с Json.
Подведем итог
Написанный код прекрасно демонстрирует широкие возможности Squeryl, но стоит отметить что для небольших задач вовсе необязательно реализовывать что-то подобное, Squeryl сможет обеспечить вас полноценной работой с БД буквально за 5 строк.
Главным на мой взгляд недостатком является отсутствие механизма миграций, максимум что может сделать Squeryl, так это выдать текущий DDL.
Я не буду проводить сравнительный анализ Squeryl с другими ORM (по крайней мере в этой статье), но лично для меня человека весьма ленивого и не желающего писать что-то лишнее при добавлении новых сущностей в БД, эта ORM подходит идеально.
Автор: lucky_libora
