VersionedRepository

Instance Constructors

new VersionedRepository(driver: JdbcProfile)(implicit arg0: VersionGenerator[V])

Type Members

type F = AppliedCompiledFunction[_, slick.jdbc.JdbcProfile.API.Query[TableType, T, Seq], Seq[T]]

Definition Classes
BaseRepository
abstract type TableType <: Versioned[ID, V] with slick.relational.RelationalProfile.Table[T]

Definition Classes
VersionedRepository → BaseRepository

Abstract Value Members

abstract def pkType: BaseTypedType[ID]

Definition Classes
BaseRepository
abstract def tableQuery: slick.jdbc.JdbcProfile.API.TableQuery[TableType]

Definition Classes
BaseRepository
abstract def versionType: BaseTypedType[V]

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def _getPrePersist: (T) ⇒ T

Attributes
protected
Definition Classes
BaseRepository
implicit lazy val _pkType: BaseTypedType[ID]

Definition Classes
BaseRepository
implicit lazy val _versionType: BaseTypedType[V]
final def asInstanceOf[T0]: T0

Definition Classes
Any
def batchInsert(entities: Seq[T]): slick.jdbc.JdbcProfile.API.DBIO[Option[Int]]

Performs a batch insert of the entities that are passed in as an argument.
Performs a batch insert of the entities that are passed in as an argument. The result will be the number of created entities in case of a successful batch insert execution (if the row count is provided by the underlying database or driver. If not, then None will be returned as the result of a successful batch insert operation).

Definition Classes
BaseRepository
val batchPersister: (Seq[T]) ⇒ slick.jdbc.JdbcProfile.API.DBIO[Option[Int]]

Batch persister
Batch persister

Attributes
protected
Definition Classes
VersionedRepository → BaseRepository
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def count(): slick.jdbc.JdbcProfile.API.DBIO[Int]

Counts all entities.
Counts all entities.

Definition Classes
BaseRepository
def delete(entity: T)(implicit ec: ExecutionContext): slick.jdbc.JdbcProfile.API.DBIO[T]

Deletes a given entity from the database.
Deletes a given entity from the database.
If the entity is not yet persisted in the database then this operation will result in an exception being thrown.

Definition Classes
BaseRepository
val driver: JdbcProfile

Definition Classes
VersionedRepository → Repository → BaseRepository
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def exclusiveLockStatement(sql: String): String

Returns the pessimistic lock statement based on the current database driver type.
Returns the pessimistic lock statement based on the current database driver type.

Definition Classes
BaseRepository
def executeTransactionally[R](work: slick.jdbc.JdbcProfile.API.DBIO[R]): slick.jdbc.JdbcProfile.API.DBIO[R]

Executes the given unit of work in a single transaction.
Executes the given unit of work in a single transaction.

Definition Classes
BaseRepository
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def findAll()(implicit ec: ExecutionContext): slick.jdbc.JdbcProfile.API.DBIO[Seq[T]]

Finds all entities.
Finds all entities.

Definition Classes
BaseRepository
def findOne(id: ID)(implicit ec: ExecutionContext): slick.jdbc.JdbcProfile.API.DBIO[Option[T]]

Finds a given entity by its primary key.
Finds a given entity by its primary key.

Definition Classes
BaseRepository
lazy val findOneCompiled: CompiledFunction[(slick.jdbc.JdbcProfile.API.Rep[ID]) ⇒ Query[TableType, TableType.TableElementType, Seq], slick.jdbc.JdbcProfile.API.Rep[ID], ID, Query[TableType, TableType.TableElementType, Seq], Seq[TableType.TableElementType]]

Attributes
protected
Definition Classes
BaseRepository
val generatedIdPersister: (T, ExecutionContext) ⇒ slick.jdbc.JdbcProfile.API.DBIO[T]

Versioned entity generated ID persister
Versioned entity generated ID persister

Attributes
protected
Definition Classes
VersionedRepository → BaseRepository
val generator: VersionGenerator[V]
def getBatchPersister(seqTransformer: (Seq[T]) ⇒ Seq[T]): (Seq[T]) ⇒ slick.jdbc.JdbcProfile.API.DBIO[Option[Int]]

Builds a batch persister
Builds a batch persister

Attributes
protected
Definition Classes
BaseRepository
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getGeneratedIdPersister(transformer: (T) ⇒ T): (T, ExecutionContext) ⇒ slick.jdbc.JdbcProfile.API.DBIO[T]

