exposed-db/dev.ust.zinc.grader.model/AssignmentConfig/Companion

Companion

object Companion : LongEntityClass<AssignmentConfig>

Properties

dependsOnColumns

open val dependsOnColumns: List<Column<out Any?>>

dependsOnTables

open val dependsOnTables: ColumnSet

entityCtor

private val entityCtor: (EntityID<Long>) -> AssignmentConfig

entityPrimaryCtor

private val entityPrimaryCtor: KFunction<AssignmentConfig>

klass

internal val klass: Class<*>

refDefinitions

private val refDefinitions: HashMap<Pair<Column<*>, KClass<*>>, Any>

table

val table: IdTable<Long>

Functions

all

open fun all(): SizedIterable<AssignmentConfig>

backReferencedOn

infix fun <TargetID : Comparable<TargetID>, Target : Entity<TargetID>, REF : Comparable<REF>> EntityClass<TargetID, Target>.backReferencedOn(column: Column<REF?>): ReadOnlyProperty<Entity<Long>, Target>

infix fun <TargetID : Comparable<TargetID>, Target : Entity<TargetID>, REF : Comparable<REF>> EntityClass<TargetID, Target>.backReferencedOn(column: Column<REF>): ReadOnlyProperty<Entity<Long>, Target>

backReferencedOn

count

fun count(op: Op<Boolean>?): Long

createInstance

protected open fun createInstance(entityId: EntityID<Long>, row: ResultRow?): AssignmentConfig

find

fun find(op: SqlExpressionBuilder.() -> Op<Boolean>): SizedIterable<AssignmentConfig>

fun find(op: Op<Boolean>): SizedIterable<AssignmentConfig>

findById

fun findById(id: Long): AssignmentConfig?

open fun findById(id: EntityID<Long>): AssignmentConfig?

findByIdAndUpdate

fun findByIdAndUpdate(id: Long, block: (it: AssignmentConfig) -> Unit): AssignmentConfig?

findSingleByAndUpdate

fun findSingleByAndUpdate(op: Op<Boolean>, block: (it: AssignmentConfig) -> Unit): AssignmentConfig?

findWithCacheCondition

fun findWithCacheCondition(cacheCheckCondition: AssignmentConfig.() -> Boolean, op: SqlExpressionBuilder.() -> Op<Boolean>): Sequence<AssignmentConfig>

forEntityIds

open fun forEntityIds(ids: List<EntityID<Long>>): SizedIterable<AssignmentConfig>

forIds

fun forIds(ids: List<Long>): SizedIterable<AssignmentConfig>

get

operator fun get(id: Long): AssignmentConfig

operator fun get(id: EntityID<Long>): AssignmentConfig

getEntities

private fun getEntities(forUpdate: Boolean?, findQuery: SizedIterable<AssignmentConfig>): List<AssignmentConfig>

invalidateEntityInCache

internal open fun invalidateEntityInCache(o: Entity<Long>)

isAssignableTo

fun <ID : Comparable<ID>, T : Entity<ID>> isAssignableTo(entityClass: EntityClass<ID, T>): Boolean

memoizedTransform

fun <TColumn, TReal> Column<TColumn>.memoizedTransform(toColumn: (TReal) -> TColumn, toReal: (TColumn) -> TReal): ColumnWithTransform<TColumn, TReal>

new

open fun new(init: AssignmentConfig.() -> Unit): AssignmentConfig

open fun new(id: Long?, init: AssignmentConfig.() -> Unit): AssignmentConfig

optionalBackReferencedOn

infix fun <TargetID : Comparable<TargetID>, Target : Entity<TargetID>, REF : Comparable<REF>> EntityClass<TargetID, Target>.optionalBackReferencedOn(column: Column<REF?>): OptionalBackReference<TargetID, Target, Long, Entity<Long>, REF>

infix fun <TargetID : Comparable<TargetID>, Target : Entity<TargetID>, REF : Comparable<REF>> EntityClass<TargetID, Target>.optionalBackReferencedOn(column: Column<REF>): OptionalBackReference<TargetID, Target, Long, Entity<Long>, REF>

optionalBackReferencedOn

infix fun <TargetID : Comparable<TargetID>, Target : Entity<TargetID>, REF : Comparable<REF>> EntityClass<TargetID, Target>.optionalBackReferencedOn(column: Column<REF>): OptionalBackReference<TargetID, Target, Long, Entity<Long>, REF>

