BaseRepository

Instance Constructors

new BaseRepository()

Type Members

type F = AppliedCompiledFunction[_, slick.jdbc.JdbcProfile.API.Query[TableType, T, Seq], Seq[T]]
abstract type TableType <: Keyed[ID] with slick.relational.RelationalProfile.Table[T]

Abstract Value Members

abstract val driver: JdbcProfile

Attributes
protected
abstract def pkType: BaseTypedType[ID]
abstract def tableQuery: slick.jdbc.JdbcProfile.API.TableQuery[TableType]

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
implicit lazy val _pkType: BaseTypedType[ID]
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).
val batchPersister: (Seq[T]) ⇒ slick.jdbc.JdbcProfile.API.DBIO[Option[Int]]

Batch persister
Batch persister

Attributes
protected
def clone(): AnyRef

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

Counts all entities.
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.
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.
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.
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.
def findOne(id: ID)(implicit ec: ExecutionContext): slick.jdbc.JdbcProfile.API.DBIO[Option[T]]

Finds a given entity by its primary key.
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
val generatedIdPersister: (T, ExecutionContext) ⇒ slick.jdbc.JdbcProfile.API.DBIO[T]

Generated ID persister
Generated ID persister

Attributes
protected
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
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
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
def getUpdater(transformer: (T) ⇒ T): (T, F, ExecutionContext) ⇒ slick.jdbc.JdbcProfile.API.DBIO[T]

Builds an updater
Builds an updater

Attributes
protected
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

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

Locks an entity using a pessimistic lock.
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]

Predefined ID persister
Predefined ID persister

Attributes
protected
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.
lazy val saveCompiled: slick.jdbc.JdbcProfile.ReturningInsertActionComposer[TableType.TableElementType, ID]

Attributes
protected
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
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.
def updateFinder(entity: T): F

Update finder
Update finder

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

Update validator
Update validator

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

Updater
Updater

Attributes
protected
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 BaseRepository[T <: Entity[T, ID], ID] extends AnyRef

Instance Constructors

new BaseRepository()

Type Members

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

abstract type TableType <: Keyed[ID] with slick.relational.RelationalProfile.Table[T]

Abstract Value Members

abstract val driver: JdbcProfile

abstract def pkType: BaseTypedType[ID]

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

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]

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]

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]

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

final def isInstanceOf[T0]: Boolean

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

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 AnyRef

Inherited from Any

Ungrouped