Builds a generated ID persister
Builds a generated ID persister

Attributes
protected
Definition Classes
BaseRepository
def getPredefinedIdPersister(transformer: (T) ⇒ T): (T, ExecutionContext) ⇒ slick.jdbc.JdbcProfile.API.DBIO[T]

Builds a predefined ID persister
Builds a predefined ID persister

Attributes
protected
Definition Classes
BaseRepository
def getUpdater(transformer: (T) ⇒ T): (T, F, ExecutionContext) ⇒ slick.jdbc.JdbcProfile.API.DBIO[T]

Builds an updater
Builds an updater

Attributes
protected
Definition Classes
BaseRepository
def hashCode(): Int

Definition Classes
AnyRef → Any
implicit val instantVersionToSqlTimestampMapper: JdbcType[InstantVersion] with BaseTypedType[InstantVersion]
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
implicit val localDateTimeVersionToSqlTimestampMapper: JdbcType[LocalDateTimeVersion] with BaseTypedType[LocalDateTimeVersion]
def lock(entity: T)(implicit ec: ExecutionContext): slick.jdbc.JdbcProfile.API.DBIO[T]

Locks an entity using a pessimistic lock.
Locks an entity using a pessimistic lock.

Definition Classes
BaseRepository
implicit val longInstantVersionToSqlTimestampMapper: JdbcType[LongInstantVersion] with BaseTypedType[LongInstantVersion]
implicit val longLocalDateTimeVersionToSqlTimestampMapper: JdbcType[LongLocalDateTimeVersion] with BaseTypedType[LongLocalDateTimeVersion]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val predefinedIdPersister: (T, ExecutionContext) ⇒ slick.jdbc.JdbcProfile.API.DBIO[T]

Versioned entity predefined ID persister
Versioned entity predefined ID persister

Attributes
protected
Definition Classes
VersionedRepository → BaseRepository
def save(entity: T)(implicit ec: ExecutionContext): slick.jdbc.JdbcProfile.API.DBIO[T]

Persists an entity for the first time.
Persists an entity for the first time.
If the entity has an already assigned primary key, then it will be persisted with that same primary key.
If the entity doesn't have an already assigned primary key, then it will be persisted using an auto-generated primary key using the generation strategy configured in the entity definition.
A new entity with the primary key assigned to it will be returned.

Definition Classes
BaseRepository
lazy val saveCompiled: slick.jdbc.JdbcProfile.ReturningInsertActionComposer[TableType.TableElementType, ID]

Attributes
protected
Definition Classes
BaseRepository
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
lazy val tableQueryCompiled: CompiledStreamingExecutable[slick.jdbc.JdbcProfile.API.TableQuery[TableType], Seq[TableType.TableElementType], TableType.TableElementType]

Attributes
protected
Definition Classes
BaseRepository
def toString(): String

Definition Classes
AnyRef → Any
def update(entity: T)(implicit ec: ExecutionContext): slick.jdbc.JdbcProfile.API.DBIO[T]

Updates a given entity in the database.
Updates a given entity in the database.
If the entity is not yet persisted in the database then this operation will result in an exception being thrown.
Returns the same entity instance that was passed in as an argument.

Definition Classes
BaseRepository
def updateFinder(entity: T): F

Update finder
Update finder

Attributes
protected
Definition Classes
VersionedRepository → BaseRepository
def updateValidator(previous: T, next: T): (Int) ⇒ T

Update validator
Update validator

Attributes
protected
Definition Classes
VersionedRepository → BaseRepository
val updater: (T, F, ExecutionContext) ⇒ slick.jdbc.JdbcProfile.API.DBIO[T]

Updater
Updater

Attributes
protected
Definition Classes
VersionedRepository → BaseRepository
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Doc: package repository

abstract class VersionedRepository[T <: VersionedEntity[T, ID, V], ID, V] extends Repository[T, ID]

Instance Constructors

new VersionedRepository(driver: JdbcProfile)(implicit arg0: VersionGenerator[V])

Type Members

type F = AppliedCompiledFunction[_, slick.jdbc.JdbcProfile.API.Query[TableType, T, Seq], Seq[T]]

abstract type TableType <: Versioned[ID, V] with slick.relational.RelationalProfile.Table[T]

Abstract Value Members

abstract def pkType: BaseTypedType[ID]

abstract def tableQuery: slick.jdbc.JdbcProfile.API.TableQuery[TableType]

abstract def versionType: BaseTypedType[V]

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def _getPrePersist: (T) ⇒ T

