exposed-dao-r2dbc/org.jetbrains.exposed.v1.dao.r2dbc/LongEntity

LongEntity

abstract class LongEntity(id: EntityID<Long>) : Entity<Long>

Base class for an Entity with a Long id, mapping a table declared as a LongIdTable. See Entity for how the entity and its properties are declared.

Constructors

LongEntity

constructor(id: EntityID<Long>)

Properties

_readValues

var _readValues: ResultRow?

This entity's committed column values. Values a transaction has staged but not committed are held by that transaction's EntityCache instead.

var db: R2dbcDatabase

The R2dbcDatabase associated with the record mapped to this Entity instance.

val id: EntityID<Long>

klass

var klass: EntityClass<Long, Entity<Long>>

The associated EntityClass that manages this Entity instance.

readValues

val readValues: ResultRow

The final column-value mapping for this Entity instance after being flushed and retrieved from the database.

Functions

delete

open suspend fun delete()

Deletes this Entity instance, both from the cache and from the database.

flush

open suspend fun flush(batch: EntityBatchUpdate? = null): Boolean

Sends all cached inserts and updates for this Entity instance to the database.

getValue

operator fun <T> Column<T>.getValue(o: Entity<Long>, desc: KProperty<*>): T

operator fun <T> CompositeColumn<T>.getValue(o: Entity<Long>, desc: KProperty<*>): T

Reads a property delegated to a CompositeColumn, which stores a single value across several columns:

operator fun <Unwrapped, Wrapped> EntityFieldWithTransform<Unwrapped, Wrapped>.getValue(o: Entity<Long>, desc: KProperty<*>): Wrapped

Reads a property delegated to a transformed column, converting the stored value on the way out:

lookup

fun <T> Column<T>.lookup(): T

Returns the value assigned to this column mapping.

refresh

open suspend fun refresh(flush: Boolean = false)

Updates the fields of this Entity instance with values retrieved from the database. Override this function to refresh some additional state, if any.

setValue

operator fun <T> Column<T>.setValue(entity: Entity<Long>, desc: KProperty<*>, value: T)

operator fun <T> CompositeColumn<T>.setValue(o: Entity<Long>, desc: KProperty<*>, value: T)

Writes a property delegated to a CompositeColumn, staging one value per underlying column.

operator fun <Unwrapped, Wrapped> EntityFieldWithTransform<Unwrapped, Wrapped>.setValue(o: Entity<Long>, desc: KProperty<*>, value: Wrapped)

Writes a property delegated to a transformed column, converting the value back to what the column stores.

via

infix fun <TID : Any, Target : Entity<TID>> EntityClass<TID, Target>.via(table: Table): InnerTableLink<Long, Entity<Long>, TID, Target>

Declares a many-to-many relationship held by the intermediate table, whose references to this entity's table and to the target's table are inferred from its foreign keys:

fun <TID : Any, Target : Entity<TID>> EntityClass<TID, Target>.via(sourceColumn: Column<EntityID<Long>>, targetColumn: Column<EntityID<TID>>): InnerTableLink<Long, Entity<Long>, TID, Target>

Declares a many-to-many relationship, naming sourceColumn and targetColumn explicitly. Use this overload when the intermediate table holds more than one reference to either side, which leaves nothing to infer: