Package-level declarations

Base class for entities that support auto-hydration from the database.

Mixin interface that adds create, update, and delete convenience methods directly on an entity class, delegating to the entity's attached Stormify instance, else the instance of the enclosing transaction, else the default. T is the entity class itself, so create and update return it, as stormify.create(entity) does.

What a reference does when its foreign key points at a row that does not exist (a dangling reference, common in legacy databases without foreign key constraints). Set per instance through Stormify.danglingReferences.

Property delegate that triggers auto-hydration from the database on first access. Use with AutoTable entities: properties delegated to db will lazily load the entity's data when read or written for the first time.

Controls how a Kotlin property maps to a database column with advanced configuration options.

Marks a Kotlin class as mapping to a specific database table.

Interface for enum classes that need custom numeric mapping to the database.

Compile-time metadata for a mapped entity class. Holds the class reference, a constructor lambda, property descriptors, and an optional table name override.

Functional interface for entity registration callbacks. Typically generated by the annotation processor (annproc) to register EntityMeta at startup.

Registry for enum classes, used by native targets where reflection is not available. On JVM, enum operations use reflection directly and this registry is not needed. On native, the annotation processor generates calls to register at startup.

Describes a single mapped field (property) of an entity, including its database column name, type, and role in CRUD operations.

Built-in naming policies for converting Kotlin property/class names to database column/table names.

Describes a single property of an entity class, including its type, getter/setter lambdas, and database mapping overrides. Used by EntityMeta and the annotation processor.

SQL dialect definitions for different database systems.

The main ORM controller. Entry point for all database operations.

Base class for entities that carry a reference to the Stormify instance that loaded them. This allows entity-level operations (e.g. AutoTable.hydrate) to use the correct Stormify instance without requiring it as an explicit parameter.

Metadata container for a mapped entity class. Holds the table name, field mappings, primary key information, and pre-built SQL queries for CRUD operations.

Utility class for type conversion with entity-aware fallback.

Controls how Stormify reacts when a ResultSet column has no matching field on the target entity — typical when the database has extra columns the entity does not declare (audit columns, trigger-populated fields, legacy leftovers).

Inserts this entity into the database and returns it with generated values populated.

Deletes this entity from the database based on its primary key.

Returns all detail (child) entities of type D related to this parent through a foreign key.

Type-safe variant of details that accepts an annotation-processor-generated reference path (e.g. Tables.AuditEntry_.createdBy) instead of a string.

Executes this SQL string as an UPDATE/INSERT/DELETE and returns the number of affected rows.

Finds all entities of type T, optionally filtered by a whereClause.

Finds a single entity of type T by its primary key id, or null if not found.

Property delegate that lazy-loads child (detail) records on first access.

Type-safe variant of lazyDetails that accepts an annotation-processor-generated reference path (e.g. Tables.AuditEntry_.modifiedBy) instead of a magic string. The compiler guarantees that the referenced property actually exists on the child type, so typos and renames are caught at build time instead of first query execution.

Creates a PagedList of T, like Stormify.pagedList, on the instance a call without one uses.

Creates a PagedQuery of T, like Stormify.pagedQuery, on the instance a call without one uses.

Calls the stored procedure named by this string. OUT/INOUT parameters use Sp.Out/Sp.InOut.

Executes this SQL string as a SELECT and returns all results as a list.

Executes this SQL string as a SELECT and processes results row-by-row via consumer. Returns the row count.

Executes this SQL string as a SELECT and returns a single result, or null if none found.

Kotlin helper for an IN parameter. Equivalent to Sp.In(value). Note: raw values passed to procedure(...) are auto-wrapped as IN, so explicit wrapping is only needed for clarity or when the caller wants to differentiate an intended IN from a potential Sp instance being passed.

Reified Kotlin helper for an INOUT parameter. Equivalent to Sp.InOut(T::class, value). Pass null with an explicit type argument (spInOut<Int>(null)) to send SQL NULL.

Reified Kotlin helper for an OUT parameter. Equivalent to Sp.Out(T::class).

Executes block as a transaction on the default Stormify instance. Inside the block, any convenience call (top-level extensions, CRUDTable, lazy-loaders) runs on the transaction's connection. Nested calls become savepoints automatically — see Stormify.transaction.

Updates this entity in the database based on its primary key.