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

Companion

object Companion : IntEntityClass<AssignmentType>

Properties

dependsOnColumns

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

dependsOnTables

open val dependsOnTables: ColumnSet

entityCtor

private val entityCtor: (EntityID<Int>) -> AssignmentType

entityPrimaryCtor

private val entityPrimaryCtor: KFunction<AssignmentType>

klass

internal val klass: Class<*>

refDefinitions

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

table

val table: IdTable<Int>

Functions

all

open fun all(): SizedIterable<AssignmentType>

backReferencedOn

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

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

backReferencedOn

count

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

createInstance

protected open fun createInstance(entityId: EntityID<Int>, row: ResultRow?): AssignmentType

find

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

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

findById

fun findById(id: Int): AssignmentType?

open fun findById(id: EntityID<Int>): AssignmentType?

findByIdAndUpdate

fun findByIdAndUpdate(id: Int, block: (it: AssignmentType) -> Unit): AssignmentType?

findSingleByAndUpdate

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

findWithCacheCondition

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

forEntityIds

open fun forEntityIds(ids: List<EntityID<Int>>): SizedIterable<AssignmentType>

forIds

fun forIds(ids: List<Int>): SizedIterable<AssignmentType>

get

operator fun get(id: Int): AssignmentType

operator fun get(id: EntityID<Int>): AssignmentType

getEntities

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

invalidateEntityInCache

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

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: AssignmentType.() -> Unit): AssignmentType

open fun new(id: Int?, init: AssignmentType.() -> Unit): AssignmentType

optionalBackReferencedOn

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

infix fun <TargetID : Comparable<TargetID>, Target : Entity<TargetID>, REF : Comparable<REF>> EntityClass<TargetID, Target>.optionalBackReferencedOn(column: Column<REF>): OptionalBackReference<TargetID, Target, Int, Entity<Int>, 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, Int, AssignmentType>

optionalReferrersOn

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

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

optionalReferrersOn

referencedOn

infix fun <REF : Comparable<REF>> referencedOn(column: Column<REF>): Reference<REF, Int, AssignmentType>

referrersOn

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

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

referrersOn

registerRefRule

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

reload

fun reload(entity: Entity<Int>, flush: Boolean): AssignmentType?

removeFromCache

fun removeFromCache(entity: Entity<Int>)

searchQuery

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

setForUpdateStatus

private fun Query.setForUpdateStatus(): Query

testCache

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

fun testCache(id: EntityID<Int>): AssignmentType?

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<AssignmentType>

warmCache

protected open fun warmCache(): EntityCache

warmUpLinkedReferences

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

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

warmUpOptReferences

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

warmUpReferences

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

wrap

fun wrap(id: EntityID<Int>, row: ResultRow?): AssignmentType

wrapRow

fun wrapRow(row: ResultRow): AssignmentType

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

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

wrapRows

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

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

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