optionalReferencedOn

infix fun <REF : Comparable<REF>> optionalReferencedOn(column: Column<REF?>): OptionalReference<REF, Long, AssignmentConfig>

optionalReferrersOn

infix fun <TargetID : Comparable<TargetID>, Target : Entity<TargetID>, REF : Comparable<REF>> EntityClass<TargetID, Target>.optionalReferrersOn(column: Column<REF?>): OptionalReferrers<Long, Entity<Long>, TargetID, Target, REF>

fun <TargetID : Comparable<TargetID>, Target : Entity<TargetID>, REF : Comparable<REF>> EntityClass<TargetID, Target>.optionalReferrersOn(column: Column<REF?>, cache: Boolean): OptionalReferrers<Long, Entity<Long>, TargetID, Target, REF>

optionalReferrersOn

referencedOn

infix fun <REF : Comparable<REF>> referencedOn(column: Column<REF>): Reference<REF, Long, AssignmentConfig>

referrersOn

infix fun <TargetID : Comparable<TargetID>, Target : Entity<TargetID>, REF : Comparable<REF>> EntityClass<TargetID, Target>.referrersOn(column: Column<REF>): Referrers<Long, Entity<Long>, TargetID, Target, REF>

fun <TargetID : Comparable<TargetID>, Target : Entity<TargetID>, REF : Comparable<REF>> EntityClass<TargetID, Target>.referrersOn(column: Column<REF>, cache: Boolean): Referrers<Long, Entity<Long>, TargetID, Target, REF>

referrersOn

registerRefRule

private inline fun <R : Any> registerRefRule(column: Column<*>, ref: () -> R): R

reload

fun reload(entity: Entity<Long>, flush: Boolean): AssignmentConfig?

removeFromCache

fun removeFromCache(entity: Entity<Long>)

searchQuery

open fun searchQuery(op: Op<Boolean>): Query

setForUpdateStatus

private fun Query.setForUpdateStatus(): Query

testCache

fun testCache(cacheCheckCondition: AssignmentConfig.() -> Boolean): Sequence<AssignmentConfig>

fun testCache(id: EntityID<Long>): AssignmentConfig?

transform

fun <TColumn, TReal> Column<TColumn>.transform(toColumn: (TReal) -> TColumn, toReal: (TColumn) -> TReal): ColumnWithTransform<TColumn, TReal>

view

inline fun view(op: SqlExpressionBuilder.() -> Op<Boolean>): View<AssignmentConfig>

warmCache

protected open fun warmCache(): EntityCache

warmUpLinkedReferences

fun <SID : Comparable<SID>> warmUpLinkedReferences(references: List<EntityID<SID>>, linkTable: Table, forUpdate: Boolean?, optimizedLoad: Boolean): List<AssignmentConfig>

internal fun <SID : Comparable<SID>> warmUpLinkedReferences(references: List<EntityID<SID>>, sourceRefColumn: Column<EntityID<SID>>, targetRefColumn: Column<EntityID<Long>>, linkTable: Table, forUpdate: Boolean?, optimizedLoad: Boolean): List<AssignmentConfig>

warmUpOptReferences

fun <SID> warmUpOptReferences(references: List<SID>, refColumn: Column<SID?>, forUpdate: Boolean?): List<AssignmentConfig>

warmUpReferences

fun <SID> warmUpReferences(references: List<SID>, refColumn: Column<SID>, forUpdate: Boolean?): List<AssignmentConfig>

wrap

fun wrap(id: EntityID<Long>, row: ResultRow?): AssignmentConfig

wrapRow

fun wrapRow(row: ResultRow): AssignmentConfig

fun wrapRow(row: ResultRow, alias: Alias<IdTable<*>>): AssignmentConfig

fun wrapRow(row: ResultRow, alias: QueryAlias): AssignmentConfig

wrapRows

fun wrapRows(rows: SizedIterable<ResultRow>): SizedIterable<AssignmentConfig>

fun wrapRows(rows: SizedIterable<ResultRow>, alias: Alias<IdTable<*>>): SizedIterable<AssignmentConfig>

fun wrapRows(rows: SizedIterable<ResultRow>, alias: QueryAlias): SizedIterable<AssignmentConfig>