All Classes and Interfaces
Class
Description
Base descriptor for
array_contains, providing its validation and type
resolution while subclasses implement database-specific rendering.Base descriptor for
array_fill, providing validation and type resolution
while subclasses implement database-specific rendering.Basic array get function configuration.
Encapsulates the validator, return type and argument type resolvers for the array_includes function.
Encapsulates the validator, return type and argument type resolvers for the array_intersects function.
Base Java descriptor for a basic array stored in one relational value.
Encapsulates the validator, return type and argument type resolvers for the array_position functions.
Encapsulates the validator, return type and argument type resolvers for the array_positions functions.
Base descriptor for
array_remove, providing validation and type resolution
while subclasses implement database-specific rendering.Encapsulates the validator, return type and argument type resolvers for the array_reverse functions.
Encapsulates the validator, return type and argument type resolvers for the array_sort functions.
Encapsulates the validator, return type and argument type resolvers for the array_remove functions.
Convenience base class for
AuxiliaryDatabaseObjects.Type Descriptor for the Postgis Geometry type
Defines a base class for events involving collections.
Base implementation of the
QueryableCollection interface.Base support for
CurrentSessionContext implementors.Base for events which denote database operations.
Basic support for implementations of
MultiTenantConnectionProvider based on DataSources.Convenience base class for custom implementors of
MetadataImplementor using delegation.Convenience base class for custom implementors of
MetadataBuilderImplementor using delegation.Convenience base class for custom implementors of
MetadataBuildingOptions using delegation.Base class for
SessionBuilder implementations that wish to implement only parts of that contract themselves
while forwarding other method invocations to a delegate instance.Base class for
SessionBuilderImplementor implementations that wish to implement only parts of that contract
themselves while forwarding other method invocations to a delegate instance.Convenience base class for custom implementors of SessionFactoryBuilder, using delegation
Convenience base class for custom implementors of
SessionFactoryBuilderImplementor, using delegationConvenience base class for custom implementations of
SessionFactoryOptions
using delegation.Base class for
SharedSessionBuilder implementations that wish to implement only parts of that contract
themselves while forwarding other method invocations to a delegate instance.Template support for DeleteCoordinator implementations.
Optional interface caching implementors can implement in their
CachedDomainDataAccess impls to automatically have them destroyed
when this region is destroyed
Basic functionality for persisting an entity via JDBC, using either generated or custom SQL.
Consolidated these onto a single helper because the 2 pieces work in tandem.
Consumer for processing table details.
AbstractFetchParent sub-class for entity-valued graph nodes
Base class for events which are generated from a
Session
or StatelessSession.Base abstract implementation of
Identifier.Base implementation for JDBC descriptors which exchange a Java time value
directly through
ResultSet.getObject() and PreparedStatement.setObject().Abstract
JdbcLiteralFormatter implementation managing the JavaTypeSupported base for an immutable, single-table JDBC mutation operation.
Base support for
JpaSelection impls.Base support for
JpaTupleElement implsSubclassable descriptor for the standard
json_array_append function.Subclassable descriptor for the standard
json_array_insert function.Standard json_insert function.
Subclassable descriptor for the standard
json_mergepatch function.Subclassable descriptor for the standard
json_remove function.Standard json_replace function.
Subclassable descriptor for the standard
json_set function.Convenience base class for lazy initialization handlers.
Default implementation of
LimitHandler interface.Basic support for
MultiTenantConnectionProvider implementations using
an individual ConnectionProvider instance per tenant behind the scenes.Base support for coordinating mutations against an entity
Superclass for
LimitHandlers that don't support
offsets at all.Common support for
Optimizer implementations.Base support for DialectOverrider annotations
Base class implementing
PersistentCollectionContract for operations which are part of a collection's operation queue.
TBH not sure why this is public
Represents an operation successfully executed by the database.
Type Descriptor for the Postgis Geometry type
Provider base for serializing and deserializing an embeddable aggregate
using the PostgreSQL component format.
Represents an operation that is about to be executed by the database.
Base implementation of
QueryParameter.Wrapper type representing unlocked items.
Interface type implemented by all wrapper objects in the cache.
Wrapper type representing locked items.
Subclassable descriptor for the
regexp_like predicate.Base for provider-owned table-mutation builders which collect key and
optimistic-lock restrictions.
Abstract
GeneratedValuesMutationDelegate implementation where
the underlying strategy causes the generated identifier to be returned as
an effect of performing the insert statement.An abstract implementation of
ReturningWork that accepts a WorkExecutor
visitor for executing a discrete piece of work and returning a result.Abstract
GeneratedValuesMutationDelegate implementation where
the underlying strategy requires a subsequent select after the
insert to determine the generated identifier.Supported provider base for a SQL AST expression which renders itself.
Convenience base class for the serialized form of
AbstractLazyInitializer.Base class for events which are generated from a Session
(EventSource).
Superclass for simple
LimitHandlers that don't
support specifying an offset without a limit.TODO : javadoc
Supported generic base for translating query and model-mutation SQL ASTs.
Base for provider-owned SQL AST traversal.
Type descriptor for the SQL Server 2008 Geometry type.
Models a join based on a mapped attribute reference.
Convenience base class for SqmFrom implementations
Base descriptor for custom SQM function generation.
Convenience base class for InsertSqmStatement implementations.
Base class for expressions that contain a json path.
Base implementation of a criteria node.
Common support for SqmParameter impls
Base support for joins to plural attributes
Base descriptor for functions which directly render their SQL AST form.
Convenience base class for
BasicType implementations.Supported provider base for Dialects derived from the Sybase family.
Base for provider-owned
TableInsertBuilder implementations.Base
TableMutation supportBase for provider-owned
TableMutationBuilder implementations.Base support for TableUpdate implementations
Base for provider-owned
TableUpdateBuilder implementations.Base Java descriptor for temporal values with precision-specific
resolution hooks.
A supported base for provider Dialects derived from the Transact-SQL family,
including Sybase and Microsoft SQL Server variants.
Abstract superclass of the built-in
Type hierarchy.Deprecated.
An abstract implementation of
Work that accepts a WorkExecutor
visitor for executing a discrete piece of work.Contract for providing callback access to a
DatabaseStructure,
typically from the Optimizer.Deprecated.
No longer used
Settings related to the property accessor strategy.
Enumerates various access strategies for accessing entity values.
Enumerates the policies for managing concurrent access to the shared
second-level cache.
Indicates that
AccessType could not be
determinedEnumerates the actions that may be performed by the
schema management tooling.
Common interface for ActionQueue implementations.
An opaque checkpoint of an
ActionQueue's state before speculative flush
preparation.Factory for ActionQueue instances.
Legacy implementation of the action queue.
Order the
ActionQueueLegacy.insertions queue such that we group inserts against the same entity together (without
violating constraints).Defines the context needed to call the
TypeSafeActivator.Collector for contributions from contributors
Contract allowing pluggable contributions of additional mapping objects.
Extension contract for
BasicType implementations which understand how to
adjust themselves relative to where/how they're used by, for example, accounting
for LOB, nationalized, primitive/wrapper, etc.A
JdbcType which may select a more appropriate descriptor for a specific
mapping context, including LOB, nationalized, or primitive/wrapper use.Allows runtime adjustment of a discrete set of Hibernate settings.
An action to be performed after an entity has been loaded.
Contract representing some process that needs to occur during after transaction completion.
Actions to perform in regard to a temporary table after each use.
Describes a structured array or table element and capacity.
Identifies a declarative aggregate schema object materialized by Hibernate.
Supplies aggregate auxiliary-object facts without exposing a namespace.
An aggregate column is a column of type
SqlTypes.STRUCT,
SqlTypes.JSON or SqlTypes.SQLXML
that aggregates a component into a single column.Handler for assignments to sub-columns of an aggregate column, which require a special write expression.
Describes one aggregate or scalar column without exposing mutable boot
mapping state.
Resolves the value assigned to one aggregate selectable.
Supplies one call's aggregate-component assignment-expression facts.
Supplies one call's aggregate-component read-expression facts.
Supplies one call's aggregate custom-write facts.
An "aggregated" composite identifier, which is another way to say that the
identifier is represented as an embeddable.
Specialized EmbeddableResultGraphNode for cases where we have an actual embeddable class.
A simple walker that checks for aggregate functions.
Models an aggregate function expression at the SQL AST level.
Describes the physical ordering of the component JDBC values of an
aggregate relative to the logical ordering defined by its mapping.
Converts aggregate values between their mapped-domain representation and
the component JDBC values consumed or produced by an
AggregateJdbcType.Declares ordered SQL commands for one aggregate schema object.
Defines aggregate-column mapping, DDL, read, assignment, and write behavior
for a
Dialect.Supplies the stable standard aggregate profile.
Declares facts materialized into Hibernate's structured-array model.
Since the query spec will render a hypothetical set window function instead of an aggregate,
the following query transformer will wrap the query spec and apply aggregation in the outer query.
Renders one aggregate-column custom write expression.
Supplies one call's aggregate write-renderer mappings.
An alias generator for SQL identifiers.
Occurs when the HQL query declares a duplicate identification variable
in the
from clause, or a duplicate result column alias in the
select clause.A wrapper for an expression that also renders an alias.
Describes one requested column-type alteration.
Renders alter-table and add-column grammar.
A
Generator which receives parameters from a custom
generator annotation or
id generator annotation.A
UserType which receives parameters from a custom annotation.An exception that occurs while reading mapping annotations.
Standard family base for databases using the ANSI
next value for
expression and ordinary create/drop sequence grammar.Maintains the set of ANSI SQL keywords
Maps a to-one cardinality association taking values over several entity types which
are not related by the usual entity inheritance, using a discriminator
value stored on the referring side of the relationship.
A mapping model object representing a polymorphic association
to one of several tables.
The discriminator Value
A simplified way to specify the type of the discriminator in an
Any
mapping, using the JPA-defined DiscriminatorType.Defines how to handle discriminator values which are not explicitly
mapped with AnyDiscriminatorValue.
Source information about the discriminator for an ANY mapping
Specifies the mapping of a single any-valued
discriminator value to its corresponding entity type.
List of
AnyDiscriminatorValues.Specifies the Java class to use for the foreign key handling
related to an
Any mapping.Form of
JavaType used to describe the foreign-key part of an ANY mapping.Form of
JdbcTypeCode used to describe the foreign key
part of an Any mapping.Models Hibernate's
@Any mapping
(reverse discrimination) as a JPA domain model type.Base description for all discriminated associations ("any mappings"), including
<any/>, <many-to-any/>, etc.Handles "any" mappings
Used to externalize discrimination per a given identifier.
Internal delegate which appends the Dialect's identity-selection SQL to an
insert and consumes the resulting row.
Contract for anything a fetch/load graph can be applied
Models a logical archive, which might be
Contract for building ArchiveDescriptor instances.
Represent an entry in the archive.
Indicates a problem related to accessing or visiting an archive.
Validates the arguments provided to an HQL function invocation.
Typechecks the arguments of HQL functions based on the assigned JDBC types.
Specifies the maximum length of a SQL array type mapped by
the annotated attribute.
An array mapping has a primary key consisting of the key columns + index column.
A
FunctionArgumentTypeResolver that resolves the array argument type based on the element argument type
or the element argument type based on the array argument type.A
ArgumentsValidator that validates the array type is compatible with the element type.A
ArgumentsValidator that validates the array type is compatible with the element type.Subclassable descriptor for concatenating an array and an element.
Subclassable descriptor for concatenating arrays.
Subclassable descriptor for array constructor expressions.
A
FunctionArgumentTypeResolver that resolves the argument types for the array_contains function.A
ArgumentsValidator that validates the arguments for the array_contains function.Special array contains function that also applies a cast to the element argument.
Subclassable
array_contains descriptor implemented using unnest.Implement the array get function by using
[] (bracket) syntax.Implement the array get function by using
unnest.A
FunctionArgumentTypeResolver that resolves the argument types for the array_includes function.A
ArgumentsValidator that validates the arguments for the array_includes function.Special array includes implementation that uses the PostgreSQL
@> operator.Implement the array includes function by using
unnest.Array intersects function that uses the PostgreSQL
&& operator.Implement the intersects function by using
unnest.Descriptor for
T[] handling.JDBC descriptor for
Types.ARRAY values.Factory for
ArrayJdbcType.Deprecated, for removal: This API element is subject to removal in a future version.
Use
ImmutableObjectArrayMutabilityPlan.get() for object arrays,
or implement a dedicated mutability plan for primitive arrays
(see for example ShortPrimitiveArrayJavaType's mutability plan).Subclassable
array_remove_index descriptor implemented using unnest.Subclassable
array_replace descriptor implemented using unnest.Implement the array set function by using
unnest.Implement the array slice function by using
unnest.A
ArgumentsValidator that validates all arguments are of the same array type.Immutable description of a Dialect's array syntax and multi-valued
parameter-binding behavior.
Build an immutable array-support profile.
An independently configurable array-syntax capability.
How multi-valued parameters are passed to the database.
A type for persistent arrays.
A
FunctionReturnTypeResolver that resolves the array type based on an argument.A
FunctionReturnTypeResolver that resolves an array type based on the arguments,
which are supposed to be of the element type.Indicates failure of an assertion: a possible bug in Hibernate.
A
Generator that doesn't generate.Deprecated, for removal: This API element is subject to removal in a future version.
replaced by
AssignedMarker interface for TableMutations which assign values - INSERT, UPDATE, MERGE.
Specialized builder for building mutations which allow assigning values (INSERT or UPDATE).
An assignment to a field or property of an entity or embeddable.
Identifies the association referenced by a
Fetch.Commonality for an association, mainly details relative to the foreign-key
Identifies a named association belonging to a particular
entity instance.
Used as part of circularity detection
A type that represents some kind of association between entities.
Contract for a mapping attribute.
Specifies an attribute access strategy to use.
Results of analyzing an attribute in terms of
handling update operations
Dirty-ness status of each attribute:
it's useful to differentiate when it's definitely dirty,
when it's definitely not dirty, and when we need to treat
it like dirty but there is no certainty - for example
because we didn't actually load the value from the database.
Allows a user-written annotation to drive some customized model binding.
Associates a user-defined annotation with an
AttributeBinder,
allowing the annotation to drive some custom model binding.An extended set of
Attribute.PersistentAttributeType adding AttributeClassification.ANYDefines a contract for the Envers mapping model in terms of being able to contain attributes.
Identifies a mapping model object which may have attributes
(fields or properties).
Describes an attribute at the mapping model level.
This is essentially a List of AttributeMapping(s), but exposing
an interface which is more suitable to our needs; in particular
it expresses the immutable nature of this structure, and allows
us to extend it with additional convenience methods such as
AttributeMappingsList.indexedForEach(IndexedConsumer).Similar to
AttributeMappingsList, this is essentially
an immutable Map of AttributeMapping(s), allowing iteration of
all mappings but also retrieval by name (a String key).Commonality for annotations which identify attributes.
An enum defining the nature (categorization) of a persistent attribute.
Represents a fetched attribute in an
entity graph.
Integration version of the
AttributeNode contract.An attribute path is, generally speaking, the path of attribute names back
to a "root" (which is either an entity or a persistent collection).
An attribute role is, generally speaking, the path of attribute names back
to a "root" (which is either an entity or a persistent collection).
Contract for sources of persistent attribute descriptions.
Contract for a container of
AttributeSource references.Transaction-scoped audit change set with shared audit merge semantics.
A collection audit change.
A merged entity audit change.
Support for building audit log mutations for collections.
Specifies that the annotated entity class is an audited entity
or audited collection.
When applied to a class, indicates that all of its properties should be audited.
Specifies a custom audit table name (and optionally schema
and catalog) for an audited collection.
Excludes the annotated attribute from auditing.
Specifies a custom audit table name for a
@SecondaryTable.Container for repeatable
Audited.SecondaryTable annotations.Specifies the audit log's table mapping for an audited
entity.
Contract for loading entity snapshots from audit tables at a specific transaction
A tuple representing an entity at a specific changeset in
the audit history.
Indicates a problem related to audit functionality.
Create restrictions or projections using a function.
Create restrictions and projections for the id of an audited entity.
A service for querying the audit log.
Factory for obtaining
AuditLog instances.
Annotation to specify a "fake" bidirectional relation.
Metadata about audit log tables for entities and collections enabled for audit logging.
Standalone legacy audit writer for entity audit rows.
The
AuditingOverride annotation is used to override the auditing
behavior of a superclass or single property inherited from MappedSuperclass
type, or attribute inside an embedded component.The
AuditingOverrides annotation is used to override the auditing
behavior for one ore more fields (or properties) inside an embedded
component.Create restrictions, projections and specify order for a property of an audited entity.
Provides access to past versions of audited entities based on
a global revision.
Create restrictions on an id of an entity related to an audited entity.
Enumerates the possible strategies for querying
audited
entities and collections.
Deprecated.
use
AuditStrategy instead.A strategy abstraction for how to audit entity changes.
A contract to initialize an
AuditStrategyTransaction-scoped queue for deferred audit row writes.
Contract for writing a single entity audit row to the
audit table at transaction completion.
A
JDBCException indicating an authentication or authorization failure.Contract for handling auto-apply
checks for JPA converters.
Event class for
automatic
stateful session flush.Defines the contract for handling of session auto-flush events.
An auxiliary database object is a trigger, function, stored procedure,
or anything similar which is defined using explicit handwritten DDL
create and drop statements in the mapping metadata.Additional, optional interface for
AuxiliaryDatabaseObjects
that want to allow expansion of allowable dialects via mapping.Runtime mapping contract for state-management state associated with an
entity or collection.
Something that can have an associated auxiliary table,
for example, an audit table or a temporal history table.
Table reference that matches both an auxiliary table expression
(history or audit table) and the current table expression.
Combined set of Hibernate and Jakarta Persistence hints.
Enumerates the configuration properties supported by Hibernate, including
properties defined by the JPA specification.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
SQLServerDialect instead.A mapping model object representing a collection of type
Collection which may
contain duplicates.Hibernate extension to the JPA
CollectionAttribute descriptorBase class for Envers' collection event related listeners
Base class for all Envers event listeners
Base support for an SQM walker
Supported base for provider-defined SQM-to-SQL-AST translators.
A type that maps between
ARRAY and T[]Contract for a basic, singular attribute.
Convenience base for a
ValueBinder which centralizes null handling and
JDBC binding diagnostics.Descriptor for handling persistent collections.
A type that maps between
ARRAY and Collection<T>Intended as support for custom resolvers which match a single db name (with optional version info).
Hibernate extension to the JPA
BasicType contract.Mapping for a simple, single-column identifier
Convenience base for a
ValueExtractor which centralizes null handling and
JDBC extraction diagnostics.Fetch for a basic-value
Specializes
JavaType for basic values in the sense of
Type.PersistenceType.BASIC.Support for
JdbcLiteralFormatter
implementations with a basic implementation of an BasicJdbcLiteralFormatter.unwrap(Object, Class, WrapperOptions) methodLazy initializer for plain Java objects.
Describes a basic plural Java value mapped to one column, such as an SQL
array or a JSON/XML collection.
A basic plural type.
A proxy factory for "basic proxy" generation.
DomainResult for a basic-value
DomainResult for basic values
Delegate for dealing with
IDENTITY columns where the dialect requires an
additional command execution to retrieve the generated IDENTITY valueA helper to centralize conversion of
SQLExceptions to JDBCExceptions.Describes a basic value mapping which combines its Java and JDBC type
descriptors with the runtime mapping contracts required by Hibernate.
A basic type reference.
A registry of
BasicType instancesResolved form of
BasicValue as part of interpreting the
boot-time model into the run-time modelSupport for basic-typed value conversions.
Any basic-typed ValueMapping.
Describes a ModelPart which is a basic value, either
a
Basic attribute
a basic-valued collection part
Represents the lifecycle of a batch of statements to be executed together.
A builder for
Batch instances.Checks the result for one row in a JDBC batch.
Much like
TooManyRowsAffectedException, indicates that more
rows than what we were expecting were affected.Indicates a failed batch entry (-3 return).
Keeps track of:
entity and collection keys that are available for batch fetching
details related to queries which load entities with sub-select-fetchable collections
Unique key for batch identification.
Commonality for loading a loadable in "batch" (more than one key at a time)
Factory for
BatchLoader instancesAn observer contract for batch events.
Specifies a maximum batch size for batch fetching of the annotated
entity or collection.
Deprecated, for removal: This API element is subject to removal in a future version.
Abstracts any kind of container for managed beans, for example,
the CDI
BeanManager.Acquisition policy read by container implementations.
Controls caching of bean references obtained from the
ManagedBeanRegistry.Contract for producing a bean instance
Event listener used to enable Bean Validation for insert/update/delete events.
In
Integrator for Bean Validation.Sub-system logging related to Bean Validation integration
A generator that is called to produce a value just before a row is written to the database.
Contract representing some process that needs to occur during before transaction completion.
Actions to perform in regards to a temporary table prior to each use.
Marker interface for Fetches that are actually references to
another fetch based on "normalized navigable path"
The following query is used throughout the javadocs for these impls
to help describe what it going on and why certain methods do certain things.
Descriptor for
BigDecimal handling.Descriptor for
BigInteger handling.Descriptor for
BIGINT handling.Enumeration of standard binary arithmetic operators
Descriptor for
BINARY handling.Wraps a binary stream to also provide the length which is needed when binding.
Defines a contract for objects that are bindable.
Contract for things at the domain mapping level that can be bound
into a JDBC
PreparedStatement.Functional interface for consuming the JDBC values, along with two values of type
X and Y.Functional interface for consuming the JDBC values.
Represents a type of argument which can be bound to a positional or named
query parameter.
A context within which a
BindableType can be resolved
to an instance of SqmExpressible.Group of all parameter bindings for a table.
Represents JDBC parameter binding for graph-based operation execution
A single JDBC parameter slot in a mutation statement.
Marker interface for non-contextually created
Blob instances.Descriptor for
Blob handling.Descriptor for
BLOB handling.Manages aspects of representing
Blob objects.Describes how long protection acquired by one operation on a row prevents
a conflicting operation in another transaction from accessing that row.
Utility for decoding boolean representations.
Descriptor for
Boolean handling.Descriptor for
BOOLEAN handling.Descriptor for
boolean[] handling.Logging related to Hibernate bootstrapping
Entry into the bootstrap process.
Defines a context for things available during the process of bootstrapping
a
SessionFactory which are expected to be cleaned up
after the SessionFactory is built.Provides the most basic services such as class loading.
Builder for
BootstrapServiceRegistry instances.A type that is assignable to every non-primitive type,
that is, the type of
null.Describes the built-in externally-nameable
PropertyAccessStrategy implementations.Specialized contract for
IdentifierGenerator implementations capable of being used in conjunction
with HQL insert statements.Deprecated.
This kind of mapping is no longer required by the JPA specification.
Encapsulates bytecode enhancement information about a particular entity.
Logging related to bytecode enhancement interceptors
Contract for providers of bytecode services to Hibernate.
Settings which control the
BytecodeProvider
used for bytecode enhancement and reflection optimization.Descriptor for
Byte handling.Marks a root entity or collection for second-level caching, and
specifies:
a named cache region in which to store
the state of instances of the entity or collection, and
an appropriate cache concurrency policy,
given the expected data access patterns affecting the entity
or collection.
An API for directly querying and managing the second-level cache.
Optional contract for JdbcOperation implementors allowing them
to be used with Query caching.
Identifies policies for managing concurrent access to the shared
second-level cache.
Base contract for accessing the cached data for a particular element of
the domain model in a transactionally ACID manner.
The type of action from which the cache call is originating.
A cached instance of a persistent class
Operations for assembly and disassembly of an array of property values.
Strategy for how cache entries are "structured" for storing into the cache.
Something went wrong in the cache.
Initiator for second level cache support
A factory for keys into the second-level cache.
Describes the data layout used for storing an object into the query cache.
Controls how the session interacts with the second-level cache
or query cache.
Models the definition of caching settings for a particular region.
Second-level cache statistics of a specific region.
Settings for Hibernate's second-level caching
Defines a context object that a
RegionFactory is asked to create
(RegionFactory.createTransactionContext(SharedSessionContractImplementor)}) when a Hibernate Session
is created.Models the caching options for an entity, natural id, or collection.
Descriptor for
Calendar handling, but just for the date (month, day, year) portion.Descriptor for
Calendar handling.Descriptor for
Calendar handling, but just for the time portion.Interprets a semantic procedure or function call as the JDBC call executed
by Hibernate.
Provides standard and database-specific callable-statement strategies.
Configures the standard callable-statement algorithm.
Represents a JPA entity lifecycle callback method.
Callback to allow SQM interpretation to trigger certain things within ORM.
Boot model definition of a Jakarta Persistence style callback.
Deprecated.
Methods of
Interceptor are no longer required to
throw this exception type.Enumerates the Jakarta Persistence style lifecycle callback types.
Deprecated, for removal: This API element is subject to removal in a future version.
Post-execution callback that performs only the essential persistence
context cleanup after a delete action is processed.
Indicates an attempt was made to add a (key)? subgraph to an
attribute type that does not support (key)? subgraphs.
Describes the point at which a cascade is occurring
Immutable, mapping-ordered selection of entity property indexes for one
exact cascade route.
A contract for defining the aspects of cascading various persistence actions.
Describes sources which define cascading.
A session action that may be cascaded from parent entity to its children
Some databases don't have a function like
least() or greatest(),
and on those platforms we emulate the function using case.ANSI SQL-inspired
cast() function, where the target types
are enumerated by CastType, and portability is achieved
by delegating to Dialect.castPattern(CastType, CastType).The HQL
str() function is now considered a synonym for cast(x as String).Defines the set of basic types which should be
accepted by the
cast() function on every
platform.Allows access to any
cfg.xml files specified for bootstrapping.Marks an entity as the changelog entity for audit logging.
Marks the property that holds the changeset identifier
in a
@Changelog.Marks a
Set<String> property of a
@Changelog that holds the
names of entity types modified in each changeset.Marks the property that holds the changeset timestamp in a
@Changelog.Base
@MappedSuperclass for changeset
entities, providing the standard REV (auto-generated
integer primary key) and REVTSTMP (Unix epoch
timestamp) columns.A built-in
ChangesetIdentifierSupplier that persists
a user-defined changelog entity and returns the
@Changelog.ChangesetId
property value as the changeset id for audit rows.Complete transaction changeset context produced by a
ChangelogSupplier.A callback invoked when a new
changelog entity is created, allowing the application to
populate custom fields such as the current user or a comment.
The transition-image exposed by a data-change table expression.
Deprecated.
This kind of mapping is no longer required by the JPA specification.
Descriptor for
Character handling.Wraps a character stream (reader) to also provide the length (number of characters) which is needed
when binding.
Descriptor for
CHAR handling.Deprecated.
Represents a table or column level
check constraint.Commonality for annotations which define check-constraints
Identifies where a check constraint is declared.
Describes one check constraint at its selected DDL placement.
Defines supported check-constraint placements and rendering.
Enumerates the possible reactions to a boot-time check.
Indicates that a package or top-level type contains HQL or JPQL
queries encoded as static strings that should be validated at
compile time by the Metamodel Generator or Query Validator.
Deprecated.
since
Check is deprecated.A chr implementation that translates integer literals to string literals.
Descriptor for
Class handling.During the process of building the metamodel, access to the
ClassLoader is
strongly discouraged.Utility class that facilitates loading of a class.
A service for interacting with class loaders.
Indicates a problem performing class loading.
A persistence provider provides an instance of this interface to the container.
Used to indicate which query clause we are currently processing
Event class for
Session.clear().Listener for notification of
Session.clear()Marker interface for non-contextually created
Clob instances.Descriptor for
Clob handling.MutabilityPlan for Clob values
Base JDBC descriptor for
Types.CLOB handling.Manages aspects of proxying
Clobs for non-contextual creation, including proxy creation and
handling proxy invocations.Helper for determining the correct clock for precision
Contract for an object that is cloneable.
Unification of
Iterator and AutoCloseable.Implement the array fill function by using
generate_series.Deprecated.
Spatial Dialects are no longer needed.
CockroachDB json_exists function.
CockroachDB json_query function.
CockroachDB json_remove function.
CockroachDB json_table function.
CockroachDB json_value function.
A SQL dialect for CockroachDB 23.2 and above.
A
BasicResultAssembler which does type coercion to handle cases
where the expression type and the expected result JavaType are different
(e.g.A problem converting between JDBC types and Java types.
Helper for type coercions.
Specifies a collation to use when generating DDL for
the column mapped by the annotated field or property.
A mapping model object representing a collection.
Shared diffing, operation planning, and binding support for audited collection row mutations.
One row-level collection audit change.
A resolved collection audit mutation operation.
Execution-agnostic plan for inserting collection audit rows.
Owning entity audit change implied by a collection mutation.
Execution-agnostic plan for closing previous validity audit rows.
Allows for the customization of an Envers audit collection table.
Contract for writing collection audit rows to the audit
table at transaction completion.
Identifies the reference state against which a
CollectionDelta is expressed.BatchLoader specialization for collection fetching
Cacheable representation of persistent collections
One ordered semantic change within a
CollectionDelta.An element newly present at its current position.
A bulk clear whose individual persisted removals are not enumerated.
An element retained while its semantic position changed.
An element no longer present at its snapshot position.
A value replaced while retaining its semantic row identity.
Represents the complete set of changes between a collection's snapshot state
and its current state.
Represents an element that was added to the collection.
Represents an element that was removed from the collection.
Represents an element that changed position within the collection.
Represents an element whose value changed at the same position.
Classifications of the plurality.
Contract for managing transactional and concurrent access to cached collection
data.
Specialized DomainDataCachingConfig describing the requested
caching config for a particular persistent collection's data
Decomposer for prepared collection mutations.
An immutable semantic description of collection changes relative to an
identified reference state.
Identifies one role/key endpoint of a collection transition.
We need an entry to tell us all about the current state
of a collection with respect to its persistent state
Read-only view of collection processing state and actions planned during the current flush.
Describe the identifier for an id-bag.
Descriptor for the collection identifier.
Specifies the Java class to use for the id of an id-bag mapping.
Form of
JavaType for describing the id of an id-bag mapping.Form of
JdbcType for describing the id of an id-bag mapping.Form of
JdbcTypeCode for describing the id of an id-bag mapping.Form of
Mutability for describing the id of an id-bag mappingForm of
Type for describing the id of an id-bag mapping.Initializer implementation for initializing collections (plural attributes)
Functional contract to create a
CollectionInitializer.Runtime and mapping facts used to interpret a collection mutation.
Outcome of interpreting a collection mutation.
Extension of the general JavaType for "collection types"
Manages standard MutationOperation, as well as parameter binding details, for collection mutations.
Uniquely identifies a collection instance in a particular session.
A loader (initialization) for collections
MappingType descriptor for the collection Java type (List, Set, etc)
Identifies one semantic collection mutation within a flush cycle.
Queue-neutral collection mutation input produced by flush visitation.
A frozen, queue-neutral interpretation of one semantic collection mutation.
Interprets a logical transition using one collection's semantics and mapping facts.
Contributes state-management-specific collection mutation plans for graph queue decomposition.
Standard support for
CollectionDataAccess
using the AccessType.NONSTRICT_READ_WRITE access type.Base contract for coordination of collection mutation operations
Hibernate understands mapping a collection into 4 parts
The key - the foreign-key defining the association to the owner
The element - for Maps this is analogous to the value
The index - the List/array index or Map key
The collection-id - this is only relevant for id-bag mappings
Represents a part of a `CollectionPart` (element or index descriptor) as a DomainPath
A strategy for persisting a mapped collection role.
Standard support for
CollectionDataAccess
using the AccessType.READ_ONLY access type.Standard support for
CollectionDataAccess
using the AccessType.READ_WRITE access type.Each instance of this interface describes the semantics of some sort of
persistent collection so that Hibernate understands how to manage the
lifecycle of instances of that sort of collection.
Resolve the collection semantics for the given mapped collection.
Collection-related statistics.
TableDescriptor for collection tables.A table group for collection tables of plural attributes.
Interface to be implemented by collection trackers that hold the expected size od collections, a simplified
Map<String, int>.Describes the logical relationship between the loaded and current collection endpoints.
Names a custom collection type for a persistent collection.
A type that handles Hibernate
PersistentCollections (including arrays).Allows to register a
UserCollectionType
to use as the default for the specified classification of collection.Registration for a UserCollectionType
Repeatable container for
CollectionTypeRegistrationAn implementation of
Selection that represents a logical column.Extracts the unique result-column alias used while auto-discovering native
SQL query results.
Contract for a container of columns.
Specifies that a column has a
default value specified in DDL.Provides the rendered inputs for a non-identity column definition.
Appends the database-specific non-identity part of a column definition.
Immutable descriptor for a column involved in a mutation.
Provides access to information about existing table columns
A pluggable contract that allows ordering of columns within
Table,
Constraint and UserDefinedObjectType.A no-op implementation.
Standard implementation that orders columns by size and name following roughly this ordering:
order by max(physicalSizeBytes, 4), physicalSizeBytes > 2048, nameRepresents a column-reference used in an order-by fragment
Models a reference to a Column in a SQL AST
Contract for source information pertaining to a physical column definition specific to a particular attribute
context.
Specifies custom SQL expressions used to read and write to the column mapped by
the annotated persistent attribute in all generated SQL involving the annotated
persistent attribute.
Plural annotation for @ColumnTransformer.
Provides access to information about existing table columns
Represents the binding of a value to a column.
Builder for
ColumnValueBinding instancesList of value bindings allowing the grouping to act as
a consumer for JDBC value mappings.
Parameter descriptor specific to mutations.
An array list for
ColumnValueParameter that implements SelectableConsumer to add new parameters.Models a column's value expression within the SQL AST.
Indicates a problem accepting/executing a schema management command.
Commonality for annotations which contain SQL comments
Identifies how a database-object comment is emitted by schema export.
Describes a comment attached to one database schema object.
Identifies the database object receiving a schema-export comment.
Registers Hibernate's stock HQL function definitions and database-specific
variants with a boot-scoped function registry.
Defines the aspects of query execution and parameter binding that apply to all
forms of querying:
queries written in HQL, or JPQL,
queries written in the native SQL dialect of the database,
criteria queries,
and
stored procedure calls.
SPI form of CommonQueryContract
Functions commonly expected in databases, as defined
by the SQL/MM specs
Information which is common across all table annotations
We frequently need the union type of Executable, Comparable of ComparableExecutable, Serializable;
this interface represents such union; this helps to simplify several generic signatures.
Enumerates the binary comparison operators.
A binary-comparison restriction
Denotes that a setting is intended to allow applications to upgrade
versions of Hibernate and maintain backwards compatibility with the
older version in some specific behavior.
For a complete predicate.
A mapping model object that represents an embeddable class.
Comparator for component arrays.
Handles embedded mappings.
Represents an identifier based on a
composite-id mapping.Mapping for a composite identifier
Common contract for composite identifiers.
For composite identifiers, defines a number of "nested" generations that
need to happen to "fill" the identifier property(s).
Contract for declaring how to locate the context for sub-value injection.
Contract for performing the actual sub-value generation, usually injecting it into the
determined context
Specifies a custom
CompositeUserType for the annotated attribute
mapping.Represents a composite type, a type which itself has typed attributes.
Registers a custom composite user type
implementation to be used by default for all references to a particular
embeddable class.
Grouping of
CompositeTypeRegistrationThis interface should be implemented by user-defined custom types
that have persistent attributes and can be thought of as something
more like an embeddable
object.
Registration for a CompositeUserType
A concat function with a pattern for clob arguments.
Annotating
ConcreteProxy on the root entity class of an inheritance hierarchy
will allow types of that hierarchy to always produce proxies that resolve to the concrete
subtype class.Contract for a model object that stores configuration parameters
A
Generator that supports "configuration".Allows the service to request access to the configuration properties for configuring itself.
A convenience API making it easier to bootstrap an instance of Hibernate.
Envers configuration.
Provides access to the initial user-provided configuration values.
Simple conversion contract for converting an untyped object to a specified type.
Describes how an
Interceptor was configured,
without resolving any CDI or managed beans.Support for XSD handling related to Hibernate's `cfg.xml` and
JPA's `persistence.xml`.
Indicates that both "hibernate.session_factory.interceptor" and
"hibernate.session_factory.session_scoped_interceptor" were configured.
Indicates the manner in which JDBC connections
are acquired.
Executes the common JDBC operations used by connection-level lock-timeout
strategies.
Extracts a timeout from the current row of a JDBC result set.
Reads and sets lock timeouts using the JDBC
Connection, generally by
executing a database command.Indicates a Dialect's level of support for lock timeouts on the JDBC connection.
A contract for obtaining JDBC connections and, optionally, for pooling connections.
Occurs when there is a problem configuring a
ConnectionProvider.Enumerates various policies for releasing JDBC connections.
A mapping model object representing a constraint on a relational database table.
Identifies how table cleaning controls referential constraints.
Identifies one rendered table and foreign-key constraint.
Supplies global or per-constraint control commands for table cleaning.
Identifies whether schema drop must explicitly remove constraints.
A
JDBCException indicating that the requested DML operation
resulted in violation of a defined data integrity constraint.Enumerates the kinds of integrity constraint violation recognized
by Hibernate.
A bean handle with lifecycle hooks for its owning
BeanContainer.States whether an optional contract applies to a Dialect profile.
Parts of the mapping model which are associated with a
contributor (ORM, Envers, etc).
Database objects (table, sequence, etc) which are associated with
a contributor (ORM, Envers, etc) and
can be selectively exported per contributor
Matcher for whether tables and sequences should be included based on its
Contributable.getContributor()Internal contract for Type and Function Contributors
A conversion of a duration to a given temporal unit,
as a result of applying the 'by unit' operator.
Indicates a problem converting an SQM tree to a SQL AST
A registered conversion.
Given a
BasicValueConverter for an array type,A converted basic array type.
Extension for implementations of
BasicType which have an implied
conversion.Manages resolution of auto-applied
AttributeConverter
references for specific mappingsBoot-time descriptor of a JPA converter.
Registers an
AttributeConverter.A registry for JPA converters.
A table group for correlated plural attributes.
A virtual
TableReference for correlated roots.Specifies that the annotated field of property is a generated creation timestamp.
Interface which allows extension of
HibernateCriteriaBuilder
with additional functionality by registering a Service.A utility class that makes it easier to build criteria queries.
Queries that allow retrieving snapshots of all entities (regardless of their particular type) changed in the given
revision.
Information about a column in the CTE table
The consumer part of a CTE statement - the select or insert or delete or update that uses
the CTE
Recursive CTE based generate_series function.
The kind of materialization that should be used for a CTE.
An object that is part of a WITH clause.
The kind of CTE search clause.
A statement using a CTE
Immutable description of a Dialect's common-table-expression (CTE) capabilities.
Builder for immutable
CteSupport profiles.Mutation-specific CTE capabilities.
The strongest location in which a WITH clause may occur.
Native recursive-CTE syntax capabilities.
Describes the table definition for the CTE - its name amd its columns
Wraps a
NamedTableReference representing the CTE and adapts it to
TableGroup for use in SQL ASTDescriptor for
Currency handling.A "function" with no parameters that returns the current date, time, or timestamp.
Defines the contract for objects which are able to manage the lifecycle
of a
Session associated with a well-defined "context" or "scope",
providing the concrete implementation behind the notion of the
current session.Defines current temporal expressions and database-side timestamp retrieval.
Access to Hibernate's standard current-temporal support.
A callback registered with the
SessionFactory that is
responsible for resolving the current tenant identifier.Specifies that the annotated field of property is a generated timestamp,
and also specifies the timing of the timestamp
generation, and whether it is generated in Java or by the database:
source = VM indicates that the virtual machine
current instant is used, and
source = DB indicates that the database
current_timestamp function should be used.Describes the JDBC command used to obtain the database current timestamp.
A custom type for mapping user-written classes that implement
PersistentCollectionDuring a flush cycle, Hibernate needs to determine which of the entities associated with a
Session
are dirty, meaning modified.Responsible for identifying when attributes are dirty.
Provides
CustomEntityDirtinessStrategy.AttributeChecker with meta information about the attributes being checked.A callback to drive dirty checking.
Deprecated.
Since hbm.xml support will go away
Commonality for annotations which define custom insert, update and delete SQL
Applies a version 1 (time-based) generation strategy (using ip address rather than mac address) but applies them in a
different layout.
A list of relational database systems for which Hibernate can resolve a
Dialect.Contract used for logging "database information" on bootstrap
Models an identifier (name), retrieved from the database.
Provides access to information about existing schema objects (tables, sequences etc) of existing database.
An implementation of
DialectResolutionInfo that delegates calls to a wrapped DatabaseMetaData.Commonality for annotations which represent database objects.
Models an auxiliary database object in the boot mapping model
Contract for model-parts which contribute to their container's
state array for database snapshots
Encapsulates definition of the underlying data structure backing
a sequence-style generator.
Details about the underlying database, as understood by a Dialect.
A
JDBCException indicating that evaluation of the
valid SQL statement against the given data resulted in some
illegal operation, mismatched types or incorrect cardinality.A helper for dealing with
BLOB and CLOB dataA concrete implementation of the
MultiTenantConnectionProvider contract bases on
a number of reasonable assumptions.Descriptor for
Date handling.Descriptor for
DATE handling.Utility class that provides access to a
DateFormat instance.Utilities for dealing with date/times
Emulation of
trunc(datetime, temporal_unit) function that leverages
formatting the datetime to string and back to truncate itA SQL dialect for Db2 for LUW (Linux, Unix, and Windows)
version 11.1 and above.
DB2's varchar_format() can't handle quoted literal strings in
the format pattern.
Type Descriptor for the DB2 Geometry type (as Clob)
Variant of the
GetObjectExtractor that catches a NullPointerException,
because the DB2 JDBC driver runs into that exception when trying to access a null value
with the getObject(int, Class) and getObject(String, Class) methods.A SQL dialect for DB2 for IBM i version 7.2 and above, previously known as "DB2/400".
Access to Hibernate's stock DB2 JDBC type descriptors.
DB2 json_arrayagg function.
DB2 json_array function.
DB2 json_objectagg function.
DB2 json_object function.
DB2 json_table function.
DB2 json_value function.
A
LimitHandler for DB2 11.1 which supports the
ANSI SQL standard syntax FETCH FIRST m ROWS ONLY
and OFFSET n ROWS FETCH NEXT m ROWS ONLY,
with the only wrinkle being that this clause comes
after the FOR UPDATE and other similar clauses.DB2's position() function always requires a code unit before version 11.
DB2-family query-mutation rendering policy.
Db2/Derby family base using ANSI value expressions,
values stand-alone
selection, and restrictive sequence drop syntax.A SQL AST translator for DB2.
DB2's substring() function requires a code unit and substr() can't optionally take it,
so we render substr() by default.
DB2 unnest function.
DB2 xmltable function.
A SQL dialect for DB2 for z/OS version 12.1 and above, previously known as:
"Db2 UDB for z/OS", and
"Db2 UDB for z/OS and OS/390".
Provides access to a
Connection that is isolated from any
"current transaction" with the designated purpose of performing DDL
commands.Descriptor for a DDL column type.
Builds a standard DDL type descriptor without exposing Hibernate's internal
descriptor implementations.
Determines which sizes represented by a descriptor are LOB values.
A registry mapping
JDBC type codes
to instances of the DdlType interface.Descriptor for
DECIMAL handling.Context for decomposition operations, providing information about entities being
mutated in the current flush.
Deprecated.
use
DefaultAuditStrategy instead.A built-in changelog entity which maps to the
REVINFO table.Annotation-based persistence interpretation using Hibernate's enhancement defaults.
Specifies the default semantics of persistent
List attributes
without explicit collection classification or ordering metadata.The supported defaults for list attributes.
A built-in changelog entity with entity change tracking.
Extension of standard
DefaultRevisionEntity that allows tracking entity names changed in each revision.A row identifier for an identifier-bag's collectio-id which is generated by
collection pre-insert processing after the delta has been frozen.
A list position calculated from persisted size plus a relative adjustment.
Memento representing the dropping of a schema as part of create-drop
hbm2ddl.auto handling.
Callback to allow the built DelayedDropAction, if indicated, to be registered
back with the SessionFactory (or the thing that will manage its later execution).
Implementation of DelayedDropRegistry for cases when the delayed-drop portion of
"create-drop" is not valid.
Mutable value reference used when a JDBC value is not known at decomposition time.
Provider base forwarding alter-table grammar to a stable delegate.
Provider base forwarding column-definition rendering to a stable delegate.
Provider base forwarding constraint-control commands to a stable delegate.
Provider base forwarding the current-temporal contract to one stable delegate.
Supported base for selectively decorating a configured identifier helper.
Provider base forwarding index DDL policy to a stable delegate.
Forwards literal rendering to another supported strategy.
Provider base which forwards the complete LOB contract to one stable
delegate.
Provider base forwarding table-creation grammar to a stable delegate.
Provider base forwarding temporal-format translation to a stable delegate.
Provider base forwarding temporal operations to a stable delegate.
Provider base which forwards the complete temporal-table contract to one
immutable delegate.
Provider base forwarding truncation rendering to a stable delegate.
Supported base for a provider which decorates another unique-key strategy.
A SQL
DELETE statement.A
DeleteEvent represents a delete operation
applied to a single entity.Coordinates the deleting of an entity.
Delete coordinator for audited entities.
Delete coordinator for
TemporalTableStrategy.HISTORY_TABLE
temporal strategy.DeleteCoordinator for soft-deletes
Coordinates standard deleting of an entity.
Delete coordinator for
TemporalTableStrategy.SINGLE_TABLE
temporal strategy.Event class for
Session.remove(Object).Defines the contract for handling of deletion events generated from a session.
Immutable semantic plan for rendering a query delete.
Render the delete directly using the translator's native delete grammar.
Move joins which cannot appear directly in the delete into a correlated
exists subquery in the where clause.Read-only semantic facts supplied by Hibernate when selecting how to render
a query delete.
Coordinates the deletion of entries removed from the collection -
For collections with a collection-table, deletes rows from the
collection table.
DeleteRowsCoordinator implementation for temporal collection tables
in the TemporalTableStrategy.HISTORY_TABLE
temporal table mapping strategy.DeleteRowsCoordinator implementation for cases where deletion is not enabled
OneToMany delete coordinator if the element is a
UnionSubclassEntityPersister.Specialization of
MutationSpecification for programmatic customization
of delete queries.Describes how completely a
CollectionDelta covers its reference state.Identifies the provenance of facts represented by a
CollectionDelta.A mapping model object representing a value which is "typed" by reference
to some other value (for example, a foreign key is typed by the referenced primary key).
Selects where a derived table's column aliases are rendered.
The semantic kind of derived table being rendered.
Immutable plan selected by
DerivedTableRenderingSupport for rendering a
derived-table reference.Rendering choices for a function table reference.
Rendering choices for a derived query part.
Rendering choices for a derived values table.
Read-only semantic facts supplied by Hibernate when selecting how to render
a derived-table reference.
Dialect strategy for selecting an immutable rendering plan for a
derived-table reference.
Contract describing source of a derived value (formula).
Extension of
JsonHelper that can be used to generate
descriptive JSON output, that is more appropriate for representing
complex data structures for displaying purposes.Thrown if a detached instance of an entity class is passed to
a
Session method that expects a managed instance.An event which may be collected by the
EventMonitor.Represents a dialect of SQL implemented by a particular RDBMS.
A database-free behavior exercised by the Dialect contract test kit.
Defines one stable, database-free Dialect test profile supplied by a
provider to
DialectTestKit.A factory for generating
Dialect instances.Logging related to Hibernate dialects
Allows certain annotations to be overridden in a given SQL
Dialect.Specializes a
Check
in a certain dialect.Specializes a
ColumnDefault
in a certain dialect.Specializes a
DiscriminatorFormula
in a certain dialect.Specializes
FilterDefs
in a certain dialect.Specializes
Filters
in a certain dialect.Specializes a
Formula
in a certain dialect.Specializes a
GeneratedColumn
in a certain dialect.Specializes a
JoinFormula
in a certain dialect.Marks an annotation type as a dialect-specific override for
some other annotation type.
Specializes a
SQLDelete
in a certain dialect.Specializes a
SQLDeleteAll
in a certain dialect.Specializes a
SQLInsert
in a certain dialect.Specializes an
SQLOrder
in a certain dialect.Specializes a
SQLRestriction
in a certain dialect.Specializes a
SQLSelect
in a certain dialect.Specializes a
SQLUpdate
in a certain dialect.Identifies a database version.
Common contract for override annotations defined in DialectOverride
Exposes information about the database and JDBC driver that can be used in resolving the appropriate Dialect
to use.
Contract for the source of
DialectResolutionInfo.Resolves a Dialect from database and driver information during bootstrap.
Selects a provider-owned Dialect class for an explicit short name.
Settings used as fallback to configure aspects of specific
Dialects
when the boot process does not have access to a DatabaseMetaData object or
its underlying JDBC Connection.A thread-confined, database-free context for inspecting SQL generated by one
Dialect profile.
Entry point for the provider-oriented, database-free Dialect contract test
kit.
Specialized
Region whose data is accessed directly,
without the need for key/item wrapping.Bridge between DirectAccessRegion and StorageAccess
Describes direct JDBC access support for Java Time classes.
Supplies immutable stock direct Java Time JDBC support profiles.
Event class for
Session.isDirty().Defines the contract for handling of session dirty-check events.
Anything that has a discriminator associated with it.
A discriminated association.
Specifies an expression written in native SQL as the discriminator for an
entity inheritance hierarchy.
Operations needed by persisters for working with discriminators.
Mapping of a discriminator, for either entity or
association (ANY) discrimination.
Optional annotation used in conjunction with the JPA-defined
DiscriminatorColumn annotation to
express Hibernate-specific discriminator properties.A persistent entity mapping that uses a single table to store entities based on a discriminator.
Contract for sources of information about a mapped discriminator.
Commonality between entity and any discriminators
Contract for a persistent entity discriminator type.
Union of
ConvertedBasicType and BasicDomainType capabilities.Represents the discriminator value used for entity mappings.
Details for a particular discriminator value.
The qualifier form a database accepts for references to target columns in
update and delete statements.
Configuration for a specific type of data to be stored in the
region
A second-level cache region that holds cacheable
domain data:
the destructured state of entity instances and collections, and
mappings from natural id to primary key.
A "parameter object" for
RegionFactory.buildDomainDataRegion(DomainDataRegionConfig, DomainDataRegionBuildingContext)
calls, giving it access to information it needs.Configuration for a named region for caching domain data.
Abstract implementation of
DomainDataRegion based
on implementations just needing to provide a DomainDataStorageAccess reference
for basic caching support - DomainDataStorageAccess acts as a simple wrapper around
some generalized cache actions such as put or get.Specialization of
StorageAccess for domain data regions.Represents a domain-path (model part path) used in an order-by fragment
A path relative to either a CollectionPartPath (element/index DomainPath) or another DomainPathContinuation
Context for execution of
Query"Represents a result value in the domain query results.
Responsible for "assembling" a result for inclusion in the domain query
result.
Contains state related to building
DomainResult and
Fetch graphsMarker for all object types that can be part of a result mapping
Printer for DomainResult graphs
Something that can produce a DomainResult as part of a SQM interpretation
Describes any type forming part of the application domain model.
Syntax used to express a do-nothing action in an on-duplicate-key clause.
Consumes the parts of a path.
A compound name.
Descriptor for
Double handling.Descriptor for
DOUBLE handling.Descriptor for
double[] handling.Raised whenever a duplicate for a certain type occurs,
such as a duplicate class, table, or property name.
Enumeration of the types of things that can be duplicated.
Defines listener duplication checking strategy, both in terms of when a duplication is detected (see
DuplicationStrategy.areMatch(Object, Object)) as well as how to handle a duplication (see DuplicationStrategy.getAction()).The enumerated list of actions available on duplication match
A duration expressed in terms of a given temporal unit.
Descriptor for
Duration, which is represented internally
as (long seconds, int nanoseconds), approximately
28 decimal digits of precision.Descriptor for
Duration.A function that dynamically dispatches to other functions,
depending on which function validates successfully first.
Specifies that SQL
insert statements for the annotated entity
are generated dynamically, and only include the columns to which a
non-null value must be assigned.Represents the type of instantiation to be performed.
Specialization of DomainResult to model
dynamic instantiation
JavaType for dynamic models
Deprecated, for removal: This API element is subject to removal in a future version.
This very old approach was never properly implemented in all
contexts, and never actually achieved the type safety it aimed for.
Specifies that SQL
update statements for the annotated entity
are generated dynamically, and only include columns which are actually
being updated.Think of this as the composite modeling of a graph and the semantic.
Defaults which are in effect for each mapping.
A
FunctionReturnTypeResolver that resolves the array element type based on an argument.Java type for embeddable aggregates, which allows resolving a recommended
JdbcType.Details about the discriminator for an embeddable hierarchy.
Hibernate extension to the JPA
EmbeddableType contract.A table group for functions that produce embeddable typed results.
A table reference for functions that produce embeddable typed results.
Special initializer contract for embeddables
Specifies a custom instantiator for a specific embedded
Instantiates embeddable values from the attribute values supplied by
Hibernate.
Registers a custom instantiator implementation to be used
for all references to a particular
Embeddable.Registered EmbeddableInstantiator
Grouping of
EmbeddableInstantiatorRegistrationUnifying contract for consuming JAXB types which describe an embeddable (in JPA terms).
Describes an embeddable - the actual type
Describes the representation of a particular embeddable type.
DomainResult specialization for embeddable-valued results
Represents the binding source for an "embeddable" (in JPA terms)
or "composite" (in legacy Hibernate terms).
Contract for things that can contain EmbeddableSource definitions.
Describes the mapping of an embeddable (composite).
Unifying contract for any JAXB types which describe an embedded (in JPA terms).
Allows specifying a pattern to be applied to the naming of columns for
a particular embedded mapping.
An easier mechanism to declare the table to which an embedded value
maps compared to the Jakarta Persistence compliant mechanism requiring
multiple
AttributeOverride
and AssociationOverride annotations.A
FindOption which represents a named
fetch profile.A specialized Getter implementation for handling getting values from
a bytecode-enhanced Class.
A specialized Setter implementation for handling setting values into
a bytecode-enhanced Class.
A specialized Setter implementation for handling setting values into a bytecode-enhanced Class
using a setter method.
A custom type that may function as an identifier or discriminator type
This is an helper object to group all state which relates to a particular entity type,
and which is needed for this interceptor.
Resolves class-file resources for an
EnhancementSession without defining
application classes.An exception indicating some kind of problem performing bytecode enhancement.
Provides basic information about the enhancement done to a class.
Describes the persistence semantics of classes and fields without defining
application classes.
Controls generated enhancement features and handling of unsupported classes.
Owns discovery and metadata for one model and bytecode environment.
Class responsible for performing enhancement.
Constants used during enhancement.
Handles decomposing for a single action type (delegation).
Commonality between `many-to-one`, `one-to-one` and `any`, as well as entity-valued collection elements and map-keys
Shared construction and binding support for audited entity JDBC mutations.
Execution-agnostic plan for one per-table audit insert operation belonging
to a logical audited entity change.
A resolved per-table audit mutation operation.
Execution-agnostic plan for closing the previous validity audit row.
BatchLoader specialization for entity fetching
Boot model representation of a Jakarta Persistence style callback defined on an entity class.
Jakarta Persistence style callbacks for a particular entity.
An observer for detection of multiple entity representations for a persistent entity being merged.
A service which creates new instances of
EntityCopyObserver.Contract for managing transactional and concurrent access to cached entity
data.
Specialized DomainDataCachingConfig describing the requested
caching config for a particular entity hierarchy's state data
Details about the discriminator for an entity hierarchy.
Extension to the JPA
EntityType contract.Information about the current state of a managed entity instance with respect
to its persistent state.
Navigation methods for extra state objects attached to
EntityEntry.Specialization of Fetch for entity-valued fetches
Thrown when a filter excludes an association target and its fetching strategy
cannot preserve the stored reference while representing the association as null.
A collection of
EntityGraph utilities.State used as part of applying entity graphs to
Hibernate
DomainResult / Fetch load graphs.Details of a particular traversal within the entity graph
Models the source-agnostic view of an entity hierarchy.
Holder for an entry in the
PersistenceContext for an EntityKey.Describes the mapping of an entity's identifier.
The style of identifier used.
Describes the possible natures of an entity-defined identifier.
Specialized implementation of
NavigablePath for handling special cases
pertaining to entity identifiers.Initializer implementation for initializing entity references.
Contract for instantiating entity values
Uses object identity for
equals/hashCode as we ensure that internally.Uniquely identifies of an entity instance in a particular Session by identifier.
Specialization of Loader for loading entities of a type
Standard entity-locking strategy factories supplied by Hibernate.
Creates the executable locking strategy for an entity-locking request.
Families of built-in entity-locking strategies available to a provider
factory.
Immutable facts used to select an entity-locking strategy.
Stable entity metadata available while selecting a locking strategy.
Represents a two-phase JPA bootstrap process for building a Hibernate
EntityManagerFactory.Mapping of an entity
Commonality for multi-loading an entity
Deprecated, for removal: This API element is subject to removal in a future version.
This contract is used only by the legacy action queue.
Contributes state-management-specific graph mutation plans for entity actions.
Context passed to delete contribution hooks.
Context passed to update contribution hooks.
Deprecated, for removal: This API element is subject to removal in a future version.
Transitional interface - use
LegacyEntityMutationTarget for legacy
coordinators or GraphEntityMutationTarget for graph-based decomposersAn object capable of determining the entity name for a given entity instance.
Describes the kind of entity name use.
Naming information about an entity.
Standard support for
EntityDataAccess
using the AccessType.NONSTRICT_READ_WRITE access type.Delegate to handle the scenario of an entity not found by a specified id.
A strategy for persisting a mapped entity class.
Standard support for
EntityDataAccess
using the AccessType.READ_ONLY access type.Standard support for
EntityDataAccess
using the AccessType.READ_WRITE access type.Specialization of
ManagedTypeRepresentationStrategy for an entity type
adding the ability to generate an instantiator and a proxy factorySpecialization of DomainResult for entity-valued results
Represents a reference to an entity either as a return, fetch, or collection element or index.
Mapping of a row-id
Contract describing source of information related to mapping an entity.
Entity-related statistics.
Immutable descriptor for a table involved in a mutation.
Descriptor for the mapping of a table relative to an entity
A callback invoked for each entity change within a transaction,
in addition to the
ChangesetListener.newChangeset(Object) callback
invoked once when the changelog entity is created.Extension of standard
RevisionListener that notifies whenever an entity instance has been
added, modified or removed within current revision boundaries.Base for types which map associations to persistent entities.
Indicates that a reference to an entity, that is, a given entity name
or Java class object, did not resolve to a known mapped entity type.
Used to uniquely key an entity instance in relation to a particular session
by some unique property reference, as opposed to identifier.
Fetchable which is entity-valued
Describes the mapping of an entity's version
Describes a Java
enum type.Represents an
enum type for databases like MySQL and H2.Resolves the relational strings represented by Java enum constants.
Defines declaration, lifecycle, and value-check behavior for finite
relational domains, including enum, Boolean, and discriminator mappings.
Supplies immutable stock enum and finite-domain profiles.
Converts an
Envelope to a PolygonMarker interface for Envers listeners for duplication handling.
Event listener duplication strategy for envers
Indicates an error happened during the Envers mapping boot process.
Metadata building context for Hibernate Envers
Envers-specific collection recreation event listener
Envers-specific entity (post) deletion event listener
Envers-specific entity (post) insertion event listener
Envers-specific entity (post) update event listener
Envers-specific collection removal event listener
Envers-specific collection update event listener
Envers-specific entity (pre) update event listener.
Configuration property names.
Provides access to configuration properties passed in
Properties objects.Composite for the things related to Hibernate's event system.
Callback for
EventEngineContributorIntegration contract for contributing event types and listeners to the Hibernate event system.
Contract for a groups of events listeners for a particular event type.
Holds the
event listener groups for the various event types.Indicates a problem registering an event listener.
Service for accessing each
EventListenerGroup by EventType,
along with convenience methods for managing the listeners registered in
each EventListenerGroup.Contract implemented by services which collect, report, or monitor
diagnostic events involving interactions
between the session and the database
or second-level cache.
Enumeration of the recognized types of events, including meta-information about each.
Enumerates event types that can result in generation of a new value.
For convenience, enumerates the possible combinations of
EventType.Most databases don't have a function like
every() or any().Event class for
Session.evict(Object)
and Session.detach(Object).Defines the contract for handling of evict events generated from a session.
Contract for how CommandAcceptanceException errors should be handled (logged, ignored, etc).
Indicates that a package or top-level type should be ignored
by the Hibernate annotation processor.
An operation which may be scheduled for later execution.
A list of executable actions.
Provides a sorting interface for
ExecutableList.A context for execution of SQL statements expressed via
SQL AST and JdbcOperation
Indicates an exception performing execution
Parameter object representing options for schema management tool execution
Identifies where an existence check occurs relative to a DDL target name.
Defines an expected DML operation outcome.
No return code checking.
Row count checking.
Essentially identical to
Expectation.RowCount except that the row count
is obtained via an output parameter of a stored procedure.Row count checking.
Row count checking.
Useful operations for dealing with
Expectations.SqlStringGenerationContext implementation with support for overriding the
default catalog and schema
Contract for entities (in the ERD sense) which can be exported via
CREATE, ALTER, etcIdentifies metamodel objects that can produce
Exportable relational stuff.Exports a relational database object as SQL create and drop commands.
Models an expression at the SQL AST level.
Immutable description of the expression-coercion adaptations required by a
Dialect's SQL rendering.
Build an immutable expression-coercion-support profile.
An independently configurable expression-coercion adaptation.
Base walker for replacing expressions in an SQL AST.
This contract and the nested LifecycleListener contract represent the changes
we'd like to propose to the CDI spec.
Contract for things interested in receiving notifications of
BeanManager lifecycle events.
A self dirtiness tracker that declares additional methods that are intended for
internal communication.
Optional contract for a
Region defining support for extra statistic information.A marker interface for Session extensions.
Raw JDBC driver and bootstrap-connection observations.
ANSI SQL-inspired
extract() function, where the date/time fields
are enumerated by TemporalUnit, and portability is achieved
by delegating to
TemporalOperationSupport.extractPattern(TemporalUnit).Defines a context for performing extraction including providing access to information about ongoing extraction as
well as to delegates needed in performing extraction.
In conjunction with
ExtractionContext.getDatabaseObjectAccess() provides access to
information about known database objects to the extractor.Encapsulates the functionality for extracting database metadata used by
SchemaManagementTool.A
TemporalUnit passed as an argument to the
ExtractFunction.Specifies the default fetching method for the annotated association.
Models an individual fetch override within a
FetchProfile.Contract for fetches including entity, collection and composite.
Any mapping with an outer-join attribute
Parts of the domain model that can be fetched.
Describes source for attributes which can be fetched.
Container of
Fetchable referencesResponsible for building a single
Fetch instance.Builds a fetch for a basic-valued mapping.
Immutable description of the
fetch clause forms accepted by a database.The form of SQL
fetch clause requested by query translation.Describes the mapping for a fetch as part of a
NamedResultSetMappingDescriptorA
LimitHandler for databases which support the ANSI
SQL standard syntax FETCH FIRST m ROWS ONLY but not
OFFSET n ROWS.This is essentially a List of Fetch(es), but exposing
an interface which is more suitable to our needs; in particular
it expresses the immutable nature of this structure, and allows
us to extend it with additional convenience methods such as
FetchList.indexedForEach(IndexedConsumer).The parent node for the fetch
Enumerates methods for fetching an association from the database,
allowing a fetching method to be specified as a
FetchOption
of an attribute node of an entity graph.Enumerates methods for fetching an association from the database.
Exception for
NotFoundAction.EXCEPTION.Fetch options
applied to a particular association fetch.
Represents an aggregated
FetchTiming and FetchStyle valueContract for things that can be the parent of a fetch
Defines a fetch profile, by specifying its
FetchProfile.name(), together
with a list of fetch strategy overrides.The runtime representation of a Hibernate
fetch profile
defined in annotations.
A mapping model object representing a
FetchProfile.An individual association fetch within the given profile.
Overrides the fetching strategy for a particular association in
the named fetch profile being defined.
Overrides the fetching strategy for the annotated association
in a certain named fetch profile.
A group of
FetchProfileOverrides.Global registration of a fetch profile
Collects together multiple fetch profiles.
Enumeration of values describing how fetching should occur.
Access to a FetchStyle
Enumeration of values describing when fetching should occur.
Access to a FetchTiming
Specifies that the annotated entity, collection, or to-one association is
affected by a named filter declared using
@FilterDef, and
allows the default filter condition
to be overridden for the annotated entity or association role.Allows control over an enabled filter at runtime.
Defines mapping elements to which filters may be applied.
Declares a filter, specifying its FilterDef.name(), optionally,
a default condition, and its
parameter names and types, if it has
parameters.
Descriptive metadata for a named
Filter.Represents the definition of a
filter.Global registration of a filter definition
Array of filter definitions.
Commonality for filter annotations
Specifies that the join table of a collection is affected by a
named filter declared using
FilterDef, and allows the
default filter condition
to be overridden for the annotated entity or collection role.Add multiple
@FilterJoinTable to a collection.Collection of
FilterPredicate.FilterFragmentPredicate sub-predicates, each
representing one enabled filter restriction.Things that can have associated
Filter declarations.Add multiple
@Filters.Defines the source of filter information.
Identifies a method of an abstract class or interface as defining
the signature of a finder method, with an implementation
generated automatically by the Hibernate Metamodel Generator.
Simple marker interface for FindOptions which can be applied to multiple id loading.
Specifies how many entities should be fetched in each request to the database.
Indicates whether the result list should be ordered relative to the
position of the identifier list.
When FindMultipleOption.SessionCheckMode is enabled, this option controls how
to handle entities which are already contained by the persistence context
but which are in a removed state (marked for removal, but not yet flushed).
Indicates whether the persistence context should be checked for entities
matching the identifiers to be loaded -
Descriptor for
Float handling.Descriptor for
FLOAT handling.Descriptor for
float[] handling.Event class for stateful session flush.
Defines the contract for handling of session flush events.
Represents a flushing strategy.
Represents a single SQL operation to be executed.
Settings related to flush behavior.
Determines whether a completed SQL statement requires follow-on locking.
The immutable facts used to decide whether a completed SQL statement
requires follow-on locking.
Effective pagination characteristics of the completed statement.
Known structural characteristics of the completed statement.
Deprecated, for removal: This API element is subject to removal in a future version.
This remains around as an implementation detail of
hbm.xml mappings.A mapping model object representing a foreign key constraint.
Describes one foreign-key constraint to be added to an existing table.
Additional contract for things which describe foreign keys.
Descriptor for foreign-keys
Represents directionality of the foreign key constraint
Describes one foreign-key constraint to be dropped from an existing table.
Selects the JDBC metadata calls used for per-table foreign-key discovery.
JDBC foreign-key metadata modes.
Defines database support for foreign-key DDL and delete semantics.
Represents the format pattern for a date/time format expression
A format function with support for composite temporal expressions.
Maps objects to and from a structured text format.
Java type for
FormatMapper based types i.e.The creation context for
FormatMapper that is passed as constructor argument to implementations.Specifies an expression written in native SQL that is used to read the value of
an attribute instead of storing the value in a
Column.An implementation of
Selection that represents a formula.Deprecated, for removal: This API element is subject to removal in a future version.
Use
Column.secondPrecision() which was introduced
in JPA 3.2The SQL AST from-clause node
Access to TableGroup indexing.
An index of various FROM CLAUSE resolutions.
A validity-guarded projection of the current rows of a persistent collection.
Emulates ANSI
FULL JOIN using set operators.Immutable Dialect support for primary-key functional-dependency analysis within
GROUP BY and ORDER BY clauses.Represents a problem with the argument list of a function in HQL/JPQL.
Pluggable strategy for resolving a function argument type for a specific call.
Boot-scoped access used by a
FunctionContributor or Dialect to register
functions with the eventual SqmFunctionRegistry.Contributes custom HQL functions to the eventual
SqmFunctionRegistry.Represents a function used in an order-by fragment
Models a function expression at the SQL AST level.
A the key vor a SpatialFunction
The kind of function e.g.
A mini-"type system" for HQL function parameters.
Renders the SQL AST representation of a self-rendering
SqmFunctionDescriptor.Describes the function return value of a
ProcedureCall
executed via a JDBC escape of form ("{? = call ...}.Pluggable strategy for resolving a function return type for a specific call.
A special table group for a table valued functions.
A table reference for a table valued function.
Specifies that the value of the annotated property is generated by the
database.
Specifies that a column is defined using a DDL
generated always as
clause or equivalent, and that Hibernate should fetch the generated value
from the database after each SQL INSERT or UPDATE.Marker interface representing TableMutations whose SQL Hibernate
has generated, as opposed to custom SQL provided by the user.
One JDBC parameter occurrence in generated SQL.
One immutable SQL statement generated by the test kit.
Simple implementation of
ResultBuilder for retrieving generated basic values.A container for database generated values
retrieved by the mutation operation.
Used from
EntityInsertBindPlan
and EntityUpdateBindPlan to aggregate
generated value collection across all tables.Each implementation defines a strategy for retrieving values
generated by
the database after execution of a mutation statement.
Immutable description of the mechanisms a Dialect supports for retrieving
arbitrary database-generated values during mutation execution.
Build an immutable generated-values profile.
Independently variable generated-value retrieval capabilities.
A
ArgumentsValidator that validates the array type is compatible with the element type.A
ArgumentsValidator that validates the array type is compatible with the element type.Standard generate_series function.
Describes a schema generation target
Describes the generation of values of a certain field or property of an entity.
Access to information useful during Generator creation and initialization.
Instantiates a
Generator.Explicitly selects a standard optimizer to use with identifier generation.
Exposes the default catalog and schema to the
generator creation process.
Service delegate for handling sequence resynchronization.
A generic dialect for ANSI-like SQL.
Specifies a generator used for generating entity
identifiers, allowing the use of custom identifier generation strategies
going beyond those provided by the four standard JPA-defined
generation types.
Generator backing
GenericGenerator.Global registration of a generic generator
Generic, non-specific flavor of
JDBCException.Deprecated.
Use
GeolatteSpatialCriteriaBuilder insteadDescriptor for geolatte-geom
Geometrys.Deprecated.
Use
GeolatteSpatialCriteriaBuilder insteadDelegate for dealing with generated values using the JDBC3 method
Statement.getGeneratedKeys().Deprecated, for removal: This API element is subject to removal in a future version.
Field-based implementation of Getter
Registrations which are considered global, collected across annotations
and XML mappings.
Represents a managed type in an
entity graph, acting as a container for:
AttributeNode references representing fetched attributes, and
treated subgraphs, each represented by a child instance of
SubGraph.Entity-specific mutation target for the graph-based action queue.
Helper containing utilities useful for graph handling
Integration version of the
Graph contract.This class provides an empty implementation of
GraphLanguageParserListener,
which can be extended to create a listener which only needs to handle a subset
of the available methods.This class provides an empty implementation of
GraphLanguageParserVisitor,
which can be extended to create a visitor which only needs to handle a subset
of the available methods.This interface defines a complete listener for a parse tree produced by
GraphLanguageParser.This interface defines a complete generic visitor for a parse tree produced
by
GraphLanguageParser.Mutation target contract for the graph-based action queue.
Common operations of
AttributeNode and Graph.Commonality between the builders for results and fetches.
Integration version of the
GraphNode contractParser for string representations of entity graphs.
Enumeration of available graph parser syntax modes.
Settings for configuring graph parser behavior.
Batch variant based on a group of prepared statements.
A binding plan whose immutable row bindings share one physical operation
template and graph placement.
H2 requires a very special emulation, because
unnest is pretty much useless,
due to https://github.com/h2database/h2database/issues/1815.Implement the array fill function by using
system_range.H2 requires a very special emulation, because
unnest is pretty much useless,
due to https://github.com/h2database/h2database/issues/1815.H2 requires a very special emulation, because
unnest is pretty much useless,
due to https://github.com/h2database/h2database/issues/1815.H2 requires a very special emulation, because
unnest is pretty much useless,
due to https://github.com/h2database/h2database/issues/1815.H2 requires a very special emulation, because
unnest is pretty much useless,
due to https://github.com/h2database/h2database/issues/1815.H2 requires a very special emulation, because
unnest is pretty much useless,
due to https://github.com/h2database/h2database/issues/1815.H2 requires a very special emulation, because
unnest is pretty much useless,
due to https://github.com/h2database/h2database/issues/1815.H2 requires a very special emulation, because
unnest is pretty much useless,
due to https://github.com/h2database/h2database/issues/1815.H2 requires a very special emulation, because
unnest is pretty much useless,
due to https://github.com/h2database/h2database/issues/1815.H2 requires a very special emulation, because
unnest is pretty much useless,
due to https://github.com/h2database/h2database/issues/1815.H2 requires a very special emulation, because
unnest is pretty much useless,
due to https://github.com/h2database/h2database/issues/1815.H2 requires a very special emulation, because
unnest is pretty much useless,
due to https://github.com/h2database/h2database/issues/1815.A SQL dialect for H2.
H2 generate_series function.
Descriptor for GeoDB Geometries.
A utility class to serialize from/to H2GIS WKB's.
Access to Hibernate's stock H2 JDBC type descriptors.
H2 json_arrayagg function.
H2 json_array function.
H2 json_exists function.
Standard json_objectagg function that uses no returning clause.
H2 json_object function.
H2 json_query function.
H2 json_table function.
H2 json_value function.
H2 unnest function.
H2 xmlconcat function.
H2 xmlelement function.
H2 xmlforest function.
H2 xmlpi function.
An SQL dialect for the SAP HANA Platform and Cloud.
HANA generate_series function.
SAP HANA json_arrayagg function.
SAP HANA json_array function.
SAP HANA json_exists function.
SAP HANA json_objectagg function.
SAP HANA json_object function.
HANA json_table function.
HANA json_value function.
HANA has a special predicate.
Utility class that extracts initial database configuration for
HANADialect.Deprecated.
Spatial dialects are no longer needed
HANA unnest function.
HANA xmltable function.
Boot-time descriptor of a result set mapping as defined in an
hbm.xml file
either implicitly or explicitlyVarious utility functions for working with proxies and lazy collection references.
Operations for obtaining references to persistent collections of a certain type.
Details about Hibernate annotations.
A JPA
CriteriaBuilder is a source of objects which may be composed
to express a criteria query.Marks a group of exceptions that generally indicate an internal Hibernate error or bug.
The base type for exceptions thrown by Hibernate.
List of Hibernate-specific (extension) hints available to query,
load, and lock scenarios.
Extends the Jakarta Persistence-defined
PersistenceConfiguration
with operations specific to Hibernate.The best-ever implementation of a JPA
PersistenceProvider.Interface implemented directly by entity proxies, exposing
access to the associated
LazyInitializer.Hibernate Spatial specific configuration settings.
Use Hibernate metadata to ignore cascade on entities.
Source-agnostic descriptor for explicit user-supplied Hibernate type information
Optimizer which applies a 'hilo' algorithm in memory to achieve
optimization.
Identifies a method of an abstract class or interface as defining
the signature of a method which is used to execute the given
HQL query, with an implementation generated
automatically by the Hibernate Metamodel Generator.
Base of exception hierarchy for exceptions stemming from
producing SQM AST trees
Specifies a custom HQL/JPQL query to be used in place of the default SQL
generated by Hibernate when an entity or collection is fetched from the
database by id.
Global integration contract for translating HQL or JPQL text to SQM.
The logger interface for the Hibernate Spatial module.
Implement the array fill function by using
sequence_array.HSQLDB has a special syntax.
HSQLDB has a special syntax.
HSQLDB array_remove function.
HSQLDB array_set function.
HSQLDB sort_array function.
HSQLDB has a special syntax.
A SQL dialect for HSQLDB (HyperSQL) 2.6.1 and above.
HSQLDB json_arrayagg function.
HSQLDB json_array function.
HSQLDB json_object function.
HSQLDB doesn't support the third argument.
Extension to the JPA
IdentifiableType contract.Common contract between Entity and MappedSuperclass sources.
Models an identifier (name), which may or may not be quoted.
Common contract for an identifier.
A bag with a generated (surrogate) key.
An enumeration of the way
DatabaseMetaData might store and return identifiersA mapping model object representing a collection with a synthetic "identifier" column,
that is, a surrogate key.
Thrown by an
IdentifierGenerator implementation class when
ID generation fails.A classic extension point from the very earliest days of Hibernate,
this interface is no longer the only way to generate identifiers.
Identifies generators which potentially aggregate other
PersistentIdentifierGenerator generators.Models the definition of an identifier generator
Factory and helper methods for
IdentifierGenerator framework.Handles configured database identifiers at runtime.
Builder for
IdentifierHelper instances.Supplies the environment-specific inputs used to build an identifier helper.
Deprecated, for removal: This API element is subject to removal in a future version.
Use forms of
Session.find(Class, Object) accepting FindOption}
or Session.getReference(Class, Object, KeyType) instead.A contract for identifier relations between persisted entities
All attributes stored here are stored in their non-key form, see IdMetadataGenerator.
Contract describing source of identifier information for the entity.
Additional contract describing the source of an identifier mapping whose
nature is
EntityIdentifierNature.AGGREGATED_COMPOSITE.Additional contract describing the source of an identifier mapping whose nature is
EntityIdentifierNature.NON_AGGREGATED_COMPOSITE.Defines database identifier quoting, limits, and helper construction.
A strategy for determining if an identifier value is an identifier of
a new transient instance or a previously persistent transient instance.
Defines the identity-column DDL, insert syntax, and identity-specific value
retrieval semantics of a
Dialect.Provider base for implementing identity-column support.
An
OnExecutionGenerator that handles IDENTITY/"autoincrement"
columns on those databases which support them.Selects how Hibernate retrieves an identifier generated by an identity
column when generated-key retrieval is enabled.
Meta-annotation used to mark another annotation as providing configuration
for a custom identifier generator.
Defines existence-check placement for schema DDL targets.
Indicates an attempted use of a name that was deemed illegal
Indicates an attempt to create a MutationQuery with a non-mutation
query (generally a select query).
Indicates either -
Thrown when an operation of the
Query interface
is called which is unsupported due to the nature of the
query itself.Indicates an attempt to create a SelectionQuery instance
with a non-selection query (generally a mutation query)
Object-typed form of
ImmutableMutabilityPlan for easier use
with Mutability for usersMarks an entity, collection, or attribute of an entity as immutable.
Deprecated, for removal: This API element is subject to removal in a future version.
This enumeration will be removed, and replaced with a simpler
boolean-valued switch.
Mutability plan for immutable objects
A mutability plan for mutable arrays of immutable, non-primitive objects.
Context for determining the implicit name for an ANY mapping's discriminator
column.
Context for determining the implicit name for an ANY mapping's key
column.
Context for determining the implicit name related to basic values.
Context for determining the implicit name for a collection table.
Common implicit name source traits for all constraint naming: FK, UK, index
A naming strategy specifically for determining the implicit naming of
tables and sequences relating to enhanced identifier-generators.
Context for determining the implicit name of an entity's discriminator column.
Resolves implicit discriminator values for an
@Any mapping when no
explicit AnyDiscriminatorValue matches.Context for determining the implicit name of an entity's primary table
Builder for implicit ResultSet mapping defined inline as part of a named native query
Context for determining the implicit name of an entity's identifier
column.
Context for determining the implicit name of a "join column" (think
JoinColumn).Context for determining the implicit name for a join table.
Context for determining the implicit name of a column used to back the key
of a
Map.Common contract for all implicit naming sources
A set of rules for determining the logical name
of a mapped relational database object when the mapping for an element of the Java
domain model is not explicitly specified, neither in annotations of the Java code,
nor in an XML-based mapping document.
An ImplicitNamingStrategy implementation which uses full composite paths
extracted from AttributePath, as opposed to just the terminal property part.
Implementation of the
ImplicitNamingStrategy contract, generally
preferring to conform to JPA standards.Implements the original legacy naming behavior.
Implementation of the ImplicitNamingStrategy contract which conforms to the
naming rules initially implemented by Hibernate for JPA 1.0, prior to many
things being clarified.
Used to help determine the implicit name of columns which are part of a primary-key,
well simultaneously being part of a foreign-key (join).
Context for determining the implicit name of an entity's tenant identifier
column.
Marks an arbitrary class as available for use in HQL queries by its unqualified name.
Comparator for things that cannot be compared (in a way we know about).
An
IdentifierGenerator that returns a long, constructed by counting
from the maximum primary key value obtained by querying the table or tables at startup.Marks the annotated Java element as incubating, potentially
recursively.
A mapping model object representing an index on a relational database table.
Commonality for annotations which define indexes
A rendered index-column expression and its mapping nullability.
Describes the rendered inputs needed for index DDL policy.
Supplies index creation grammar and name qualification policy.
Indexed collections include Lists, Maps, arrays and
primitive arrays.
A consumer, like
Consumer, accepting a value and its index.Provides access to information about existing index in the database
Defines whether index names are qualified in generated DDL.
Descriptor for
InetAddress handling.An in-flight representation of
Metadata while it is being built.Extracts information about objects in database schemas.
Creates context-bound stock information extractors without exposing
Hibernate's concrete extractor implementations.
A SQL
IN expression.The inheritance type for a given entity hierarchy
A general SQL command to be used while initializing a schema.
An event that occurs when a collection wants to be
initialized
Defines the contract for handling of collection initialization events
generated by a session.
Defines a multi-step process for initializing entity, collection and
composite state.
Provides access to information about the owner/parent of a fetch
in relation to the current "row" being processed.
Producer for
Initializer based on a FetchParent.Marker interface for optimizer which wishes to know the user-specified initial value.
Annotation to allow services to request injection of other services.
Describes in-line view source information.
Represents the InnoDB storage engine.
Contract for building InputStreams, especially in on-demand situations
Second-level cache bookkeeping for graph-based entity inserts.
Semantic action requested by an insert conflict clause.
Immutable plan for rendering insert-conflict semantics.
Render an ordinary single-row insert and emulate
do nothing by handling
an eligible unique-constraint violation during execution.Render a do-update insert as a
merge statement.Render an ordinary insert because no conflict action was requested.
Render an
on duplicate key update clause.Render standard
on conflict syntax from the complete semantic conflict
clause.Read-only semantic facts supplied by Hibernate when selecting how to render
an insert-conflict clause.
Dialect strategy for selecting an immutable plan for insert-conflict
semantics.
Coordinates the inserting of an entity.
Insert coordinator for audited entities.
Insert coordinator for
TemporalTableStrategy.HISTORY_TABLE
temporal strategy.Coordinates the insertion of an entity.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
GeneratedValuesMutationDelegate instead.Delegate for dealing with generated values where the dialect supports
returning the generated column directly from the mutation statement.
Coordinates the logical insertion of collection entries which are not yet persistent.
A tri-predicate for including / excluding collection entries
from iterative processing inside
InsertRowsCoordinator.insertRows(PersistentCollection, Object, InsertRowsCoordinator.EntryFilter, SharedSessionContractImplementor).InsertRowsCoordinator for audited collections.
InsertRowsCoordinator implementation for temporal collection tables
in the TemporalTableStrategy.HISTORY_TABLE
temporal table mapping strategy.OneToMany insert coordinator if the element is a
UnionSubclassEntityPersister.todo (6.2) - Would much prefer to split insert-values and
insert-select into individual contracts - something like
`InsertStatement` and `InsertSelectStatement` e.g.
Specialization of MutationStatement for inserts
Emulates the ANSI SQL-standard
overlay() function using insert()
substring(), and concat().Contract for classes whose instances are uniquely identifiable through a simple
int value,
and can be mapped via InstanceIdentityMap.Thrown if Hibernate can't instantiate a class at runtime.
Marks the canonical constructor to be used for instantiation of an embeddable.
Strategy for instantiating a managed type
Java type descriptor for the Java
Instant type.Descriptor for handling Instant directly through the JDBC driver
Descriptor for
Integer handling.Descriptor for
INTEGER handling.Descriptor for
int[] handling.Used in place of
TimestampaddFunction for databases which don't
support fractional seconds in the timestampadd() function.Indicates a problem integrating Hibernate and the Bean Validation spec.
Contract for extensions that integrate with Hibernate.
Inputs which are valid during SessionFactory integration but are not
represented by the finalized metadata or the in-flight SessionFactory.
An object that provides a list of
Integrators to the JPA persistence provider.Allows user code to inspect and/or change entity property values before they are
written to the database, or after they are read from the database.
Strategy for resolving and managing
Interceptor instances
across session lifecycle boundaries.Describes how an
Interceptor was configured.Marks the annotated Java element as forming part of the internal
implementation of Hibernate, meaning that clients should expect absolutely
no guarantees with regard to the binary stability from release to release.
Represents a generic unhandled problem which occurred while translating
HQL/JPQL.
Identifies the native SQL interval family supplied to temporal arithmetic.
Thrown by
GraphParser to indicate textual entity graph representation parsing errors.Indicates a problem parsing the mapping document at a given
Origin.Thrown when a mapping is found to be invalid.
Contract for performing work in a manner that isolates it from any current transaction.
Implementation of FormatMapper for Oracle OSON support
Converts Jakarta Data
restrictions to Hibernate query restrictions or
directly applies them to JPA criteria queries, and
Jakarta Data constraints to
JPA predicates.
Marker annotation identifying integration points which Hibernate supports loading as a
Java service.
Common marker interface for mapping Java Time objects
directly through the JDBC driver.
Specify an explicit
BasicJavaType to use for a particular
column mapping.Describes the Java side of a value mapping.
Primes the
JavaTypeBaseline.BaselineTarget (which is essentially the JavaTypeRegistry)
with Hibernate's baseline JavaType registrationsThe target of the baseline registrations
AbstractClassJavaType for cases where we do not know a proper
JavaType for a given Java type.Contract for something that has an associated JavaType
Registers a
BasicJavaType as the default Java type descriptor for the given
JavaTypeRegistration.javaType().JavaType registration
Grouping of
JavaTypeRegistration
See notes on JavaTypeRegistration about using on packages
versus use on classesA registry mapping
Java classes to implementations
of the JavaType interface.Subsystem logging related to JDBC batch execution
Models the function return when the JdbcOperationQueryCall represents a call to a database
function.
Controls extracting values from OUT/INOUT parameters.
Provides centralized access to JDBC connections.
A
JDBCException indicating a problem communicating with the
database (can also include incorrect JDBC setup).Coordinates JDBC-related activities.
Models a JDBC data type.
Descriptor for
Date handling.Initial look at this concept we keep talking about with merging information from
DatabaseMetaData
and DialectActs as a wrapper to another
SqmFunctionDescriptor, rendering the
standard JDBC escape sequence {fn f(x, y)} around the invocation
syntax generated by its delegate.Acts as an observer for various events regarding JDBC interactions and doing one or more of -
delegating to StatisticsImplementor
delegating to SessionEventListenerManager
logging
Wraps a
SQLException arising from the JDBC driver.Inspects a JDBC exception chain for vendor error information.
Descriptor for a table insert originating from a flush
Represents a literal in the SQL AST.
Records which stage owns pessimistic locking for a JDBC select plan.
Subsystem logging related to JDBC interactions
Describes the mapping for things which can be expressed in a SQL query.
Container for one-or-more JdbcMappings
Effective JDBC metadata used for Hibernate runtime decisions.
Determines how JDBC metadata is read by the schema management tooling.
Whether access to JDBC metadata is allowed during bootstrap.
Immutable overrides applied to raw JDBC metadata reports.
Build an immutable JDBC-metadata-override profile.
Resolution to apply to one raw JDBC support report.
Primary operation, which is an (
INSERT, UPDATE or DELETE) performed via JDBC.Executor for model-mutation operations
JdbcOperation for a mapping-model mutation originating from a persistence
context flush.A command to perform through JDBC, normally with a
PreparedStatement or CallableStatement.A JdbcOperation which (possibly) originated from a Query.
An anonymous call block (sometimes called an anonymous procedure) to be executed
on the database.
Basic contract for an insert operation
A query-language insert, update, or delete operation performed through JDBC.
Creates Hibernate-owned JDBC operations from the output of a custom SQL AST
translator.
Builder for a query-language insert, update, or delete operation.
Builder for a
JdbcSelect.Records which stage owns pagination for a JDBC select plan.
Performs parameter value binding to a JDBC PreparedStatement.
Access to all the externalized JDBC parameter bindings
Access to the mapping between an SqmParameter and all of its JDBC parameters
Creates JDBC parameter expressions for SQL AST translation without exposing
Hibernate's concrete parameter implementations.
The collection
Conceptually similar to a List of JdbcParameters, but exposing a
read-only immutable contract.
Models access to the resource transaction of the underlying JDBC resource.
Provides access to
JdbcResourceTransaction (JDBC transaction stand-in) for use in
building resource-local TransactionCoordinator
instances.Primary selection operation performed through JDBC.
An executor for JdbcSelect operations.
Contract used while building a
JdbcSelect which might potentially
include pre- and/or post- actions.Provides access to services related to JDBC operations.
Provides the "JDBC session" with contextual information it needs during its lifecycle.
Contract for something that controls a
JdbcSessionContext.Settings related to JDBC, Connections, pools, Dialects, and so on.
Descriptor for
Time handling.Descriptor for
Timestamp handling.Specifies an explicit
JdbcType to use for a particular column mapping.
When applied to a Map-valued attribute, describes the Map value.Describes the SQL/JDBC side of a value mapping.
Specifies the JDBC type-code to use for the column mapping.
When applied to a Map-valued attribute, describes the Map value.
Constructs a
JdbcType parameterized by an element JdbcType.Information pertaining to JDBC type families.
A parameter object that helps determine the
SQL/JDBC type
recommended by the JDBC spec (explicitly or implicitly) for a given Java type.Maintains the JDBC recommended mappings for JDBC type-code to/from Java Class
as defined in Appendix B: Data Type Conversion Tables of the JDBC
Specification.
(Badly named) helper for dealing with standard JDBC types as defined by
TypesException indicating
JavaType.getRecommendedJdbcType(JdbcTypeIndicators) could not
determine a recommended JDBC type descriptorJdbcType registration
Grouping of
JdbcTypeRegistration
See notes on JdbcTypeRegistration about using on packages
versus use on classesA registry mapping
JDBC type codes
to implementations of the JdbcType interface.Describes the update of a single table
Used to track JDBC value bindings (generally parameters) used in mutation operations.
The JDBC values for a mutation
Allows supplying a custom
JdbcValueBindingsImplementor into the executor.SPI extension to
JdbcValueBindings to allow access to bound values.Descriptor for JDBC value within an operation.
Provides access to details needed while binding
Implementation of
JdbcValueDescriptor.Provides unified access to query results (JDBC values - see
RowProcessingState.getJdbcValue(SqlSelection) whether they come from
query cache or ResultSet.The "resolved" form of
JdbcValuesMappingProducer providing access
to resolved JDBC results (SqlSelection) descriptors and resolved
domain results (DomainResult) descriptors.Producer for JdbcValuesMapping references.
Pluggable contract for providing custom
JdbcValuesMappingProducer implementations.The "resolved" form of
JdbcValuesMapping providing access
to resolved (DomainResultAssembler) descriptors and resolved
initializer (Initializer) descriptors.Access to information about the underlying JDBC values
such as type, position, column name, etc
Essentially processing options only for entity loading
Provides a context for processing the processing of the complete
set of rows from a JdbcValuesSource.
Generic contract for wrapped JDBC objects.
An exception indicating trouble accessing JNDI
Indicates a problem with a given JNDI name being deemed as not valid.
Service providing simplified access to JNDI related features needed by Hibernate.
Contract that represents a secondary table join that is part of an entity hierarchy.
A mapping model object representing some sort of auxiliary table, for
example, an association table,
a secondary table, or a
table belonging to a joined subclass.
Deprecated, for removal: This API element is subject to removal in a future version.
Contract for entity mappings that support secondary table joins.
A mapping model object that represents a subclass in a "joined" or
"table per subclass"
inheritance hierarchy.
An
EntityPersister implementing the normalized
InheritanceType.JOINED inheritance
mapping strategy for an entity and its inheritance hierarchy.A persistent entity mapping that uses joined table(s) to store the hierarchy of entity types.
Specifies a join condition based on an arbitrary native SQL formula
instead of a column name.
Enumerates the possible kinds of join in HQL and ANSI SQL.
Descriptors for JPA annotations
Adapts a JPA-standard
AttributeConverter to the native
BasicValueConverter.Access to information that implementors of
ConverterDescriptor.createJpaAttributeConverter(JpaAttributeConverterCreationContext) might
needAPI extension to the JPA
BooleanExpression contractThe target for cast.
Specialization of
JpaJoin for Collection typed attribute joinsAPI extension to the JPA
ComparableExpression contractEncapsulates settings controlling whether Hibernate complies strictly
with certain debatable strictures of the JPA specification.
Marker interface for exceptions describing JPA compliance violations.
A conflict clause for insert statements.
The update action that should happen on a unique constraint violation for an insert statement.
The commonalities between insert-select and insert-values.
A representation of SqmInsertSelectStatement at the
org.hibernate.query.criteria level, even though JPA does
not define support for insert-select criteria.A representation of SqmInsertValuesStatement at the
org.hibernate.query.criteria level, even though JPA does
not define support for insert-values criteria.Base contract for nodes making up the criteria tree
JpaParameterExpression created via JPA CriteriaBuilder.Extension of the JPA
CriteriaQueryExtension of the JPA
CriteriaSelect.Common contract for criteria parts that can hold CTEs (common table expressions).
A CTE (common table expression) criteria.
Describes the attribute of a
JpaCteCriteriaType.A CTE (common table expression) criteria type.
Represents a derived join, that is, a subquery that occurs as the
target of a join in the
from clause of the query.Distinction between the 2 different styles or approaches of lifecycle events defined by JPA.
API extension to the JPA
Expression contractAPI extension to the JPA
From contractContract for expressions which model a SQL function call.
A special expression for the
json_exists function.The base for
json_exists function nodes.The behavior of the json exists expression when a JSON processing error occurs.
A special expression for the
json_query function.The base for
json_query function nodes.The behavior of the json query expression when a JSON path does not resolve for a JSON document.
The behavior of the json query expression when a JSON processing error occurs.
The kind of wrapping to apply to the results of the query.
A special expression for the definition of columns within the
json_table function.A special expression for the
json_table function.The behavior of the json exists expression when a JSON processing error occurs.
A special expression for the
json_value function.The base for
json_value function nodes.The behavior of the json value expression when a JSON path does not resolve for a JSON document.
The behavior of the json value expression when a JSON processing error occurs.
Extensions to the JPA-defined metamodel of
persistent Java types.
SPI extending
JpaMetamodel.API extension to the JPA
NumericExpression contractContract for things that need to be aware of JPA
orm.xml-defined persistence-unit-defaults.Represents the
persistence-unit-defaults to be appliedAPI extension to the JPA
Path contractCommon contract for the forms of criteria that are "queryable" - can be
converted into a
Query.A query group i.e.
Models a query part i.e.
Models a
SELECT query.Serves the role of
Reference which is
unfortunately sealed, and so we cannot directly extend.Represents the search order for a recursive CTE (common table expression).
Commonality between a JPA
JpaCriteriaQuery and JpaSubQuery,
mainly in the form of delegation to JpaQueryStructureAPI extension to the JPA
Selection contractA set returning function criteria.
Enumerates SPI-related settings that are specific to the use of Hibernate
as a JPA
PersistenceProvider.Extension to the JPA StatementReference contract.
JPA ties the notion of
SourceDescriptor and TargetDescriptor
together: meaning that a SourceDescriptor is specific to a given TargetDescriptor.API extension to the JPA
TemporalExpression contractAPI extension to the JPA
TextExpression contractAPI extension to the JPA
TupleElement contractExtension to the JPA TypedQueryReference contract.
A tuple of values.
Common contract for window parts used in window and aggregate functions.
Common contract for a
JpaWindow frame specification.A special expression for the
xmlelement function.A special node for column defined for a
xmltable function.A special expression for the
xmltable function.Subclassable descriptor for the standard
json_arrayagg function.Subclassable descriptor for the standard
json_array function.JDBC descriptor for
JSON_ARRAY and the JSON array SQL data type.Factory for
JsonArrayJdbcType.A
FunctionReturnTypeResolver that resolves a JSON encoded array type based on the arguments,
which are supposed to be of the element type.Specialized type mapping for
JSON_ARRAY and the JSON SQL data type.Factory for
JsonArrayJdbcType.Specialized type mapping for
JSON and the JSON SQL data type.Json item types
JSON document reader.
JSON document producer.
Subclassable descriptor for the standard
json_exists function.Stateless helper class to serialize managed type values to JSON.
A Helper for serializing and deserializing JSON, based on an
EmbeddableMappingType.JDBC descriptor for
JSON and the JSON SQL data type.Subclassable descriptor for the standard
json_objectagg function.Subclassable descriptor for the standard
json_object function.Subclassable descriptor for the standard
json_query function.Standard json_table function.
Subclassable descriptor for the standard
json_value function.Adapter for JSON value on given JDBC types.
Factory class to get proper
JsonValueJDBCTypeAdapter.A
Service that defines how Hibernate interacts with JTA on a certain
platform.Indicates a problem interacting with the underlying JTA platform.
A
ServiceLoader-style provider of JtaPlatform
instances.A
Service defining a strategy for obtaining a JtaPlatform
in configurations where the application did not explicitly specify one.Descriptor for JTS
Geometrys.Deprecated.
Use
JTSSpatialCriteriaBuilder insteadContract for declaring a column name of a foreign key.
Contract that defines an attribute that can participate in a key.
Support for pagination based on a unique key of the result
set instead of the
offset.Support for pagination based on a unique key of the result
set instead of the
offset.Internal contract for a collection of SqmFunctionDescriptors, together with their key
Specifies whether an identifier value passed to
get() or
find() should be
interpreted as a regular id (the default)
or as a natural id.A mapping model
Value which may be treated as an identifying key of a
relational database table.Receives SQL keywords while a Dialect's immutable keyword profile is built.
Defines the stable SQL keywords of a Dialect and filters driver observations.
Selects how a lateral derived-table reference is introduced.
Descriptor for an attribute which is enabled for bytecode lazy fetching
Interceptor that loads attributes lazily
This is an helper object to group all state which relates to a particular entity type,
and which is needed for this interceptor.
Information about the bytecode lazy attributes for an entity
Specifies the fetch group for a persistent attribute of an entity
class.
The most general abstraction over collections which may be fetched lazily.
Indicates an attempt to access unfetched data outside the context
of an open stateful
Session.Handles fetching of the underlying entity for a proxy.
Contract for controlling how lazy properties get initialized.
Deprecated.
Prefer the form of these methods defined on
BytecodeLazyAttributeInterceptor insteadThe purpose of this table group is to defer creating the actual table group until it is really needed.
Optional legacy mutation support for an
AuxiliaryMapping.A
LimitHandler for DB2.DB2 10.5 xmlexists function.
DB2 10.5 xmlquery function.
Entity-specific mutation target for the legacy (sequential) action queue.
Builds a fetch defined by legacy
hbm.xml mappings or by calls to
NativeQuery.addFetch(String, String, String) and related methods.This class provides an empty implementation of
LegacyGraphLanguageParserListener,
which can be extended to create a listener which only needs to handle a subset
of the available methods.This class provides an empty implementation of
LegacyGraphLanguageParserVisitor,
which can be extended to create a visitor which only needs to handle a subset
of the available methods.This interface defines a complete listener for a parse tree produced by
LegacyGraphLanguageParser.This interface defines a complete generic visitor for a parse tree produced
by
LegacyGraphLanguageParser.Slight variation from
HiLoOptimizer, maintaining compatibility with the values generated by the
legacy Hibernate hilo based generators.Mutation target contract for the legacy (sequential) action queue.
Naming strategy which implements the behavior of older versions of
Hibernate, for the most part.
Deprecated.
Use the
SpecHints form insteadDefines a list of useful constant values that may be used
to specify long column lengths in the JPA
Column annotation.A length function with separate patterns for string and clob argument.
Paging limits
Dialect strategy for applying execution-time limit and offset to
already-rendered SQL.
Limit handler for MySQL and CUBRID which support the syntax
LIMIT n and LIMIT m, n.A
LimitHandler for databases like PostgreSQL, H2,
and HSQL that support the syntax LIMIT n OFFSET m.A mapping model object representing a collection of type
List.Boot model representation of a Jakarta Persistence style callback defined as a separate listener class.
Specifies the base value for the order column of a persistent list or array, that is, the order column value
of the first element of the list or array.
Form of
JavaType for describing the column mapping
for the index of a List or array.Form of
JdbcType for describing
the column mapping for the index of a List or array.Form of
JdbcTypeCode for describing the column mapping
for the index of a List or array.Hibernate extension to the JPA
ListAttribute descriptorResultsConsumer for creating a List of results
Ways this consumer can handle in-memory row de-duplication
A wrapper for a literal to render as parameter through a cast function.
Renders database-specific SQL literal expressions.
Common details for things that can be loaded by a loader - generally
entities and
plural attributes (collections).
Maintains a Stack of processing state related to performing load operations.
Models the information gleaned from parsing a
cfg.xml file.Used to collect entity and collection values which are loaded as part of
JdbcValues processing.
Details about a loaded collection.
Details about a loaded entity.
Common contract for all value-mapping loaders.
Logging for loaders
Defines an event class for the loading of an entity.
Defines the contract for handling of load events generated from a session.
Represents a collection currently being loaded.
Centralize all options which can influence the SQL query needed to load an
entity.
Provides callback access into the context in which the LOB is to be created.
The callback contract for making use of the JDBC
Connection.Contract for creating various LOB references.
Materializes LOB data using Hibernate's standard resource-handling and
exception-conversion semantics.
Strategy for how dialects need
LOB values to be merged.Defines the database and driver policy for LOB creation, binding,
materialization, type classification, mutation ordering, and VALUE LOB DDL.
Supplies immutable stock LOB policy profiles.
Java type descriptor for the
LocalDate type.Descriptor for handling LocalDate directly through the JDBC driver
Java type descriptor for the
LocalDateTime type.Descriptor for handling LocalDateTime directly through the JDBC driver
Descriptor for
Locale handling.Specialization of the MetadataBuildingContext contract specific to a given origin.
Wraps an exception thrown from a "local synchronization" (one registered in the SynchronizationRegistry).
Java type descriptor for the
LocalTime type.Descriptor for handling LocalTime directly through the JDBC driver
When Hibernate loads an XSD we fully expect that to be resolved from our
jar file via ClassLoader resource look-up.
Emulates the ANSI SQL-standard
position() function using locate().A
JDBCException indicating a problem acquiring a lock
on the database.Event class for
Session.lock(Object, LockMode).Defines the contract for handling of lock events generated from a session.
Support for various aspects of pessimistic locking.
In certain circumstances, Hibernate may need to acquire locks
through the use of additional queries.
Renders a complete pessimistic locking clause from a focused request.
A complete, read-only request to render a pessimistic locking clause.
A qualified column-reference locking target.
A table-alias locking target.
A structured target named by a locking clause.
Per-translation strategy for collecting lock targets and rendering
statement-level pessimistic locking.
Applies a Dialect's pessimistic locking syntax to already-rendered SQL.
A complete, read-only request to apply pessimistic locking to already-
rendered SQL.
The immutable outcome of applying pessimistic locking to already-rendered
SQL.
Classification of the rewrite outcome.
Acquires an entity lock in the underlying database.
An error applying a
LockingStrategy to an entity.Cohesive Dialect profile for pessimistic-locking capabilities and operations.
Immutable description of the locking syntax and timeout capabilities of a
Dialect.
Instances represent a lock mode for a row of a relational
database table.
Deprecated, for removal: This API element is subject to removal in a future version.
Since JPA 3.2 and Hibernate 7, a
LockMode, Timeout,
or PessimisticLockScope may be passed directly as an option
to find(), refresh(), or lock().A
JDBCException indicating that a lock
request timed out on the database.The way, if any, that a Dialect supports specifying lock timeouts.
Marker interface for user types which want to perform custom
logging of their corresponding values
Represents a continuous logical connection to the database to the database via JDBC.
SPI contract for
LogicalConnection.Models a logical UPDATE to a table.
Descriptor for
Long handling.Descriptor for
LONGNVARCHAR handling.Descriptor for
long[] handling.Descriptor for
LONGVARBINARY handling.Descriptor for
LONGVARCHAR handling.HQL function inspired by the ANSI SQL trim function,
with a funny syntax involving a
TrimSpec.Contract for classes (specifically, entities and components/embeddables) that are "managed".
Generalized contract for a (CDI or Spring) "managed bean" as seen by Hibernate
A registry for
ManagedBean instances.Specialized
Managed contract for
embeddable classes.Extensions to the JPA-defined
ManagedType contract.Specialized
Managed contract for entity classes, providing access to information
about the association between the instance and the PersistenceContext, including:
The EntityEntry, by way of ManagedEntity.$$_hibernate_getEntityEntry() and
ManagedEntity.$$_hibernate_setEntityEntry(EntityEntry).Specialized
Managed contract for
mapped superclasses.Mapping-model corollary to
ManagedTypeRepresents the result of the first step of the process of building
MetadataSources
reference into a Metadata reference.Reads rows without producing a result.
Pluggable strategy handling resolution of ManagedTypeRepresentationStrategy to use.
Defines a singular extension point for capabilities pertaining to
a representation mode.
Maps a to-many cardinality association taking values over several
entity types which are not related by the usual entity
inheritance, using a discriminator value stored in an
association table.
A mapping model object representing a many-to-one association.
Represents a plural attribute mapping of a
many-to-one or key-many-to-one.A many-to-one association to an entity.
A mapping model object representing a collection of type
Map.Descriptor for
Map.Entry.Form of
CompositeType for use with map-keysForm of
JavaType for describing the key of a MapForm of
JdbcType for describing the key of a MapForm of
JdbcTypeCode for describing the key of a MapForm of
Mutability for describing the key of a MapForm of
Type for use with map keys.Lazy initializer for "dynamic-map" entity representations.
A mapping model object representing a mapped superclass
of an entity class.
Extension of the JPA
MappedSuperclassType contractHibernate extension to the JPA
MapAttribute descriptorDescribes an audit mapping context.
Declares operations used by implementors of
Type that are common to the fully-"compiled"
runtime mapping metadata held by a SessionFactory and the incomplete metamodel
which exists during the metadata building process.Values to use as defaults in the absence of certain mapping information.
Indicates a problem parsing a mapping document.
An exception that occurs while reading mapping sources, either
XML or annotations, usually as a result of something screwy in
the O/R mappings.
Access to information about the runtime relational O/R mapping model.
Something that can be expressible at the mapping model level.
Indicates that a mapping document could not be found at a given
Origin.Represents a
<mapping/> element within a cfg.xml file.Common descriptor for types in the mapping model - entities, embeddables, String, Integer, etc
Support for XSD handling related to Hibernate's `hbm.xml` and
JPA's `orm.xml`.
Proxy for "dynamic-map" entity representations.
Extension of
CollectionSemantics for MapsDescribes a relationship annotated with
MapsIdA SQL dialect for MariaDB 10.6 and above.
Access to Hibernate's stock MariaDB JDBC type descriptors.
MariaDB json_arrayagg function.
MariaDB json_array_append function.
MariaDB json_array function.
MariaDB json_objectagg function.
MariaDB json_query function.
MariaDB json_value function.
A strategy for matching strings using "like".
Indicates a problem resolving a member from ClassDetails
MergeContext is a specialized Map implementation used by a
merge event listener
to keep track of each entity being merged and its corresponding managed result.Merge coordinator for audited entities.
Merge coordinator for
TemporalTableStrategy.HISTORY_TABLE
temporal strategy.Specialized
UpdateCoordinator for merge into.Merge coordinator for
TemporalTableStrategy.SINGLE_TABLE
temporal strategy.Event class for
Session.merge(T).Defines the contract for handling of merge events generated from a session.
JdbcMutationOperation implementation for MERGE handlingMessageHelper methods for rendering log messages relating to managed
entities and collections typically used in log statements and exception
messages.
Common interface for things that can handle meta attributes.
A meta attribute is a named value or values.
Represents the ORM model as determined by aggregating the provided mapping sources.
Contract for specifying various overrides to be used in metamodel building.
Deprecated, for removal: This API element is subject to removal in a future version.
Use settings,
TypeContributor, FunctionContributor or
AdditionalMappingContributor instead depending on needAn extension point for integrators that wish to hook into the process of how a
Metadata is built.Internal API for
MetadataBuilder exposing the building options being collected.Contract for contributing to the initialization of
MetadataBuilder.Describes the context in which the process of building
Metadata
from MetadataSources occurs.Describes the options used while building the
Metadata
object during MetadataBuilder.build() processing.Represents the process of transforming a
MetadataSources
reference into a Metadata reference.The SPI-level
Metadata contract.Enumeration of the known places from which a piece of metadata may come.
Defines the steps in processing metadata sources.
Entry point for working with sources of O/R mapping metadata, either
in the form of annotated classes, or as XML mapping documents.
A bootstrap process hook for contributing sources to
MetadataSources.Most databases don't have a function like
every() or any().Indicates that a column defined as part of a SQL ResultSet mapping was not part
of the query's ResultSet
Logging related to entity and collection mutations stemming from persistence-context events
Base descriptor, within the mapping model, for any part of the
application's domain model: an attribute, an entity identifier,
collection elements, and so on.
Functional interface for consuming the JDBC values, along with two values of type
X and Y.Functional interface for consuming the JDBC values.
Access to a group of ModelPart by name or for iteration.
A ResultMappingMementoNode that is a reference to some part of the user's
domain model
The type of modification recorded in the
modification type column of the audit log.
Defines a naming strategy for applying modified columns to the audited entity metamodel.
Marks a property which holds entity names that have been modified during each revision.
Deprecated, for removal: This API element is subject to removal in a future version.
Use Session.findMultiple(Class, List, FindOption...) accepting
options instead.
EntityMultiLoader implementation based on identifier.
Encapsulation of the options for loading multiple entities (of a type)
by id.
Loader specialization for loading multiple loadable
references by primary, foreign or natural key.
Strategy for determining an optimal size for loading by multiple keys.
Encapsulation of the options for loading multiple entities (of a type)
by key.
EntityMultiLoader implementation based on identifier.
Encapsulation of the options for loading multiple entities (of a type)
by natural-id.
Support for overloaded functions defined in terms of a
list of patterns, one for each possible function arity.
Exception used to indicate that a query is attempting to simultaneously fetch multiple
bags
Simply as a matter of code structuring, it is often worthwhile to put all of the execution code into a separate
handler (executor) class.
The build result of a
MultiTableHandler.Selects the Hibernate-owned fallback family used for an SQM mutation of a
multi-table entity.
Immutable selection of Hibernate's fallback strategy families for SQM
mutations of multi-table entities.
Exposes useful multitenancy-related strategy objects to user-written components.
Describes the source information related to mapping the multi-tenancy of an entity
A specialized
Connection provider contract used when the application is using
multi-tenancy support requiring tenant-aware connections.Specifies a
MutabilityPlan for a basic value mapping.Describes the mutability semantics of a Java type.
Something that exposes a MutabilityPlan
A builder that generates a Serializable Object to be used as a key into the query results cache.
Base mutability plan for mutable values.
Extension to QueryOptions providing ability to mutate the values.
Specialized TableReference for model mutation operations
Acts as a TableGroup for DML query operations.
Ordered binding slots for a mutation operation.
Coordinates the mutation operations of an entity.
Main contract for performing the mutation.
Deprecated, for removal: This API element is subject to removal in a future version.
This service executes the statement groups used only by the legacy
action queue.
Grouping of table mutations for the given target for
the given type of mutation
Builder (pattern) for
TableMutation referencesKind of table mutation
The kind of SQL mutation statement whose syntax is being described.
Mutation for a specific table as part of a logical mutation on the entity.
Deprecated, for removal: This API element is subject to removal in a future version.
This contract is used only by the legacy action queue.
Unifies
StatementOrTypedQuery with Query, allowing backward
compatibility with older versions of Hibernate and JPA which did not carefully
distinguish selection queries from insert, update,
and delete mutation statements.Within the context of an active session,
an instance of this type represents an executable mutation query, that is,
an
insert, update, or delete.SPI form of MutationQuery
Specialization of
QuerySpecification for programmatic customization of
mutation queries.A function capable of modifying or augmenting a criteria query.
Specialization of Statement for mutation (DML) statements
Interface to the object that prepares JDBC
PreparedStatements related to mutations
on behalf of a JdbcCoordinator.A native SQL mutation-syntax capability.
Immutable description of a Dialect's native SQL mutation syntax.
Build an immutable mutation-syntax profile.
Deprecated, for removal: This API element is subject to removal in a future version.
Transitional interface - use
LegacyMutationTarget for legacy
coordinators or GraphMutationTarget for graph-based decomposersThe supported semantic view of a model mutation target.
The type of mutation
Represents the MyISAM storage engine.
Deprecated.
Use "hibernate.dialect.storage_engine=innodb" environment variable or JVM system property instead.
Deprecated.
Spatial Dialects are no longer needed
Deprecated.
Use "hibernate.dialect.storage_engine=innodb" environment variable or JVM system property instead.
Deprecated.
Spatial Dialects are no longer needed
A SQL dialect for MySQL 8 and above.
Descriptor for MySQL Geometries.
Access to Hibernate's stock MySQL JDBC type descriptors.
MySQL json_arrayagg function.
MySQL json_array function.
MySQL json_exists function.
MySQL json_objectagg function.
MySQL json_object function.
MySQL json_query function.
MySQL json_table function.
MySQL json_value function.
Utility class that extract some initial configuration from the database
for
MySQLDialect and related dialects.Deprecated.
SpatialDialects are no longer needed in Hibernate 6
Describes the schema and foreign-key behavior of a MySQL storage engine.
Contract for query implementations
which can be converted to named query mementos for storage
in the
NamedObjectRepository.Commonality for annotations that are named within a repeatable container.
Mainly this is used to support legacy sequence exporting.
Renders one named parameter of a JDBC procedure or function call.
Represents a "memento" (disconnected, externalizable form) of a
ProcedureCall.Defines a named entity graph
based on Hibernate's entity graph language.
Models a @NamedEntityGraph
A grouping of
NamedEntityGraph definitions.Boot-time descriptor of a named query define using HQL.
Used to model named mutation-query attributes.
A grouping of
NamedNativeQuery definitions.Declares a named query written in native SQL.
Boot-time descriptor of a named native query.
Descriptor for a named native query in the runtime environment
Repository for references to named things related to queries.
Thrown to indicate that an attempt was made to register a stored procedure named parameter, but the underlying
database reports to not support named parameters.
Boot-time descriptor of a named procedure/function query, as defined in
annotations or xml
A grouping of
NamedQuery definitions.Declares a named query written in HQL or JPQL.
Boot-model representation of named queries.
The runtime representation of named queries.
Indicates that validation and translation of one or more named
queries failed at initialization time.
Models the "boot view" of a ResultSet mapping used in the mapping
of native and procedure queries.
Used to keep information about named result mappings defined by the
application which can then be applied to native-sql and stored-procedure
queries.
Boot-model mapping of named queries which define a selection query.
Models NamedQueryMemento which is a selection-query
Provides a standard implementation that supports the majority of the HQL
functions that are translated to SQL.
Provides a standard implementation that supports the majority of the HQL
functions that are translated to SQL.
Target for NamedStrategyContributor
Discoverable contributor for named references which are resolvable via StrategySelector.
Represents a reference to a "named" table in a query's from clause.
Describes whether qualified database object names admit catalogs, schemas,
both namespace kinds, or neither.
Represents a namespace (named schema/catalog pair) with a Database and manages objects defined within.
Defines the catalog and schema lifecycle operations used by schema tooling.
Supplies immutable stock catalog and schema lifecycle strategies.
Helper contract for dealing with naming strategies.
Describes how a database represents nationalized character data.
Specifies that the annotated character data should be stored with
nationalization support.
Manages a mapping between nationalized and non-nationalized variants of JDBC types.
Generator that picks a strategy based on the dialect.
Generator that picks a strategy based on the dialect.
Within the context of an active session,
an instance of this type represents an executable query written in the
native SQL dialect of the underlying database.
Allows access to further control how collection returns are mapped back
from result sets.
Allows access to further control how join fetch returns are mapped back
from result sets.
Simple unification interface for all returns from the various
addXYZ()
methods.A
NativeQuery.ResultNode which can be a query result.Allows access to further control how properties within a root or join
fetch are mapped back from the result set.
Allows access to further control how root returns are mapped back from
result sets.
A
TupleTransformer for handling Object[] results from native queries.A
TupleTransformer which packages each native query result in
an instance of the result class by calling an appropriate constructor.Service contract for dealing with native queries.
A
TupleTransformer for handling List results from native queries.A
TupleTransformer for handling Map results from native queries.Specialization of
QueryPlan for NativeQuery
plansA
TypedTupleTransformer for handling JPA Tuple results from native queries.Access the values defining a native select query
Specifies that a field or property of an entity class is part of
the natural id of the entity.
Specifies that mappings from the natural id values of the annotated
entity to the corresponding entity id values should be cached in the
shared second-level cache.
Models a non-aggregated composite natural-id for the purpose of loading.
Contract for managing transactional and concurrent access to cached naturalId
data.
Specialized DomainDataCachingConfig describing the requested
caching config for the natural-id data of a particular entity (hierarchy)
Deprecated.
Use Session.find(Class, Object) or Session.getReference(Class, Object)
with KeyType.NATURAL instead.
Loader for
NaturalIdOptions for loading by natural-id
Mapping for an entity's natural-id, if one is defined.
Deprecated.
(since 7.3) Use Session.find(Class, Object) with KeyType.NATURAL instead.
A ternary boolean enum for describing the mutability aspects of an
attribute as a natural id.
Standard support for
NaturalIdDataAccess
using the AccessType.NONSTRICT_READ_WRITE access type.Standard support for
NaturalIdDataAccess
using the AccessType.READ_ONLY access type.Standard support for
NaturalIdDataAccess
using the AccessType.READ_WRITE access type.Manages the cached resolutions related to natural-id (to and from identifier)
Statistics pertaining to the execution of queries which resolve a natural
id lookup against the database.
Indicates whether natural id synchronization (a sort of flush)
should occur before a find by natural id.
A compound name where the root path element is an entity name or a collection role
and each the path sub-path from the root references a domain or mapping model part
relative to a root path.
A compound path which represents a
ModelPart
and uniquely identifies it with the runtime metamodel.Descriptor for
NCHAR handling.Marker interface for non-contextually created
NClob instances.Descriptor for
NClob handling.Base JDBC descriptor for
Types.NCLOB handling.Manages aspects of proxying
NClobs for non-contextual creation, including proxy creation and
handling proxy invocations.Model a column which is relative to a base expression e.g.
Standard family base for databases using
sequence.nextval and
sequence.currval expressions.Indicates a condition where a second-level cache implementation was expected to be available, but
none was found on the classpath.
Common contract for all nodes in the order-by fragment AST
Adapts the JPA CriteriaBuilder to generate SQM nodes.
Indicates that all outputs have been processed.
A "non-aggregated" composite identifier, which means that the entity itself
does not define a singular representation of its identifier like an
aggregated mapping does.
Think of an AttributeConverter for id values to account for representation
difference between virtual and id-class mappings
QueryInterpretations key for non-select NativeQuery instances
Marker interface for exceptions thrown during mapping-model creation which
are not transient errors - they will never succeed
Thrown when Hibernate encounters a non-unique SQL alias in the ResultSet
while processing the results of a NativeQuery
using auto-discovery to understand the ResultSet metadata
for mapping the JDBC values to the domain result.
This exception is thrown when an operation would break session-scoped identity.
Thrown when the application calls
Query.getSingleResult() or
Query.uniqueResult() and the query returns more than one row
from the database.Handler not supporting query LIMIT clause.
An optimizer that performs no optimization.
Indicates a condition where we expect rows in the JDBC results,
but none were returned.
When applied to a field, indicates that this field should not be audited.
Indicates that a many to one,
one to one, or
many to many association
maps to a column holding foreign keys, but without a foreign key
constraint, and which may therefore violate referential integrity.
Specifies how Hibernate should handle the case of an orphaned foreign
key with no associated row in the referenced table.
Indicates an attempt to use a non-indexed collection as indexed.
Indicates a condition where an instrumented/enhanced class was expected, but the class was not
instrumented/enhanced.
Descriptor for binding nulls with Types.NULL
Nullness restriction - IS (NOT)? NULL
The ordering of null values used by a Dialect's
NullOrderingSupport.getDefaultOrdering() profile value.Immutable description of a Dialect's default null ordering and native
explicit null-precedence syntax.
Build an immutable null-ordering-support profile.
An independently configurable null-ordering syntax capability.
Defines the possible null handling modes.
Indicates an attempt to register a null synchronization.
The base for generate_series function implementations that use a static number source.
Handles conversion to/from
Boolean as 0 (false) or 1 (true)Descriptor for
NUMERIC handling.Descriptor for
NVARCHAR handling.Oracle 8i had no
coalesce() function,
so we emulate it using chained nvl()s.Descriptor for
Object[] handling, usually used for tuples.Thrown when the user tries to do something illegal with a deleted object.
Descriptor for binding objects using any JDBC type code.
Provides centralized normalization of how database object names are handled.
Thrown when
Session.find(Class, Object) fails to select a row
with the given primary key (identifier value).Descriptor for binding objects, but binding nulls with Types.VARBINARY
Descriptor for binding objects, but binding nulls with Types.NULL
Selects how an untyped Java
null is bound through JDBC.Descriptor for binding objects, but binding nulls with the resolved parameter type
Java type descriptor for the
OffsetDateTime type.Descriptor for handling OffsetDateTime directly through the JDBC driver
A
LimitHandler for databases which support the
ANSI SQL standard syntax FETCH FIRST m ROWS ONLY
and OFFSET n ROWS FETCH NEXT m ROWS ONLY.Java type descriptor for the
OffsetTime type.Descriptor for handling OffsetTime directly through the JDBC driver
Specifies an
on delete action for a foreign key constraint.Enumerates the possible actions for the
on delete clause
of a foreign key constraint.A mapping model object representing a many-to-one association.
Marker interface for one-to-many collection decomposers
A table group for one-to-many plural attributes.
A mapping model object representing a many-to-one association.
A one-to-one association to an entity
A generator which produces a new value by actually going ahead and writing a row to the
database, then retrieving the value which was generated by the database itself as a side
effect of the SQL
insert or update statement which wrote the row.A kind of database operation on an existing row, used to ask a
TransactionConcurrency descriptor about read guarantees and conflicts
between transactions.Monitors the physical execution of one or more related flush operations.
Callback for producing a
JdbcMutationOperation given
a collection-table referenceUsed to check the results of a statement execution
Used to check the results of a statement execution
Deprecated, for removal: This API element is subject to removal in a future version.
Specifies how optimistic lock checking works for the annotated entity.
Describes how an entity should be optimistically locked.
Enumerates the possible optimistic lock checking strategies.
Commonality between sequence-based and table-based generators
Performs optimization on an optimizable identifier generator.
Factory for
Optimizer instances.Logging related to Optimizer operations in identifier generation
Legacy "upsert" handling, conditionally using INSERT, UPDATE and DELETE
statements as required for optional secondary tables.
The complete provider input for selecting or constructing an optional-table
update operation.
Uses
OptionalTableInsert for the insert operation,
to avoid primary key constraint violations when inserting only primary key columns.A
LimitHandler for Oracle 12c and later.Oracle concatenation function for array and an element.
Oracle concatenation function for arrays.
Oracle array_fill function.
Oracle array_get function.
Oracle array_remove function.
Oracle array_remove_index function.
Oracle array_replace function.
Oracle array_reverse function.
Oracle array_set function.
Oracle array_slice function.
Oracle array_sort function.
Oracle array_to_string function.
Oracle array_trim function.
A SQL dialect for Oracle 19c and above.
Access to Hibernate's stock Oracle JDBC type descriptors.
Oracle json_arrayagg function.
Oracle json_array_append function.
Specialized type mapping for
JSON and the BLOB SQL data type for Oracle.Oracle json_array function.
Oracle json_array_insert function.
Specialized type mapping for
JSON and the BLOB SQL data type for Oracle.Oracle json_insert function.
Oracle json_mergepatch function.
Oracle json_objectagg function.
Oracle json_object function.
Oracle json_remove function.
Oracle json_replace function.
Oracle json_set function.
Oracle json_table function.
Oracle json_value function.
Provides supported access to Oracle-specific schema exporters.
Utility class that extract some initial configuration from the database for
OracleDialect.Deprecated.
A SpatialDialect is no longer required.
Deprecated.
A SpatialDialect is no longer required.
Oracle trunc function which uses emulation when truncating datetimes to seconds
or when truncating offset-aware datetimes.
The Oracle specific JDBC type code.
Oracle unnest function.
Oracle xmltable function.
A rule for sorting a query result set.
Contact to define if a plural attribute source is orderable or not.
Applies a mapped collection ordering to a SQL AST.
Envers specific FunctionContributor
Responsible for performing the translation of the order-by fragment associated
with an order set or map.
A specialization of the map type, with (resultset-based) ordering.
Revision number generator has to produce values in ascending order (gaps may occur).
Describes a sequence that supports ordered sequences.
Models an ordered set-aggregate function expression at the SQL AST level.
A specialization of the set type, with (resultset-based) ordering.
Contract for anything that can be a sort expression
This class provides an empty implementation of
OrderingParserListener,
which can be extended to create a listener which only needs to handle a subset
of the available methods.This class provides an empty implementation of
OrderingParserVisitor,
which can be extended to create a visitor which only needs to handle a subset
of the available methods.This interface defines a complete listener for a parse tree produced by
OrderingParser.This interface defines a complete generic visitor for a parse tree produced
by
OrderingParser.An individual sort specification in an order-by fragment
Represents an
enum type for databases like MySQL and H2.The HQL
ordinal() function returns the ordinal value of an enumOSON-based implementation of
JsonDocumentReaderImplementation of
JsonDocumentWriter for OSON document.JDBC type adapter for OSON-based JSON document reader.
Indicates a Dialect's level of support for applying locks
to select statements with joins.
Common contract for individual outputs which can be either results
or update counts.
Specialization of
DomainType for types that
can be used as a parameter output for a ProcedureCall.Marker interface for valued model parts that have a declaring/owner type.
Identifies a page of query results by page size
and page number.
Pagination requested for a database-free SQL translation.
Immutable JDBC execution instructions produced by a
LimitHandler together
with paginated SQL.Immutable semantic plan for SQL AST pagination rendering.
A combined trailing limit clause whose first operand is the offset and
second operand is the row count, for example
select ... limit 5, 10.A trailing fetch clause whose count is increased by the offset.
A select-clause
first form without native offset syntax.A select-clause
first ... skip ... form, for example
select first 10 skip 5 ....Separate trailing
limit and offset clauses, for example
select ... limit 10 offset 5.No SQL AST pagination syntax.
ANSI offset/fetch syntax rendered at the end of the query part.
A trailing inclusive row range, for example
select ... rows 5 to 14 for
a ten-row range beginning at the database-specific first-row value.A select-clause
skip ... first ... form, for example
select skip 5 first 10 ....A
top clause rendered immediately after select.A select-clause
top ... start at ... form, for example
select top 10 start at 5 ....Emulate pagination by wrapping the query part and filtering a derived row
number.
Read-only semantic facts supplied by Hibernate when selecting how to render
pagination for one query part.
Dialect strategy for selecting the SQL rendering plan for a paginated query
part.
Immutable input supplied by Hibernate to a
LimitHandler for applying
execution-time pagination to completed SQL.Immutable result returned by
LimitHandler.processSql(PaginationRequest), pairing completed SQL
with all JDBC and result-set work required by its pagination.A pair of objects.
Details about a parameter declared in a
FilterDef.Generic parameter (a key/value pair) used to parametrize other annotations.
Describes the context in which a parameter is declared.
Support for parameterizable types.
Indicates a problem with the labelling of query parameters.
Immutable limits on JDBC parameters accepted by a database.
Generates parameter markers for prepared SQL statements.
Information about the parameters
of a query.
Thrown to indicate a misuse of a parameter
Indicates a problem during parameter recognition via
ParameterRecognizerDefines the "callback" process of recognizing native query parameters.
The style/strategy of parameter registration used in a particular procedure call definition.
Indicates Hibernate is unable to determine the type details for a parameter.
Describes how a parameter is used in a mutation statement
Specifies that the annotated field or property of an embeddable
class is a reference to the owning entity.
Occurs when an unexpected condition is encountered while interpreting the
output of the HQL parser.
Identifies a field of an entity that holds the
partition key of a table mapped by the entity
class.
Allows construction of a
Restriction on a compound path.Represents the translation of an individual part of a path in `@OrderBy` translation
Similar in purpose to
DotIdentifierConsumer, but for `@OrderBy` translationIndicates that an element of a path did not resolve to
a mapped program element.
Indicates a problem with a path expression in HQL/JPQL.
Interpretation of a
SqmPath as part of the translation to SQL AST.Indicates a problem resolving a domain-path occurring in an order-by fragment
Any element of the domain model which can be used to create an
element of a path expression in a query.
Indicates that a parameter of type
String of a
finder method is a pattern involving
wildcard characters _ and %.Support for HQL functions that have different representations
in different SQL dialects, where the difference can be handled
via a pattern template.
A
PersistEvent represents a persist operation
applied to a single entity.Shared deferred handle for the persisted size of one collection mutation.
PersistenceUnitDescriptor wrapper around PersistenceConfiguration
Represents the state of "stuff" Hibernate is tracking, including (not exhaustive):
entities
collections
snapshots
proxies
Settings related to persistence-units
Represents a JPA persistence unit lifecycle callback method.
Boot model representation of a Jakarta Persistence persistence-unit lifecycle callback.
Enumerates JPA persistence unit lifecycle callback types.
Abstraction for dealing with
<persistence-unit/> information
specified in the persistence.xml file.Models persistence unit lifecycle callbacks declared by an
@EntityListener class.Aggregator of information from
entity-mappings/persistence-unit-metadata
and entity-mappings/persistence-unit-metadata/persistence-unit-defaults
across all mapping XML files in the persistence-unit.Used by Hibernate to parse
persistence.xml files in SE environments.A dummy collection wrapper for an array.
Hibernate extension to the JPA
Attribute contractThe base contract for interceptors that can be injected into
enhanced entities for the purpose of intercepting attribute access
An unordered, un-keyed collection that can contain the same element
multiple times.
A mapping model object that represents an entity class.
Persistent collections are treated as value objects by Hibernate.
Contract for a persisted entity mapping.
An "identifier bag" implements "bag" semantics more efficiently than a
regular bag by adding a synthetic identifier column to the table.
An
IdentifierGenerator that requires creation of database objects.A persistent wrapper for a
List.A persistent wrapper for a
Map.Thrown when the user passes a persistent instance to a
Session
method that expects a transient instance.A persistent wrapper for a
Set.A persistent wrapper for a
SortedMap.A persistent wrapper for a
SortedSet.Standard composable strategy for persistent tables used as temporary tables.
Given an entity or collection mapping, resolve the appropriate persister class to use.
Contract for creating persister instances (both
EntityPersister and CollectionPersister varieties).Event class for
Session.persist(Object).Defines the contract for handling of create events generated from a session.
Thrown when a pessimistic locking conflict occurs.
The focused kind of pessimistic lock requested by SQL rendering.
Indicates how a dialect supports acquiring pessimistic locks
as part of a
SELECT statement.Type Descriptor for the Postgis Geography type
Type Descriptor for the Postgis Geometry type
Type Descriptor for the Postgis Geography type
Type Descriptor for the Postgis Geometry type
The immutable physical realization selected for a semantic collection mutation.
Insert every retained current row for a logical create.
The semantic mutation owns no collection-table mutation.
Remove all rows belonging to the loaded collection endpoint.
Physically replace all rows while retaining update lifecycle semantics.
Apply a semantics-specific immutable row-change set.
Enumerates valid combinations of
ConnectionAcquisitionMode and
ConnectionReleaseMode.Provides access to manage "transactionality" via the JDBC
Connection.A set of rules for determining the physical names of objects in a relational
database schema from the logical names specified by the object/relational
mappings.
Converts
camelCase or MixedCase logical names to snake_case.Standard implementation of the
PhysicalNamingStrategy contract.Options for controlling operation planning and scheduling.
Contract for an attribute that represents multiple values.
Describes the nature of plural attribute elements in terms of relational implications.
Describes the source for the elements of persistent collections (plural
attributes) where the elements are basic types
Describes the source for the elements of persistent collections (plural
attributes) where the elements are composites/embeddables.
Describes the source for the elements of persistent collections (plural
attributes) where the elements are defined by Hibernate's any mapping
Describes the source for the elements of persistent collections (plural
attributes) where the elements are many-to-many association
Describes the source for the elements of persistent collections (plural
attributes) where the elements are a one-to-many association
Describes the nature of plural attribute indexes in terms of relational implications.
Highly abstract concept of the index of an "indexed persistent collection".
Describes the source mapping of plural-attribute (collection) foreign-key information.
Additional source information for
<map-key-many-to-many/> and
<index-many-to-many/>.Describes source information about the key of a persistent map.
Mapping of a plural (collection-valued) attribute
Describes the nature of the collection itself as declared by the metadata.
Represents the collection as a DomainPath
Defines the index of a persistent list/array
Extension of the JPA-defined
PluralAttribute interface.Optimizer which uses a pool of values, backed by a logical sequence.
Variation of
PooledOptimizer which interprets the incoming database
value as the lo value, rather than the hi value, as well as using thread local
to cache the generation state.Optimizer which uses a pool of values, backed by a logical sequence.
An action to be performed after a PrimaryOperation.
Shared contract for listeners notified after an entity insert, update,
delete, or upsert action.
An event that occurs after a collection is recreated
Called after recreating a collection
An event that occurs after a collection is removed
Called after removing a collection
An event that occurs after a collection is updated
Called after updating a collection
Called after an entity delete is committed to the datastore.
Called after an entity insert is committed to the datastore.
Called after an entity update is committed to the datastore.
Occurs after deleting an item from the datastore
Called after deleting an item from the datastore
Post-execution callback for entity delete actions.
Support for callbacks after the execution of a FlushOperation.
Deprecated.
Deprecated.
A SpatialDialect is no longer required.
Deprecated.
A SpatialDialect is no longer required.
Deprecated.
A SpatialDialect is no longer required.
An SQL dialect for Postgres Plus
PostgreSQL variant of the function to properly return
null when the array argument is null.PostgreSQL variant of the function to properly return
null when one of the arguments is null.Special array constructor function that also applies a cast to the array literal,
based on the inferred result type.
Custom casting for the array fill function.
PostgreSQL variant of the function.
PostgreSQL variant of the function.
PostgreSQL array_reverse emulation for versions before 18.
PostgreSQL array_sort emulation for versions before 18.
PostgreSQL array_trim emulation, since the function was only introduced in version 14.
A SQL dialect for PostgreSQL 14 and above.
Supported SQL AST translator base for PostgreSQL-derived databases.
Access to Hibernate's stock PostgreSQL JDBC type descriptors.
PostgreSQL json_arrayagg function.
PostgreSQL json_array_append function.
PostgreSQL json_array function.
PostgreSQL json_array_insert function.
PostgreSQL json_exists function.
PostgreSQL json_insert function.
PostgreSQL json_mergepatch function.
PostgreSQL json_objectagg function.
PostgreSQL json_object function.
PostgreSQL json_query function.
PostgreSQL json_remove function.
PostgreSQL json_replace function.
PostgreSQL json_set function.
PostgreSQL json_table function.
PostgreSQL json_value function.
PostgreSQL doesn't support min/max for uuid yet,
but since that type is comparable we want to support this operation.
A SQL AST translator for PostgreSQL.
Custom
TruncFunction for PostgreSQL which uses the dialect-specific function for numeric truncationPostgreSQL only supports the two-argument
trunc and round functions
with the following signatures:
trunc(numeric, integer)
round(numeric, integer)
PostgreSQL unnest function.
PostgreSQL xmlquery function.
Occurs after inserting an item in the datastore
Called after inserting an item in the datastore
The counterpart to
IdentifierGenerator for values generated by the database.Occurs after an entity instance is fully loaded.
Occurs after an entity instance is fully loaded.
Occurs after the datastore is updated
Called after updating the datastore
Occurs after the datastore is updated via a SQL
mergeCalled after updating the datastore
An action to be performed before a PrimaryOperation.
An event that occurs before a collection is recreated
Called before recreating a collection
An event that occurs before a collection is removed
Called before removing a collection
An event that occurs before a collection is updated
Called before updating a collection
Represents a
pre-delete event, which occurs just prior to
performing the deletion of an entity from the database.Called before deleting an item from the datastore
Pre-execution callback for entity delete actions.
Models a predicate in the SQL AST
Something that can contain predicates
Immutable description of a Dialect's native predicate syntax and predicate
placement support.
Build an immutable predicate-support profile.
An independently configurable predicate capability.
Callback invoked immediately before executing a planned operation.
An event that occurs just before arguments are bound to JDBC
parameters during execution of HQL.
A listener for events of type
PreFlushEvent.Represents a
pre-insert event, which occurs just prior to
performing the insert of an entity into the database.Called before inserting an item in the datastore
Called before injecting property values into a newly loaded entity instance.
Called before injecting property values into a newly
loaded entity instance.
MutationOperation that is capable of being handled as a
JDBC
PreparedStatement
Person ( PERSON, PERSON_SUPP )
- PERSON_SUPP is optional secondary tableDescriptor for details about a
PreparedStatementGrouping of
PreparedStatement references.Represents a
pre-update event, which occurs just prior to
performing the update of an entity in the database.Called before updating the datastore
Represents a pre-upsert event, which occurs just prior to
performing the upsert of an entity in the database.
Called before updating the datastore
A mapping model object representing a primary key constraint.
Provides access to information about existing primary key for a table
A primary operation to be executed using JDBC.
Read-only semantic context for rendering a prefix before a primary table
reference.
The semantic kind of primary table reference.
For a full explanation of the purpose of this interface see
ManagedTypeHelper.A primitive array has a primary key consisting of the key columns + index column.
Descriptor for
byte[] handling.Descriptor for
char[] handling.Additional descriptor contract for primitive and primitive-wrapper Java
types.
Defines support for executing database stored procedures and functions using the
JDBC stored procedure SQL escape syntax.
Represents the outputs of executing a JDBC statement.
Describes an input value binding for any IN/INOUT parameters.
Optional
Type contract for implementations that are aware of
how to extract values from stored procedure OUT/INOUT parameters.SPI extension for ProcedureParameter
Optional
Type contract for implementations enabled
to set store procedure OUT/INOUT parameters values by name.Allows a
SelectionSpecification to be augmented with the specification
of a projection list.Allows typesafe access to elements of the
Object[]
arrays returned by the query.A mapping model object representing a property or field of an entity
or embeddable class.
Indicates a problem while building a
PropertyAccess.Indicates a problem reading or writing value from/to a persistent property.
A problem occurred accessing a property of an instance of a
persistent class by reflection, or via enhanced entities.
Service providing access to
AccessorFactory.Creates
PropertyAccess instances for persistent attributes using field,
JavaBeans-style property, or another access mechanism.Contract for resolving the
PropertyAccessStrategy to use.Describes an attribute with a property access.
Details about an attribute as we process the boot model.
Indicates that an expected getter or setter method could not be
found on a class.
Allows to specify the target of a foreign-key using a "target attribute" as opposed to
join column(s).
Describes how an entity's mapped properties are selected for one cascade route.
Thrown when an
IllegalArgumentException occurs calling a property setter method.Monomorphic dispatcher for property value access.
Thrown when the (illegal) value of a property can not be persisted.
Helper for handling checks to see whether Hibernate is the requested
PersistenceProvider.A proxy configuration allows the definition of an interceptor object that decides on the behavior of a proxy.
An interceptor object that is responsible for invoking a proxy's method.
A static interceptor that guards against method calls before the interceptor is set.
Contract for runtime, proxy-based lazy initialization proxies.
An interface for factories of
proxy factory instances.Represents a fully qualified column name for uniqueness checks.
Models the qualified name of a database object.
Parses a qualified name.
Contract for rendering qualified object names for use in queries, etc.
Within the context of an active session,
an instance of this type represents an executable query, either:
a query written in HQL or native SQL,
a named query written in HQL or native SQL, or
a criteria query.
An error that occurs binding an argument to a query parameter.
Configures the layout for the entity or collection data in a query cache.
Aggregation and encapsulation of the components Hibernate uses
to execute queries (HQL, Criteria and native)
User configuration options related to the
QueryEngine.A problem occurred translating a Hibernate query to SQL due to illegal query
syntax, an operation which is not well-typed, an unresolvable reference to
an entity or attribute, an unknown named query, or any similar problem.
Identifies the final position of a leading database hint relative to a user comment.
Provides reusable SQL query-hint rendering operations.
Cache for various parts of translating or interpreting queries.
A key that identifies a particular query with bound parameter values.
todo (6.0) : integrate work from original 6.0 branch
Represents a literal in the SQL AST.
Dialect strategy for selecting immutable rendering plans for query-language
update and delete statements.
Declares various selection query and
mutation statement options.
Specifies a comment for the SQL query.
Specifies the JDBC fetch size to use for the query.
Specifies that the query result set should be cached in the given
region.
Encapsulates options for the execution of a query.
Represents a parameter defined in the source (HQL/JPQL or criteria) query.
The value and type binding information for a particular query parameter.
Manages all the parameter bindings for a particular query.
A resolver for
BindableType based on a parameter value being bound, when no explicit type information is
supplied.Indicates a problem with the runtime arguments bound to query parameters.
A special table group for a sub-queries.
A table reference for a query part.
Common contract for select and mutation query plans
Responsible for managing query result list caching in a specific
query cache region.
Defines the contract for a cache region that stores query results.
Commonality for all query specifications which allow iterative,
programmatic building of a query.
Statistics relating to a particular query written in HQL or SQL.
A
JDBCException indicating that a database query timed
out on the database.Indicates a mismatch between the expected and actual result types of a query.
Immutable view of one command in an uninitialized collection's operation queue.
Indicates
ActionQueue implementations.Specifies an allowed set or range of values for a value being restricted.
Guarantees for existing rows successfully returned by a read.
A
FindOption which requests that
entities be loaded in ReadOnlyMode.READ_ONLY mode or in regular
ReadOnlyMode.READ_WRITE mode.Deprecated.
use
FloatJdbcTypePerform JDBC REF_CURSOR registration and extraction as one coherent
strategy.
Creation-only context for selecting and constructing a REF_CURSOR access
strategy.
Create the single REF_CURSOR JDBC access strategy used by a service
registry.
Supported factories for common REF_CURSOR JDBC access strategies.
Specialized CacheEntry for storing direct references to entity instances.
A
RefreshEvent represents a refresh operation
applied to a single entity.Event class for
Session.refresh(Object).Defines the contract for handling of refresh events generated from a session.
PostgreSQL and CockroachDB have a special predicate.
Oracle and SQL Server have a special predicate function.
MariaDB and legacy MySQL have a special predicate.
Contract for a named cache "region".
Contract for building second-level cache regions, including
regions dedicated to storing:
entity and collection
instances,
query result sets,
and
timestamps used to
determine when a cached query result set is stale.
A registered conversion.
Unifying interface for
ColumnSource and DerivedValueSource.Contract for a container of
RelationalValueSource references.Defines the actions on how to handle
EntityNotFoundException cases when a relation
between two entities (audited or not) cannot be found in the data store.Indicates that the annotated element is planned for removal as part of a
deprecation process.
Removes the collection:
For collections with a collection-table, this will execute a DELETE based
on the collection-key
For one-to-many collections, this executes an UPDATE to unset the collection-key
on the association table
RemoveCoordinator for audited collections.
RemoveCoordinator implementation for temporal collection tables
in the TemporalTableStrategy.HISTORY_TABLE
temporal table mapping strategy.Handles complete removal of a collection by its key
OneToMany remove coordinator if the element is a
UnionSubclassEntityPersister.Enumeration of the built-in ways that Hibernate can represent the
application's domain model.
Used to put natural id values into collections.
Indicates an attempt was made to use a closed resource, such as
a closed
Session or SessionFactory.Abstraction for locating class-path resources
A registry for tracking JDBC resources.
Abstraction for locating class-path resources
Things that can have
SQLRestriction,
and/or Filter applied to them.Specialized TableMutation implementation for mutations which
define a where-clause
Specialized builder for building mutations which have a restrictions (aka,
where clause).A rule for restricting query results.
A restriction (predicate) to be applied to a query
Qualifies mapped columns in SQL restrictions using the tables that actually declare them.
Builds one
DomainResult for a native-query result-set mapping.Builds a scalar result for a result-set mapping.
Builds an entity-valued result for a result-set mapping.
Builds a dynamic-instantiation result for a result-set mapping.
Describes the mapping for a result as part of a
NamedResultSetMappingDescriptorAny node (result or fetch) in the result graph
Models a SQL ResultSet mapping generally defined via annotations.
Consumes
JdbcValues and returns the consumed values in whatever form this
consumer returns, generally a List or a ScrollableResultsJdbcValuesMappingProducer implementation based on a graph of ResultBuilder
and FetchBuilder reference.
Models a
ResultSet as an Output.Specialization of
SimpleDomainType for types that can
be used as function returns.The semantic source of a mutation requesting returned columns.
Immutable plan selected by
ReturningRenderingSupport for returning
generated mutation values.Wrap the mutation in an
old, new, or final data-change table and
select the requested columns from the wrapper.Render a standard trailing
returning clause after the mutation.Render only the mutation because no columns were requested.
Read-only semantic facts supplied by Hibernate when selecting how a mutation
returns generated column values.
Dialect strategy for selecting an immutable plan for returning generated
column values from a mutation.
A discrete piece of work making use of a JDBC connection
and returning a result.
Marks an entity to be created whenever a new revision is generated.
An implementation of this class, having a no-arg constructor, should be passed as an argument to the
RevisionEntity annotation.Marks a property which will hold the number of the revision in a revision entity, see
RevisionListener.Marks a property which will hold the timestamp of the revision in a revision entity, see
RevisionListener.Type of the revision.
A mapping model object that represents the root class in an entity class
inheritance hierarchy.
Extends the JPA-defined
EntityGraph with additional operations.Integration version of the
RootGraph contract.A persistent entity mapping that represents the root entity of an entity hierarchy.
SequencePart implementation used to translate the root of a path
Contract for things that can produce the
TableGroup that is a root of a
from-clauseSpecifies that a
rowid-like column or pseudo-column should be
used as the row locator in CRUD operations for an entity,
instead of the primary key of the table.Descriptor for
ROWID handling.Defines row-locator expression, JDBC type, and optional physical-column
declaration behavior.
Supplies immutable stock row-id support profiles.
Defines the database capabilities, schema DDL, and connection operation
used for database-native row-level security.
Declares one ordered row-level-security schema object or command group.
Defines schema-creation ordering for a row-level-security declaration.
Provides the rendered table and tenant-column facts needed to produce
row-level-security schema DDL.
Provides stock row-level-security strategies.
The strategy for rendering which row to lock with the
FOR UPDATE OF clause.Composition of the
MutationOperation references for a collection mapping.State pertaining to the processing of a single "row" of a JdbcValuesSource
Coordinates the process of reading a single result values row
Defines transformation of a raw row in the domain query result row.
Immutable description of a Dialect's native row-value syntax.
Build an immutable row-value-support profile.
An independently configurable row-value syntax feature.
Entry point providing access to the runtime metamodels:
the domain model, our implementation of the
JPA-defined model
of the Java types, and
our relational mapping model of how these
types are made persistent.
SPI extending
RuntimeMetamodels and mixing in MappingContext.Discovers ordinary types, package descriptors, module descriptors, and mapping resources.
Access to information useful while performing discovery.
Provider for
Scanner instances.Categorized discoveries from archive scanning, excluding explicit declarations.
Defines comment placement and rendering for database schema objects.
Stock database-object comment profiles for schema export.
Service delegate for handling schema creation.
Service delegate for handling schema dropping.
Defines table-drop composition and ordered pre-drop commands.
Defines a filter for Hibernate's schema tooling.
Used to specify the
SchemaFilters to be used by create, drop, migrate and validate
operations on the database schema.Immutable create and drop commands for the test kit's fixed mapping model.
Indicates a problem in performing schema management.
Contract for schema management tool integration.
Responsible for coordinating
SchemaManagementTool execution
whether from "hibernate.hbm2ddl.auto", JPA-standard
"jakarta.persistence.schema-generation.database.action", or
SchemaManager.For JPA-style schema-gen, database and script target handing are configured
individually - this tuple allows interpreting the action for both targets
simultaneously
Allows programmatic schema export,
schema validation,
data cleanup,
data population, and
schema cleanup as a convenience for
writing tests.
Service delegate for handling schema migration.
Resolves the current schema name for a JDBC connection.
Service delegate for handling schema population.
Service delegate for handling schema truncation.
Service delegate for handling schema validations
Contract for hiding the differences between a passed Reader, File or URL in terms of how we read input
scripts.
Contract for hiding the differences between a passed
Writer,
File or URL in terms of how we write output scripts.A result iterator that allows moving around within the results by
arbitrary increments.
Specifies the type of JDBC scrollable result set
to use underneath a
ScrollableResults.Descriptor for the Oracle Spatial SDO_GEOMETRY type
ValueExtractor for SDO_GEOMETRY
Common marker interface for PreAction and PostAction.
Specifies how the row of a
SecondaryTable should be managed.A grouping of
SecondaryRows.Hibernate builds its build-time model
incrementally, often delaying operations until other pieces of information
are available.
Consumer used to visit selectable (column/formula) mappings
Mapping of a selectable (column/formula)
A container for multiple selectable (column, formula) mappings.
The path for a selectable.
The SELECT CLAUSE in the SQL AST.
A generator that
selects the just-inserted row to determine the
column value assigned by the database.A contract for a selection, can be a column or a formula.
Within the context of an active session,
an instance of this type represents an executable selection query, that is,
a
select.SPI form of SelectionQuery
Specialization of
QuerySpecification for programmatic customization of
selection queries with ordering and restriction criteria.A function capable of modifying or augmenting a criteria query.
How a SQL AST translator refers to a select item from a
group by clause.General contract for performing execution of a query returning results.
Contract for an entity to report that it tracks the dirtiness of its own state,
as opposed to needing Hibernate to perform state-diff dirty calculations.
Extension to MutationOperation for cases where the operation wants to
handle execution itself.
Representation of an aggregate function call in the SQL AST for impls that know how to
render themselves.
A self rendering object that is part of a WITH clause, like a function.
Representation of a function call in the SQL AST for impls that know how to
render themselves.
Representation of an aggregate function call in the SQL AST for impls that know how to
render themselves.
Represents a self rendering expression i.e.
Represents a self rendering expression that renders a SQL fragment.
Representation of a window function call in the SQL AST for impls that know how to
render themselves.
The semantic difference information retained by a collection mutation
interpretation independently of its physical mutation strategy.
Prior collection contents are removed without claiming that their rows are enumerable.
An enumerable semantic difference relative to an identified baseline.
No separate semantic difference was materialized.
Represents an error in the semantics (meaning) of a HQL/JPQL query.
Contract for things that can be part of a path structure, including:
Support for walking a Semantic Query Model (SQM) tree
Models a database
SEQUENCE.Logging related to
TableGenerator operationsGlobal registration of a sequence generator
Extension of standard
SequenceIdRevisionEntity that allows tracking entity names changed in each revision.Extension of standard
SequenceIdRevisionMapping that allows tracking entity names changed in each revision.Read-only information extracted for an existing database sequence.
Extract information about existing database sequences when JDBC metadata
does not expose it.
Create immutable sequence-information extractors from lookup SQL and row
readers.
Configure the row mapping used by a standard single-query extractor.
Read one value from the current row of a sequence-discovery result set.
Describes the strategy for handling the mismatch between a database sequence configuration and
the one defined by the entity mapping.
Represents an individual identifier in a dot-identifier sequence
Describes a sequence.
Generates identifier values based on a sequence-style database structure.
Defines database sequence value expressions and lifecycle DDL for a
Dialect.Provides stable stock sequence-support strategies without exposing
Hibernate's vendor-specific implementations.
Manages aspects of proxying
Blobs to add serializability.Manages aspects of proxying
Clobs to add serializability.Descriptor for general
Serializable handling.Manages aspects of proxying
NClobs to add serializability.A type that maps between a
VARBINARY and Serializable classes.Thrown when a property cannot be serialized/deserialized
Marker interface for services.
Models a binding for a particular service.
Contract for contributing services.
Indicates a problem with a service.
Base contract for an initiator of a service.
A registry of services.
Allows services to be injected with the
ServiceRegistry during configuration phase.Additional integration contracts for a service registry.
The main runtime interface between a Java application and Hibernate.
Contains the state necessary to properly implement SessionAssociableInterceptor;
this allows reuse of this particular object across multiple interceptor instances
and keeps them from getting too allocation-intensive.
Allows creation of a new
Session with specific options
overriding the defaults from the SessionFactory.Defines the internal contract between the
SessionBuilder and
other parts of Hibernate.Declares various for session and
stateless session creation options.
Specify the instant for reading temporal
entity data.
Specifies that the named filter
should be enabled with the given arguments to its parameters.
Enables batch fetching and specifies how many entities should be fetched in
each request to the database.
Enables JDBC statement batching and specifies a batch size.
Enables or disables the use of subselect fetching.
Specifies the tenant id which should
be used when accessing a multi-tenant database.
A wrapper class that delegates all method invocations to a delegate instance of
SessionImplementor.Implemented by custom listeners that respond to low-level events
involving interactions between the
Session and the database
or second-level cache.Thrown when the user calls a method of a
Session that is
in an inappropriate state for the given call (for example, the
session is closed or disconnected).A
SessionFactory represents an "instance" of Hibernate: it maintains
the runtime metamodel representing persistent entities, their attributes,
their associations, and their mappings to relational database tables, along
with configuration that
affects the runtime behavior of Hibernate, and instances of services that
Hibernate needs to perform its duties.The contract for building a
SessionFactory given a specified set of options.An extension point for integrators that wish to hook into the process of how a SessionFactory
is built.
Additional SPI contract for
SessionFactoryBuilder, mainly intended for
implementors of SessionFactoryBuilderFactory.Allows bootstrapping Hibernate ORM using a custom
SessionFactoryBuilderImplementor.Defines the internal contract between the
SessionFactory and the internal
implementation of Hibernate.Allows reaction to basic
SessionFactory lifecycle events.Aggregator of special options used to build the
SessionFactory.Contract for an initiator of services that target the specialized service registry
SessionFactoryServiceRegistry.Specialized
ServiceRegistry implementation that
holds services which need access to the SessionFactory
during initialization.Contract for builder of
SessionFactoryServiceRegistry instances.Defines the "internal contract" between
Session and other parts of Hibernate
including implementors of Type, EntityPersister,
and CollectionPersister.This helper class allows decorating a Session instance, while the
instance itself is lazily provided via a
Supplier.Information about the first-level (session) cache for a particular
instance of
Session.A mapping model object representing a collection of type
List.A plural attribute that represents a
set.Immutable description of a Dialect's set-operation grammar.
Build an immutable set-operation-support profile.
An independently configurable structural set-operation capability.
The SQL set operators.
Hibernate extension to the JPA
SetAttribute descriptorSupport for
SqmSetReturningFunctionDescriptors that ultimately want
to perform SQL rendering themselves.Immutable semantic plan for rendering a named set-returning function.
Emulate the requested ordinality column using a derived table.
Wrapper applied to the function invocation inside the derived table.
SQL expression used to synthesize ordinality.
Render the native function invocation, optionally followed by native
with ordinality syntax.Native ordinality syntax to append to the invocation.
Wrap the invocation with the database's
table(...) syntax.Report that the requested invocation cannot be rendered safely.
Read-only semantic facts supplied by Hibernate when selecting how to render
a named set-returning function.
Dialect strategy for selecting an immutable rendering plan for a named
set-returning function.
The semantic type information needed while rendering a set-returning
function.
Pluggable strategy for resolving a function return type for a specific call.
Pluggable strategy for resolving a function return type for a specific call.
Deprecated, for removal: This API element is subject to removal in a future version.
Field-based implementation of Setter
Allows creation of a child
Session which shares some options with
another pre-existing parent session.Declares operations that are common between
Session and StatelessSession.Defines the internal contract shared between
Session and
StatelessSession as used by other parts of Hibernate,
including implementors of Type, EntityPersister,
and CollectionPersister.Allows creation of a child
StatelessSession which shares some options
with another pre-existing parent session.Descriptor for
Short handling.Descriptor for
short[] handling.A simple implementation of
AbstractAuxiliaryDatabaseObject in which the
CREATE and DROP strings are provided up front.Simple version of DatabaseVersion
Describes any non-collection type.
Simple implementation of FromClauseAccess
Represents a simple identifier mapping.
Deprecated.
Use Session.find(Class, Object) or Session.getReference(Class, Object)
with KeyType.NATURAL instead.
Allows a
SelectionSpecification to be augmented with the specification of
a single projected attribute or path.A SQL
SELECT statement with no table joins.A simple implementation of StrategyRegistration.
Generates increasing identifiers (in a single VM only).
A mapping model object that represents any value that maps to columns.
Loader for loading a single entity by primary or unique key
Loader for loading an entity by a single identifier value.
An
ImplicitDatabaseObjectNamingStrategy using a single structure for all
implicit names:
"hibernate_sequence" for sequences
"hibernate_sequences" for tables
Used beneath
SelectionQuery.getResultCount().Immutable description of the SQL used by a Dialect for a reusable
single-row table and for an otherwise table-less select.
Build an immutable single-row-table-support profile.
Batch variant for a single JDBC statement shape.
The default implementation of the
EntityPersister interface.A mapping model object that represents a subclass in a
single table
inheritance hierarchy.
Loader subtype for loading an entity by a single unique-key value.
Contract for an attribute that represents a singular value.
Mapping for a singular (non-collection) attribute.
Describes possible natures of a singular attribute.
Source-agnostic description of information needed to bind a singular attribute.
Describes an
<any/> mappingRepresents the binding source for a singular attribute that is "embedded"
or "composite".
Further contract for sources of singular associations (
one-to-one and many-to-one).Extension of the JPA-defined
SingularAttribute interface.Models size restrictions/requirements on a column's data type.
Strategy supplied by a Dialect for resolving the column size of a mapped
Java and JDBC type.
Descriptor for
SMALLINT handling.Marker interface for objects that carry both an element and its snapshot position/key.
A
JDBCException indicating that a request failed due to snapshot isolation.Deprecated, for removal: This API element is subject to removal in a future version.
This is no longer needed after the
introduction of
Stateful.Model part which can be soft-deleted
Describes a soft-delete indicator mapping.
Used as the default for SoftDelete.converter(), indicating that
dialect and
settings
resolution should be used.
Metadata about the indicator column for entities and collections enabled
for soft delete
Enumeration of defines styles of soft-delete
Memento object for use by synchronous concurrency strategies
Contact to define if the source of plural attribute is sortable or not.
Enumerates the directions in which query results may be sorted.
Describes a source for schema create, drop and migrate actions.
Specifies the source of a generated value, either the virtual machine,
or the database.
Enumerates the various types of sources understood by the schema management
tooling.
Uses typed array literals for
null arrays like ARRAY<type>[null], to resolve ambiguity.A SQL dialect for Cloud Spanner.
uses unix_seconds function for EPOCH unit
The format function for Spanner.
Access to Hibernate's stock Spanner JDBC type descriptors.
Spanner PostgreSQL variant of the function to properly return
null when the array argument is null
without generating casts which Spanner doesn't support.Emulation of PostgreSQL's array_remove function for Spanner PostgreSQL dialect.
Spanner PostgreSQL specific emulation of array_remove_index.
Emulation of PostgreSQL's array_replace function for Spanner PostgreSQL dialect.
Spanner PostgreSQL emulation for array_trim.
Spanner PostgreSQL json_array function.
Spanner PostgreSQL json_object function.
Spanner-specific TruncFunction that extends PostgreSQLTruncFunction to handle
both numeric and datetime truncation, reusing PostgreSQL logic where
applicable.
The trunc function for Spanner.
A marker interface for spatial (geometric/geographic) types.
An extended
HibernateCriteriaBuilder with spatial functionalityDeprecated.
SpatialDialects are no longer needed since Hibernate 6.0
Deprecated.
To be replaced by
CommonSpatialFunctionManages initialization of the hibernate-spatial integration
Deprecated.
Will be removed in 6
Central service for spatial integration
The hints explicitly defined by the Jakarta Persistence specification
which are available for both queries and loading.
A one-to-one association that maps to specific formula(s)
instead of the primary key column of the owning entity.
Identifies a contract intended for participation by an external service
provider and specifies how provider code is expected to participate.
Describes how external provider code participates in an SPI contract.
Identifies a method of an abstract class or interface as defining
the signature of a method which is used to execute the given
SQL query, with an implementation generated
automatically by the Hibernate Metamodel Generator.
A generator for new incremental SQL aliases based on a stem
A SqlAliasBase that always returns the same constant.
Generator for SqlAliasBase instances based on a stem.
Standard SqlAliasBase impl
Helper used in creating unique SQL table aliases for a SQL AST
Appends complete SQL fragments to an in-flight SQL buffer.
MultiKeyLoader implementation based on a SQL ARRAY valued parameter
The "context" in which creation of SQL AST occurs.
Access to stuff used while creating a SQL AST
The rendering mode to use for
SqlAstNode.Generalized access to state information relative to the "current process" of
creating a SQL AST.
SqlAstProcessingState specialization for query parts
SqlAstProcessingState specialization for query parts
The complete, typed input supplied by Hibernate to create one SQL AST
translator.
Request to translate a mapping-model table mutation into its matching JDBC
mutation operation.
Request to translate a query-language update or delete into a
JdbcOperationQueryMutation.Request to translate a query select into a
JdbcSelect.Translates one [#getSqlAst SQL AST] and produces a
JdbcOperation.Factory supplied by a Dialect for creating single-use SQL AST translators.
Supported provider base for translators which implement a full
insert-or-update-or-delete
MERGE command.Deprecated, for removal: This API element is subject to removal in a future version.
Visitor callbacks for traversing the SQL AST.
Escapes text embedded in SQL comments.
Specifies a custom SQL DML statement to be used in place of the default SQL
generated by Hibernate when an entity or collection row is deleted from the
database.
Specifies a custom SQL DML statement to be used in place of the default SQL generated by
Hibernate when an entire collection is deleted from the database.
A grouping of
SQLDeletes.Converts database-specific SQL exceptions as one step in Hibernate's
exception-conversion chain.
An object that interprets JDBC
SQLExceptions and converts
them to subtypes of Hibernate JDBCExceptions.Helper for handling
SQLExceptions in various manners.Standard SQLWarning handler for logging warnings
Contract for handling warnings.
Basic support for
SqlExceptionHelper.WarningHandler implementations which handle warningsUnifying contract for things that are capable of being an expression in
the SQL AST.
Resolution of a SqlSelection reference for a given SqlSelectable.
Defines an interpolated alias occurring in a SQL
filter condition.
Predicate based on a SQL fragment
A function to pass through a SQL fragment.
Inputs for translating one HQL statement through the test kit's fixed
internal mapping model.
Immutable result of translating one HQL statement.
Specialization of
JDBCException indicating that the SQL sent to the
database server was invalid, either due to a syntax error, unrecognized name,
or similar problem.MultiKeyLoader implementation based on SQL IN predicate
Specifies a custom SQL DML statement to be used in place of the default SQL
generated by Hibernate when an entity or collection row is inserted in the
database.
A grouping of
SQLInserts.Specifies a restriction written in native SQL to add to the generated SQL
when querying the join table
of a collection.
Order a collection using an expression or list of expression written
in native SQL.
Specifies a restriction written in native SQL to add to the generated
SQL for an entity, collection, or to-one association.
Registration of a SqlResultSetMapping while processing managed resources as part of
building the domain metamodel
Contract for extracting statements from source/import/init scripts.
Indicates a problem
This class provides an empty implementation of
SqlScriptParserListener,
which can be extended to create a listener which only needs to handle a subset
of the available methods.This class provides an empty implementation of
SqlScriptParserVisitor,
which can be extended to create a visitor which only needs to handle a subset
of the available methods.This interface defines a complete listener for a parse tree produced by
SqlScriptParser.This interface defines a complete generic visitor for a parse tree produced
by
SqlScriptParser.Specifies a custom SQL query to be used in place of the default SQL
generated by Hibernate when an entity or collection is loaded from the
database by id.
Represents a selection at the SQL/JDBC level.
Represents a selection that is "re-used" in certain parts of the query
other than the select-clause (mainly important for order-by, group-by and
having).
A
LimitHandler compatible with SQL Server 2012 which
introduced support for the ANSI SQL standard syntax
OFFSET m ROWS FETCH NEXT n ROWS ONLY, though this syntax
is considered part of the ORDER BY clause, and with the
wrinkle that both ORDER BY and the OFFSET clause
are required.Custom
TruncFunction for SQL Server versions before 16,
which uses the custom SqlServerConvertTruncFunction.DateTruncConvertEmulationA dialect for Microsoft SQL Server 2014 and above.
SQL Server doesn't have a function like
every() or any().SQL Server behaves strangely when the first argument to format is of the type time, so we cast to datetime.
SQL Server generate_series function.
Type descriptor for the SQL Server 2008 Geography type.
Type descriptor for the SQL Server 2008 Geometry type.
Access to Hibernate's stock SQL Server JDBC type descriptors.
SQL Server json_arrayagg function.
SQL Server json_array_append function.
SQL Server json_array function.
SQL Server json_array_insert function.
SQL Server json_exists function.
SQL Server json_insert function.
SQL Server json_objectagg function.
SQL Server json_object function.
SQL Server json_query function.
SQL Server json_remove function.
SQL Server json_replace function.
SQL Server json_set function.
SQL Server json_table function.
SQL Server json_value function.
Reusable pagination-plan selection for SQL Server syntax families.
Deprecated.
A SpatialDialect is no longer required.
SQL Server unnest function.
SQL Server xmlagg function.
SQL Server xmlconcat function.
SQL Server xmlelement function.
SQL Server xmlexists function.
SQL Server xmlforest function.
SQL Server xmlpi function.
SQL Server xmlquery function.
SQL Server xmltable function.
Centralize logging for SQL statements, with some configuration:
Enum interpretation of the valid values from
DatabaseMetaData.getSQLStateType()A context provided to methods responsible for generating SQL strings on startup.
Introduced as an analog of
QueryEngine
and/or NodeBuilder for the SQL
translation and rendering phases.Base exception type for problems building a SQL tree.
An expression that has SQL type information.
A
JdbcType with a fixed SQL type name.Models the type of a thing that can be used as an expression in a SQL query
Defines a list of constant type codes used to identify generic SQL types.
Specifies a custom SQL DML statement to be used in place of the default SQL
generated by Hibernate when an entity or collection row is updated in the
database.
A grouping of
SQLUpdates.A SQM aggregate function.
Models any aliased expression.
Models a reference to a
SqmAliasedNode
used in the order-by or group-by clause by either position or alias,
though the reference is normalized here to a positional refModels a join based on a mapped attribute reference.
An SQM node which may be used to disambiguate the type of an argument to a query parameter.
Represents an expression whose type is boolean, and can therefore be used as a predicate.
Base contract for any SQM AST node caching.
Represents the
SIZE() function.Specialization of
SqmFrom for sub-query correlationsThe context in which all SQM creations occur.
Options for semantic analysis
State related to SQM creation, like
SqmCreationState, but specific
to its "current processing" - which generally means specific to each statement
and sub-queryModels the state pertaining to the creation of a single SQM.
Stuff and things
In some cases it is useful to be able to handle UPDATE or DELETE SQM trees
using a single contract.
Common extension of SqmStatement for DML (delete, update and insert-select)
statements.
Represents a dynamic instantiation (
select new XYZ(...) ...) as part of the SQM.Represents an individual argument to a dynamic instantiation.
Represents the thing-to-be-instantiated in a dynamic instantiation expression.
Specialized SQM literal defined by an enum reference.
Anything in the application domain model that can be used in an
SQM query as an expression.
Accessor for
SqmExpressible.The base contract for any kind of expression node in the SQM tree.
Reference to the key-side (as opposed to the target-side) of the
foreign-key of a to-one association.
Effectively a query-literal but we want to handle it specially in the SQM to SQL AST conversion
Models a SqmPathSource's inclusion in the
FROM clause.Contract representing a from clause.
Unified contract for things that can contain a SqmFromClause.
A SQM function
Produces SQM nodes for invocations of a named HQL function.
Boot-scoped registry of
SqmFunctionDescriptor instances and alternate
registration keys.Used to model numeric literals found in HQL queries.
The general contract for INSERT statements.
Specialization for attributes that that can be used in creating SQM joins
todo (6.0) : should we define this for entities as well to handle cross joins and "entity joins"?
- the result type would need to change to just SqmJoin...
Represents a canonical join type.
Models either a
Tuple or Object[] selection as defined by the
JPA Criteria API.Acts as the per-use wrapper for a
JpaCriteriaParameter
(CriteriaBuilder.parameter(Class)).Special expression for the json_exists function that also captures special syntax elements like error behavior and passing variables.
Describes how a
null should be treated in a JSON document.Specifies if a
json_objectagg may aggregate duplicate keys.Special expression for the json_query function that also captures special syntax elements like error and empty behavior.
Special expression for the json_value function that also captures special syntax elements like error and empty behavior.
Represents a literal value in the sqm, e.g.
1
'some string'
some.JavaClass.CONSTANT
some.JavaEnum.VALUE
etc
Represents a reference to an embeddable type as a literal.
Represents a reference to an entity type as a literal.
Represents the reference to a Map attribute's
Map.Entry entries
in a select clauseRepresents a
SqmModifiedSubQueryExpression.Modifier.ALL, SqmModifiedSubQueryExpression.Modifier.ANY, SqmModifiedSubQueryExpression.Modifier.SOME modifier applied to a subquery as
part of a comparison.Pluggable strategy for defining how insertion (`INSERT`) queries should be handled when the target
entity is mapped to multiple tables via secondary tables or certain inheritance strategies or uses an
identifier generator that uses an optimizer.
Pluggable strategy for defining how mutation (
UPDATE or DELETE) queries should
be handled when the target entity is mapped to multiple tables via secondary tables or certain
inheritance strategies.Pluggable contract for providing custom
SqmMultiTableMutationStrategy and
SqmMultiTableInsertStrategy implementations.A named expression.
Represents a named query parameter in the SQM tree.
Contract for predicates that have a negated form, e.g.
Base contract for any SQM AST node.
A SQM ordered set-aggregate function.
Models a parameter expression declared in the query.
Entity type expression based on a parameter - `TYPE( :someParam )`
The parameter-correlation operations available during one SQM-to-SQL-AST
translation.
Models a reference to a part of the application's domain model as part of an SQM tree.
Registry for SqmPath references providing the ability to access them
in multiple ways - by alias, by NavigablePath, etc
Represents any part of the domain model which can be used to create a
SqmPath node.SqmPath specialization for an SqmPath that wraps another SqmPath
A plural-valued path selection produced by the plural collection functions
elements(), values(), indices(), and keys().An SqmPath for plural attribute paths
Acts as the
EntityDomainType for a "polymorphic query" grouping.Models a positional parameter expression
A grouping of predicates, such as a where-clause, join restriction, ...
Commonality between a top-level statement and a sub-query
A grouped list of queries connected through a certain set operator.
Defines the ordering and fetch/offset part of a query which is shared with query groups.
Identifies the source of an SQM statement.
Defines the commonality between a root query and a subquery.
Context used while rendering SQM nodes to HQL.
Defines a SQM AST node that can be used as a selection in the query,
or as an argument to a dynamic-instantiation.
The semantic select clause.
Represents an individual selection within a select clause.
A SQM set-returning function
A factory for SQM nodes representing invocations of a certain
named set-returning function.
The basic SQM statement contract for top-level statements
Provides access to an underlying SQM AST
Specialized SemanticQueryWalker (SQM visitor) for producing SQL AST.
Information obtained from the interpretation of an SqmStatement
The complete supported input for creating one SQM-to-SQL-AST translator.
Request to translate an SQM mutation statement.
Request to translate an SQM select statement.
Global integration contract for creating single-use SQM-to-SQL-AST
translators.
A TREAT form of SqmCrossJoin
Needed to pass TrimSpecification as an SqmExpression when we call out to
SqmFunctionTemplates handling TRIM calls as a function argument.
A tuple constructor, that is, a list of expressions wrapped in parentheses,
for example,
(x, y, z).Optional contract for
SqmNode implementations which are typed.Optional contract for SqmNode implementations that can be visited
by a SemanticQueryWalker.
Unified contract for things that can contain a SqmWhereClause.
A SQM window function.
Special expression for the json_query function that also captures special syntax elements like error and empty behavior.
Special expression for the xmlelement function that also captures special syntax elements like xmlattributes.
Stack implementation exposing useful methods for Hibernate needs.
A specialized
StaleStateException that carries information about
the particular entity instance that was the source of the failure.Thrown when a version number or timestamp check failed, indicating that
the
Session contained stale data (when using long transactions
with versioning).Maps a stale-state failure reported while checking a JDBC batch result.
Standard aggregate base for focused provider overrides.
References to common instances of
BasicTypeReference.A BasicType adapter targeting partial portability to 6.0's type
system changes.
Marker for Hibernate defined converters of Boolean-typed domain values
Standard representation of entity cached data using the "disassembled state".
Creates standard connection-level lock-timeout strategies.
Marker for Hibernate supplied converter classes.
Standard set of setting converters.
Appends the standard datetime body used while composing a SQL literal.
Factory for Hibernate's standard DDL type descriptor algorithms.
Standard and family derived-table rendering profiles.
Stock exporter for relational
ForeignKey constraints.Standard family strategy for global temporary tables.
Stock exporter for relational
Index definitions.Standard immutable insert-conflict rendering profiles.
Standard family strategy for local temporary tables.
Creates the standard per-translation locking-clause strategies.
Factory for the standard already-rendered SQL locking strategies.
Creates standard pessimistic-locking profiles for a custom Dialect.
The standard implicit naming strategy
for identifier sequences and tables.
Enumeration of the standard Hibernate id generation optimizers.
Standard immutable fixed-plan pagination profiles.
Standard immutable query-mutation rendering profiles.
Implements a "random" UUID generation strategy as defined by the
UUID.randomUUID() method.Standard and family returning-column rendering profiles.
Standard exporter for relational
Sequence definitions.Contract for an initiator of services that target the standard
ServiceRegistry.Central definition of the standard set of service initiators defined by Hibernate.
Specialization of the
ServiceRegistry contract mainly for type safety.Builder for standard
ServiceRegistry instances.Standard and family named set-returning-function rendering strategies.
Standard column-size resolution used by
Dialect.The final phase of query translation.
Standard
SqlAstTranslatorFactory and supported base for custom factories.Simplified API allowing users to contribute
SqmFunctionDescriptors
to HQL.Standard
SqmTranslatorFactory and reusable base for global integrations.A general-purpose stack impl supporting null values.
Standard exporter for relational
Table definitions.Standard and family table-join rendering strategies.
Standard composition-based temporary-table exporter.
Stock exporter for relational
UserDefinedType definitions.Lifecycle contract for services which wish to be notified when it is time to start.
Abstracts over things which can have a customized state management strategy, providing slots to plug in
extra columns related to custom state management.
A command-oriented API often used for performing bulk operations against
the database.
Allows creation of a new
StatelessSession with specific options
overriding the defaults from the SessionFactory.SPI extension of StatelessSession
Integrates a state-management strategy with Hibernate's mapping model and
mutation execution infrastructure.
Graph action-queue integration for a state-management strategy.
Legacy action-queue integration for a state-management strategy.
Base contract for any statement
Access to a JDBC Statement.
Binds one row worth of values to a JDBC statement.
Implementors may inspect and even process each SQL command issued
by a session, before a JDBC
statement is prepared.
Observation of (almost) all JDBC statements performed by Hibernate.
Interface to the object that prepares JDBC
Statements and PreparedStatements
on behalf of a JdbcCoordinator.Helps identify similar mutations more concretely that just type+table.
Exposes statistics collected from all sessions belonging to a given
SessionFactory.Factory for custom implementations of
StatisticsImplementor.A service SPI for collecting statistics about various events occurring at runtime.
Represents the status of an entity with respect to
this session.
Lifecycle contract for services which wish to be notified when it is time to stop.
A general read/write abstraction over the specific "cache" object from the caching provider.
Describes the registration of a named strategy implementation.
Responsible for providing the registrations of one or more strategy selectors.
An object that provides a list of
StrategyRegistrationProviders to the JPA persistence provider.Indicates a problem performing the selection/resolution.
Service which acts as a registry for named strategy implementations.
Indicates violations of strict JPQL syntax while strict JPQL syntax checking was enabled.
Access to appending SQL fragments to a StringBuilder
The HQL
string() function returns the string value of an enumDescriptor for
String handling.base class for JSON document String reader
Enum class for JSON object markers.
Implementation of
JsonDocumentReader for String representation of JSON objects.Implementation of
JsonDocumentWriter for String-based OSON document.JDBC type adapter for String-based JSON document reader.
Describes independent database semantics for empty strings and trailing
spaces in fixed-width character values.
Fixed-width character trailing-space behavior.
Empty-string behavior.
Specifies the UDT (user defined type) name for the annotated embeddable
type or embedded attribute.
A Helper for serializing and deserializing struct, based on an
EmbeddableMappingType.Structured CacheEntry format for entities.
Structured CacheEntry format for persistent collections (other than Maps, see
StructuredMapCacheEntry).An aggregate
JdbcType represented by a named SQL structured type.Structured CacheEntry format for persistent Maps.
A mapping model object that represents a subclass in an entity class
inheritance hierarchy.
Extends the JPA-defined
Subgraph with additional operations.Integration version of the
SubGraph contract.Immutable description of the subquery placements supported by a Dialect.
Build an immutable subquery-support profile.
An independently configurable subquery placement.
Maps an immutable and read-only entity to a given
SQL
select expression.Encapsulates details related to entities which contain sub-select-fetchable
collections and which were loaded in a Session so that those collections may
be sub-select fetched later during initialization
Resolve according to JPA spec 4.8.5
A SQL dialect for Sybase Adaptive Server Enterprise 16 and above.
Sybase ASE generate_series function.
Sybase ASE unnest function.
Sybase ASE xmltable function.
Superclass for all Sybase dialects.
Access to Hibernate's stock Sybase jTDS JDBC type descriptors.
Custom
TruncFunction for Sybase which uses a dialect-specific emulation function for datetimesManages a registry of (local) JTA
Synchronization instancesSPI contract for
SynchronizationRegistry implementors.Specifies a table or tables that hold state mapped by the annotated
entity or collection.
Represents the abstract notion of a query whose results are affected by the data stored
in a given set of named query spaces.
Represents a syntax error in a HQL/JPQL query.
Models a property which does not actually exist in the model.
Immutable description of a synthetic table root required while building a
SQL AST query specification.
Determines whether resolving a grouping or ordering expression requires a
synthetic table root in the current SQL AST query specification.
A mapping model object representing a relational database table.
Produces the complete ordered SQL used to clean mapped tables.
Container for Table and Join reference
Identifies the table-creation command selected by schema export.
Supplies table and view creation grammar.
Models an DELETE to a model (entity or collection) table,
triggered from flush
TableMutationBuilder implementation for delete statements.Standard TableDeleteBuilder implementation used when
Hibernate generates the delete statement.
Deletion defined using custom sql-delete
Details about a table in the domain model, used to creation mutation
operations in the graph-based ActionQueue implementation.
Adapts a
TableDescriptor to the TableMapping interface,
allowing graph-based infrastructure to use standard SQL model mutation builders.Details about a table
Details about a column within the key group
Details about the primary key of a table
An enhanced version of table-based id generation.
Logging related to
TableGenerator operationsGlobal registration of a table generator
Group together
TableReference references related to a single entity or
collection, along with joins to other TableGroupsMarker interface for anything which produces a TableGroup
Used to check if a table should be included in the current execution
Provides access to information about existing tables in the database
Models an insert into a model (entity or collection) table,
triggered from flush
TableMutationBuilder implementation for insert statements.Standard TableInsertBuilder
Insertion defined using custom sql-insert
The commonalities between
TableGroupJoin and TableReferenceJoin.The semantic kind of table join being rendered.
Immutable semantic plan for rendering a table join.
Render SQL Server-style
cross apply or outer apply syntax.The concrete
apply operator.Render the joined table as a comma-separated table reference.
Render the SQL AST join type and its predicate using standard syntax.
Report that the requested join cannot be rendered without changing its
semantics.
Read-only semantic facts supplied by Hibernate when selecting how to render
a table join.
Dialect strategy for selecting an immutable rendering plan for a table join.
Descriptor for primary key columns.
Renders the SQL fragment used with a table-reference fragment to request a
pessimistic lock.
Read-only context for rendering a lock hint for a table-expression
fragment.
Describes a table as far as Hibernate understands it from mapping details
Details for the mutation of a table
Produces the alter-table commands needed to update a table definition.
Describes the mutation of a model table (mapped by an entity or collection)
triggered from flush.
Generalized contract for building
TableMutation instancesOptional contract implemented by some subtypes of
PersistentClass.Represents a reference to a table (derived or physical) in a query's from clause.
The semantic location where a table-reference alias is rendered.
Represents a join to a
TableReference; roughly equivalent to a SQL join.Represents a Set of TableMapping(s); table mappings are
identified by an ordered unique id: the order in which
they are updated within the scope of a particular persister.
Contract describing source of table information
Contract describing source of "table specification" information.
Describes a table used to mimic sequence behavior
Models an update to a model (entity or collection) table,
triggered from flush
TableMutationBuilder implementation for update statements.Standard TableUpdateBuilder implementation
Update defined using custom sql-update
Describes the target(s) of schema create, drop and migrate actions.
Specifies the target type for a
Embedded entity property.Describes the allowable targets (SPI wise) for schema management actions.
Parses SQL fragments specified in mapping documents.
Extracts a violated database constraint name from an error message
by matching the error message against a template.
Specifies that the annotated entity class is a temporal entity
or temporal collection.
Excludes the annotated attribute from temporal
versioning.
Enables partitioning for a temporal table mapped by
a temporal entity or collection
in the single table temporal mapping strategy.
Specifies the name of the separate history table for
a temporal entity or collection
when the history table strategy is used.
A
CollectionKey for a temporal (historical) snapshot of a collection,
loaded from an audit table at a specific changeset identifier.An
EntityKey for a temporal (historical) snapshot of an entity,
loaded from an audit table at a specific changeset identifier.Translates Hibernate datetime format patterns to database SQL fragments.
Access to Hibernate's standard temporal-format translation.
Specialized
JavaType for temporal values and precision resolution.Metadata about temporal columns for entities enabled for temporal history.
Defines SQL extraction and timestamp arithmetic patterns and unit names.
Access to Hibernate's standard temporal-operation support.
Provides the ephemeral query facts needed to choose temporal column
restrictions without exposing query-engine state.
Declares ordered schema commands required by a temporal table strategy.
Defines whether an auxiliary object is shared by the database or belongs
to one temporal table.
Describes one temporal table using names already rendered for the active
schema-export context.
Enumerates the possible mapping strategies for
temporal
entities and collections.
Defines the database grammar and capabilities used for temporal table DDL
and historical queries.
Constructs immutable stock temporal-table profiles without exposing a
Hibernate vendor implementation.
A temporal field type which can occur as an argument
to
extract() or as the unit of a duration
expression.Immutable temporal precision-adjustment and literal-offset semantics.
Read-only description of a temporary-table column.
Read-only description of a temporary table supplied to a
TemporaryTableExporter.An exporter for temporary tables.
Classifies the kinds of temporary table implementations.
Provides stable stock temporary-table strategies without exposing
Hibernate's vendor-specific implementations.
Defines how Hibernate interacts with one kind of temporary table.
Supplies
tenant-specific credential to use to connect to the database.
Identifies a field of an entity that holds a tenant id in discriminator-based multitenancy.
A tenant restriction, whose value comes from the session.
Indicates that tenant identifiers did not match in cases where
CurrentTenantIdentifierResolver.validateExistingCurrentSessions()
returns true and there is a mismatch found.Identifies the database-side source consulted by a row-level-security
policy for the current tenant identifier.
The tenant attribute and generated tenant components of an entity identifier.
Supplies the name of a database schema for a given tenant identifier when
schema-based multitenancy is enabled.
Indicates an attempt to dereference a terminal path
(usually a path referring to something of basic type)
Descriptor for
TIMESTAMP_WITH_TIMEZONE handling.Descriptor for
TIME handling.Helpers for dealing with timeout
values, including some "magic values".
The
timestampadd() or dateadd() function has a funny
syntax which accepts a TemporalUnit as the first argument,
and the actual set of accepted units varies widely.The
timestampdiff() or datediff() function has a funny
syntax which accepts a TemporalUnit as the first argument, and
the actual set of accepted units varies widely.Descriptor for
TIMESTAMP handling.Tracks invalidation of "query spaces" (tables) for the purpose of
determining if a cached query result set is stale.
Responsible for building the
TimestampsCache to use for
managing query results with respect to staleness of the underlying
tables (sometimes called "query spaces" or "table spaces").Defines the contract for a cache region that stores timestamps.
Descriptor for
TIMESTAMP_UTC handling.Descriptor for
TIMESTAMP_UTC handling.Descriptor for
TIMESTAMP_UTC handling.Descriptor for
TIMESTAMP_WITH_TIMEZONE handling.Descriptor for
TIME_UTC handling.Descriptor for
TIME_UTC handling.Descriptor for
TIME_WITH_TIMEZONE handling.Specifies the mapped column for storing the time zone information,
for use in conjunction with
TimeZoneStorageType.COLUMN or
TimeZoneStorageType.AUTO.Descriptor for
TimeZone handling.Specifies how the time zone information of a persistent property or field should be persisted.
Enumerates the possible storage strategies for offset or zoned datetimes.
Describes the storage of timezone information for zoned datetime types,
in particular, for the types
OffsetDateTime and
ZonedDateTime.Describes how a database stores SQL types declared
with time zone.Descriptor for
TINYINT handling.Represents a collection of "tooling hints" (
<meta/> mapping info) keyed by a name.Indicates that more rows were affected than we were expecting to be.
A mapping model object representing an association where the target side has cardinality one.
A
LimitHandler for Transact SQL and similar
databases which support the syntax SELECT TOP n.Extension of
ChangelogMapping that tracks which
entity types were modified in each revision.Extension of standard
RevisionMapping that allows tracking entity names changed in each revision.Represents a resource-local transaction, where resource-local is interpreted
by Hibernate to mean any transaction under the control of Hibernate.
Factory for immutable concurrency declarations and dialect profiles.
Mutable builder; built profiles do not retain its state.
Immutable read guarantees, suitable for a programmatic declaration.
Immutable, resolved database concurrency rules for a factory's connections.
A concurrency configuration error which must not be hidden by the normal
ALLOW bootstrap-metadata fallback.
Determines the transaction concurrency behavior that Hibernate should
assume for a session factory's connections.
Models the coordination of all transaction related flows.
Provides the means for resource-local transactions (as transaction drivers) to control the
underlying "physical transaction" currently associated with the
TransactionCoordinator.Builder for
TransactionCoordinator instances.Access to options that are specific to each
TransactionCoordinator instance.Models an owner of a
TransactionCoordinator.Indicates that a transaction could not be begun, committed
or rolled back.
Thrown when user code causes the end of a transaction that is
being managed by the
SessionFactory.Observer of internal transaction events.
Indicates a call to
TransactionCoordinator.explicitJoin() that requires an
active transaction where there currently is none.A
JDBCException indicating a transaction failed because it could not be placed into a serializable ordering
among all currently-executing transactionsEnumeration of statuses in which a transaction facade (
Transaction) might be.A special function that renders a T-SQL
str() function
if more than a single argument is given, or otherwise renders
a cast() expression just like CastStrEmulation.Thrown if a transient instance of an entity class is passed to
a
Session method that expects a persistent instance,
or if the state of an entity instance cannot be made persistent
because the instance holds a reference to a transient entity.Thrown when the state of an entity cannot be made persistent
because the entity holds a reference to a transient entity.
Access to information needed while translating a collection's order-by fragment
An implementation of
NavigablePath with special handling for treated paths.Indicates a problem with a TREAT usage
ANSI SQL-standard
trim() function, which has a funny syntax
involving a TrimSpec, and portability is achieved using
Dialect.trimPattern(TrimSpec, boolean).Variations of the
trim() function.Handles conversion to/from
Boolean as 'T' or 'F'Identifies whether truncation is rendered per table or for all tables.
Provides the ordered rendered table names for truncation.
Renders ordered table-truncation commands.
Subclassable descriptor for numeric and datetime truncation.
Argument validators exposed to
TruncFunction subclasses.Rendering state exposed to
TruncFunction subclasses.Immutable description of a Dialect's aggregate tuple-count syntax.
Build an immutable tuple-count-support profile.
A complete native syntax choice for one tuple-count form.
Describes any structural type without a direct java type representation.
Specifies a custom
UserType for the annotated attribute mapping.Defines a mapping between a Java type and one or more JDBC types,
as well as describing the in-memory semantics of the given Java type, including:
how to compare values and check for "dirtiness",
how to clone values, and
how to assemble/disassemble values for storage in the second-level cache.
Allows a user-written annotation to drive some customized model binding.
Associates a user-defined annotation with a
TypeBinder,
allowing the annotation to drive some custom model binding.Provide a way to customize the
Type instantiation process.Each instance defines a set of types available in a given
persistence unit, and isolates them from other configurations.
Optional contract for a
Type which is aware
of its scoping to a TypeConfiguration and which receives access
to the TypeConfiguration to which it is scoped.Registration callbacks used by a
TypeContributor or
Dialect to contribute custom types and descriptors
to the eventual TypeConfiguration.Contributes custom type contracts and descriptors to a
TypeConfiguration through TypeContributions.Deprecated, for removal: This API element is subject to removal in a future version.
Consider using discovery instead to
dynamically locate contributors.
Models the information pertaining to a custom type definition supplied by the user.
Represents a typed argument to a query parameter.
Extension to
TupleTransformer exposing the transformation target type.An ordered pair of a value and its Hibernate type.
Certain operations for working with arrays of property values.
Used when a user provided type does not match the expected one.
Describes the intrinsic nullability of a data type as reported by the JDBC driver.
Registers a custom user type implementation
to be used by default for all references to a particular class of
basic type.
Grouping of
TypeRegistrationDescribes the searchability of a data type as reported by the JDBC driver.
Immutable description of a Dialect's resolved type-sizing limits and
defaults.
Mutable construction state for an immutable profile snapshot.
Contract for a type specification mapping.
Oracle Universal Connection Pool settings.
Enumerates the unary prefix operators.
A mapping model object that represents a subclass in a "union" or
"table per concrete class"
inheritance hierarchy.
An
EntityPersister implementing the
InheritanceType.TABLE_PER_CLASS
mapping strategy for an entity and its inheritance hierarchy.A persistent entity mapping that uses the table-per-class inheritance strategy.
Commonality for annotations which define unique-constraints
Unique columns and unique keys both use unique constraints in most dialects.
Applies logical unique declarations to database DDL.
Supported composition facade for stock unique-key strategies.
A mapping model object representing a unique key
constraint on a relational database table.
Useful metadata representing a unique key within a Persister
Identifies the database object used for a logical unique declaration.
Describes syntax which requires a unique declaration to be represented as
an index instead of a relational unique constraint.
Uses a unique key of the inserted entity to locate the newly inserted row.
Indicates that an unknown AccessType external name was encountered
or that an AccessType was requested that the underlying cache provider
does not support.
Indicates a problem resolving an attribute's type details - typically with dynamic models.
AbstractJavaType adapter for cases where we do not know a proper
JavaType for a given Java type.Indicates a failure to resolve an entity name in HQL to a known mapped
entity type.
Indicates an attempt was made to refer to an unknown entity name or class.
Indicates a request against an unknown filter name.
Occurs when a named query is requested, and there is no known
HQL or native SQL query registered under the given name.
Indicates an attempt to access the parameter for an unknown column
Indicates an attempt to find an unknown query parameter or an attempt to
bind a value to an unknown query parameter
Indicates a failure to resolve an element of a path expression in HQL/JPQL.
Indicates that the persister to use is not known and could not be determined.
Indicates a request against an unknown fetch profile name.
Indicates that an unknown service was requested from the registry.
Indicates a request for named ResultSet mapping which could not be found
Thrown when a
TableReference cannot be resolved
for a table-name.Thrown when an operation requires a managed persistent
instance associated with the current persistence context
and encounters a transient or detached object instead.
Standard unnest function.
A numeric literal coming from an HQL query, which needs special handling
Thrown when Hibernate could not resolve an object by id, especially when
loading an association.
Denotes that a setting is considered unsafe.
The base contract for determining transient status versus detached status.
Unstructured CacheEntry format (used to store entities and collections).
The expected behavior when encountering a class that cannot be enhanced,
in particular when attribute names don't match field names.
Indicated a problem with a mapping.
Specialized exception indicating that an unsupported
orm.xml XSD version was specifiedA SQL
UPDATE statement.Second-level cache bookkeeping for graph-based entity updates.
Coordinates the updating of an entity.
Update coordinator for audited entities.
Update coordinator for
TemporalTableStrategy.HISTORY_TABLE
temporal strategy.Coordinates the updating of an entity.
Update coordinator for
TemporalTableStrategy.SINGLE_TABLE
temporal strategy.Models a return that is an update count (count of rows affected)
Immutable semantic plan for rendering a query update.
Render the update directly using native syntax.
Emulate the update using an inline view.
Emulate the update using a merge statement.
Emulate the from-clause using scalar subqueries in the set clause.
Emulate the update using tuple assignment.
Read-only semantic facts supplied by Hibernate when selecting how to render
a query update.
UpdateRowsCoordinator implementation for temporal collection tables
in the TemporalTableStrategy.HISTORY_TABLE
temporal table mapping strategy.UpdateRowsCoordinator implementation for cases with a separate collection table
OneToMany update coordinator if the element is a
UnionSubclassEntityPersister.UpdateRowsCoordinator implementation for temporal collection tables
in the TemporalTableStrategy.SINGLE_TABLE
temporal table mapping strategy.Specialization of
MutationSpecification for programmatic customization
of update queries.Specifies that the annotated field of property is a generated update timestamp.
The timestamp is regenerated every time an entity instance is updated in the database.
Contains an aggregated analysis of the values for an update mutation
to determine behavior such as skipping tables which contained no changes,
etc.
Resolves an application-generated version after a conditional update on dialects which do not
support update returning.
JdbcMutationOperation implementation for UPSERT handlingDescriptor for
URL handling.A custom type for mapping user-written classes which implement
PersistentCollection.Handles
CompositeUserTypes.A mapping model object representing a named relational database array type.
A mapping model object representing a relational database UDT.
A mapping model object which represents a user defined type.
Configures standard user-defined-type create and drop command rendering.
This interface should be implemented by user-defined custom types
that extend the set of types
defined in
org.hibernate.type.Access to information useful during UserType creation and initialization.
Convenience
UserType implementation which mimics the legacy @Type
annotation which was based on the hbm.xml mapping's string-based type support.Registration for a UserType
A user type that may be used for a version property
Specialization of
BasicJavaType for types which model a
representation of a UUID.Converts values to and from Java's
UUID representation.Deprecated.
see
UUIDGeneratorSpecifies that an entity identifier is generated as an
IETF RFC 4122 UUID.
Deprecated.
use
UuidGenerator and
UuidGenerator insteadRepresents a kind of UUID, that is, what RFC 4122 calls a "version".
Deprecated.
This remains around as an implementation detail of
hbm.xml mappings.Descriptor for
UUID handling.JDBC descriptor for
UUID and the UUID SQL data type.Logging related to UUID/GUID identifier generators
Represents a specific algorithm for producing UUID values.
Implements UUID Version 6 generation strategy as defined by the RFC 9562.
Implements UUID Version 7 generation strategy as defined by the RFC 9562.
Duplicates the
jakarta.validation enumeration.Deprecated.
use
ValidityAuditStrategy instead.A mapping model object which represents something that's persisted "by value",
instead of "by reference", that is, anything with no primary key.
Provides access to the values for a managed type (currently just embeddables).
Binds values to a JDBC
PreparedStatement.Any "value mapping" (id, version, attribute, collection element, etc.)
belongs to one of several broad categories.
Describes a ModelPart that is also a ValueMapping (and therefore also a SelectableMappings).
Extracts values from a JDBC
ResultSet or the output parameters of a
CallableStatement.Meta-annotation used to mark another annotation as providing configuration
for a custom value generation strategy.
This enum defines how values passed to JPA Criteria API are handled.
An enum of the different ways a value might be "included".
Describes a mapping related to any part of the app's domain model,
for example, an attribute, an entity identifier, collection elements, etc.
Marker interface for analysis of new/old values.
Immutable description of the contexts in which a Dialect supports native
values syntax.A SQL context in which a values list may occur.
How an on-duplicate-key clause refers to the proposed insert row.
A special table group for a VALUES clause.
Selects the SQL form used for a values-table source.
Descriptor for
VARBINARY handling.Descriptor for
VARCHAR handling.Specialized type mapping for
UUID and the UUID SQL data type,
which binds and reads the UUID through JDBC getString/setString methods.Information about the version of Hibernate.
Additional Java-type contract for values used to version and
optimistically lock data.
Indicates that the version of Hibernate used to enhance
a class is different from the version being used at runtime.
A strategy for determining if a version value is a version of
a new transient instance or a previously persistent transient instance.
Maps an entity to a database view.
Extracts a violated database-constraint name from a vendor
SQLException.Marker interface for parts of the application domain model that do not actually
exist in the model classes.
Marker interface for TableGroup impls that are virtual - should not be rendered
into the SQL.
Things which can have
SQLRestriction
declarations - entities and collectionsModels a window function expression at the SQL AST level.
Immutable description of a Dialect's native window-function syntax.
Build an immutable window-function-support profile.
An independently configurable window-function syntax feature.
A discrete piece of work making use of a JDBC connection.
A visitor used for executing a discrete piece of work encapsulated in a
Work or ReturningWork instance.This interface provides a way to execute unrelated "work" objects using
polymorphism.
Optional contract for services that wrap stuff that to which it is useful to have access.
Contract for
Blob wrappers.Contract for
Clob wrappers.Contract for
NClob wrappers.Possible options for how to handle
Byte[] and Character[] basic mappings
encountered in the application domain model.Options for binding values to and extracting values from JDBC prepared statements and result sets.
Coordinates writing index (order column) values for indexed collections.
WriteIndexCoordinator implementation for collections without
@OrderColumn.Standard WriteIndexCoordinator implementation for collections with
@OrderColumn.Thrown when loading an entity (by identifier) results in a value that
cannot be treated as the subclass type requested by the caller.
Standard xmlagg function.
Specialized type mapping for
XML_ARRAY and the XML ARRAY SQL data type.Factory for
XmlArrayJdbcType.Specialized type mapping for
XML_ARRAY and the XML ARRAY SQL data type.Factory for
XmlAsStringArrayJdbcType.Specialized type mapping for
SQLXML and the XML SQL data type.Standard xmlconcat function.
Context for a specific XML mapping file
Standard xmlelement function.
Standard xmlexists function.
Standard xmlforest function.
A Helper for serializing and deserializing XML, based on an
EmbeddableMappingType.Specialized type mapping for
SQLXML and the XML SQL data type.Holds the XML binder and a classloader used for binding mappings, as well
as access to methods to perform binding of sources of mapping XML.
Standard xmlpi function.
Performs pre-processing across XML mappings to collect data
that makes additional steps easier and more efficient
Collected XML override mappings we can apply wholesale after
processing metadata-complete mappings and annotations.
Tuple of an override descriptor (
managedType) along with the JAXB root it came fromProcesses XML mappings - applying metadata-complete mappings and collecting
override mappings for later processing.
Standard xmlquery function.
Generally indicates a problem locating an XML resource
Standard xmltable function.
Representation of a locally resolved XSD
Describes the
Year Java typeHandles conversion to/from
Boolean as 'Y' or 'N'Selects how a zero UTC offset is rendered in a SQL datetime literal.
Java type descriptor for the
ZonedDateTime type.Descriptor for handling ZonedDateTime directly through the JDBC driver
Describes the
ZoneId Java type.Descriptor for
ZoneOffset handling.
UUIDHexGeneratoris deprecated