Package-level declarations

What a non-nullable many-to-one reference declared with referencedOn gives back. Declare the property as a val, read the referenced entity by invoking it, and write it with set:

What a one-to-one relationship declared with backReferencedOn gives back: the single child entity that references this one, read by invoking the property.

Base class for an Entity with an id made of several columns (CompositeID), mapping a table declared as a CompositeIdTable. See Entity for how the entity and its properties are declared.

Base class for the companion object of a CompositeEntity: the entry point for creating, finding, and deleting the rows of table.

EntityID implementation for R2DBC DAOs. This is the R2DBC equivalent of org.jetbrains.exposed.v1.dao.DaoEntityID.

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

Class responsible for performing a batch update operation on multiple instances of an Entity class.

Class responsible for the storage of Entity instances in a specific transaction.

Stores details about a state-change event for an Entity instance.

Represents the possible states of an Entity throughout its lifecycle.

The entry point for the entities of one table: creating, finding, and deleting them.

Class responsible for enabling Entity field transformations, which may be useful when advanced database type conversions are necessary for entity mappings.

Class responsible for providing functions that expose EntityChange state logic and entity lifecycle features for alerting triggers or customizing additional functionality. Subscribers are suspend because the R2DBC lifecycle runs inside coroutines.

Represents a GlobalSuspendStatementInterceptor specifically responsible for the statement lifecycle of Entity instances, which is loaded whenever an R2dbcTransaction instance is initialized.

API marked with this annotation is experimental. The shape of the R2DBC DAO API may change in incompatible ways while it stabilizes even in patch releases.

What a many-to-many relationship declared with via gives back: the entities linked to this one through an intermediate table.

Property delegate companion to InnerTableLink — implements SizedIterable over the linked targets of entity via the join table defined by link. R2DBC-specific because the iteration is built around Flow.collect, whereas the JDBC implementation uses blocking iteration directly on InnerTableLink.

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

Base class for the companion object of an IntEntity: the entry point for creating, finding, and deleting the rows of table.

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.

Base class for the companion object of a LongEntity: the entry point for creating, finding, and deleting the rows of table.

What a nullable many-to-one reference declared with optionalReferencedOn gives back. Same val + invoke()/set shape as Accessor, except that both ends accept null:

What a one-to-one relationship declared with optionalBackReferencedOn gives back: the single child entity that references this one, or null if there is none.

Class representing an optional table relation between two Entity classes, which is responsible for retrieving the parent entity optionally referenced by the child entity. R2DBC counterpart of JDBC's OptionalReference; the property delegate yields an OptionalAccessor for suspending lookups.

Class representing a table relation between two Entity classes, which is responsible for retrieving the parent entity referenced by the child entity. R2DBC counterpart of JDBC's Reference from References.kt; the property delegate yields an Accessor for suspending lookups.

What a one-to-many relationship declared with referrersOn gives back: every child entity whose reference column points at this one.

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

Base class for the companion object of a UIntEntity: the entry point for creating, finding, and deleting the rows of table.

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

Base class for the companion object of a ULongEntity: the entry point for creating, finding, and deleting the rows of table.

Base class for an Entity with a client-generated kotlin.uuid.Uuid id, mapping a table declared as a UuidTable. See Entity for how the entity and its properties are declared.

Base class for the companion object of a UuidEntity: the entry point for creating, finding, and deleting the rows of table.

The EntityCache belonging to the transaction, created on first access.

Triggers alerts for all unprocessed entity events using any state-change actions previously registered via EntityHook.subscribe.

Sends all pending Entity inserts and updates stored in this transaction's EntityCache to the database.

Loads the given relations for this single entity up front:

Creates a new EntityChange with this id and registers it as an entity event.

Returns a list of all EntityChange events that have been registered in this R2dbcTransaction.

Returns the actual Entity instance associated with this event, or null if the entity is not found.

Returns the actual Entity instance associated with this event, or null if either its class type is neither equivalent to nor a subclass of klass, or if the entity is not found.

Loads the given relations for entities that are already in memory, one query per relation:

Loads the given relations for every entity of this SizedIterable up front, one query per relation, instead of one query per entity as it is traversed:

Calls the specified body with the given state-change action, registers the action, and returns its result.