All Classes and Interfaces
Class
Description
Base support for ArchiveDescriptor implementors.
Encapsulates the validator, return type and argument type resolvers for the array_contains function.
Encapsulates the validator, return type and argument type resolvers for the array_contains function.
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.
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.
Encapsulates the validator, return type and argument type resolvers for the array_remove functions.
Encapsulates the validator, return type and argument type resolvers for the array_remove functions.
Convenience base class for
AuxiliaryDatabaseObjects.Abstract adapter for
Java type descriptors.Defines a base class for events involving collections.
Base implementation of the
QueryableCollection interface.Base support for
CurrentSessionContext implementors.Abstract supertype of
AbstractPostDatabaseOperationEvent
and AbstractPostDatabaseOperationEvent.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
Defines a base class for
Session-generated events.Abstract adapter for Java type descriptors.
Abstract
JdbcLiteralFormatter implementation managing the JavaTypeExecutable JDBC command
Base support for
JpaSelection impls.Base support for
JpaTupleElement implsStandard json_array_append function.
Standard json_array_insert function.
Standard json_insert function.
Standard json_mergepatch function.
Standard json_remove function.
Standard json_replace function.
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.
Implementation for serializing/deserializing an embeddable aggregate to/from the PostgreSQL component format.
Deprecated, for removal: This API element is subject to removal in a future version.
Represents an operation that is about to be executed by the database.
Wrapper type representing unlocked items.
Interface type implemented by all wrapper objects in the cache.
Wrapper type representing locked items.
AbstractRestrictedTableMutationBuilder<O extends MutationOperation,M extends RestrictedTableMutation<O>>
Specialization of TableMutationBuilder for mutations which contain a
restriction.
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.Base
LockingStrategy implementation to support implementations
based on issuing SQL SELECT statements.Convenience base class for the serialized form of
AbstractLazyInitializer.Superclass for simple
LimitHandlers that don't
support specifying an offset without a limit.TODO : javadoc
A simple walker that checks for aggregate functions.
Models a join based on a mapped attribute reference.
Convenience base class for SqmFrom implementations
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
Convenience base class for
BasicType implementations.Base support for TableInsertBuilder implementations
Base
TableMutation supportBase support for TableMutationBuilder implementations
Base support for TableUpdate implementations
Base support for TableUpdateBuilder implementations
An abstract base class for Sybase and MS SQL Server dialects.
Abstract superclass of the built-in
Type hierarchy.Deprecated.
since
UUIDHexGenerator is deprecatedAn 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.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.
Responsible for maintaining the queue of actions related to events.
Wrapper class allowing to bind the same transaction completion process queues in different sessions.
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.Extension contract for JdbcType implementations that understand how to
adjust themselves relative to where/how they are used (e.g.
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.
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.
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.
A set of operations providing support for aggregate column types
in a certain SQL dialect.
The actual write expression for an aggregate column
which gives access to the value expressions for the respective selectable mapping.
Contract for rendering the custom write expression that updates a selected set of aggregated columns
within an aggregate column to the value expressions as given by the
aggregateColumnWriteExpression.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.
An alias generator for SQL identifiers.
A simple walker that checks for aggregate functions.
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.
Deprecated.
since
ResultTransformer is deprecatedDeprecated.
since
ResultTransformer is deprecatedDeprecated.
since
ResultTransformer is deprecatedA
UniqueDelegate which uses alter table commands to create and drop
the unique constraint.A
UniqueDelegate which uses create unique index commands when necessary.A
Generator which receives parameters from a custom
generator annotation or
id generator annotation.An exception that occurs while reading mapping annotations.
ANSI SQL compliant sequence support, for dialects which
support the ANSI SQL syntax
next value for seqname.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.
Contract for anything a fetch/load graph can be applied
Describes the context for visiting the entries within an archive
Models a logical archive, which might be
a jar file
a zip file
an exploded directory
etc
Contract for building ArchiveDescriptor instances.
Represent an entry in the archive.
Handler for archive entries, based on the classified type of the entry
Indicates a problem accessing or visiting the 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.Concatenation function for array and an element.
Concatenation function for arrays.
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.
Implement the array contains function by using
unnest.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.Descriptor for
ARRAY handling.Factory for
ArrayJdbcType.Deprecated.
Use
ImmutableObjectArrayMutabilityPlan.get() for object arrays,
or implement a dedicated mutability plan for primitive arrays
(see for example ShortPrimitiveArrayJavaType's mutability plan).Implement the array remove index function by using
unnest.Implement the array replace function by 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.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
AssignedIdentifies 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.
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.ANYIdentifies 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.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.Combined set of Hibernate and Jakarta Persistence hints.
Enumerates the configuration properties supported by Hibernate, including
properties defined by the JPA specification.
A SQL dialect for Azure SQL Server.
A mapping model object representing a collection of type
Collection which may
contain duplicates.Hibernate extension to the JPA
CollectionAttribute descriptorBase support for an SQM walker
Deprecated, for removal: This API element is subject to removal in a future version.
Just implement
SessionEventListener directly.A type that maps between
ARRAY and T[]Convenience base implementation of
ValueBinderDescriptor 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 implementation of
ValueExtractorFetch 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(java.lang.Object, java.lang.Class<X>, org.hibernate.type.descriptor.WrapperOptions) methodLazy initializer for plain Java objects.
Descriptor for a basic plural Java type.
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.Marker interface for basic types.
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 a batch of statements to be executed together.
A builder for
Batch instances.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.
Specify a batch size, that is, how many entities should be
fetched in each request to the database, for an invocation of
Session.findMultiple(Class, List, FindOption...).Abstracts any kind of container for managed beans, for example,
the CDI
BeanManager.Contract for producing a bean instance
Models how the lifecycle for a bean should be managed.
Event listener used to enable Bean Validation for insert/update/delete events.
In
Integrator for Bean Validation.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.
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.
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.
Marker interface for non-contextually created
Blob instances.Descriptor for
Blob handling.Descriptor for
BLOB handling.Manages aspects of representing
Blob objects.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.Descriptor for
Byte[] handling, which disallows null elements.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.
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
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(org.hibernate.engine.spi.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.Represents a JPA entity lifecycle callback method.
Callback to allow SQM interpretation to trigger certain things within ORM.
Deprecated.
Methods of
Interceptor are no longer required to
throw this exception type.Registry of JPA entity lifecycle callbacks by entity and type.
Contract for injecting the registry of Callbacks into event listeners.
Deprecated, for removal: This API element is subject to removal in a future version.
Indicates an illegal attempt to make a
Graph become
an EntityGraph via Graph.makeRootGraph(String, boolean).Indicates an attempt was made to add a (key)? subgraph to an
attribute type that does not support (key)? subgraphs.
Deprecated, for removal: This API element is subject to removal in a future version.
Use the JPA-defined
CascadeTypeA contract for defining the aspects of cascading various persistence actions.
Describes sources which define cascading.
Deprecated, for removal: This API element is subject to removal in a future version.
Use the JPA-defined
CascadeType.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.Descriptor for
Character[] handling, which disallows null elements.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
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 a class file.
Descriptor for
Class handling.During the process of building the metamodel, access to the
ClassLoader is
strongly discouraged.A service for interacting with class loaders.
Indicates a problem performing class loading.
Exposes the Classmate
TypeResolver and MemberResolver.A persistence provider provides an instance of this interface to the
PersistenceUnitInfo.addTransformer(jakarta.persistence.spi.ClassTransformer) method.Used to indicate which query clause we are currently processing
An object that produces the SQL required to truncate the tables in a schema.
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
Descriptor for
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
Unification of Iterator and AutoCloseable
Implement the array fill function by using
generate_series.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.1 and above.
A SQL AST translator for Cockroach.
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.
BatchLoader specialization for collection fetching
Cacheable representation of persistent collections
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
We need an entry to tell us all about the current state
of a collection with respect to its persistent state
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.Extension of the general JavaType for "collection types"
Uniquely identifies a collection instance in a particular session.
A loader (initialization) for collections
MappingType descriptor for the collection Java type (List, Set, etc)
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.Custom table delete builder for many-to-many collection join tables that handles row deletes
Custom table update builder for one-to-many collections that handles row deletes
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.
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>.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
CollectionTypeRegistrationStrategy for extracting the unique column alias out of a
ResultSetMetaData.Specifies that a column has a
default value specified in DDL.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
Support an array of columns.
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 instancesParameter descriptor specific to mutations.
An array list for
ColumnValueParameter that implements SelectableConsumer to add new parameters.Common operations of
TableUpdateBuilder and TableInsertBuilder.Models a column's value expression within the SQL AST.
Indicates a problem accepting/executing a schema management command.
Deprecated.
Prefer
Table.comment(),
Column.comment(), etc.Commonality for annotations which contain SQL comments
Deprecated.
Per Comment, prefer Table.comment()
Enumeratoes common function template definitions.
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.
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.
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.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.
Provides access to the initial user-provided configuration values.
Simple conversion contract for converting an untyped object to a specified type.
Support for XSD handling related to Hibernate's `cfg.xml` and
JPA's `persistence.xml`.
Indicates the manner in which JDBC connections
are acquired.
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.
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.
Releasable extension to
ContainedBean.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()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.A
UniqueDelegate which includes the unique constraint in the create table
statement, except when called during schema migration.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.
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
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.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.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.
Models the information for custom SQL execution defined as part of
the mapping for a primary or secondary table.
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.
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.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 10.5 and above.
DB2's varchar_format() can't handle quoted literal strings in
the format pattern.
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.1 and above, previously known as "DB2/400".
Sequence support for
DB2iDialect.A SQL AST translator for DB2i.
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.
Sequence support for
DB2Dialect.A SQL AST translator for DB2.
DB2 supports UDTs but not in JDBC, so there is a feature called "transforms",
which allows to specify an automatic translation from one data type to another.
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".
Sequence support for
DB2zDialect.A SQL AST translator for DB2z.
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.
A registry mapping
JDBC type codes
to instances of the DdlType interface.Descriptor for
DECIMAL handling.default implementation of EnhancementContext.
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.
A SQL
DELETE statement.A
DeleteEvent represents a delete operation
applied to a single entity.Coordinates the deleting of an entity.
DeleteCoordinator for soft-deletes
Coordinates standard deleting of an entity.
Event class for
Session.remove(java.lang.Object).Defines the contract for handling of deletion events generated from a session.
Coordinates the deletion of entries removed from the collection -
For collections with a collection-table, deletes rows from the
collection table.
DeleteRowsCoordinator implementation for cases where deletion is not enabled
OneToMany delete coordinator if the element is a
UnionSubclassEntityPersister.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).
Contract describing source of a derived value (formula).
An event which may be collected by the
EventMonitor.Represents a dialect of SQL implemented by a particular RDBMS.
Pluggable strategy for determining the
Size to use for
columns of a given SQL type.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.Contract for determining the
Dialect to use based on information about the database / driver.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.Specialized
Region whose data is accessed directly,
without the need for key/item wrapping.Bridge between DirectAccessRegion and StorageAccess
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.
Deprecated, for removal: This API element is subject to removal in a future version.
The functionality of DiscriminatorMetadata,
DiscriminatorType and MetaType have been
consolidated into EntityDiscriminatorMapping and DiscriminatorConverterOptional annotation used in conjunction with the JPA-defined
DiscriminatorColumn annotation to
express Hibernate-specific discriminator properties.Contract for sources of information about a mapped discriminator.
Commonality between entity and any discriminators
Union of
ConvertedBasicType and BasicDomainType capabilities.Deprecated, for removal: This API element is subject to removal in a future version.
The functionality of DiscriminatorType,
DiscriminatorMetadata and MetaType have been
consolidated into EntityDiscriminatorMapping and DiscriminatorConverterDetails for a particular discriminator value.
Indicates the level of qualifier support used by
the dialect when referencing a column.
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(org.hibernate.cache.cfg.spi.DomainDataRegionConfig, org.hibernate.cache.cfg.spi.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.
Base for problems creating
DomainResult
instancesContains state related to building
DomainResult and
Fetch graphsMarker for all object types that can be part of a result mapping
Printer for DomainResult graphs
Describes any type forming part of the application domain model.
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(java.lang.Object, java.lang.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.Handles conversion of discriminator values for embeddable subtype classes
to their domain typed form.
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
Contract for instantiating embeddable values.
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.
A
FindOption which requests 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
The context for performing an enhancement.
An exception indicating some kind of problem performing bytecode enhancement.
Provides basic information about the enhancement done to a class.
Class responsible for performing enhancement.
Constants used during enhancement.
Commonality between `many-to-one`, `one-to-one` and `any`, as well as entity-valued collection elements and map-keys
BatchLoader specialization for entity fetching
An observer for detection of multiple entity representations for a persistent entity being merged.
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.Contract to build
EntityEntrySpecialization of Fetch for entity-valued fetches
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
Represents a two-phase JPA bootstrap process for building a Hibernate
EntityManagerFactory.Mapping of an entity
Commonality for multi-loading an entity
Anything that can be the target of mutations
An 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.
Descriptor for the mapping of a table relative to an entity
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.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.Deprecated, for removal: This API element is subject to removal in a future version.
Renamed
EventMonitor.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(java.lang.Object)
and Session.detach(java.lang.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
executeble actions.Provides a sorting interface for
ExecutableList.Deprecated, for removal: This API element is subject to removal in a future version.
Use an
Expectation classA 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
Defines an expected DML operation outcome.
No return code checking.
Essentially identical to
Expectation.RowCount except that the row count
is obtained via an output parameter of a stored procedure.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.Defines a contract for exporting of database objects (tables, sequences, etc)
for use in SQL
CREATE and DROP scripts.Models an expression at the SQL AST level.
A walker that allows to replace expressions.
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.Information extracted from
DatabaseMetaData regarding what the JDBC driver reports as
being supported or not.ANSI SQL-inspired
extract() function, where the date/time fields
are enumerated by TemporalUnit, and portability is achieved
by delegating to Dialect.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.FetchBuilder specialization for basic mappings
The kind of fetch to use for the
FETCH clause.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.
Represents an association fetching strategy.
Exception for
NotFoundAction.EXCEPTION.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.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 an entity or 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.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.
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.
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.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
QueryFlushMode.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.
Additional contract for things which describe foreign keys.
Descriptor for foreign-keys
Represents directionality of the foreign key constraint
Represents the format pattern for a date/time format expression
A format function with support for composite temporal expressions.
A mapper for mapping objects to and from a format.
Java type for
FormatMapper based types i.e.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.A SQL
FOR UPDATE clause.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.
Dialect support information 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.
Allows custom function descriptors to be contributed to the eventual
SqmFunctionRegistry, either by a Dialect
or by a FunctionContributor.On object that contributes custom HQL functions, eventually to a
SqmFunctionRegistry, via an
instance of FunctionContributions.Represents a function used in an order-by fragment
Models a function expression at the SQL AST level.
The kind of function e.g.
A mini-"type system" for HQL function parameters.
Support for
SqmFunctionDescriptors that ultimately want
to perform SQL rendering themselves.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.Simple implementation of
ResultBuilder for retrieving generated basic values.A container for database generated values
retrieved by the mutation operation.
Each implementation defines a strategy for retrieving values
generated by
the database after execution of a mutation statement.
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.Exposes the default catalog and schema to the
generator creation process.
A generic dialect for ANSI-like SQL.
Deprecated, for removal: This API element is subject to removal in a future version.
Use the new approach based on
IdGeneratorType.Global registration of a generic generator
Deprecated, for removal: This API element is subject to removal in a future version.
since
GenericGenerator is deprecated.Generic, non-specific flavor of
JDBCException.Delegate for dealing with generated values using the JDBC3 method
Statement.getGeneratedKeys().The contract for getting the value of a persistent attribute from its container/owner.
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.Helper containing utilities useful for graph handling
Integration version of the
Graph contract.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.
Deprecated.
use
UuidGeneratorH2 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.A SQL dialect for H2.
Identity column support for H2 2+ versions
Deprecated, for removal: This API element is subject to removal in a future version.
Use
H2JsonJdbcType insteadH2 generate_series function.
H2 json_arrayagg function.
H2 requires binding JSON via
setBytes methods.Factory for
H2JsonArrayJdbcType.H2 json_exists function.
H2 requires binding JSON via
setBytes methods.Standard json_objectagg function that uses no returning clause.
H2 json_query function.
H2 json_table function.
H2 json_value function.
A SQL AST translator for H2.
H2 unnest function.
Sequence support for
H2Dialect.Sequence support for
H2Dialect.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.
Sequence support for
HANADialect.Utility class that extracts some initial configuration from the database for
HANADialect.An SQL AST translator for HANA.
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.
Deprecated, for removal: This API element is subject to removal in a future version.
Renamed
DiagnosticEvent.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.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.
Main entry point into building semantic queries.
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 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.
Sequence support for
HSQLDialect.A SQL AST translator for HSQL.
Extension to the JPA
IdentifiableType contract.Common contract between Entity and MappedSuperclass sources.
Models an identifier (name), which may or may not be quoted.
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.Helper for handling
Identifier instances.Builder for
IdentifierHelper instances.Loads an entity by its primary identifier.
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.A strategy for determining if an identifier value is an identifier of
a new transient instance or a previously persistent transient instance.
A set of operations providing support for identity columns
in a certain
SQL dialect.An
OnExecutionGenerator that handles IDENTITY/"autoincrement"
columns on those databases which support them.Meta-annotation used to mark another annotation as providing configuration
for a custom identifier generator.
Indicates an attempted use of a name that was deemed illegal
Indicates an attempt to call
QueryProducer.createMutationQuery(String),
QueryProducer.createNamedMutationQuery(String) or
QueryProducer.createNativeMutationQuery(String) with a non-mutation
query (generally a select query)Indicates a named-query has specified options that are not legal
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 call
QueryProducer.createSelectionQuery(String)
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.
Used in cases where we have no explicit AnyDiscriminatorValue
mapping which 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
Indexed collections include Lists, Maps, arrays and
primitive arrays.
Provides access to information about existing index in the database
Deprecated, for removal: This API element is subject to removal in a future version.
Moved to
DialectDescriptor for
InetAddress handling.An in-flight representation of
Metadata while it is being built.Contract for extracting information about objects in the database schema(s).
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
A SQL
INSERT statement.Coordinates the inserting of an entity.
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(org.hibernate.collection.spi.PersistentCollection<?>, java.lang.Object, org.hibernate.persister.collection.mutation.InsertRowsCoordinator.EntryFilter, org.hibernate.engine.spi.SharedSessionContractImplementor).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.Deprecated, for removal: This API element is subject to removal in a future version.
Deprecated, for removal: This API element is subject to removal in a future version.
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.Defines a common API for dealing with data of integral data type.
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.
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.
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.
Deprecated, for removal: This API element is subject to removal in a future version.
This enum still has exactly one member, and was
placed in a package from which it has no usages.
Specialized
JdbcWrapper contract for wrapped objects that can additionally be invalidatedThrown 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.
Optional contract for ArchiveDescriptorFactory implementations to implement
to be able to adjust
<jar-file/> URL's defined in persistence.xml
files.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.Descriptor for 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.Sub-system 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.Descriptor for a table insert originating from a flush
Represents a literal in the SQL AST.
A formatter object for rendering values of a given Java type
as SQL literals of a certain JDBC/SQL type.
The strategy to use for applying locks to a
JdbcOperationQuerySelect.Sub-system logging related to JDBC interactions
Describes the mapping for things which can be expressed in a SQL query.
Container for one-or-more JdbcMappings
Determines how JDBC metadata is read by the schema management tooling.
Executor for model-mutation operations
JdbcOperation extension for model mutations stemming from
persistence context flushesA JDBC operation to perform.
Unifying contract for any SQL statement we want to execute via JDBC.
An anonymous call block (sometimes called an anonymous procedure) to be executed
on the database.
Basic contract for an insert operation
Specialization of JdbcOperation for cases which mutate
table state (i.e.
Executable JDBC command
Executable JDBC command
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
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.An executor for JdbcSelect operations.
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, etc
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.Descriptor for 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.
Factory for any
JdbcType which is parameterized by
a second JdbcType, the "element" type.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(org.hibernate.type.descriptor.jdbc.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
The JDBC values for a mutation
Descriptor for JDBC value within an operation.
Provides unified access to query results (JDBC values - see
RowProcessingState.getJdbcValue(org.hibernate.sql.ast.spi.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.
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.
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.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(org.hibernate.boot.model.convert.spi.JpaAttributeConverterCreationContext) might
needDeprecated.
This is no longer implemented by any listener
The target for cast.
Specialization of
JpaJoin for Collection typed attribute joinsEncapsulates 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.
JPA-style event listener with support for resolving callback methods from
XML
or from annotation.
JPA defines 2 ways events callbacks can happen...
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.Contract 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.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.JPA ties the notion of
SourceDescriptor and TargetDescriptor
together: meaning that a SourceDescriptor is specific to a given TargetDescriptor.API extension to the JPA
TupleElement contractA 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.Standard json_arrayagg function.
Standard json_array function.
Specialized type mapping 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.Standard json_exists function.
A Helper for serializing and deserializing JSON, based on an
EmbeddableMappingType.Specialized type mapping for
JSON and the JSON SQL data type.Standard json_objectagg function.
Standard json_object function.
Standard json_query function.
Standard json_table function.
Standard json_value function.
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.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.A mapping model
Value which may be treated as an identifying key of a
relational database table.Descriptor for an attribute which is enabled for bytecode lazy fetching
Interceptor that loads attributes lazily
Information about the bytecode lazy attributes for an entity
Information about a particular bytecode lazy attribute grouping.
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.
A
LimitHandler for DB2.DB2 10.5 xmlexists function.
DB2 10.5 xmlquery function.
Specialized FetchBuilder implementations which handle building fetches defined via:
hbm.xml definitions
calls to NativeQuery.addFetch(java.lang.String, java.lang.String, java.lang.String), and friends
Slight variation from
HiLoOptimizer, maintaining compatibility with the values generated by the
legacy Hibernate hilo based generators.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
Contract defining dialect-specific limit and offset handling.
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.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.
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.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.
Strategy for how dialects need
LOB values to be merged.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(java.lang.Object, org.hibernate.LockMode).Defines the contract for handling of lock events generated from a session.
A strategy abstraction for how locks are obtained in the underlying database.
Represents an error trying to apply a
LockingStrategy to an entityInstances 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.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.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.Standard initializer for the
ManagedBeanRegistry service.Specialized
Managed contract for component/embeddable classes.Extensions to the JPA-defined
ManagedType contract.Specialized
Managed contract for entity classes.Specialized
Managed contract for MappedSuperclass classes.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.
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 descriptorDeclares 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.
Descriptor for a mapping (XML) file.
Access to information about the runtime relational O/R mapping model.
Logger used during mapping-model creation
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
MapsIdFactory for
MariaDBCastingJsonArrayJdbcType.A SQL dialect for MariaDB 10.5 and above.
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.
Sequence support for
MariaDBDialect.A SQL AST translator for MariaDB.
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.Specialized
UpdateCoordinator for merge into.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
Loads multiple instances of a given entity type at once, by
specifying a list of identifier values.
Loader subtype for loading multiple entities by multiple identifier values.
Encapsulation of the options for loading multiple entities 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.
Base contract for options for multi-load operations
Loader for entities by multiple natural-ids
Encapsulation of the options for loading multiple entities by natural-id
Support for overloaded functions defined in terms of a
list of patterns, one for each possible function arity.
Condition where an attribute indicates multiple natures
Exception used to indicate that a query is attempting to simultaneously fetch multiple
bags
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 aspects of a given 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.
Mutability plan for mutable objects
Specialized TableReference for model mutation operations
Acts as a TableGroup for DML query operations.
Coordinates the mutation operations of an entity.
Main contract for performing the mutation.
Service for creating executors for model mutation operations
Grouping of table mutations for the given target for
the given type of mutation
Builder (pattern) for
TableMutation referencesMutation for a specific table as part of a logical mutation on the entity.
Group of
MutationOperation references for a specific
logical operation (target + type)Within the context of an active session,
an instance of this type represents an executable mutation query, that is,
an
insert, update, or delete.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.Target of mutations from persistence context events
The type of mutation
Represents the MyISAM storage engine.
Factory for
MySQLCastingJsonArrayJdbcType.A SQL dialect for MySQL 8 and above.
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.A SQL AST translator for MySQL.
This interface defines how various MySQL storage engines behave in regard to Hibernate functionality.
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.
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 HQL query, as defined in
annotations or xml
A grouping of
NamedNativeQuery definitions.Declares a named query written in native SQL.
Boot-time descriptor of a named native query, as defined in
annotations or xml
Descriptor for a named native query in the runtime environment
Repository for references to named things related to queries.
Descriptor regarding a named parameter.
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.
Common attributes shared across the mapping of named HQL, native
and "callable" queries defined in annotations, orm.xml and hbm.xml
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.
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.
Enumerated values representing the level of support for catalog and schema.
Represents a namespace (named schema/catalog pair) with a Database and manages objects defined within.
Helper contract for dealing with naming strategies.
Indicates if and how a database supports the use of nationalized
character data (Unicode).
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.
Access the values defining a native non-select query
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 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
ResultTransformer 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.
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)
Loads an entity by its natural identifier, which may be a
composite value comprising more than one attribute of the
entity.
Loader for
NaturalId handlingOptions for loading by natural-id
Logging related to natural-id operations
Mapping for an entity's natural-id, if one is defined.
Loads multiple instances of a given entity type at once, by
specifying a list of natural id values.
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.
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.Descriptor for
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.
Sequence support for dialects which support the common
Oracle-style syntax
seqname.nextval.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.
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.
An instance of
SequenceSupport support indicating that
the SQL dialect does not support sequences.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 order of null.
Deprecated.
Use Jakarta Persistence Nulls instead.
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
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.
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.Callback for producing a
JdbcMutationOperation given
a collection-table referenceUsed to check the results of a statement execution
Represents an error trying to apply an optimistic
LockingStrategy to an entityAn optimistic locking strategy that verifies that the version
has not changed and then forces an increment of the version,
just before committing the transaction.
Specifies whether mutating the annotated attribute should trigger an increment
to the version of the entity instance.
Specifies how optimistic lock checking works for the annotated entity.
An optimistic locking strategy that simply verifies that the
version has not changed, just before committing the transaction.
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.Legacy "upsert" handling, conditionally using INSERT, UPDATE and DELETE
statements as required for optional secondary tables.
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.Oracle concatenation function for array and an element.
Oracle concatenation function for arrays.
Oracle array_fill function.
Oracle array_get function.
Descriptor for
ARRAY handling.Factory for
OracleArrayJdbcType.Oracle array_remove function.
Oracle array_remove_index function.
Oracle array_replace function.
Oracle array_set function.
Oracle array_slice function.
Oracle array_to_string function.
Oracle array_trim function.
A SQL dialect for Oracle 19c and above.
Represents a named
enum type on Oracle 23ai+.The following class provides some convenience methods for accessing JdbcType instance,
that are loaded into the app class loader, where they have access to the JDBC driver classes.
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 JSON SQL data type for Oracle.Factory for
OracleJsonArrayJdbcType and OracleJsonArrayBlobJdbcType.Specialized type mapping for
JSON and the BLOB SQL data type for Oracle.Oracle json_insert function.
Specialized type mapping for
JSON and the JSON SQL data type for Oracle.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.
Descriptor for
TABLE handling.Factory for
OracleNestedTableJdbcType.Represents a named
enum type on Oracle 23ai+.Sequence support for
OracleDialect.Utility class that extract some initial configuration from the database for
OracleDialect.A SQL AST translator for Oracle.
Custom
TruncFunction for Oracle which uses emulation when truncating datetimes to secondsThe Oracle specific JDBC type code.
Oracle unnest function.
Factory for
OracleXmlArrayJdbcType.Oracle xmltable function.
A rule for sorting a query result set.
Contact to define if a plural attribute source is orderable or not.
Represents the translation result.
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.
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
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 enumDescriptor regarding an ordinal parameter.
Common contract for individual return objects which can be either results (
ResultSetOutput) or update
counts (UpdateCountOutput).Specialization of
DomainType for types that
can be used as a parameter output for a ProcedureCall.Represents the outputs of executing a JDBC statement accounting for mixing of result sets and update counts
hiding the complexity of how this is exposed in the JDBC API.
Marker interface for valued model parts that have a declaring/owner type.
Descriptor for a package (as indicated by a package-info.class file).
Identifies a page of query results by page size
and page number.
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.
Strategy for generating parameter markers used in preparable SQL strings.
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
Reference the property as a pointer back to the owner (generally 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.
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.
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.PersistenceUnitDescriptor wrapper around PersistenceConfiguration
Represents the state of "stuff" Hibernate is tracking, including (not exhaustive):
entities
collections
snapshots
proxies
Settings related to persistence-units
Abstraction for dealing with
<persistence-unit/> information
specified in the persistence.xml file, which might be:
passed by the Jakarta EE container as an instance of
PersistenceUnitInfo, or,
in an SE environment, parsed by Hibernate itself.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.
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.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(java.lang.Object).Defines the contract for handling of create events generated from a session.
Represents an error trying to apply a pessimistic
LockingStrategy to an entityA pessimistic locking strategy where a lock is obtained by incrementing
the version immediately, obtaining an exclusive write lock by side effect.
Thrown when a pessimistic locking conflict occurs.
A pessimistic locking strategy where
LockMode.PESSIMISTIC_READ
is obtained via a select statement.A pessimistic locking strategy where a lock is obtained via
an update statement.
A pessimistic locking strategy where
LockMode.PESSIMISTIC_WRITE
lock is obtained via a select statement.A pessimistic locking strategy where a lock is obtained via
an update statement.
The following class provides some convenience methods for accessing JdbcType instance,
that are loaded into the app class loader, where they have access to the JDBC driver classes.
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.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.Variation of
PooledOptimizer which interprets the incoming database
value as the lo value, rather than the hi value.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, storing the next low value of the range
in the database.
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
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.
Descriptor for
ARRAY handling.Factory for
PostgreSQLArrayJdbcType.PostgreSQL variant of the function.
PostgreSQL variant of the function.
PostgreSQL array_trim emulation, since the function was only introduced in version 14.
Factory for
PostgreSQLCastingJsonArrayJdbcType.A SQL dialect for PostgreSQL 13 and above.
Represents a named
enum type on PostgreSQL.PostgreSQL json_arrayagg function.
PostgreSQL json_array_append function.
PostgreSQL json_array function.
PostgreSQL json_array_insert function.
Factory for
PostgreSQLCastingJsonArrayJdbcType.Factory for
PostgreSQLCastingJsonArrayJdbcType.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.
Represents a named
enum type on PostgreSQL.Sequence support for
PostgreSQLDialect.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 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
Models a predicate in the SQL AST
Something that can contain predicates
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
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 contract for primitive / primitive wrapper Java types.
Defines support for executing database stored procedures and functions using the
JDBC stored procedure SQL escape syntax.
Specialization of the
Outputs contract providing access to the stored procedure's registered
output parameters.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.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.
Describes a strategy for accessing a persistent attribute,
for example: field, JavaBean-style property, or whatever.
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).
Thrown when an
IllegalArgumentException occurs calling a property setter method.Thrown when the (illegal) value of a property can not be persisted.
ManagedBean implementation for cases where we have been handed an actual
instance to use.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.Most of this code was originally an internal detail of
PojoEntityTuplizer,
then extracted to make it easier for integrators to initialize a custom
ProxyFactory.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,
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.
Enumerates the possible flush modes for execution of a
Query.Deprecated, for removal: This API element is subject to removal in a future version.
Moved to
DialectDeprecated.
Use
AvailableHints insteadCache 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.
Encapsulates options for the execution of a HQL/Criteria/native query
Represents a parameter defined in the source (HQL/JPQL or criteria) query.
The value/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.
Represents a "parameter list" binding: aka the binding of a collection of values for a single
query parameter.
A special table group for a sub-queries.
A table reference for a query part.
Common contract for select and mutation query plans
An object which can produce instances of
SelectionQuery and MutationQuery.Deprecated, for removal: This API element is subject to removal in a future version.
This interface is no longer needed and will be removed.
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.
Specifies an allowed set or range of values for a value being restricted.
A
FindOption which requests that
entities be loaded in ReadOnlyMode.READ_ONLY mode or in regular
ReadOnlyMode.READ_WRITE mode.Deprecated.
use
FloatJdbcTypeContract for JDBC REF_CURSOR support.
Specialized CacheEntry for storing direct references to entity instances.
Represents reflection optimization for a particular class.
Represents optimized entity property access.
Represents optimized entity instantiation.
A
RefreshEvent represents a refresh operation
applied to a single entity.Event class for
Session.refresh(java.lang.Object).Defines the contract for handling of refresh events generated from a session.
Contract for a named cache "region".
Deprecated.
Moved, but still need this definition for ehcache
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.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
Handles complete removal of a collection by its key
OneToMany remove coordinator if the element is a
UnionSubclassEntityPersister.Event class for
Session.replicate(java.lang.Object, org.hibernate.ReplicationMode).Deprecated.
since
Session.replicate(java.lang.Object, org.hibernate.ReplicationMode) is deprecatedDeprecated.
since
Session.replicate(Object, ReplicationMode) is deprecatedEnumeration 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
TableMutationBuilder implementation for building mutations
which have a where clause.A rule for restricting query results.
A restriction (predicate) to be applied to a query
Responsible for building a single
DomainResult.ResultBuilder specialization for cases involving scalar results.
ResultBuilder specialization for cases involving embeddable results.
ResultBuilder specialization for cases involving entity results.
ResultBuilder specialization for cases involving dynamic-instantiation results.
Deprecated, for removal: This API element is subject to removal in a future version.
Use an
Expectation class instead.Describes the mapping for a result as part of a
NamedResultSetMappingDescriptorAny node (result or fetch) in the result graph
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 return that is a result set.
Deprecated.
Use
TupleTransformer and/or ResultListTransformer insteadSpecialization of
SimpleDomainType for types that can
be used as function returns.A discrete piece of work making use of a JDBC connection
and returning a result.
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.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.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.
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.Describes the environment in which the scan will occur.
Defines the contract for Hibernate to be able to scan for classes, packages and resources inside a
persistence unit.
Support for scanning various sources to detect
managed resources
for a persistence unit.Options for performing scanning
A "parameter object" passed to
Scanner.scan(org.hibernate.boot.archive.scan.spi.ScanEnvironment, org.hibernate.boot.archive.scan.spi.ScanOptions, org.hibernate.boot.archive.scan.spi.ScanParameters) to help support future
changes in terms of needing to pass additional stuff to scanning.Defines the result of scanning
Deprecated, for removal: This API element is subject to removal in a future version.
This enumeration is currently unused and will be removed.
Service delegate for handling schema creation.
Service delegate for handling schema dropping.
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.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, and
schema cleanup as a convenience for
writing tests.
Service delegate for handling schema migration.
Contract for resolving the schema of a
Connection.Deprecated, for removal: This API element is subject to removal in a future version.
Use SchemaNameResolver instead.
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.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.Within the context of an active session,
an instance of this type represents an executable selection query, that is,
a
select.Specialization of
QuerySpecification for programmatic customization of
selection queries with ordering and restriction criteria.A function capable of modifying or augmenting a criteria query.
Strategies for referring to a select item.
A locking strategy where an optimistic lock is obtained via a select
statement.
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.
Represents an error in the semantics (meaning) of a HQL/JPQL query.
Support for walking a Semantic Query Model (SQM) tree
Models a database
SEQUENCE.Global registration of a sequence generator
Access to information about existing sequences.
Because JDBC (at least up to and including Java 7, JDBC 4) still does not have support for obtaining information
about sequences from DatabaseMetaData.
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.
A set of operations providing support for sequences in a
certain
SQL dialect.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.
Allows creation of a new
Session with specific options.Defines the internal contract between the
SessionBuilder and
other parts of Hibernate.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.Base delegating implementation of the
SessionFactory and
SessionFactoryImplementor contracts for intended for easier
implementation of SessionFactory.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.The SQL set operators.
Hibernate extension to the JPA
SetAttribute descriptorSupport for
SqmSetReturningFunctionDescriptors that ultimately want
to perform SQL rendering themselves.Pluggable strategy for resolving a function return type for a specific call.
Pluggable strategy for resolving a function return type for a specific call.
The contract for setting the value of a persistent attribute on its container/owner.
Field-based implementation of Setter
Specialized
SessionBuilder with access to stuff from another 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.A wrapper class that delegates all method invocations to a delegate instance of
SharedSessionContractImplementor.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
Loads an entity by its natural identifier.
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().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.
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.
Deprecated, for removal: This API element is subject to removal in a future version.
A
UniqueDelegate that only creates unique constraints on not-null columns, and ignores requests for
uniqueness for nullable columns.Descriptor for
SMALLINT handling.A
JDBCException indicating that a request failed due to snapshot isolation.Part of the boot model which can be soft-deleted
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.
Deprecated, for removal: This API element is subject to removal in a future version.
use
CurrentTimestamp insteadDescribes 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.
A SQL dialect for Cloud Spanner.
A SQL AST translator for Spanner.
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 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
Access to appending SQL fragments to an in-flight 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
Factory for obtaining single-use SQL AST translators
Base for translators which support a full insert-or-update-or-delete (MERGE) command.
Base SqlAstTranslator for translators which support an insert-or-update (UPSERT) command
Dedicated logger for rendering a SQL AST
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.Allow a
SQLExceptionConverter to work by chaining together
multiple delegates.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.
A function to pass through a SQL fragment.
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 entities or collections.
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
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 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.Factory for
SQLServerCastingXmlArrayJdbcType.Custom
TruncFunction for SQL Server versions before 16,
which uses the custom SqlServerConvertTruncFunction.DateTruncConvertEmulationA dialect for Microsoft SQL Server 2012 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.
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.
Sequence support for
SQLServerDialect.A SQL AST translator for SQL Server.
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.
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.
Logs a debug representation of the SQL AST.
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.
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
A factory for SQM nodes representing invocations of a certain
named function.
Defines a registry for
SqmFunctionDescriptor instances.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.
Acts as the per-use wrapper for a JpaCriteriaParameter (
CriteriaBuilder.parameter(java.lang.Class<T>)).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 )`
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
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, ...
Query based on an SQM tree.
Commonality between a top-level statement and a sub-query
A grouped list of queries connected through a certain set operator.
QueryImplementor specialization for SQM-based Query referencesDefines 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
Specialized SemanticQueryWalker (SQM visitor) for producing SQL AST.
Information obtained from the interpretation of an SqmStatement
Factory for various
SqmTranslatorsA TREAT form of SqmCrossJoin
Logger used to log information about the creation of an SQM tree.
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.
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).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".
Marker for Hibernate supplied converter classes.
Standard set of setting converters.
The standard implicit naming strategy
for identifier sequences and tables.
Enumeration of the standard Hibernate id generation optimizers.
Implements a "random" UUID generation strategy as defined by the
UUID.randomUUID() method.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.The final phase of query translation.
Standard implementation of SqlAstTranslatorFactory
Simplified API allowing users to contribute
SqmFunctionDescriptors
to HQL.Standard implementation of the SqmTranslatorFactory
Lifecycle contract for services which wish to be notified when it is time to start.
A command-oriented API often used for performing bulk operations against
the database.
Allows creation of a new
StatelessSession with specific options.Base contract for any statement
Helper for creating JDBC statements.
Implementors may inspect and even process each SQL command issued
by a session, before a JDBC
statement is prepared.
Options for the creation of a JDBC statement
Interface to the object that prepares JDBC
Statements and PreparedStatements
on behalf of a JdbcCoordinator.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
Descriptor for
String handling.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).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.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
Sybase ASE supports the
xmlextract() function which is used to implement aggregate support.A SQL dialect for Sybase Adaptive Server Enterprise 16 and above.
Sybase ASE generate_series function.
A SQL AST translator for Sybase ASE.
Sybase ASE unnest function.
Sybase ASE xmltable function.
Superclass for all Sybase dialects.
Specialized
GetGeneratedKeysDelegate which appends the database
specific clause which signifies to return generated IDENTITY values
to the end of the insert statement.A SQL AST translator for Sybase.
A SQM to SQL AST translator for Sybase ASE.
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.
A mapping model object representing a relational database table.
Container for Table and Join reference
Models an update 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
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.
Global 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
The commonalities between
TableGroupJoin and TableReferenceJoin.Describes a table as far as Hibernate understands it from mapping details
Details for the mutation of a table
An object that produces an
alter table statements
needed to update the definition of a table.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.
Represents a join to a
TableReference; roughly equivalent to a SQL join.Functional contract for producing the join-predicate related to a
TableReferenceJoin.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
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.
Specialized JavaType for temporal types.
A temporal field type which can occur as an argument
to
extract() or as the unit of a duration
expression.A column in a IdTable.
An exporter for temporary tables.
Classifies the kinds of temporary table implementations.
Deprecated.
All dialects currently use
TempTableDdlTransactionHandling.NONE, so it's obsolete.Identifies a field of an entity that holds a tenant id in discriminator-based multitenancy.
Indicates that tenant identifiers did not match in cases where
CurrentTenantIdentifierResolver.validateExistingCurrentSessions()
returns true and there is a mismatch found.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 the extent to which a given database supports the SQL
with time zone types.Descriptor for
TINYINT handling.Deprecated.
since
ResultTransformer is deprecatedRepresents 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.Represents a resource-local transaction, where resource-local is interpreted
by Hibernate to mean any transaction under the control of Hibernate.
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.
Deprecated, for removal: This API element is subject to removal in a future version.
This is no longer needed
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.Deprecated.
since
ResultTransformer is deprecatedThrown when the user passes a transient instance to a
Session
method that expects a persistent instance.Thrown when a property cannot be persisted because it is an association
with a transient unsaved entity instance.
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'Custom function that manages both numeric and datetime truncation
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.Allows custom types and type descriptors to be contributed to the eventual
TypeConfiguration, either by a Dialect
or by a TypeContributor.On object that contributes custom types and type descriptors, eventually to
a
TypeConfiguration, via an instance of
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.
Deprecated, for removal: This API element is subject to removal in a future version.
Internal code should use the internal implementation class
TypeDefinitionRegistryStandardImpl.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.
Deprecated, for removal: This API element is subject to removal in a future version.
This class is no longer used and will be removed
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.
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.Commonality for annotations which define unique-constraints
Unique columns and unique keys both use unique constraints in most dialects.
Dialect-level delegate responsible for applying unique constraints in DDL.
A mapping model object representing a unique key
constraint on a relational database table.
Useful metadata representing a unique key within a Persister
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.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.Coordinates the updating of an entity.
Coordinates the updating of an entity.
Models a return that is an update count (count of rows affected)
A locking strategy where a lock is obtained via an update statement.
UpdateRowsCoordinator implementation for cases with a separate collection table
OneToMany update coordinator if the element is a
UnionSubclassEntityPersister.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.
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.
This interface should be implemented by user-defined custom types
that extend the set of types
defined in
org.hibernate.type.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
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.Specialized type mapping for
UUID and the UUID SQL data type.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.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).
Contract for binding values to a JDBC
PreparedStatement.It is a JpaCriteriaParameter created from a value when ValueHandlingMode is equal to BIND
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).
Contract for extracting values from a JDBC
ResultSet or
from output the 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.
A special table group for a VALUES clause.
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 contract for types which may be used to version (and optimistic 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.
An object that can extract the name of a violated database constraint
from a
SQLException that results from the constraint violation.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.
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.
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.
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.
XmlProcessingResult.OverrideTuple<M extends org.hibernate.boot.jaxb.mapping.spi.JaxbManagedType>
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'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.
PostInsertIdentifierGeneratorandBulkInsertionCapableIdentifierGenerator, or even better, simply implementOnExecutionGeneratordirectly.