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_overlaps 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.
Deprecated, for removal: This API element is subject to removal in a future version.
No direct replacement.
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.Deprecated, for removal: This API element is subject to removal in a future version.
No direct replacement
Base support for
CurrentSessionContext implementors.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
Deprecated, for removal: This API element is subject to removal in a future version.
No direct replacement
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.
AbstractFetchParent sub-class for entity-valued graph nodes
Defines a base class for
Session-generated events.Base support for FetchParentAccess implementations.
Deprecated, for removal: This API element is subject to removal in a future version.
Will be replaced with
HANADialect in the future.Functionality common to all implementations of
IdentifiableType.Abstract adapter for Java type descriptors.
Abstract
JdbcLiteralFormatter implementation managing the JavaTypeExecutable JDBC command
Base support for
JpaSelection impls.Base support for
JpaTupleElement implsConvenience base class for lazy initialization handlers.
Default implementation of
LimitHandler interface.Convenient base class for proxy-based LobCreator for handling wrapping.
Functionality common to all implementations of
ManagedType.Basic support for
MultiTenantConnectionProvider implementations using
individual ConnectionProvider instances per tenant behind the scenes.Base support for coordinating mutations against an entity
Deprecated, for removal: This API element is subject to removal in a future version.
No direct replacement.
Deprecated, for removal: This API element is subject to removal in a future version.
Abstraction was not useful, so it was inlined into
EntityFetchJoinedImpl directlySuperclass for
LimitHandlers that don't support
offsets at all.Common support for
Optimizer implementations.Base class implementing
PersistentCollectionContract for operations which are part of a collection's operation queue.
TBH not sure why this is public
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.
Subclasses should now directly inherit
PostInsertIdentifierGenerator and
BulkInsertionCapableIdentifierGenerator, or even better, simply implement
OnExecutionGenerator directly.Represents an operation we are about to perform against the database.
Deprecated, for removal: This API element is subject to removal in a future version.
Replaced by
EntityMappingTypeWrapper 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 statementsConvenience 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 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.
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.
CompositeIdMapping which is physically an embeddable and represented by a single attribute.
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.
Deprecated, for removal: This API element is subject to removal in a future version.
Replaced by
AnnotationBasedGeneratorThe table group producer for an anonymous tuple type.
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.
A simplified way to specify the type of the discriminator in an
Any
mapping, using the JPA-defined DiscriminatorType.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.Descriptor for
T[] handling.Descriptor for
ARRAY handling.Factory for
ArrayJdbcType.A mutability plan for arrays.
Array overlaps function that uses the PostgreSQL
&& operator.Implement the overlaps function by using
unnest.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.
An
IdentifierGenerator that returns the current identifier assigned
to an instance.Identifies the association referenced by a
Fetch.Commonality for an association, mainly details relative to the foreign-key
Identifies a named association belonging to a particular
entity instance.
Used as part of circularity detection
A type that represents some kind of association between entities.
Deprecated, for removal: This API element is subject to removal in a future version.
Replaced by
AttributeMappingSpecifies 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).
Deprecated, for removal: This API element is subject to removal in a future version.
no longer used
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).Metadata about a persistent attribute
An enum defining the nature (categorization) of a persistent attribute.
Extends the JPA-defined
AttributeNode with additional operations.Integration version of the
AttributeNode contractAn 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.Contract for handling auto-apply checks for JPA AttributeConverters
Defines an event class for the auto-flushing of a session.
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 mapping model object representing a collection of type
Collection which may
contain duplicates.Hibernate extension to the JPA
CollectionAttribute descriptorDeprecated, for removal: This API element is subject to removal in a future version.
No direct replacement, though see
AttributeMapping
and AttributeMetadataBase support for an SQM walker
A no-op implementation of SessionEventListener.
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
Deprecated, for removal: This API element is subject to removal in a future version.
Replaced by
EntityMappingTypeConvenience 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
Deprecated.
see
MultiKeyLoadSizingStrategy insteadUnique key for batch identification.
Provides access to a BatchKey as part of creating an executor.
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.
Represents a backend "bean container" - CDI, Spring, etc
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.
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.
Types that can be used to handle binding
Query parametersContract for performing JAXB binding.
Represents a JAXB binding, as well as keeping information about the origin
of the processed XML
Responsible for processing managed-resources
and table them into Hibernate's boot-time model.
Group of all parameter bindings for a table.
The idea here is mostly the role filled by InFlightMetadataCollector upstream.
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 underlying cached data for a particular
Navigable of the user's 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.
Deprecated.
Models the caching options for an entity, natural-id, or collection.
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.Deprecated.
will move to
org.hibernate.boot.model.source.spi, where its only uses areDescriptor 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 event callback (the method).
Callback to allow SQM interpretation to trigger certain things within ORM.
Intended to be thrown from
Lifecycle
and Interceptor callbacks.Registry of Callbacks by entity and type
Contract for injecting the registry of Callbacks into event listeners.
Originally copied from Spring Boot as this strategy is popular there
(original name is SpringPhysicalNamingStrategy).
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)? sub-graph to an
attribute type that does not support (key)? sub-graphs.
Specifies the persistence operations that should cascade
to associated entity instances.
A contract for defining the aspects of cascading various persistence actions.
Describes sources which define cascading.
Enumerates the persistence operations which may be cascaded from
one entity instance to associated entity instances.
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.The application's domain model, understood at a very rudimentary level - we know
a class is an entity, a mapped-superclass, ...
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.Specifies a
check constraint to be included in the generated DDL.Represents a table or column level
check constraint.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.
A list of
Checks.A chr implementation that translates integer literals to string literals.
Possible class-level AccessType values.
Descriptor for a class file.
Defines handling and filtering for class file entries within an archive
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.
Deprecated.
Use Hibernate's mapping model
MappingMetamodelA 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.
An event for
Session.clear() listeningListener 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.A SQL dialect for CockroachDB 21.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.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 an identifier column for a bag.
Descriptor for the collection identifier.
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)
Deprecated.
Use Hibernate's mapping model
MappingMetamodelStandard 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 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()
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: HQL/JPQL queries, native SQL queries,
criteria queries, and
stored procedure calls.
We frequently need the union type of Executable, Comparable of ComparableExecutable, Serializable;
this interface represents such union; this helps to simplify several generic signatures.
Defines the comparison operators.
A binary-comparison restriction
CompleteFetchBuilder for embeddable-valued ModelParts
CompleteFetchBuilder for entity-valued ModelParts
For a complete predicate.
CompleteResultBuilder for basic-valued ModelParts
Nominal extension to ResultBuilder for cases involving scalar results
ResultBuilder for scalar results defined via:
JPA
ColumnResult
`<return-scalar/>` as part of a `<resultset/>` stanza in `hbm.xml`
ResultBuilder for scalar results defined via:
JPA
ColumnResult
`<return-scalar/>` as part of a `<resultset/>` stanza in `hbm.xml`
CompleteResultBuilderEntityValued implementation specific to JPA.
ResultBuilder for dynamic instantiation results (
ConstructorResultA mapping model object that represents an embeddable class.
Comparator for component arrays.
Handles embedded mappings.
Deprecated, for removal: This API element is subject to removal in a future version.
Replaced by
EmbeddedCollectionPartMapping for a composite identifier
Common contract for composite identifiers.
Id-mapping which is embeddable - either physically
or virtually.
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.An
IdentifierGenerator 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.
An observer of logical connection events.
A no-op adapter for
ConnectionObserver.A contract for obtaining JDBC connections and, optionally, for pooling connections.
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 integrity constraint.Release-able 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 AttributeConverter
Registers an
AttributeConverter.A registry for JPA converters.
Indicates that the class is copied from hibernate-core and should ultimately use that one
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.
Deprecated.
use
CurrentTimestampGenerationInterface 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
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 ASTThe table group producer for a CTE tuple type.
Descriptor 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.
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.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.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.
Extends
JDBCException indicating that evaluation of the
valid SQL statement against the given data resulted in some
illegal operation, mismatched types or incorrect cardinality.A help for dealing with BLOB and CLOB data
A 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 itDeprecated.
use
DB2zIdentityColumnSupportDeprecated.
Use
DB2iDialectDeprecated.
Use
DB2iDialectA 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.
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.
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.Deprecated.
NamingStrategy itself has been deprecatedImplements the default discriminator assignment strategy defined by JPA,
that is, the discriminator value is the JPA (unqualified) entity name.
default implementation of EnhancementContext.
Deprecated.
NamingStrategy itself has been deprecatedDeprecated.
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.
Defines an event class for the deletion of an entity.
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).
Deprecated.
Just used to singly extend all the deprecated collection persister roles
Deprecated.
Just used to singly extend all the deprecated entity persister roles
A SQL dialect for Apache Derby 10.15.2 and above.
A
LimitHandler for Apache Derby, which
fully supports the ANSI SQL standard syntax
FETCH FIRST m ROWS ONLY and
OFFSET n ROWS FETCH NEXT m ROWS ONLY.A derby implementation for lpad.
A derby implementation for rpad.
Sequence support for
DerbyDialect.A SQL AST translator for Derby.
Contract describing source of a derived value (formula).
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 wrapper of Dialect, to allow decorating some selected methods
without having to extend the original class.
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.Deprecated, for removal: This API element is subject to removal in a future version.
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.
Deprecated.
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
Defines an event class for the dirty-checking of a session.
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 that occurs in the application's 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.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
Deprecated.
since
Instantiator is deprecatedJavaType for dynamic models
Types which implement this interface will have
ParameterizedType.setParameterValues(Properties) called with an
instance of the class DynamicParameterizedType.ParameterType
instead of the key "org.hibernate.type.ParameterType".ResultBuilder specialization for results added through the Hibernate-specific
NativeQuery result definition methods.DynamicResultBuilder based on a named mapped attribute
A ResultBuilder for explicitly converted scalar results
Standard DynamicResultBuilder for basic values.
An entity-valued DynamicResultBuilder for cases when the user has not supplied
specific column to attribute mappings.
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.
Deprecated, for removal: This API element is subject to removal in a future version.
Replaced by
CollectionPartA
FunctionReturnTypeResolver that resolves the array element type based on an argument.Java type for embeddable aggregates, which allows resolving a recommended
JdbcType.Hibernate extension to the JPA
EmbeddableType contract.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).
Deprecated.
Use
EmbeddableDomainType instead.Deprecated.
implement
Interceptor directlyA
FindOption which requests a named
fetch profile.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
Deprecated, for removal: This API element is subject to removal in a future version.
No direct replacement
Deprecated, for removal: This API element is subject to removal in a future version.
No direct replacement
Deprecated, for removal: This API element is subject to removal in a future version.
No direct replacement
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
Deprecated.
use
AppliedGraph insteadA 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 an entity hierarchy comprised of entity
and mapped-superclass types.
Describes a type's place in the hierarchy relative to the root entity
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.Common interface for all entity mappings (root entity and sub-entity mappings).
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
Deprecated, for removal: This API element is subject to removal in a future version.
Replaced by
EntityMappingType.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.
Metadata about an 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.Deprecated, for removal: This API element is subject to removal in a future version.
Use the built-in support for enums
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.
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.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().Defines an event class for the evicting of an entity.
Defines the contract for handling of evict events generated from a session.
Contract for how CommandAcceptanceException errors should be handled (logged, ignored, etc).
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.Deprecated.
Use
Expectation.RowCount, creating a custom subclass if necessaryDeprecated.
Use
Expectation.OutParameter, creating a custom subclass if necessaryContract 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.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
FetchStyleAny 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
DomainResult instance as part of
the overall mapping of native / procedure query results.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
Provides access to information about the owner/parent of a fetch
in relation to the current "row" being processed.
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.
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.Deprecated.
this class is no longer used
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.Defines an event class for the flushing of a session.
Defines the contract for handling of session flush events.
Represents a flushing strategy.
Enumeration extending the JPA flush modes
with flush modes specific to Hibernate, and a "null" mode,
FlushModeType.PERSISTENCE_CONTEXT,
for use as a default annotation value.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.Deprecated, for removal: This API element is subject to removal in a future version.
use the JPA 2.1
ForeignKey annotationA 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.
Indicates that the associated temporal value should be stored with fractional seconds.
The 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.Deprecated, for removal: This API element is subject to removal in a future version.
Use
FunctionRenderer insteadDescribes the function return for ProcedureCalls that represent calls to
a function (
"{? = call ...} syntax) rather that a proc ({call ...} syntax)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.
Deprecated.
use
EventType and EventTypeSets insteadDeprecated, for removal: This API element is subject to removal in a future version.
Replaced by
EventType as id-generation has been
redefined using the new broader generation
approach.Delegate for defining how to handle the various types of
GenerationType possibilities.A
ServiceLoader contract for registering implementations
of GenerationTypeStrategy.Describes the generation of values of a certain field or property of an entity.
Access to resolve IdentifierGeneratorDefinition instances
Deprecated.
ValueGenerationType and AnnotationValueGeneration
now provide a much more powerful and typesafe alternativeA generic dialect for ANSI-like SQL.
Deprecated.
Use the new approach based on
IdGeneratorType.Global registration of a generic generator
Deprecated.
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.
A container for
AttributeNode references.Helper containing utilities useful for graph handling
Integration version of the
Graph contractThis class provides an empty implementation of
GraphLanguageParserListener,
which can be extended to create a listener which only needs to handle a subset
of the available methods.This class provides an empty implementation of
GraphLanguageParserVisitor,
which can be extended to create a visitor which only needs to handle a subset
of the available methods.This interface defines a complete listener for a parse tree produced by
GraphLanguageParser.This interface defines a complete generic visitor for a parse tree produced
by
GraphLanguageParser.Common operations of
AttributeNode and Graph.Integration version of the
GraphNode contractParser for string representations of JPA
EntityGraph
(RootGraph) and Subgraph (SubGraph),
using a simple syntax defined by the `graph.g` Antlr grammar.Strategies for rendering a constant in a group by.
Strategies for rendering summarization function like rollup and cube in a group by.
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.A SQL dialect for H2.
Identity column support for H2 2+ versions
Specialized type mapping for
JSON that utilizes the custom
'? format json' write expression for H2.A SQL AST translator for H2.
Sequence support for
H2Dialect.Sequence support for
H2Dialect.Deprecated, for removal: This API element is subject to removal in a future version.
use
HANADialect with DatabaseVersion.make( 4 ) insteadDeprecated, for removal: This API element is subject to removal in a future version.
use
HANADialect insteadAn SQL dialect for the SAP HANA Platform and Cloud.
Deprecated, for removal: This API element is subject to removal in a future version.
use
HANADialect insteadSequence support for
AbstractHANADialect.Utility class that extract some initial configuration from the database for
HANADialect.A SQL AST translator for HANA.
Boot-time descriptor of a result set mapping as defined in an
hbm.xml file
either implicitly or explicitlyLogging for HBM transformation
Transforms a JAXB binding of a hbm.xml file into a unified orm.xml representation
Various 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.
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
This class provides an empty implementation of
HqlParserListener,
which can be extended to create a listener which only needs to handle a subset
of the available methods.This class provides an empty implementation of
HqlParserVisitor,
which can be extended to create a visitor which only needs to handle a subset
of the available methods.This interface defines a complete listener for a parse tree produced by
HqlParser.This interface defines a complete generic visitor for a parse tree produced
by
HqlParser.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.
Sequence support for
HSQLDialect.A SQL AST translator for HSQL.
Extension to the JPA
IdentifiableType contract.Metadata about an identifiable type
Common contract between Entity and MappedSuperclass sources.
Models an identifier (name), which may or may not be quoted.
Deprecated, for removal: This API element is subject to removal in a future version.
No direct replacement; see
EntityIdentifierMappingA bag with a generated (surrogate) key.
An enumeration of the way DatabaseMetaData might store and return identifiers
A mapping model object representing a collection with a synthetic "identifier" column,
that is, a surrogate key.
Nothing more than a distinguishing subclass of
Insert used to
indicate intent.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
Contract for a factory of
IdentifierGenerator instances.Factory and helper methods for
IdentifierGenerator framework.Deprecated, for removal: This API element is subject to removal in a future version.
supply a
GenerationTypeStrategyRegistration insteadHelper for handling
Identifier instances.Builder for IdentifierHelper instances.
Loads an entity by its primary identifier.
Deprecated, for removal: This API element is subject to removal in a future version.
No direct replacement; see
EntityIdentifierMappingContract 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.Deprecated.
this class is no longer used
Meta-annotation used to mark another annotation as providing configuration
for a custom identifier generator.
Logging related to IdentifierGeneratorFactory
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.
This enum defines how
Immutable entities are handled when
executing a bulk update statement.Mutability plan for immutable 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.
FetchBuilder used when an explicit mapping was not given
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.
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).
ResultBuilder for handling
NamedNativeQuery.resultClass() when the
class does not refer to an entityContext 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.
Deprecated.
NamingStrategy itself has been deprecatedComparator 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.
Deprecated.
Use
Index instead.A mapping model object representing an index on a relational database table.
Deprecated.
Deprecated.
Use
IndexedBiConsumer insteadIndexed collections include Lists, Maps, arrays and
primitive arrays.
Deprecated.
Use
IndexedConsumer insteadProvides access to information about existing index in the database
Adds an INDEX query hint as follows:
SELECT *
FROM TEST
USE INDEX (hint1, hint2)
WHERE X=1
Descriptor 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.
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.Deprecated.
This is not used anymore in any of the
GeneratedValuesMutationDelegate implementations.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().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
Deprecated.
This contract is no longer used by Hibernate.
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.
The different types of intervals that SQL defines.
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.Maps a discriminator value to its corresponding entity name.
JAXB binding interface for discriminated association based attributes (any and many-to-any)
JAXB binding interface for describing the discriminator of a discriminated association
The key of a
JaxbAnyMapping - the (logical) foreign-key valueDescribes the discriminator of a discriminated association (any, many-to-any),
including the mapping of discriminator values to matching entity name
See `@org.hibernate.annotations.Any`
Describes the "foreign key" of a discriminated association (any, many-to-any).
JAXB binding interface for association attributes (to-one and plural mappings)
JAXB binding interface for commonality between things which contain attributes.
This element contains the entity field or property mappings.
See `@jakarta.persistence.Basic`
See `@jakarta.persistence.Lob`
See `@jakarta.persistence.Temporal`
See `@jakarta.persistence.Enumerated`
See `@jakarta.persistence.Convert`
See `@org.hibernate.annotations.Nationalized`
See `@org.hibernate.annotations.OptimisticLock`
See `@org.hibernate.annotations.AttributeAccessor`
See `@org.hibernate.annotations.Type`
See `@org.hibernate.annotations.JavaType`
See `@org.hibernate.annotations.JdbcType`
See `@org.hibernate.annotations.JdbcTypeCode`
See `@org.hibernate.annotations.Mutability`
See `@org.hibernate.annotations.Immutable`
A model part that is (or can be) basic-valued - JaxbIdImpl, JaxbBasicImpl and
JaxbElementCollectionImpl
Common type for things that can get be bound to a
Binding for
mapping documents.See @org.hibernate.annotations.Cache
Used to specify Hibernate-specific extra control over the caching
of entity and collection state.
public enum CascadeType { ALL, PERSIST, MERGE, REMOVE, REFRESH, DETACH }
Java class for CacheUsageEnum.
Java class for CollectionCacheType complex type.
Java class for ConfigPropertyType complex type.
Java class for EntityCacheType complex type.
Java class for EventListenerGroupType complex type.
Java class for EventListenerType complex type.
Java class for EventTypeEnum.
Java class for anonymous complex type.
Java class for anonymous complex type.
Java class for anonymous complex type.
Java class for anonymous complex type.
Java class for MappingReferenceType complex type.
See `@org.hibernate.annotations.CollectionId`
See `@org.hibernate.annotations.CollectionIdType`
See `@org.hibernate.annotations.CollectionIdJavaType`
See `@org.hibernate.annotations.CollectionIdJdbcType`
See `@org.hibernate.annotations.CollectionIdJdbcTypeCode`
See `@org.hibernate.annotations.CollectionType`
See @CollectionTypeRegistration
Base definition for XSD column mappings
Composition of the aspects of column definition most commonly exposed in XSD "column types"
See `@jakarta.persistence.Column`
See `@org.hibernate.annotations.Comment`
See `@org.hibernate.annotations.Check`
See `@org.hibernate.annotations.ColumnDefault`
See `@org.hibernate.annotations.ColumnTransformer`
Composition of the aspects of column definition for join "column types" exposed in XSD
Composition of the aspects of column definition for standard "column types" exposed in XSD
See @CompositeTypeRegistration
Configuration parameter user-types
See @ConverterRegistration
org.hibernate.annotations.SQLInsert
org.hibernate.annotations.SQLUpdate
org.hibernate.annotations.SQLDelete
org.hibernate.annotations.SQLDeleteAll
Marker interface for database objects
Java class for database-object complex type.
Java class for anonymous complex type.
Java class for database-object-scope complex type.
Mapping of a discriminator value to the corresponding entity-name
Java class for embeddable-attributes complex type.
See `@jakarta.persistence.Embeddable`
See @EmbeddableInstantiatorRegistration
A model part that is (or can be) embeddable-valued (composite) - JaxbEmbeddedIdImpl,
JaxbEmbeddedIdImpl and JaxbElementCollectionImpl
Java class for emptyType complex type.
Defines the settings and mappings for an entity.
Defines an entity listener to be invoked at lifecycle events
for the entities that list this listener.
The entity-mappings element is the root element of a mapping
file.
JAXB binding interface for commonality between entity and mapped-superclass mappings
Java class for fetch-profile complex type.
Java class for anonymous complex type.
Specifies a filter definition.
Used to identify all bind parameters in the condition element
Names a org.hibernate.id.IdentifierGenerator implementation (class attribute)
as well as any configuration information need by the implementation (Hibernate
will pass it the parameters after instantiation).
A discriminated association where the discriminator is part of the
association, not the associated entity (compared to discriminator subclass)
Defines the mapping of a discriminator value to a concrete entity in an any or
any-to-many mapping.
Java class for ArrayType complex type.
Java class for AuxiliaryDatabaseObjectType complex type.
Java class for anonymous complex type.
Java class for BagCollectionType complex type.
Type definition that acts as a base for concrete definitions of mapped
attributes that can function as the basis of optimistic locking.
Java class for BasicAttributeType complex type.
Declares the element type of a collection where the element is of basic type
Java class for CacheInclusionEnum.
Java class for CacheType complex type.
Java class for ClassRenameType complex type.
Java class for CollectionIdType complex type.
The column element is an alternative to column attributes and required for
mapping associations to classes with composite ids.
A component is a user-defined class, persisted along with its containing entity
to the table of the entity class.
A composite element allows a collection to hold instances of an arbitrary
class, without the requirement of joining to an entity table.
A composite key may be modelled by a java class with a property for each
key column.
Describes the key of a java.util.Map which is a composite.
A property embedded in a composite identifier or map index (always not-null).
A many-to-one association embedded in a composite identifier or map index
(always not-null, never cascade).
Java class for ConfigParameterContainer complex type.
Java class for ConfigParameterType complex type.
Java class for CustomSqlDmlType complex type.
Java class for DialectScopeType complex type.
Subclass declarations are nested beneath the root class declaration to achieve
polymorphic persistence with the table-per-hierarchy mapping strategy.
A dynamic-component maps columns of the database entity to a java.util.Map
at the Java level
Java class for EntityBaseDefinition complex type.
Polymorphic data requires a column holding a class discriminator value.
Java class for FetchProfileType complex type.
Java class for anonymous complex type.
Java class for FetchStyleEnum.
Java class for FetchStyleWithSubselectEnum.
Java class for filter-alias-mapping-type complex type.
Java class for FilterDefinitionType complex type.
Applies a filter defined by hbm-filter-def usage
Java class for anonymous complex type.
Java class for FilterParameterType complex type.
FILTER element; used to apply a filter.
Generators generate unique identifiers.
Java class for anonymous complex type.
Java class for IdBagCollectionType complex type.
Java class for IdentifierGeneratorDefinitionType complex type.
Java class for index-many-to-any-type complex type.
Describes the key of a java.util.Map which is an FK-association.
Describes the index of an indexed collection.
Joined subclasses are used for the normalized table-per-subclass mapping strategy
See the note on the class element regarding
Declares the column name of a foreign key.
Java class for LazyEnum.
Java class for LazyWithExtraEnum.
Java class for LazyWithNoProxyEnum.
Java class for ListIndexType complex type.
Java class for ListType complex type.
The loader element allows specification of a named query to be used for fetching
an entity or collection
A "many to any" defines a polymorphic association to any table
with the given identifier type.
Java class for ManyToManyCollectionElementType complex type.
Java class for ManyToOneType complex type.
Describes the key of a java.util.Map where the key is a basic (JPA term) type
Describes the key of a java.util.Map where the key is a composite type
Describes the key of a java.util.Map where the key is an association (FK)
Java class for MapType complex type.
Java class for multi-tenancy-type complex type.
The sql-query element declares a named SQL query string
Java class for NamedQueryType complex type.
Java class for NativeQueryCollectionLoadReturnType complex type.
Java class for NativeQueryJoinReturnType complex type.
Java class for NativeQueryPropertyReturnType complex type.
Java class for anonymous complex type.
Defines a return component for a sql-query.
Java class for anonymous complex type.
Java class for NativeQueryScalarReturnType complex type.
Java class for NaturalIdCacheType complex type.
A natural-id element allows declaration of the unique business key
Java class for nested-composite-element-type complex type.
Java class for NotFoundEnum.
Java class for OnDeleteEnum.
Java class for OneToManyCollectionElementType complex type.
Java class for OneToOneType complex type.
Java class for OuterJoinEnum.
The parent element maps a property of the component class as a pointer back to
the owning entity.
Java class for PolymorphismEnum.
Java class for PrimitiveArrayType complex type.
properties declares that the contained properties form an alternate key.
The query-param element is used only by tools that generate
finder methods for named queries
The resultset element declares a named resultset mapping definition for SQL queries
Root entity mapping.
A join allows some properties of a class to be persisted to a second table
Java class for SetType complex type.
Declares the id type, column and generation algorithm for an entity class.
Java class for SubclassEntityBaseDefinition complex type.
Java class for synchronize-type complex type.
Optimistic locking attribute based on a (last-updated) timestamp.
Java class for TimestampSourceEnum.
Describes an XSD base type for any complex type that can contain "tooling hints".
<meta.../> is used to assign meta-level attributes to a class
or property.
TUPLIZER element; defines tuplizer to use for a component/entity for a given entity-mode
Java class for TypeDefinitionType complex type.
Declares the type of the containing property (overrides an eventually existing type
attribute of the property).
Union subclasses are used for the table-per-concrete-class mapping strategy
See the note on the class element regarding
Java class for UnsavedValueCompositeIdEnum.
Java class for UnsavedValueTimestampEnum.
Java class for UnsavedValueVersionEnum.
Optimistic locking attribute based on an incrementing value.
Java class for hql-import complex type.
See @JavaTypeRegistration
See @JdbcTypeRegistration
JAXB binding interface for lifecycle callbacks.
JAXB binding interface for commonality between things which
allow callback declarations.
Non-id, non-version singular attribute
Common interface for JAXB bindings representing entities, mapped-superclasses and embeddables (JPA collective
calls these "managed types" in terms of its Metamodel api).
Defines the settings and mappings for a mapped superclass.
See `@org.hibernate.annotations.TenantId`
See `@org.hibernate.annotations.Nationalized`
JAXB binding interface for natural-id definitions
See `@org.hibernate.annotations.NaturalId`
Java class for anonymous complex type.
Configuration of a persistence unit.
Java class for anonymous complex type.
Java class for anonymous complex type.
These defaults are applied to the persistence unit as a whole
unless they are overridden by local annotation or XML
element settings.
Metadata that applies to the persistence unit and not just to
the mapping file in which it is contained.
Common interface for JAXB bindings that represent persistent attributes.
See `@org.hibernate.annotations.ManyToAny`
Java class for anonymous complex type.
JAXB binding interface for plural attributes
Java class for plural-fetch-mode.
Models a named query hint in the JAXB model
Used only by tools to generate finder methods for named queries
Common interface for JAXB bindings that understand database schema (tables, sequences, etc).
See `@jakarta.persistence.SecondaryTable`
See `@org.hibernate.annotations.SecondaryRow`
Java class for singular-fetch-mode.
Commonality between non-id, non-version and non-embedded.
Java class for synchronized-table complex type.
See `@org.hibernate.annotations.TenantId`
See `@org.hibernate.annotations.Type`
See @TypeRegistration
See `@org.hibernate.annotations.UuidGenerator`
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.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 flushes
Deprecated, for removal: This API element is subject to removal in a future version.
It is no longer possible to plug custom implementations
of this SPI.
A 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.Implementation of JdbcValuesMapping for native / procedure queries
Producer for JdbcValuesMapping references.
Pluggable contract for providing custom
JdbcValuesMappingProducer implementations.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.
Descriptors for JPA annotations
BasicValueConverter extension for AttributeConverter-specific supportAccess to information that implementors of
ConverterDescriptor.createJpaAttributeConverter(org.hibernate.boot.model.convert.spi.JpaAttributeConverterCreationContext) might
needDefines an event listener that is sensitive to whether a native or jpa bootstrap was performed
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.
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 contractEnumerates 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.Hibernate extension to the Jakarta Persistence
Tuple
contractAPI 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
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 and the JSON SQL data type.A Helper for serializing and deserializing JSON, based on an
EmbeddableMappingType.Specialized type mapping for
JSON and the JSON SQL data type.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
Deprecated.
Use the JPA-defined
FetchType.EAGER
instead of LazyCollection(FALSE).Deprecated.
Use the JPA-defined
FetchType.EAGER
instead of LazyCollection(FALSE).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.
Deprecated.
use JPA annotations to specify the
FetchTypeA
LimitHandler for DB2.Deprecated.
use
DB2SequenceSupportContract for handling Hibernate's legacy way of representing fetches through
NativeQuery.addFetch(java.lang.String, java.lang.String, java.lang.String), NativeQuery.addJoin(java.lang.String, java.lang.String),
`hbm.xml` mappings, etcSlight variation from
HiLoOptimizer, maintaining compatibility with the values generated by the
legacy Hibernate hilo based generators.A
LimitHandler for HSQL prior to 2.0.Naming strategy which implements the behavior of older versions of
Hibernate, for the most part.
A
LimitHandler for Oracle prior to 12c, which uses ROWNUM.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.
Provides callbacks from the
Session to the persistent object.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.
Pluggable contract for consuming literals encountered in an HQL query.
Common details for things that can be loaded by a loader - generally
entities and
plural attributes (collections).
Deprecated, for removal: This API element is subject to removal in a future version.
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.
Deprecated, for removal: This API element is subject to removal in a future version.
Now modeled through
EntityHolderCentralize 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.A help for dealing with BLOB and CLOB data
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().Deprecated, for removal: This API element is subject to removal in a future version.
A
JDBCException indicating a problem acquiring a lock
on the database.Defines an event class for the locking of an entity.
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.
Contains a set of options describing how a row of a database table
mapped by an entity should be locked.
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.Hibernate's 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.Processes a ManagedResources (classes, mapping, etc.) and
produces a categorized domain model
Metadata about a managed type
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.
Conversion of discriminator values between the entity name/Class domain form and
its generally CHARACTER or INTEGER based relational form
A mapping model object representing a mapped superclass
of an entity class.
Extension of the JPA
MappedSuperclassType contractMetadata about a mapped-superclass
Hibernate extension to the JPA
MapAttribute descriptorDeprecated.
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
MapsIdDeprecated.
use
MariaDBDialect(1060)A SQL dialect for MariaDB 10.3 and above.
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.An event class for merge() and saveOrUpdateCopy()
Defines the contract for handling of merge events generated from a session.
JdbcMutation implementation for MERGE handling
MessageHelper 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.Deprecated.
Prefer
JpaMetamodelDeprecated.
Use
MappingMetamodel or
JpaMetamodel
instead.Deprecated, for removal: This API element is subject to removal in a future version.
The functionality of MetaType,
DiscriminatorType and DiscriminatorMetadata have been
consolidated into EntityDiscriminatorMapping and DiscriminatorConverterMost 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
todo : find the proper min/max id range
Contextual information used while building ManagedTypeMetadata and friends.
todo : find the proper min/max id range
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
ResultBuilder or FetchBuilder that refers to some part
of the user's domain modelA 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 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.
Deprecated.
use
MySQLDialect(800)A SQL dialect for MySQL 5.7 and above.
Represents an
enum type on MySQL.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 impls that can be converted to a named query memento to be
stored in the
NamedObjectRepositoryMainly this is used to support legacy sequence exporting.
Represents a "memento" (disconnected, externalizable form) of a ProcedureCall
Models a @NamedEntityGraph
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.
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.
Deprecated, for removal: This API element is subject to removal in a future version.
ImplicitNamingStrategy
and PhysicalNamingStrategy should
be used instead.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.
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 for handling List results from native queries.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.Commonality for non-scalar root returns for a native query result mapping
Specialization of
QueryPlan for NativeQuery
plansShared contract between the various types of returns definable in HBM.
A
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.
Details about caching related to the natural-id of an entity
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.
Effectively a tri-function
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 java.sql.NClob instances..
Descriptor for
NClob handling.Descriptor for
NCLOB handling.Manages aspects of proxying java.sql.NClobs for non-contextual creation, including proxy creation and
handling proxy invocations.
Sequence support for dialects which support the common
Oracle-style syntax
seqname.nextval.Deprecated.
this class is no longer used
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
CompositeIdMapping which is virtually an embeddable and represented by one-or-more
id-attributes identified by one-or-more
@Id
annotations.Defines handling and filtering for all non-class file (package-info is also a class file...) entries within an archive
LobCreator implementation using non-contextual or local creation, meaning that we generate the LOB
references ourselves as opposed to delegating to the JDBC Connection.Additional optional contract for connection observers to indicate that
they should be released when the physical connection is released.
Deprecated, for removal: This API element is subject to removal in a future version.
No direct replacement
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.
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.
This object contains factory methods for each
Java content interface and Java element interface
generated in the org.hibernate.boot.jaxb.cfg.spi package.
This object contains factory methods for each
Java content interface and Java element interface
generated in the org.hibernate.boot.jaxb.configuration.spi package.
This object contains factory methods for each
Java content interface and Java element interface
generated in the org.hibernate.boot.jaxb.hbm.spi package.
This object contains factory methods for each
Java content interface and Java element interface
generated in the org.hibernate.boot.jaxb.mapping.spi package.
Descriptor for binding objects using any JDBC type code.
Provides centralized normalization of how database object names are handled.
Thrown when
EntityManager.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.
Deprecated, for removal: This API element is subject to removal in a future version.
no longer used, use
GetGeneratedKeysDelegate insteadA
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 11g Release 2 and above.
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.
Specialized type mapping for
JSON and the BLOB SQL data type for Oracle.Specialized type mapping for
JSON and the JSON SQL data type for Oracle.Descriptor for
ARRAY handling.Factory for
OracleNestedTableJdbcType.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.
A rule for sorting a query result set.
Contact to define if a plural attribute source is orderable or not.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
SQLOrder instead.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
This class provides an empty implementation of
OrderingParserListener,
which can be extended to create a listener which only needs to handle a subset
of the available methods.This class provides an empty implementation of
OrderingParserVisitor,
which can be extended to create a visitor which only needs to handle a subset
of the available methods.This interface defines a complete listener for a parse tree produced by
OrderingParser.This interface defines a complete generic visitor for a parse tree produced
by
OrderingParser.An individual sort specification in an order-by fragment
Descriptor regarding an ordinal parameter.
Describes the origin of an XML document.
Deprecated, for removal: This API element is subject to removal in a future version.
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).
Defines handling and filtering for package-info file entries within an archive
Identifies a page of query results by page size
and page number.
Details about a parameter declared in a
FilterDef.Generic parameter (basically a key/value combination) 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.
Access to known information about the parameters for 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
Deprecated, for removal: This API element is subject to removal in a future version.
No longer used
Internal in-flight representation of a recognized named parameter
Internal in-flight representation of a recognized named parameter
Internal in-flight representation of a recognized named parameter
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.
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
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
Deprecated.
NamingStrategy itself has been deprecatedAbstraction for dealing with either
<persistence-unit/> information whether that comes from
an EE container in the form of PersistenceUnitInfo or in an SE environment
where Hibernate has parsed the persistence.xml file 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.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
Contract responsible for resolving the members that identify the persistent
attributes for a given class descriptor representing a managed type.
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.
Deprecated.
Use
RuntimeModelCreationContext insteadContract for creating persister instances (both
EntityPersister and CollectionPersister varieties).An event class for persist()
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 a lock is obtained via a
select statements.
A pessimistic locking strategy where a lock is obtained via
an update statement.
A pessimistic locking strategy where a 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.
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".
Commonality between the various forms of plural attribute (collection) mappings:
<bag/>, <set/>, etc.Adaptive implementation of the
PluralAttributeInfo for <idbag/> mappings which
do not support all the configuration available on other collection mappings.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.Deprecated.
Like
Instantiator itself, deprecated.Deprecated.
This annotation is hardly ever useful.
Deprecated.
since
Polymorphism is deprecatedVariation 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.
PostgreSQL variant of the function.
PostgreSQL variant of the function.
PostgreSQL array_trim emulation, since the function was only introduced in version 14.
A SQL dialect for PostgreSQL 11 and above.
Represents a named
enum type on PostgreSQL.PostgreSQL doesn't support min/max for uuid yet,
but since that type is comparable we want to support this operation.
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)
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.Deprecated, for removal: This API element is subject to removal in a future version.
Use
EntityPersister instead.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
Called 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.
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
store 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.
Deprecated, for removal: This API element is subject to removal in a future version.
No direct replacement
Deprecated.
This is replaced by
ValueGeneration and
GenerationTiming, and is no longer usedDeprecated, for removal: This API element is subject to removal in a future version.
This interface is obsolete
Indicates that an expected getter or setter method could not be
found on a class.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
NavigablePath or NavigableRole
instead, depending on need.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.Deprecated.
This annotation is almost never useful.
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.
Deprecated.
Use
EntityMappingType
insteadDeprecated, for removal: This API element is subject to removal in a future version.
Given the mapping-model and SQM, this contract is no longer needed.
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.
Contract defining how query hints get applied.
Deprecated.
Use
AvailableHints insteadDeprecated.
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
Contract for things that can produce instances of
Query and NativeQuery.The internal contract for QueryProducer implementations.
Responsible for managing query result list caching in a specific
query cache region.
Defines the contract for a cache region that stores query results.
Deprecated.
This helper class is no longer used
Statistics relating to a particular query written in HQL or SQL.
Thrown when a database query timeout occurs.
Indicates a mismatch between the expected and actual result types of a query.
Exposes a
Reader as an InputStream.A
FindOption which requests that
entities be loaded in ReadOnlyMode.READ_ONLY mode or in regular
ReadOnlyMode.READ_WRITE mode.Deprecated.
use
FloatJdbcTypeDeprecated.
Was only ever referenced in a single place, in an extremely dubious way.
Contract 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.Defines an event class for the refreshing of an 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.Defines an event class for the replication of an entity.
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.
Defines an event class for the resolving of an entity id from the entity's natural-id
Defines the contract for handling of resolve natural id events generated from a session.
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
Specialized TableMutation implementation for mutations which
define a where-clause
Specialized
TableMutationBuilder implementation for building mutations
which have a where clause.A restriction (predicate) to be applied to a query
Responsible for building a single
DomainResult instance as part of
the overall mapping of native / procedure query results.Nominal extension to ResultBuilder for cases involving scalar results
Specialization of ResultBuilder for building an EntityResult
Nominal extension to ResultBuilder for cases involving dynamic-instantiation results
Deprecated.
Use an
Expectation class instead.Defines how we need to reference columns in the group-by, having, and order-by
clauses.
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 ScrollableResultsDeprecated, for removal: This API element is subject to removal in a future version.
this interface is unnecessary and no longer used
Acts as the
JdbcValuesMappingProducer for NativeQuery
or ProcedureCall / StoredProcedureQuery
instances.SqlSelection used in
ResultSetMapping resolution.Models a return that is a result set.
Deprecated.
Use
TupleTransformer and/or ResultListTransformer insteadSpecialization of DomainType 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.
Deprecated.
No longer used
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.An event class for saveOrUpdate()
Deprecated.
since
Session.saveOrUpdate(java.lang.Object) and friends are deprecatedDescribes 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.
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
Defines the possible values for "hibernate.hbm2ddl.auto".
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.Contract for resolving the schema of a
Connection.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.Common interface for mappings that may contain secondary table (join) mappings.
Hibernate builds its build-time model
incrementally, often delaying operations until other pieces of information
are available.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
SecondPass insteadConsumer 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.
Deprecated.
Since
Session.update(Object) is deprecatedThe 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.Strategies for referring to a select item.
A locking strategy where a 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
Deprecated.
this is no longer used
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 java.sql.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.
Deprecated.
simply construct a
LockOptions and pass
it to Session.lock(Object, LockOptions).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 number 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.Deprecated, for removal: This API element is subject to removal in a future version.
this is no longer used
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 descriptorThe 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 datatype.
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.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.
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.
From what type of source did we obtain the data
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.
Deprecated, for removal: This API element is subject to removal in a future version.
Deprecated.
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
This class provides an empty implementation of
SqlScriptParserListener,
which can be extended to create a listener which only needs to handle a subset
of the available methods.This class provides an empty implementation of
SqlScriptParserVisitor,
which can be extended to create a visitor which only needs to handle a subset
of the available methods.This interface defines a complete listener for a parse tree produced by
SqlScriptParser.This interface defines a complete generic visitor for a parse tree produced
by
SqlScriptParser.Specifies a custom SQL query to be used in place of the default SQL
generated by Hibernate when an entity or collection is loaded from the
database by id.
Represents a selection that is "re-used" in certain parts of the query
other than the select-clause (mainly important for order-by, group-by and
having).
Deprecated.
use
SQLServerDialect(11)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.Deprecated.
use
SQLServerDialect(13)Custom
TruncFunction for SQL Server versions before 16,
which uses the custom SqlServerConvertTruncFunction.DateTruncConvertEmulationA dialect for Microsoft SQL Server 2008 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.
Sequence support for
SQLServerDialect.A SQL AST translator for SQL Server.
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.
Base exception type for problems building a SQL tree.
Logs a debug representation of the SQL AST.
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.
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 (think SessionFactory).
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>)).Represents a literal value in the sqm, e.g.
1
'some string'
some.JavaClass.CONSTANT
some.JavaEnum.VALUE
etc
Represents an 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.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.
Informational - used to identify the source of an SQM statement.
Defines the commonality between a root query and a subquery.
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.
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
A 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.
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
BasicTypeReference instancesA 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.
Marker interface for Hibernate-provided implementations of
Generator.The standard implicit naming strategy
for identifier sequences and tables.
Enumeration of the standard Hibernate id generation optimizers.
Deprecated, for removal: This API element is subject to removal in a future version.
Replaced by
AttributeMappingImplements 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
particular
SessionFactory.Factory for custom implementations of
StatisticsImplementor.A service SPI for collecting statistics about various events that occur 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.
Common interface for all sub-entity mappings.
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
Indicates that a package or top-level type should be ignored
by the Hibernate annotation processor.
A SQL dialect for Sybase Adaptive Server Enterprise 16 and above.
A SQL AST translator for Sybase ASE.
Superclass for all Sybase dialects.
Specialized
IdentifierGeneratingInsert 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.
Deprecated, for removal: This API element is subject to removal in a future version.
The options available here are all now offered by other newer and better-designed
annotations in this package.
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 TableGroupsA TableGroup created with regards to a SQL ResultSet mapping
Marker 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
Common interface for all mappings that contain relational table information
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
Describes the mutation of a model table (mapped by an entity or collection)
triggered from flush.
Generalized contract for building
TableMutation instancesMarker for things which can "own" a table
Optional contract implemented by some subtypes of
PersistentClass.Following the ANSI SQL "table reference" rule, will be one of
a physical table
a secondary table
a physical view
a in-line view
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.Deprecated, for removal: This API element is subject to removal in a future version.
since
Table is deprecatedRepresents 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
Deprecated.
use annotation members of JPA association mapping
annotations, for example,
OneToMany.targetEntity()Describes the target(s) of schema create, drop and migrate actions.
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.
Enum describing how creation and dropping of temporary tables should be done in terms of
transaction handling.
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)
A SQL dialect for TiDB.
Sequence support for
TiDBDialect.A SQL AST translator for TiDB.
Descriptor for
TIMESTAMP_WITH_TIMEZONE handling.Descriptor for
TIME handling.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.Deprecated.
This style of generation has been replaced by
org.hibernate.generatorDescriptor 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 deprecatedContract for JAXB bindings which are containers of tooling hints.
Represents a collection of "tooling hints" (
<meta/> mapping info) keyed by a name.Indicates that more rows were affected then 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 to are specific to each
TransactionCoordinator instance.Models an owner of a
TransactionCoordinator.Indicates that a transaction could not be begun, committed
or rolled back.
Defines the "internal contract" for an implementation of
Transaction.Thrown when user code causes the end of a transaction that is
being managed by the
SessionFactory.Deprecated.
Observer of internal transaction events.
Indicates a call to
TransactionCoordinator.explicitJoin() that requires an
active transaction where there currently is none.Enumeration 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).Handles conversion to/from
Boolean as 'T' or 'F'Custom function that manages both numeric and datetime truncation
An enumeration of truth values.
Describes any structural type without a direct java type representation.
Deprecated.
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.
BeanInstanceProducer implementation for building beans related to custom types.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.
Deprecated.
no longer used
Models the information pertaining to a custom type definition supplied by the user.
Basic implementation of
TypeDefinitionRegistry.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.
Models type info extracted from
DatabaseMetaData.getTypeInfo()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.
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.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
Deprecated.
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.
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.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.
The base contract for determining transient status versus detached status.
Unstructured CacheEntry format (used to store entities and collections).
How to handle features in the transformed `hbm.xml` which are not supported
in the `mapping.xml` XSD
This exception is thrown when an invalid
LockMode is selected for an entity.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.
Deprecated.
use
CurrentTimestampGenerationContains an aggregated analysis of the values for an update mutation
to determine behavior such as skipping tables which contained no changes,
etc.
JdbcMutation implementation for UPSERT handling
Descriptor for
URL handling.A custom type for mapping user-written classes which implement
PersistentCollection.Handles
CompositeUserTypes.A mapping model object representing a relational database UDT.
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.
Generates
UUIDs.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.Duplicates the jakarta.validation enum (because javax validation might not be on the runtime classpath)
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
At the end of the day, any "value mapping" (id, version, attribute, collection element, etc.)
can be one of a few classifications.
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.Deprecated, for removal: This API element is subject to removal in a future version.
Replaced by
GeneratorMeta-annotation used to mark another annotation as providing configuration
for a custom value generation strategy.
Deprecated, for removal: This API element is subject to removal in a future version.
Replaced by
GeneratorThis 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.
Deprecated, for removal: This API element is subject to removal in a future version.
Replaced by
EntityVersionMappingA 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.
Deprecated.
since
GeneratorType is deprecatedDeprecated.
Use
SQLRestrictionDeprecated.
Things which can have
Where
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.
Specialized type mapping for
SQLXML and the XML SQL data type.Context for a specific XML mapping file
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.
Performs pre-processing across XML mappings to collect data
that makes additional steps easier and more efficient
Collected XML override mappings we can apply wholesale after
processing metadata-complete mappings and annotations.
Tuple of an override descriptor (
managedType) along with the JAXB root it came fromProcesses XML mappings - applying metadata-complete mappings and collecting
override mappings for later processing.
Generally indicates a problem locating an XML resource
An XML document containing O/R mapping metadata, either:
a JPA
orm.xml file, or
a Hibernate .hbm.xml file.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.