All Classes and Interfaces
Class
Description
Extension of
AbstractMetamodel that implements Metamodel.Key, indicating that the field has a
uniqueness constraint.Implementation that is used by the generated models.
Marker interface used within an SQL template to indicate where bind variables (parameters) should be injected.
A listener for record events within a SQL query context.
Represents metadata about a single column in a database table, as derived from the entity or projection model.
Resolves the column name for a record component.
Declares how a
Converter should be applied.Converts between an entity value type and a database column type.
Marker interface for record-based data classes.
Specifies the name for the column, table or view.
Annotation for specifying multiple database column names, e.g., for compound keys.
Specifies how an enum should be mapped when reading or writing to a column.
Suppresses schema validation for the annotated entity type or record component.
Specifies the schema name for the table or view.
Default implementation of the
JoinType interface used to represent the default join types.Defines how dirty checking is performed for an entity.
Configures discriminator behavior for sealed type hierarchies.
The discriminator column types supported for sealed type hierarchies.
Configures how changes are detected and how UPDATE statements are generated for a specific entity.
Represents an element in a ST/ORM SQL query.
Optional marker interface for record-based entities.
Typed callback interface for entity lifecycle events.
Provides a generic interface with CRUD operations for entities.
Defines the strategy to use when mapping enums.
Marks a field as a foreign key.
Resolves the column name for a foreign key component.
Defines the strategy to use when generating values for primary keys.
Indicates that the underlying fields of the record component are inlined in this record.
A builder for specifying the ON condition of a JOIN clause using a custom string template expression.
Represents a join type in a SQL query.
Marks a record component as a json object.
The metamodel provides type-safe references to entity fields for use in queries.
Marker interface for metamodel fields that correspond to columns known to be unique.
Delegating wrapper that adds the
Metamodel.Key marker to an existing Metamodel instance.Marks an annotation type to be represented as the specified type in the
Metamodel.Provides metadata about an entity or projection type, including its table name, primary key type, and column
definitions.
Thrown when
getSingleResult is executed on a query and there is more than one result from the query.Thrown when
getSingleResult is executed on a query and there is no result to return.Represents a comparison operator in a SQL query.
Thrown when an optimistic locking conflict occurs.
The primary entry point for Storm's ORM functionality, combining SQL template query construction with
repository access.
Represents a page of query results for offset-based pagination.
Represents a pagination request with a zero-based page number, page size, and optional sort orders.
Represents a sort order for a single metamodel field.
Allows the persistence properties of a record component to be configured.
Thrown when a database or sql problem occurs.
Marks a field as the primary key of an entity.
Specifies the inheritance strategy for a sealed entity hierarchy.
The inheritance strategies for sealed entity hierarchies.
Represents a composable predicate for the WHERE clause of a query, supporting
AND and OR composition.Represents an eagerly constructed, reusable query that supports batch operations and generated key retrieval.
Marker interface for record-based projections.
Projection records marked with this annotation type can specify a SQL query that represents the projection.
Provides a generic interface with read operations for projections.
Represents a constructed SQL statement that is ready for execution.
A fluent builder for constructing type-safe SELECT and DELETE queries using the entity graph and metamodel.
Provides methods for constructing SQL queries and query builders using String Templates or the fluent API.
Represents metadata about a field in a data record type.
Represents metadata about a data record type.
Ref records are used to represent reference to records, allowing them to be fetched from the database.
Base interface for all Storm repositories, providing access to the underlying
ORMTemplate.Provides access to repositories.
Enumeration of the different modes for resolving an alias.
Represents a scroll request that captures the cursor state needed to fetch a window of results.
Specifies how much data a query should select for an entity or projection.
Represents a slice of query results — a chunk of data with informational navigation flags.
Annotation for capturing and logging SQL statements.
Immutable, untyped configuration for the Storm ORM framework.
Provides factory methods for constructing subqueries that can be correlated with or embedded in an outer query.
Resolves the table name for a given record type.
Decorator used for integrations with applications and frameworks.
The
Templates interface provides a collection of static methods for constructing SQL query elements
and creating ORM repository templates.Represents the type of a temporal attribute.
A builder for specifying the ON condition of a JOIN clause using a type-safe entity relation or a custom expression.
Marks a field as a unique key.
Controls how changes are detected and how UPDATE statements are generated for entities.
Marks a record component as a version field to detect optimistic locking conflicts.
A builder for constructing the WHERE clause of a query, providing type-safe predicate construction.
Represents a window of query results from a scrolling operation with
Scrollable navigation tokens.