address/de.fenste.ms.address.domain.model/Street/EntityClass

EntityClass

object EntityClass : UUIDEntityClass<Street>

Functions

open fun all(): SizedIterable<Street>

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

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

count

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

find

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

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

findById

fun findById(id: UUID): Street?

open fun findById(id: EntityID<UUID>): Street?

findWithCacheCondition

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

forEntityIds

open fun forEntityIds(ids: List<EntityID<UUID>>): SizedIterable<Street>

forIds

fun forIds(ids: List<UUID>): SizedIterable<Street>

get

operator fun get(id: UUID): Street

operator fun get(id: EntityID<UUID>): Street

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

open fun new(id: UUID?, init: Street.() -> Unit): Street

optionalBackReferencedOn

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

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

optionalReferencedOn

infix fun <REF : Comparable<REF>> optionalReferencedOn(column: Column<REF?>): OptionalReference<REF, UUID, Street>

optionalReferrersOn

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

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

referencedOn

infix fun <REF : Comparable<REF>> referencedOn(column: Column<REF>): Reference<REF, UUID, Street>

referrersOn

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

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

reload

fun reload(entity: Entity<UUID>, flush: Boolean): Street?

removeFromCache

fun removeFromCache(entity: Entity<UUID>)

searchQuery

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

testCache

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

fun testCache(id: EntityID<UUID>): Street?

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

warmUpLinkedReferences

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

warmUpOptReferences

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

warmUpReferences

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

wrap

fun wrap(id: EntityID<UUID>, row: ResultRow?): Street

wrapRow

fun wrapRow(row: ResultRow): Street

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

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

wrapRows

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

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

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

Properties

dependsOnColumns

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

dependsOnTables

open val dependsOnTables: ColumnSet

table

val table: IdTable<UUID>

Extensions

backReferencedOn

optionalBackReferencedOn

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

optionalReferrersOn

referrersOn