implicit lazy val _pkType: BaseTypedType[ID]

implicit lazy val _versionType: BaseTypedType[V]

final def asInstanceOf[T0]: T0

def batchInsert(entities: Seq[T]): slick.jdbc.JdbcProfile.API.DBIO[Option[Int]]

val batchPersister: (Seq[T]) ⇒ slick.jdbc.JdbcProfile.API.DBIO[Option[Int]]

def clone(): AnyRef

def count(): slick.jdbc.JdbcProfile.API.DBIO[Int]

def delete(entity: T)(implicit ec: ExecutionContext): slick.jdbc.JdbcProfile.API.DBIO[T]

val driver: JdbcProfile

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exclusiveLockStatement(sql: String): String

def executeTransactionally[R](work: slick.jdbc.JdbcProfile.API.DBIO[R]): slick.jdbc.JdbcProfile.API.DBIO[R]

def finalize(): Unit

def findAll()(implicit ec: ExecutionContext): slick.jdbc.JdbcProfile.API.DBIO[Seq[T]]

def findOne(id: ID)(implicit ec: ExecutionContext): slick.jdbc.JdbcProfile.API.DBIO[Option[T]]

lazy val findOneCompiled: CompiledFunction[(slick.jdbc.JdbcProfile.API.Rep[ID]) ⇒ Query[TableType, TableType.TableElementType, Seq], slick.jdbc.JdbcProfile.API.Rep[ID], ID, Query[TableType, TableType.TableElementType, Seq], Seq[TableType.TableElementType]]

val generatedIdPersister: (T, ExecutionContext) ⇒ slick.jdbc.JdbcProfile.API.DBIO[T]

val generator: VersionGenerator[V]

def getBatchPersister(seqTransformer: (Seq[T]) ⇒ Seq[T]): (Seq[T]) ⇒ slick.jdbc.JdbcProfile.API.DBIO[Option[Int]]

final def getClass(): Class[_]

def getGeneratedIdPersister(transformer: (T) ⇒ T): (T, ExecutionContext) ⇒ slick.jdbc.JdbcProfile.API.DBIO[T]

def getPredefinedIdPersister(transformer: (T) ⇒ T): (T, ExecutionContext) ⇒ slick.jdbc.JdbcProfile.API.DBIO[T]

def getUpdater(transformer: (T) ⇒ T): (T, F, ExecutionContext) ⇒ slick.jdbc.JdbcProfile.API.DBIO[T]

def hashCode(): Int

implicit val instantVersionToSqlTimestampMapper: JdbcType[InstantVersion] with BaseTypedType[InstantVersion]

final def isInstanceOf[T0]: Boolean

implicit val localDateTimeVersionToSqlTimestampMapper: JdbcType[LocalDateTimeVersion] with BaseTypedType[LocalDateTimeVersion]

def lock(entity: T)(implicit ec: ExecutionContext): slick.jdbc.JdbcProfile.API.DBIO[T]

implicit val longInstantVersionToSqlTimestampMapper: JdbcType[LongInstantVersion] with BaseTypedType[LongInstantVersion]

implicit val longLocalDateTimeVersionToSqlTimestampMapper: JdbcType[LongLocalDateTimeVersion] with BaseTypedType[LongLocalDateTimeVersion]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val predefinedIdPersister: (T, ExecutionContext) ⇒ slick.jdbc.JdbcProfile.API.DBIO[T]

def save(entity: T)(implicit ec: ExecutionContext): slick.jdbc.JdbcProfile.API.DBIO[T]

lazy val saveCompiled: slick.jdbc.JdbcProfile.ReturningInsertActionComposer[TableType.TableElementType, ID]

final def synchronized[T0](arg0: ⇒ T0): T0

lazy val tableQueryCompiled: CompiledStreamingExecutable[slick.jdbc.JdbcProfile.API.TableQuery[TableType], Seq[TableType.TableElementType], TableType.TableElementType]

def toString(): String

def update(entity: T)(implicit ec: ExecutionContext): slick.jdbc.JdbcProfile.API.DBIO[T]

def updateFinder(entity: T): F

def updateValidator(previous: T, next: T): (Int) ⇒ T

val updater: (T, F, ExecutionContext) ⇒ slick.jdbc.JdbcProfile.API.DBIO[T]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from Repository[T, ID]

Inherited from BaseRepository[T, ID]

Inherited from AnyRef

Inherited from Any

Ungrouped