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

Entity

open class Entity<ID : Any>(val id: EntityID<ID>)

A row of EntityClass.table, with the columns it should expose declared as delegated properties.

Subclass one of the typed variants — IntEntity, LongEntity, UuidEntity, CompositeEntity — and give the class a companion object of the matching EntityClass:

class Film(id: EntityID<Int>) : IntEntity(id) {
    var title by Films.title
    val director by Director referencedOn Films.director

    companion object : IntEntityClass<Film>(Films)
}

Reading and writing a column property does not suspend and issues no statement: a write is staged in the current transaction's EntityCache and reaches the database on the next flush. The operations that do use the connection — flush, refresh, delete, and the relationship accessors — are suspending.

Parameters

The unique stored identity value for the mapped record.

Inheritors

Constructors

Entity

constructor(id: EntityID<ID>)

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

klass

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

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<ID>, desc: KProperty<*>): T

operator fun <T> CompositeColumn<T>.getValue(o: Entity<ID>, 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<ID>, 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<ID>, desc: KProperty<*>, value: T)

operator fun <T> CompositeColumn<T>.setValue(o: Entity<ID>, 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<ID>, 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<ID, Entity<ID>, 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<ID>>, targetColumn: Column<EntityID<TID>>): InnerTableLink<ID, Entity<ID>, 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: