All Classes and Interfaces

Class	Description
AbstractKeyMetamodel<T,E,V>	Extension of AbstractMetamodel that implements Metamodel.Key, indicating that the field has a uniqueness constraint.
AbstractMetamodel<T,E,V>	Implementation that is used by the generated models.
AbstractNavigableMetamodel<T,E>	Base implementation for generated navigation-only metamodels — nodes that navigate the entity graph beyond a Ref foreign key.
BindVars	Marker interface used within an SQL template to indicate where bind variables (parameters) should be injected.
BindVars.RecordListener	A listener for record events within a SQL query context.
BuilderImpl	Builds the Java facade over an engine template builder.
Column	Represents metadata about a single column in a database table, as derived from the entity or projection model.
ColumnImpl	Represents a column in a database table.
ColumnNameResolver	Resolves the column name for a record component.
Convert	Declares how a Converter should be applied.
Converter<D,E>	Converts between an entity value type and a database column type.
CursorCodec<T>	Encodes and decodes a single scalar value for cursor serialization.
CursorCodecEntry<T>	A cursor codec registration entry, binding a tag, Java type, and codec together.
CursorCodecProvider	Service provider interface for registering custom cursor codecs.
Data	Marker interface for record-based data classes.
DbColumn	Specifies the name of the database column.
DbColumns	Annotation for specifying multiple database column names, e.g., for compound keys.
DbEnum	Specifies how an enum should be mapped when reading or writing to a column.
DbIgnore	Suppresses schema validation for the annotated entity type or record component.
DbTable	Specifies the name of the database table or view, and optionally its schema.
DefaultConverter	Marks a Converter as eligible for automatic application when its entity type matches a type and no explicit @Convert annotation is present.
DefaultJoinType	Default implementation of the JoinType interface used to represent the default join types.
DirtyCheck	Defines how dirty checking is performed for an entity.
Discriminator	Configures discriminator behavior for sealed type hierarchies.
Discriminator.DiscriminatorType	The discriminator column types supported for sealed type hierarchies.
DynamicUpdate	Configures how changes are detected and how UPDATE statements are generated for a specific entity.
Element	Represents an element in a ST/ORM SQL query.
Engine	Verifies that the engine backing this API is on the runtime classpath.
Entity<ID>	Optional marker interface for record-based entities.
EntityCallback<E>	Typed callback interface for entity lifecycle events.
EntityCallbacks	Declares the EntityCallback types that apply to the annotated entity.
EntityRepository<E,ID>	Provides a generic interface with CRUD operations for entities.
EnumType	Defines the strategy to use when mapping enums.
ExceptionContext	Describes the execution context in which a failure occurred.
ExceptionMapper	Maps failures raised during query execution to the runtime exception thrown to the caller.
FK	Marks a field as a foreign key.
ForeignKeyResolver	Resolves the column name for a foreign key component.
GenerateMetamodel	Indicates that a metamodel class should be generated for the annotated record or data class.
GenerationStrategy	Defines the strategy to use when generating values for primary keys.
IllegalTransactionStateException	Thrown when a transaction block cannot open against the transaction state it finds: MANDATORY without a transaction, NEVER inside one, or a joining block that states a stricter isolation level than the transaction it joins runs at.
Inline	Indicates that the underlying fields of the record component are inlined in this record.
Instantiator<T>	Constructs record instances without reflection.
InvalidCursorException	Thrown when a cursor string cannot be turned into a position: it is malformed, was issued by an earlier cursor format, was issued for another ordering or codec registry, or carries a value of the wrong type.
JoinBuilder<T,R,ID>	A builder for specifying the ON condition of a JOIN clause using a custom string template expression.
JoinType	Represents a join type in a SQL query.
Json	Marks a record component as a json object.
Metamodel<T,E>	The metamodel provides type-safe references to entity fields for use in queries.
Metamodel.Key<T,E>	Marker interface for metamodel fields that correspond to columns known to be unique.
Metamodel.KeyDelegate<T,E>	Delegating wrapper that adds the Metamodel.Key marker to an existing Metamodel instance.
MetamodelType	Marks an annotation type to be represented as the specified type in the Metamodel.
Model<E,ID>	Provides metadata about an entity or projection type, including its table name, primary key type, and column definitions.
ModelImpl<E,ID>	Represents the model of an entity.
Navigable<T,E>	The navigational part of a Metamodel: everything needed to locate a field within the entity graph and use it in a query (filter, join, order, group, select), without exposing value extraction.
NonUniqueResultException	Thrown when getSingleResult is executed on a query and there is more than one result from the query.
NoResultException	Thrown when getSingleResult is executed on a query and there is no result to return.
Operator	Represents a comparison operator in a SQL query.
OptimisticLockException	Thrown when an optimistic locking conflict occurs.
Order	A sort order for one metamodel field.
ORMTemplate	The primary entry point for Storm's ORM functionality, combining SQL template query construction with repository access.
ORMTemplate.Builder	Builder for constructing an ORMTemplate with instance-scoped integration strategies.
ORMTemplateImpl
Page<R>	Represents a page of query results for offset-based pagination.
Pageable	Represents a pagination request with a zero-based page number, page size, and optional sort orders.
Persist	Allows the persistence properties of a record component to be configured.
PersistenceException	Thrown when a database or sql problem occurs.
PK	Marks a field as the primary key of an entity.
Polymorphic	Specifies the inheritance strategy for a sealed entity hierarchy.
Polymorphic.Strategy	The inheritance strategies for sealed entity hierarchies.
Position	The row a scroll request continues from, and on which side of it.
PredicateBuilder<T,R,ID>	Represents a composable predicate for the WHERE clause of a query, supporting AND and OR composition.
PreparedQuery	Represents an eagerly constructed, reusable query that supports batch operations and generated key retrieval.
PreparedQueryImpl
Projection<ID>	Marker interface for record-based projections.
ProjectionQuery	Projection records marked with this annotation type can specify a SQL query that represents the projection.
ProjectionRepository<P,ID>	Provides a generic interface with read operations for projections.
Query	Represents a constructed SQL statement that is ready for execution.
QueryBuilder<T,R,ID>	A fluent builder for constructing type-safe SELECT and DELETE queries using the entity graph and metamodel.
QueryBuilderImpl<T,R,ID>
QueryContext	Describes a single statement execution observed by a QueryObserver.
QueryContext.ExecutionKind	Classifies how a statement is executed.
QueryImpl
QueryObserver	Observes query executions performed by an ORM template.
QueryObserver.Observation	Tracks a single observed statement execution.
QueryObserver.TransactionObservation	Tracks a single observed physical transaction.
QueryTemplate	Provides methods for constructing SQL queries and query builders using String Templates or the fluent API.
QueryTemplateImpl
ReadOnlyTransactionException	Thrown when a statement Storm recognises as a write, an INSERT, UPDATE or DELETE, is executed inside a read-only transaction.
RecordField	Represents metadata about a field in a data record type.
RecordType	Represents metadata about a data record type.
Ref<T>	Ref records are used to represent reference to records, allowing them to be fetched from the database.
Repository	Base interface for all Storm repositories, providing access to the underlying ORMTemplate.
RepositoryLookup	Provides access to repositories.
ResolveScope	Enumeration of the different modes for resolving an alias.
SchemaResolver	Resolves the schema a table lives in, per template.
Scrollable<T>	A scroll request: an ordering, a window size, and the position to continue from.
SelectMode	Specifies how much data a query should select for an entity or projection.
Slice<R>	A slice of query results: the shape a Page, a Window and a plain slice share.
SqlCommenter	Contributes a comment appended to SQL statements at execution time.
SqlLog	Records the statements a call executes, so a unit of work can be judged by what it cost the database.
SqlLog.Scope	A scope opened with SqlLog.open(java.lang.String), reporting its summary once closed.
SqlOperation	Represents the SQL mode.
SqlTemplateException	Thrown to indicate an error occurred while processing a SQL template.
StatementOrigin	Classifies what caused a statement to execute.
StormConfig	Immutable, untyped configuration for the Storm ORM framework.
StringTemplates
SubqueryTemplate	Provides factory methods for constructing subqueries that can be correlated with or embedded in an outer query.
TableNameResolver	Resolves the table name for a given record type.
TemplateDecorator	Decorator used for integrations with applications and frameworks.
Templates	The Templates interface provides a collection of static methods for constructing SQL query elements and creating ORM repository templates.
TemporalType	Represents the type of a temporal attribute.
Transaction	Handle to the transaction a transactional block runs in: exposes the rollback-only state and registration of completion callbacks.
TransactionBlock<R,E>	A transactional block executed by Transactions.transaction(st.orm.template.TransactionBlock<R, E>).
TransactionCallbackException	Thrown when a transaction completion callback fails.
TransactionIsolation	Transaction isolation levels, mapping to the JDBC isolation constants.
TransactionOptions	Options for a transactional block.
TransactionPropagation	Defines how a transaction block relates to a transaction that is already active when the block starts.
Transactions	Programmatic transactions for Java.
TransactionSupplier<R,E>	A block executed with scoped transaction defaults by Transactions.withTransactionOptions(st.orm.TransactionOptions, TransactionSupplier).
TransactionTimedOutException	Thrown when a transaction does not complete within its timeout.
TypedJoinBuilder<T,R,ID>	A builder for specifying the ON condition of a JOIN clause using a type-safe entity relation or a custom expression.
TypedMetamodel<T,E,V>	A Metamodel that also carries the declared component type of the field it represents.
UK	Marks a field as a unique key.
UnexpectedRollbackException	Thrown when a transaction completes with an unexpected rollback: the block finished normally, but the physical transaction was rolled back, for example because a joined inner scope marked it rollback-only.
UpdateMode	Controls how changes are detected and how UPDATE statements are generated for entities.
Version	Marks a record component as a version field to detect optimistic locking conflicts.
WhereBuilder<T,R,ID>	A builder for constructing the WHERE clause of a query, providing type-safe predicate construction.
Window<R>	Represents a window of query results from a scrolling operation with Scrollable navigation tokens.
WriteSet	Dependency-aware write operations over mixed-type sets of entities.