Module storm.foundation

Package st.orm

@NullMarked package st.orm

Foundation of the data model: the mapping annotations and the record interfaces.

Null-marked: type uses are non-null unless annotated @Nullable.

Related Packages

Module	Package	Description
storm.foundation	st.orm.mapping	Record mapping contracts.
storm.java	st.orm.repository	Java repository API.
storm.foundation	st.orm.spi
storm.java	st.orm.template	Java client API: templates, query builders and transactions.

Class	Description
AbstractKeyMetamodel<T extends Data,E,V extends @Nullable Object>	Extension of AbstractMetamodel that implements Metamodel.Key, indicating that the field has a uniqueness constraint.
AbstractMetamodel<T extends Data,E,V extends @Nullable Object>	Implementation that is used by the generated models.
AbstractNavigableMetamodel<T extends Data,E>	Base implementation for generated navigation-only metamodels — nodes that navigate the entity graph beyond a Ref foreign key.
AcceptAdvice	Accepts advice for the annotated entity, repository, class or method, so the advice log stops reporting it there.
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.
Convert	Declares how a Converter should be applied.
Converter<D,E>	Converts between an entity value type and a database column type.
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.
Entity<ID>	Optional marker interface for record-based entities.
EntityCallback<E extends Entity<?>>	Typed callback interface for entity lifecycle events.
EntityCallbacks	Declares the EntityCallback types that apply to the annotated entity.
EnumType	Defines the strategy to use when mapping enums.
FK	Marks a field as a foreign key.
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, a joining block that states a stricter isolation level than the transaction it joins runs at, or a block that states retries but does not own its physical transaction.
Inline	Indicates that the underlying fields of the record component are inlined in this record.
IntegrityViolation	A value that breaks a rule of its table: a duplicate under a unique key, a reference to a row that does not exist, a null in a column that refuses it, a value a check constraint rejects, or a value too large for its column.
IntegrityViolation.Check	A value a check constraint rejects.
IntegrityViolation.ForeignKey	A foreign key that references a row that does not exist.
IntegrityViolation.Length	A string longer than its column.
IntegrityViolation.NotNull	A null in a column that does not accept one.
IntegrityViolation.NumericRange	A number with more digits before the decimal point than its column holds.
IntegrityViolation.Referenced	A row that other rows still reference through a foreign key, so it cannot be removed, or have its key changed.
IntegrityViolation.Unique	A value, or a combination of values, that another row already holds under a unique key or the primary key.
IntegrityViolationException	Thrown when a value breaks a rule of its table: a write the database refuses for a constraint, a null in a non-nullable field at write time, or a value that validateOrThrow finds too large for its column.
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.
JoinType	Represents a join type in a SQL query.
Json	Marks a record component as a json object.
Match<T extends Data>	A text column of a search or suggest with the form a typed word matches it in.
Match.Anywhere<T extends Data>	A word matches anywhere in the value: LOWER(column) LIKE LOWER('%word%').
Match.Exact<T extends Data>	A word matches the whole value.
Match.Prefix<T extends Data>	A word matches at the start of the value.
Match.WordStart<T extends Data>	A word matches at the start of any word in the value: the value's start, or the text after a space or one of the punctuation characters that join or separate the words of a name, a hyphen, an apostrophe, an opening parenthesis, a slash, a colon, a period or a comma, so marie matches "Anne-Marie" and brien "O'Brien".
Metamodel<T extends Data,E>	The metamodel provides type-safe references to entity fields for use in queries.
Metamodel.Key<T extends Data,E>	Marker interface for metamodel fields that correspond to columns known to be unique.
Metamodel.KeyDelegate<T extends Data,E>	Delegating wrapper that adds the Metamodel.Key marker to an existing Metamodel instance.
Metamodel.Outer<T extends Data,E>	A path named in the query that encloses the subquery it is used in, see Metamodel.outer(Navigable).
MetamodelType	Marks an annotation type to be represented as the specified type in the Metamodel.
Navigable<T extends Data,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: the row changed, or was removed, after the entity was read.
Order	A sort order for one metamodel field.
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.
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.
QueryColumn	Declares a column a query names but the entity or projection does not carry: a query column.
QueryColumns	Declares several query columns in one annotation.
ReadOnlyTransactionException	Thrown when a statement Storm recognises as a write, an INSERT, UPDATE or DELETE, is executed inside a read-only transaction.
Ref<T extends Data>	Ref records are used to represent reference to records, allowing them to be fetched from the database.
ResolveScope	Enumeration of the different modes for resolving an alias.
Scrollable<T extends Data>	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.
SqlFunction<E>	A SQL function of one argument, applied to a column wherever a query takes a column.
SqlFunction.Call<T extends Data,E>	The call of a function on a path.
SqlTemplateException	Thrown to indicate an error occurred while processing a SQL template.
StormConfig	Immutable, untyped configuration for the Storm ORM framework.
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.
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.
TransactionTimedOutException	Thrown when a transaction does not complete within its timeout.
TransientPersistenceException	Thrown when a failure stems from concurrent activity, such as a deadlock, a serialization failure or an optimistic lock conflict.
TypedMetamodel<T extends Data,E,V extends @Nullable Object>	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.
UnexpectedRowCountException	Thrown when a write affects a different number of rows than it expects: an insert, update or remove of an entity that affects no row, or a batch whose affected row count differs from its size.
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.
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.