All Classes and Interfaces
Class
Description
Used in mapping dynamic models to signify that an entity should be considered abstract.
Base support for ArchiveDescriptor implementors.
Encapsulates the validator, return type and argument type resolvers for the array_contains function.
Encapsulates the validator, return type and argument type resolvers for the array_contains function.
Encapsulates the validator, return type and argument type resolvers for the array_includes function.
Encapsulates the validator, return type and argument type resolvers for the array_intersects function.
Encapsulates the validator, return type and argument type resolvers for the array_position functions.
Encapsulates the validator, return type and argument type resolvers for the array_positions functions.
Encapsulates the validator, return type and argument type resolvers for the array_remove functions.
Encapsulates the validator, return type and argument type resolvers for the array_remove functions.
Models the commonality of the JPA
Attribute hierarchy.Deprecated, for removal: This API element is subject to removal in a future version.
No direct replacement.
AbstractAuditAssociationQuery<Q extends org.hibernate.envers.query.internal.impl.AuditQueryImplementor>
An abstract base class for all
AuditAssociationQuery implementations.Convenience base class for
AuxiliaryDatabaseObjects.AbstractBatchEntitySelectFetchInitializer<Data extends AbstractBatchEntitySelectFetchInitializer.AbstractBatchEntitySelectFetchInitializerData>
Type Descriptor for the Postgis Geometry type
Abstract adapter for
Java type descriptors.Defines a base class for events involving collections.
Base support for CollectionInitializer implementations
Initializes a persistent collection.
Abstract base class for various collection-based metadata generators.
Base implementation of the
QueryableCollection interface.Base implementation for composite identifier mappings
An abstract identifier mapper implementation specific for composite identifiers.
Deprecated, for removal: This API element is subject to removal in a future version.
No direct replacement
Defines how identifier values are selected from the updatable/deletable tables.
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.
Abstract SqmPathSource implementation for discriminators
Optional interface caching implementors can implement in their
CachedDomainDataAccess impls to automatically have them destroyed
when this region is destroyed
Convenience base class test domain models based on annotated classes
Base support for dynamic-map instantiators
Base support for EmbeddableMappingType implementations
Deprecated, for removal: This API element is subject to removal in a future version.
No direct replacement
Base support for EntityCollectionPart implementations
A base implementation of
EntityEntry.Represents a boolean flag stored within a number value, using one bit at a specified offset.
Represents an enum value stored within a number value, using four bits starting at a specified offset.
Template support for IdGeneratorResolver implementations dealing with entity identifiers
A base class for entity insert actions.
Base support for instantiating entity values as POJO representation
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 Serializable form for field (used as Getter or Setter)
A convenience base class for listeners whose functionality results in flushing.
Base class for any and all source objects coming from
hbm.xml parsing.Functionality common to all implementations of
IdentifiableType.Base abstract implementation of
Identifier.The base abstract class implementation for identifier mappers.
AbstractImmediateCollectionInitializer<Data extends AbstractImmediateCollectionInitializer.ImmediateCollectionInitializerData>
Base support for CollectionInitializer implementations that represent
an immediate initialization of some sort (join, select, batch, sub-select)
for a persistent collection.
Abstract adapter for Java type descriptors.
Abstract
JdbcLiteralFormatter implementation managing the JavaTypeExecutable JDBC command
Base support for JdbcInsertMutation implementations
Base support for
JpaSelection impls.Base support for
JpaTupleElement implsStandard json_array_append function.
Standard json_array_insert function.
Standard json_insert function.
Standard json_mergepatch function.
Standard json_remove function.
Standard json_replace function.
Standard json_set function.
Convenience base class for lazy initialization handlers.
Default implementation of
LimitHandler interface.Convenient base class for proxy-based
LobCreator for handling wrapping.Base support for
LogicalConnection implementationsFunctionality common to all implementations of
ManagedType.A base class for all entity mapper implementations.
Abstract base class for all metadata generator implementations.
An abstract base class for all middle component mappers.
Base support for
MultiIdEntityLoader implementations.Basic support for
MultiTenantConnectionProvider implementations using
an individual ConnectionProvider instance per tenant behind the scenes.Base support for coordinating mutations against an entity
Base support for
MutationExecutor implementationsBase support for
NaturalIdLoader implementationsDeprecated, for removal: This API element is subject to removal in a future version.
No direct replacement.
AbstractNonJoinCollectionInitializer<Data extends AbstractCollectionInitializer.CollectionInitializerData>
Base support for CollectionInitializer implementations that don't join data
Superclass for
LimitHandlers that don't support
offsets at all.Template class for property mappers that manage one-to-one relation.
Common support for
Optimizer implementations.Base support for DialectOverrider annotations
Base class implementing
PersistentCollectionContract for operations which are part of a collection's operation queue.
TBH not sure why this is public
Base support for POJO-based instantiation
Type Descriptor for the Postgis Geometry type
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.
Abstract implementation of a
PropertyMapper.Wrapper type representing unlocked items.
Interface type implemented by all wrapper objects in the cache.
Wrapper type representing locked items.
Base class for implementers of
RelationQueryGenerator contract.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.A convenience base class for listeners responding to save events.
Base implementation of
SchemaMigrator.Base implementation of
SchemaValidator.Convenience base class for ScriptSourceInput implementations
Base implementation of the ScrollableResults interface intended for sharing between
ScrollableResultsImpl and FetchingScrollableResultsImplAbstract
GeneratedValuesMutationDelegate implementation where
the underlying strategy requires a subsequent select after the
insert to determine the generated identifier.Base
LockingStrategy implementation to support implementations
based on issuing SQL SELECT statements.Convenience base class for the serialized form of
AbstractLazyInitializer.Basic implementation of the
ServiceRegistry and ServiceRegistryImplementor contracts.Base Serializable form for setter methods
Base class for implementations of
SharedSessionContract and
SharedSessionContractImplementor.Superclass for simple
LimitHandlers that don't
support specifying an offset without a limit.TODO : javadoc
Common base class for
<component/> and <composite-id/> mappings.A simple walker that checks for aggregate functions.
Type descriptor for the SQL Server 2008 Geometry type.
Models a join based on a mapped attribute reference.
Convenience base class for SqmFrom implementations
Convenience base class for InsertSqmStatement implementations.
Base class for expressions that contain a json path.
Base implementation of a criteria node.
Common support for SqmParameter impls
Base support for joins to plural attributes
Convenience base class for
BasicType implementations.Base support for TableInsertBuilder implementations
Base
TableMutation supportBase support for TableMutationBuilder implementations
Base support for TableUpdate implementations
Base support for TableUpdateBuilder implementations
Base class for property mappers that manage to-one relation.
Simple descriptor of an entity.
An abstract base class for Sybase and MS SQL Server dialects.
Abstract superclass of the built-in
Type hierarchy.Deprecated.
since
UUIDHexGenerator is deprecatedAbstract superclass of algorithms that walk
a tree of property values of an entity, and
perform specific functionality for collections,
components and associated entities.
An abstract implementation of
Work that accepts a WorkExecutor
visitor for executing a discrete piece of work.Contract for providing callback access to a
DatabaseStructure,
typically from the Optimizer.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
determinedEncapsulates the access type information for a single class.
JAXB marshalling for JPA's
AccessTypeEnumerates 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.
Deprecated, for removal: This API element is subject to removal in a future version.
Use JUnit 5 along with one of the Hibernate ORM's class-level test annotations
(
BaseUnitTest,
SessionFactory,
Jpa,
SessionFactoryFunctionalTesting,
ServiceRegistryFunctionalTesting, ...)
and AfterAll.An action to be performed after an entity has been loaded.
Contract representing some process that needs to occur during after transaction completion.
Actions to perform in regard to a temporary table after each use.
An aggregate column is a column of type
SqlTypes.STRUCT,
SqlTypes.JSON or SqlTypes.SQLXML
that aggregates a component into a single column.Handler for assignments to sub-columns of an aggregate column, which require a special write expression.
Processes aggregate component annotations from Java classes and produces the Hibernate configuration-time metamodel,
that is, the objects defined in the package
org.hibernate.mapping.An "aggregated" composite identifier, which is another way to say that the
identifier is represented as an embeddable.
A Fetch for an embeddable that is mapped as aggregate e.g.
An initializer for an embeddable that is mapped as aggregate e.g.
Specialized EmbeddableResultGraphNode for cases where we have an actual embeddable class.
A Result for an embeddable that is mapped as aggregate e.g.
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.
ConnectionProvider based on Agroal connection pool
To use this ConnectionProvider set:
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 deprecatedUsed to indicate to the Forbidden APIs library that a specific usage
of
Throwable.printStackTrace(PrintStream) is allowable.Used to indicate to the Forbidden APIs library that a specific usage
of
System.out is allowable.A
UniqueDelegate which uses alter table commands to create and drop
the unique constraint.A
UniqueDelegate which uses create unique index commands when necessary.Type of annotation of a class will give its type
A mapping to a column, logically representing a
Column annotation, but not
every instance corresponds to an explicit annotation in
the Java code.A list of columns that are mapped to a single Java property
or field.
A
DiscriminatorColumn annotationAn element of a join condition, logically representing a
JoinColumn annotation, but not
every instance corresponds to an explicit annotation in the
Java code.A list of
JoinColumns that form a single join
condition, similar in concept to JoinColumns,
but not every instance of this class corresponds to an explicit annotation
in the Java code.A
Generator which receives parameters from a custom
generator annotation or
id generator annotation.Reads annotations from Java classes and produces the Hibernate configuration-time metamodel,
that is, the objects defined in the package
org.hibernate.mapping.An exception that occurs while reading mapping annotations.
Captures all information about an annotated persistent attribute.
Class used to collect meta information about an annotated type (entity, embeddable or mapped superclass).
Class used to collect meta information about an annotated package.
A helper class to read versioning meta-data from annotations on a persistent class.
The 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.
The discriminator Value
A simplified way to specify the type of the discriminator in an
Any
mapping, using the JPA-defined DiscriminatorType.Defines how to handle discriminator values which are not explicitly
mapped with AnyDiscriminatorValue.
Acts as a ModelPart for the discriminator portion of an any-valued mapping
Source information about the discriminator for an ANY mapping
SqmPathSource implementation for AnyDiscriminatorSpecifies 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.Acts as a ModelPart for the key portion of an any-valued mapping
A means to pass along the String type name from the mapping xml.
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
Helper for dealing with archives
Specialized QueryResultAssembler for use as a "reader" for dynamic-
instantiation arguments.
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.Implementation of
BinaryStream backed by a byte[] array.Initializes a map.
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.Given a
BasicValueConverter for array elements, handles conversion
to and from an array of the converted element type.Implement the array get function by using
unnest.A
FunctionArgumentTypeResolver that resolves the argument types for the array_includes function.A
ArgumentsValidator that validates the arguments for the array_includes function.Special array includes implementation that uses the PostgreSQL
@> operator.Implement the array includes function by using
unnest.Array intersects function that uses the PostgreSQL
&& operator.Implement the intersects function by using
unnest.Descriptor for
T[] handling.Descriptor for
ARRAY handling.Factory for
ArrayJdbcType.A mutability plan for arrays.
Implement the array remove index function by using
unnest.Implement the array replace function by using
unnest.Implement the array set function by using
unnest.Implement the array slice function by using
unnest.A
ArgumentsValidator that validates all arguments are of the same array type.A type for persistent arrays.
A
FunctionReturnTypeResolver that resolves the array type based on an argument.A
FunctionReturnTypeResolver that resolves an array type based on the arguments,
which are supposed to be of the element type.Indicates failure of an assertion: a possible bug in Hibernate.
A
Generator that doesn't generate.Deprecated, for removal: This API element is subject to removal in a future version.
replaced by
AssignedIdentifies the association referenced by a
Fetch.Commonality for an association, mainly details relative to the foreign-key
Identifies a named association belonging to a particular
entity instance.
Used as part of circularity detection
A type that represents some kind of association between entities.
Contract for a mapping attribute.
Deprecated, for removal: This API element is subject to removal in a future version.
Replaced by
AttributeMappingSpecifies an attribute access strategy to use.
Configures the
PropertyAccessStrategy for an attribute.Results of analyzing an attribute in terms of
handling update operations
Dirty-ness status of each attribute:
it's useful to differentiate when it's definitely dirty,
when it's definitely not dirty, and when we need to treat
it like dirty but there is no certainty - for example
because we didn't actually load the value from the database.
Allows a user-written annotation to drive some customized model binding.
Associates a user-defined annotation with an
AttributeBinder,
allowing the annotation to drive some custom model binding.An extended set of
Attribute.PersistentAttributeType adding AttributeClassification.ANYDefines a contract for the Envers mapping model in terms of being able to contain attributes.
Identifies a mapping model object which may have attributes
(fields or properties).
Used during creation of the type
Bundle's a Hibernate property mapping together with the JPA metamodel information
of the attribute owner.
Describes a conversion
The default
MutabilityPlan for a
converted value assumes,
in the absence of additional evidence, that the value is mutable, so
that dirty checking, deep copying, and second-level caching all work correctly
in the case where it really is mutable.A factory for building
Attribute instances.Describes an attribute at the mapping model level.
This is essentially a List of AttributeMapping(s), but exposing
an interface which is more suitable to our needs; in particular
it expresses the immutable nature of this structure, and allows
us to extend it with additional convenience methods such as
AttributeMappingsList.indexedForEach(IndexedConsumer).Similar to
AttributeMappingsList, this is essentially
an immutable Map of AttributeMapping(s), allowing iteration of
all mappings but also retrieval by name (a String key).Commonality for annotations which identify attributes.
Basic contract for describing an attribute.
An enum defining the nature (categorization) of a persistent attribute.
Extends the JPA-defined
AttributeNode with additional operations.Implementation of
AttributeNode.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).
Helper for handling persistent attributes defined in mapping XML in metadata-complete mode
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.When applied to a class, indicates that all of its properties should be audited.
Implementations hold other audited properties.
Reads persistent properties form a
PersistentPropertiesSource and adds the ones that are audited to a
AuditedPropertiesHolder, filling all the auditing data.A registry of audited and not-audited entity runtime configurations.
A register of all audit entity names used so far.
Create restrictions or projections using a function.
Create restrictions and projections for the id of an audited entity.
A data class that represents an
AuditJoinTable annotation.
Annotation to specify a "fake" bi-directional relation.
The
AuditingOverride annotation is used to override the auditing
behavior of a superclass or single property inherited from MappedSuperclass
type, or attribute inside an embedded component.A boot-time descriptor that represents a
AuditOverride annotation.The
AuditingOverrides annotation is used to override the auditing
behavior for one ore more fields (or properties) inside an embedded
component.Create restrictions, projections and specify order for a property of an audited entity.
Provides access to past versions of audited entities based on
a global revision.
An interface exposed by a VersionsReader to library-facing classes.
Create restrictions on an id of an entity related to an audited entity.
Deprecated.
use
AuditStrategy instead.A strategy abstraction for how to audit entity changes.
A contract to initialize an
AuditStrategyProvides the audit strategy implementations to the
StrategySelector service.Holds information necessary to create an audit table: its name, schema and catalog, as well as the audit
entity name.
TODO: refactor constructors into factory methods
A
JDBCException indicating an authentication or authorization failure.Contract for handling auto-apply checks for JPA AttributeConverters
An implementation of AutoApplicableConverterDescriptor that always reports
no auto-apply match
Standard implementation of AutoApplicableConverterDescriptor
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 SQL dialect for Azure SQL Server.
A mapping model object representing a collection of type
Collection which may
contain duplicates.Initializer for both
PersistentBag and PersistentIdentifierBag
collectionsHibernate extension to the JPA
CollectionAttribute descriptorApplies functional testing logic for core Hibernate testing on top of
BaseUnitTestCaseBase class for Envers' collection event related listeners
Base class for all Envers event listeners
Deprecated, for removal: This API element is subject to removal in a future version.
No direct replacement, though see
AttributeMapping
and AttributeMetadataBase support for load-by-natural-id
Applies functional testing logic for core Hibernate testing on top of
BaseUnitTestCase.Base support for an SQM walker
Deprecated, for removal: This API element is subject to removal in a future version.
Just implement
SessionEventListener directly.Template (GoF pattern) based abstract class for tests bridging the legacy
approach of SessionFactory building as a test fixture
The base unit test adapter.
Base for XMLEventReader that implements the
BaseXMLEventReader.getElementText() and BaseXMLEventReader.nextTag() APIs in a
way that is agnostic from the rest of the XMLEventReader implementation.A type that maps between
ARRAY and T[]Contract for a basic, singular attribute.
ColumnAndFormulaSource implementation handling basic attribute mappings.
PropertySource implementation handling basic attribute mappings.
Normal implementation of
BatchKeyConvenience base implementation of
ValueBinderKey produced by DefaultCacheKeysFactory; this is the specialized implementation
for the case in which the disassembled identifier is not an array and the tenantId
is not being defined.
Initializes a non-indexed java collection (set or list, eventually sorted).
Descriptor for handling persistent collections.
A type that maps between
ARRAY and Collection<T>Template (as in template pattern) support for
ConnectionCreator implementors.Intended as support for custom resolvers which match a single db name (with optional version info).
Hibernate extension to the JPA
BasicType contract.A
DotIdentifierConsumer used to interpret paths outside any
specific context.Mapping for a simple, single-column identifier
Mapping of a simple identifier
Convenience base implementation of
ValueExtractorFetch for a basic-value
Performs formatting of basic SQL statements (DML + query).
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.
Generates metadata for basic properties: immutable types (including enums).
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.Implementation of the
JdbcServices contract for use by tests.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 modelA stateful binder responsible for creating instances of
BasicValue.Support for basic-typed value conversions.
Models a basic collection element/value or index/key
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.A builder for
Batch instances.Initiator for the
BatchBuilder serviceMuch 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
Standard implementation of
BatchLoads entities from the persistence context or creates proxies if not found there,
and initializes all proxies in a batch.
Unique key for batch identification.
Commonality for loading a loadable in "batch" (more than one key at a time)
Factory for
BatchLoader instancesInitiator for
StandardBatchLoaderFactoryAn observer contract for batch events.
Specifies a maximum batch size for batch fetching of the annotated
entity or collection.
Specify a batch size, that is, how many entities should be
fetched in each request to the database, for an invocation of
Session.findMultiple(Class, List, FindOption...).Binder for the
BatchSize annotation.Represents a backend "bean container" - CDI, Spring, etc
Utility for helping deal with
BeanInfoContract for producing a bean instance
Indicates a problem dealing with
BeanInfo via the BeanInfoHelper delegate.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.Deprecated, for removal: This API element is subject to removal in a future version.
Use JUnit 5 along with one of the Hibernate ORM's class-level test annotations
(
BaseUnitTest,
SessionFactory,
Jpa,
SessionFactoryFunctionalTesting,
ServiceRegistryFunctionalTesting, ...)
and BeforeAll.A generator that is called to produce a value just before a row is written to the database.
Contract representing some process that needs to occur during before transaction completion.
Actions to perform in regards to a temporary table prior to each use.
Descriptor for
BigDecimal handling.Descriptor for
BigInteger handling.Descriptor for
BIGINT handling.Enumeration of standard binary arithmetic operators
Descriptor for
BINARY handling.Wraps a binary stream to also provide the length which is needed when binding.
Defines a contract for objects that are bindable.
Contract for things at the domain mapping level that can be bound
into a JDBC
PreparedStatement.Functional interface for consuming the JDBC values, along with two values of type
X and Y.Functional interface for consuming the JDBC values.
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
A context within which a
BindableType can be resolved
to an instance of SqmExpressible.Group of all parameter bindings for a table.
LobCreator which can use Connection.createBlob() and Connection.createClob(),
but NClob references are created locally.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.
Used to define the bootstrap ServiceRegistry to be used for testing.
Builder for
BootstrapServiceRegistry instances.ServiceRegistry implementation containing specialized "bootstrap" services, specifically:
ClassLoaderService
IntegratorService
StrategySelector
Producer of BootstrapServiceRegistry
A type that is assignable to every non-primitive type,
that is, the type of
null.A hash table supporting full concurrency of retrievals and
adjustable expected concurrency for updates.
Buffers XML events for later re-reading
Note, copied from the uPortal project by permission of author.
Commonly helpful creators for ResultBuilder and FetchBuilder references.
Describes the built-in externally-nameable
PropertyAccessStrategy implementations.Specialized contract for
IdentifierGenerator implementations capable of being used in conjunction
with HQL insert statements.An
ActionQueue Executable for
ensuring shared cache cleanup in relation to performed bulk HQL queries.An InputStreamAccess implementation based on a byte array
Descriptor for
Byte[] handling, which disallows null elements.A utility to hold all ByteBuddy related state, as in the current version of
Hibernate the Bytecode Provider state is held in a static field, yet ByteBuddy
is able to benefit from some caching and general state reuse.
Shared proxy definition helpers.
Encapsulates bytecode enhancement information about a particular entity.
BytecodeEnhancementMetadata implementation for non-POJO models, mainly
RepresentationMode.MAPBytecodeEnhancementMetadata implementation for
POJO modelsLogging related to bytecode enhancement interceptors
Contract for providers of bytecode services to Hibernate.
This BytecodeProvider represents the "no-op" enhancer; mostly useful
as an optimisation when not needing any byte code optimisation applied,
for example when the entities have been enhanced at compile time.
Settings which control the
BytecodeProvider
used for bytecode enhancement and reflection optimization.Descriptor for
Byte handling.A connection provider that uses a C3P0 connection pool.
The jboss-logging
MessageLogger for the hibernate-c3p0 module.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.
JAXB marshalling for Hibernate's
AccessTypeIdentifies 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
Allows multiple entity classes / collection roles to be stored in the same cache region.
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.
JAXB marshalling for Hibernate's
CacheModeModels the definition of caching settings for a particular region.
Second-level cache statistics of a specific region.
Second level cache statistics of a specific region
Settings for Hibernate's second-level caching
Defines a context object that a
RegionFactory is asked to create
(RegionFactory.createTransactionContext(org.hibernate.engine.spi.SharedSessionContractImplementor)}) when a Hibernate Session
is created.Models the caching options for an entity, natural id, or collection.
Descriptor for
Calendar handling, but just for the date (month, day, year) portion.Descriptor for
Calendar handling.Descriptor for
Calendar handling, but just for the time portion.Represents a JPA event callback (the method).
Callback to allow SQM interpretation to trigger certain things within ORM.
Resolves JPA callback definitions
Intended to be thrown from
Interceptor callbacks.Indicates an exception while performing a callback on the test
Implementation of Callback that does nothing
Registry of JPA entity lifecycle callbacks by entity and type.
Contract for injecting the registry of Callbacks into event listeners.
The intent of this class is to use a lighter implementation
when standard JPA entity lifecycle callbacks are disabled via
SessionFactoryOptions.areJPACallbacksEnabled().Deprecated, for removal: This API element is subject to removal in a future version.
Indicates an illegal attempt to make a
Graph become
an EntityGraph via Graph.makeRootGraph(String, boolean).Indicates an attempt was made to add a (key)? sub-graph to an
attribute type that does not support (key)? sub-graphs.
Indicates an internal attempt to mark a column as non-nullable
(because it's part of a primary key, for example) when we cannot
force that column to be non-nullable.
Descriptor for a SQL type.
Deprecated.
Use the JPA-defined
CascadeTypeDelegate responsible for, in conjunction with the various
actions, implementing cascade processing.
Describes the point at which a cascade is occurring
A contract for defining the aspects of cascading various persistence actions.
Describes sources which define cascading.
Deprecated.
Use the JPA-defined
CascadeTypeA session action that may be cascaded from parent entity to its children
Wraps a ConcurrentHashMap having all keys as Strings
and ensures all keys are lowercased.
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.Helper class for helping deal with the reflection calls relating to CDI
in terms of building CDI-based
BeanContainer
instance
We need to avoid statically linking CDI classed into the ClassLoader which
would lead to errors if CDI is not available on the classpath.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.
Implementation of
CharacterStreamDescriptor for
CHAR handling.Specifies a
check constraint to be included in the generated DDL.This listener should be called before the discovery request is sent to the test engines.
Represents a table or column level
check constraint.Commonality for annotations which define check-constraints
Indicates that a package or top-level type contains HQL or JPQL
queries encoded as static strings that should be validated at
compile time by the Metamodel Generator or Query Validator.
A list of
Checks.A chr implementation that translates integer literals to string literals.
Boot-time audit data for a specific entity class.
ConverterDescriptor implementation for cases where we know the
AttributeConverter Class.
Descriptor for a class file.
A helper class holding auditing meta-data for all persistent classes during boot-time.
Mimic a JDK 5 enum.
Descriptor for
Class handling.During the process of building the metamodel, access to the
ClassLoader is
strongly discouraged.Utility class that facilitates loading of a class.
Standard implementation of ClassLoaderAccess
A ClassLoaderAccess implementation based on lazy access to
MetadataBuildingOptionsA service for interacting with class loaders.
Standard implementation of the service for interacting with class loaders
Adapts ClassLoaderService to the ClassLoading contract
Indicates a problem performing class loading.
Exposes the Classmate
TypeResolver and MemberResolver.EnhancementSelector based on class name
A persistence provider provides an instance of this interface to the
PersistenceUnitInfo.addTransformer(jakarta.persistence.spi.ClassTransformer) method.Helper class to write the actual metamodel class using the
Filer API.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
Contract for an object that is cloneable.
Unification of Iterator and AutoCloseable
Implement the array fill function by using
generate_series.Deprecated.
Spatial Dialects are no longer needed.
CockroachDB json_exists function.
CockroachDB json_query function.
CockroachDB json_remove function.
CockroachDB json_table function.
CockroachDB json_value function.
A SQL dialect for CockroachDB 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.A problem converting between JDBC types and Java types.
Helper for type coercions.
Specifies a collation to use when generating DDL for
the column mapped by the annotated field or property.
Handles
Collate annotations.A mapping model object representing a collection.
Any action relating to insert/update/delete of a collection
Allows for the customization of an Envers audit collection table.
BatchLoader specialization for collection fetching
CollectionBatchLoader using a SQL ARRAY parameter to pass the key values.CollectionBatchLoader for batch fetching using a SQL IN predicate.Base class for stateful binders responsible for producing mapping model objects of type
Collection.Cacheable representation of persistent collections
Allows the collection cache to be automatically evicted if an element is inserted/removed/updated *without* properly
managing both sides of the association (ie, the ManyToOne collection is changed w/o properly managing the OneToMany).
Used in mapping dynamic models to signify the type of collection to use for a plural attribute
Classifications of the plurality.
JAXB marshalling for
CollectionClassificationHandles conversion to/from a collection of a converted element type.
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
Various helper util methods for handling collections.
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
Main implementation of CollectionLoader for handling a load of a single collection-key
A one-time use
CollectionLoader for applying a subselect fetch.Helper class that provides a way to resolve the
mappedBy attribute for collections.MappingType descriptor for the collection Java type (List, Set, etc)
Metadata building context used for collections to hold per-collection state.
Standard support for
CollectionDataAccess
using the AccessType.NONSTRICT_READ_WRITE access type.Base contract for coordination of collection mutation operations
Hibernate understands mapping a collection into 4 parts
The key - the foreign-key defining the association to the owner
The element - for Maps this is analogous to the value
The index - the List/array index or Map key
The collection-id - this is only relevant for id-bag mappings
Represents a part of a `CollectionPart` (element or index descriptor) as a DomainPath
A strategy for persisting a mapped collection role.
Standard support for
CollectionDataAccess
using the AccessType.READ_ONLY access type.Standard support for
CollectionDataAccess
using the AccessType.READ_WRITE access type.The action for recreating a collection
The action for removing a collection
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
Implements book-keeping for the collection persistence by reachability algorithm
Collection second pass
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.
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
CollectionTypeRegistrationThe action for updating a collection
An implementation of
Selection that represents a logical column.Strategy for extracting the unique column alias out of a
ResultSetMetaData.Contract for a container of columns.
Specifies that a column has a
default value specified in DDL.Provides access to information about existing table columns
JDBC column metadata
Utility class to build a column name iterator over different column collection types.
A pluggable contract that allows ordering of columns within
Table,
Constraint and UserDefinedObjectType.A no-op implementation.
Standard implementation that orders columns by size and name following roughly this ordering:
order by max(physicalSizeBytes, 4), physicalSizeBytes > 2048, nameRepresents a column-reference used in an order-by fragment
Models a reference to a Column in a SQL AST
Visitor to determine if all visited column references use the same qualifier.
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()
Commonality for annotations which contain SQL comments
Handles
Comment annotations.Deprecated.
Per Comment, prefer Table.comment()
Handles the
Comments annotation.Data that is used by all collection mappers, regardless of the type.
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.
Functions commonly expected in databases, as defined
by the SQL/MM specs
Information which is common across all table annotations
Delegates to Comparable
We frequently need the union type of Executable, Comparable of ComparableExecutable, Serializable;
this interface represents such union; this helps to simplify several generic signatures.
Enumerates the binary comparison operators.
A binary-comparison restriction
Denotes that a setting is intended to allow applications to upgrade
versions of Hibernate and maintain backwards compatibility with the
older version in some specific behavior.
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.
Reads the audited properties for components.
Audit mapping meta-data for component.
Generates metadata for components.
PropertyHolder for composites (Embeddable/Embedded).Handles embedded mappings.
Represents an identifier based on a
composite-id mapping.Mapping for a composite identifier
Descriptor for
<key-property/>Descriptor for
<key-many-to-one/> mappingCommon contract for composite identifiers.
For composite identifiers, defines a number of "nested" generations that
need to happen to "fill" the identifier property(s).
Contract for declaring how to locate the context for sub-value injection.
Contract for performing the actual sub-value generation, usually injecting it into the
determined context
small low memory class to keep references to composite owners
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
NaturalIdLoader implementation for compound natural-ids
Multi-attribute NaturalIdMapping implementation
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.Standard Hibernate implementation of SelectQueryPlan for SQM-backed
Query implementations, which means
HQL/JPQL or CriteriaQueryAn advanced hash table supporting configurable garbage collection semantics
of keys and values, optional referential-equality, full concurrency of
retrievals, and adjustable expected concurrency for updates.
An option specifying which Java reference type should be used to refer
to a key and/or value.
Deprecated.
Use
ClassLoaderService insteadLoads
cfg.xml files.Contract for a model object that stores configuration parameters
A
Generator that supports "configuration".Allows the service to request access to the configuration properties for configuring itself.
A convenience API making it easier to bootstrap an instance of Hibernate.
Envers configuration.
TODO : javadoc
Collection of helper methods for dealing with configuration settings.
Provides access to the initial user-provided configuration values.
Simple conversion contract for converting an untyped object to a specified type.
The standard
ConfigurationService implementation.The
ServiceInitiator for the ConfigurationService.Support for XSD handling related to Hibernate's `cfg.xml` and
JPA's `persistence.xml`.
Indicates the manner in which JDBC connections
are acquired.
The default factory for
ConnectionCreator instances.A contract for obtaining JDBC connections and, optionally, for pooling connections.
Defines the JDBC connection information (currently H2) used by Hibernate for unit (not functional!) tests
This
ConnectionProvider extends any other ConnectionProvider
that would be used by default taken the current configuration properties.Instantiates and configures an appropriate
ConnectionProvider.Enumerates various policies for releasing JDBC connections.
Contract for validating JDBC connections.
A mapping model object representing a constraint on a relational database table.
JAXB marshalling for JPA's
ConstraintModeA
JDBCException indicating that the requested DML operation
resulted in violation of a defined integrity constraint.Release-able extension to
ContainedBean.A
BeanLifecycleStrategy to use when CDI compliance is required
(i.e.ValidationEventHandler implementation providing easier access to where (line/column) an error occurred.
Validation event handler used for obtaining line and column numbers in case of parsing failures.
Parts of the mapping model which are associated with a
contributor (ORM, Envers, etc).
Database objects (table, sequence, etc) which are associated with
a contributor (ORM, Envers, etc) and
can be selectively exported per contributor
Matcher for whether tables and sequences should be included based on its
Contributable.getContributor()Internal contract for Type and Function Contributors
A conversion of a duration to a given temporal unit,
as a result of applying the 'by unit' operator.
Indicates a problem converting an SQM tree to a SQL AST
A registered conversion.
Given a
BasicValueConverter for an array type,A converted basic array type.
Extension for implementations of
BasicType which have an implied
conversion.Manages resolution of auto-applied
AttributeConverter
references for specific mappingsBoot-time descriptor of a JPA AttributeConverter
Helpers related to handling converters
Registers an
AttributeConverter.A registry for JPA converters.
Quite sad, really, when you need helpers for generating loggers...
The jboss-logging
MessageLogger for the hibernate-core module.A TypePool which only loads, and caches, types whose package
name starts with certain chosen prefixes.
A table group for correlated plural attributes.
A virtual
TableReference for correlated roots.A
UniqueDelegate which includes the unique constraint in the create table
statement, except when called during schema migration.Specifies that the annotated field of property is a generated creation timestamp.
Interface which allows extension of
HibernateCriteriaBuilder
with additional functionality by registering a Service.A utility class that makes it easier to build criteria queries.
Queries that allow retrieving snapshots of all entities (regardless of their particular type) changed in the given
revision.
Information about a column in the CTE table
The consumer part of a CTE statement - the select or insert or delete or update that uses
the CTE
Bulk mutation delete handler that uses CTE and VALUES lists.
Recursive CTE based generate_series function.
The kind of materialization that should be used for a CTE.
An object that is part of a WITH clause.
The kind of CTE search clause.
Specialized CteDeleteHandler for soft-delete handling
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.Value generation strategy which produces a timestamp using the database
current_timestamp function or the JVM
current instant.A custom type for mapping user-written classes that implement
PersistentCollectionA collection semantics wrapper for
CollectionType.During 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.
Wrapper of
CustomMutabilityConvertedBasicTypeImpl for primitive type.Allows the
CustomRunner features in parameterized tests.The Hibernate-specific
Runner implementation which layers ExtendedFrameworkMethod
support on top of the standard JUnit FrameworkMethod for extra information after checking to make sure the
test should be run.Models the information for custom SQL execution defined as part of
the mapping for a primary or secondary table.
Commonality for annotations which define custom insert, update and delete SQL
Applies a version 1 (time-based) generation strategy (using ip address rather than mac address) but applies them in a
different layout.
Captures all information about an annotated persistent attribute.
A list of relational database systems for which Hibernate can resolve a
Dialect.Contract used for logging "database information" on bootstrap
Standard implementation of
DatabaseConnectionInfoModels an identifier (name), retrieved from the database.
Provides access to information about existing schema objects (tables, sequences etc) of existing database.
An implementation of
DialectResolutionInfo that delegates calls to a wrapped DatabaseMetaData.Commonality for annotations which represent database objects.
Contract for model-parts which contribute to their container's
state array for database snapshots
Encapsulates definition of the underlying data structure backing a
sequence-style generator.
Details about the underlying database, as understood by a Dialect.
A
JDBCException indicating that evaluation of the
valid SQL statement against the given data resulted in some
illegal operation, mismatched types or incorrect cardinality.A helper for dealing with
BLOB and CLOB dataA concrete implementation of the
MultiTenantConnectionProvider contract bases on
a number of reasonable assumptions.A
ConnectionProvider that manages connections from an underlying DataSource.Descriptor for
Date handling.Descriptor for
DATE handling.Utility class that provides access to a
DateFormat instance.Utilities for dealing with date/times
Emulation of
trunc(datetime, temporal_unit) function that leverages
formatting the datetime to string and back to truncate itDB2 implementation of CallableStatementSupport.
A 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.
Type Descriptor for the DB2 Geometry type (as Clob)
Variant of the
GetObjectExtractor that catches a NullPointerException,
because the DB2 JDBC driver runs into that exception when trying to access a null value
with the getObject(int, Class) and getObject(String, Class) methods.A SQL dialect for DB2 for IBM i version 7.1 and above, previously known as "DB2/400".
Sequence support for
DB2iDialect.A SQL AST translator for DB2i.
DB2 json_arrayagg function.
DB2 json_array function.
DB2 json_objectagg function.
DB2 json_object function.
DB2 json_table function.
DB2 json_value function.
A
LimitHandler for DB2 11.1 which supports the
ANSI SQL standard syntax FETCH FIRST m ROWS ONLY
and OFFSET n ROWS FETCH NEXT m ROWS ONLY,
with the only wrinkle being that this clause comes
after the FOR UPDATE and other similar clauses.DB2's position() function always requires a code unit before version 11.
Sequence support for
DB2Dialect.A SQL AST translator for DB2.
DB2 supports UDTs but not in JDBC, so there is a feature called "transforms",
which allows to specify an automatic translation from one data type to another.
DB2's substring() function requires a code unit and substr() can't optionally take it,
so we render substr() by default.
DB2 unnest function.
DB2 xmltable function.
A SQL dialect for DB2 for z/OS version 12.1 and above, previously known as:
"Db2 UDB for z/OS", and
"Db2 UDB for z/OS and OS/390".
Sequence support for
DB2zDialect.A SQL AST translator for DB2z.
Performs formatting of DDL SQL statements.
Provides access to a
Connection that is isolated from any
"current transaction" with the designated purpose of performing DDL
commands.DdlExecutor for use in JTA environments
DdlExecutor for use in non-JTA environments (JDBC transaction)
Descriptor for a DDL column type.
Descriptor for a SQL type.
A registry mapping
JDBC type codes
to instances of the DdlType interface.Descriptor for
DECIMAL handling.Deprecated.
use
DefaultAuditStrategy instead.Default implementation of the
AuditStrategy contract.Defines the default flush event listeners used by hibernate for
flushing session state in response to generated auto-flush events.
Second level cache providers now have the option to use custom key implementations.
Used by the container to instantiate a Jakarta Data repository.
The default implementation of
CustomEntityDirtinessStrategy which does nada.Defines the default delete event listener used by hibernate for deleting entities
from the datastore in response to generated delete events.
Defines the default dirty-check event listener used by hibernate for
checking the session for dirtiness in response to generated dirty-check
events.
default implementation of EnhancementContext.
Defines the default evict event listener used by hibernate for evicting entities
in response to generated flush events.
An event that occurs for each entity instance at flush time
Defines the default flush event listeners used by hibernate for
flushing session state in response to generated flush events.
Defines the default load event listeners used by hibernate for loading entities
in response to generated load events.
Defines the default lock event listeners used by hibernate to lock entities
in response to generated lock events.
Defines the default copy event listener used by hibernate for copying entities
in response to generated copy events.
Defines the default create event listener used by hibernate for creating
transient entities in response to generated create events.
When persist is used as the cascade action, persistOnFlush should be used
Performs needed
EntityEntry.getLockMode()-related processing.Called before injecting property values into a newly
loaded entity instance.
Defines the default refresh event listener used by hibernate for refreshing entities
in response to generated refresh events.
Deprecated.
since
Session.replicate(java.lang.Object, org.hibernate.ReplicationMode) is deprecatedDefines the default load event listeners used by hibernate for loading entities
in response to generated load events.
Default implementation of the SchemaFilter contract, which is to just include everything.
Default implementation of the SchemaFilterProvider contract, which returns
DefaultSchemaFilter for all filters.Default implementation of
SchemaNameResolver.This is the default implementation of SessionFactoryBuilderService, which just
returns the default SessionFactoryBuilderImpl.
Extension of standard
DefaultRevisionEntity that allows tracking entity names changed in each revision.Automatically adds entity names, that have been changed during current revision, to revision entity.
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.
ManagedBean implementation for delayed
ParameterizedType
handling (parameter injection) for a UserCollectionTypeActs as a stand-in for an entity identifier which is supposed to be
generated on insert (like an IDENTITY column) where the insert needed to
be delayed because we were outside a transaction when the persist operation
was called (save currently still performs the insert).
Descriptor for
STRUCT handling, which is only a temporary placeholder.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.
Handler for dealing with multi-table SQM DELETE queries.
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).
Class to consolidate logging about usage of deprecated features.
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.Defines a means to check
Dialect features for use in "test protection" checks.Container class for different implementation of the
DialectCheck interface.A wrapper of Dialect, to allow decorating some selected methods
without having to extend the original class.
A factory for generating
Dialect instances.Standard implementation of the
DialectFactory service.Standard initiator for the standard
DialectFactory serviceContainer class for different implementation of the
DialectFeatureCheck interface.Does the database support nationalized data in any form
Does the database specifically support the explicit nationalized data types
JUnit 5 extension used to add
RequiresDialect and SkipForDialect
handlingLogging related to Hibernate dialects
Allows certain annotations to be overridden in a given SQL
Dialect.Specializes a
Check
in a certain dialect.Specializes a
ColumnDefault
in a certain dialect.Specializes a
DiscriminatorFormula
in a certain dialect.Specializes
FilterDefs
in a certain dialect.Specializes
Filters
in a certain dialect.Specializes a
Formula
in a certain dialect.Specializes a
GeneratedColumn
in a certain dialect.Specializes a
JoinFormula
in a certain dialect.Marks an annotation type as a dialect-specific override for
some other annotation type.
Specializes a
SQLDelete
in a certain dialect.Specializes a
SQLDeleteAll
in a certain dialect.Specializes a
SQLInsert
in a certain dialect.Specializes an
SQLOrder
in a certain dialect.Specializes a
SQLRestriction
in a certain dialect.Specializes a
SQLSelect
in a certain dialect.Specializes a
SQLUpdate
in a certain dialect.Identifies a database version.
Common contract for override annotations defined in DialectOverride
Exposes information about the database and JDBC driver that can be used in resolving the appropriate Dialect
to use.
Contract for the source of
DialectResolutionInfo.Contract for determining the
Dialect to use based on information about the database / driver.Standard initiator for the
DialectResolver serviceA
DialectResolver implementation which coordinates resolution by delegating to sub-resolvers.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.
Do we have a dirty collection here?
If it's a new application-instantiated collection, return true.
Interface to be implemented by dirty trackers, a simplified Set of String.
A
CacheImplementor service used when the second-level cache is disabled.Implementation of Scanner that does nothing.
Anything that has a discriminator associated with it.
Singular, any-valued attribute
Represents the "type" of an any-valued mapping
A discriminated association.
SqmPathInterpretation for discriminated association (ANY) mappings
Initializer for discriminated mappings.
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.Handles
DiscriminatorOptions annotations.SqmPathInterpretation and DomainResultProducer implementation for entity discriminator
A persistent entity mapping that uses a single table to store entities based on a discriminator.
Contract for sources of information about a mapped discriminator.
Commonality between entity and any discriminators
Contract for a persistent entity discriminator type.
Union of
ConvertedBasicType and BasicDomainType capabilities.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 DiscriminatorConverterSpecialization of ConvertedBasicTypeImpl to expose access to the
DiscriminatorTypeImpl.underlyingJdbcMapping of this discriminator - the bit that handles
the relationship between the relational JavaType and the JdbcTypeJAXB marshalling for
DiscriminatorTypeDetails 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.
DomainDataRegionConfig implementation
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.In-flight holder for various things as we process metadata sources
Describes a standard domain model
hibernate-testing implementation of a few JUnit5 contracts to support SessionFactory-based testing,
including argument injection (or see
DomainModelScopeAware)Helper containing utilities useful for domain model handling
Maintains a cross-reference between SqmParameter and QueryParameter references.
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
Specialized "intermediate" SemanticPathPart for processing domain model paths/
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 graphsCentral implementation of DomainResultCreationState,
SqlAstCreationState, SqlAstProcessingState and
SqlExpressionResolver used while building
ResultSetMapping references.
Marker for all object types that can be part of a result mapping
Printer for DomainResult graphs
Something that can produce a DomainResult as part of a SQM interpretation
Describes any type 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.A specialized
ConnectionCreator which uses Driver.connect(String, Properties)
to obtain JDBC connections.A specialized
ConnectionCreator which uses DriverManager.getConnection(String, Properties)
to obtain JDBC connections.A connection provider that uses the
DriverManager directly to open connections and provides
a very rudimentary connection pool.Deprecated.
Hibernate now uses StAX for XML processing and the role of this class is served
now by
LocalXmlResourceResolverRaised 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.Contract for
PropertyMapper implementations to expose whether they should be included
as a wrapper for a <dynamic-component/> mapping.A function that dynamically dispatches to other functions,
depending on which function validates successfully first.
Specifies that SQL
insert statements for the annotated entity
are generated dynamically, and only include the columns to which a
non-null value must be assigned.Represents a dynamic-instantiation (from an SQM query) as a DomainResultProducer
A QueryResultAssembler implementation representing handling for dynamic-
instantiations targeting a List (per-"row"),
E.g.`select new list( pers.name, pers.dateOfBirth ) ...`
A QueryResultAssembler implementation representing handling for dynamic-
instantiations targeting a Map, e.g.`select new map( pers.name, pers.dateOfBirth ) ...`
Represents the type of instantiation to be performed.
Specialization of DomainResult to model
dynamic instantiation
JavaType 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.
A
FunctionReturnTypeResolver that resolves the array element type based on an argument.Java type for embeddable aggregates, which allows resolving a recommended
JdbcType.A binder responsible for interpreting
Embeddable classes and producing
instances of the mapping model object Component.Represents a JPA callback on the embeddable type
Handles conversion of discriminator values for embeddable subtype classes
to their domain typed form.
Details about the discriminator for an embeddable hierarchy.
Implementation of
DiscriminatorValueDetails used for embeddable inheritance.Hibernate extension to the JPA
EmbeddableType contract.A table group for functions that produce embeddable typed results.
A table reference for functions that produce embeddable typed results.
Special initializer contract for embeddables
Specifies a custom instantiator for a specific embedded
Contract for instantiating embeddable values.
Support for instantiating embeddables as dynamic-map representation
Support for instantiating embeddables as POJO representation through a constructor
Support for instantiating embeddables as POJO representation
using bytecode optimizer
Support for instantiating embeddables as POJO representation
EmbeddableInstantiator used for instantiating "proxies" of an embeddable.
Support for instantiating embeddables as record representation
Support for instantiating embeddables as record representation
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 a "normal" embeddable.
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).
Defines additional information for a EmbeddableSource in relation to
the thing that contains it.
Contract for things that can contain EmbeddableSource definitions.
A virtual embeddable; what Hibernate historically (pre-JPA) called an embedded
component.
Implementation of
EmbeddableType.A computed expression that produces an embeddable valued model part.
Describes the mapping of an embeddable (composite).
Unifying contract for any JAXB types which describe an embedded (in JPA terms).
SqmPath specialization for an embeddable discriminatorSqmPathSource implementation for embeddable discriminator
Deprecated.
Use
EmbeddableDomainType instead.Support for
EmbeddedIdAn identifier mapper implementation for
EmbeddedId mappings.An
EventManager that ignores all events.An interceptor that does nothing.
A
CacheImplementor service used when the second-level cache is enabled.A
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.
Used by
BytecodeEnhancerRunner to determine which classes should
be enhanced.Class responsible for performing enhancement.
Extends the TypePool contract of ByteBuddy with our additional needs.
Constants used during enhancement.
Extracts constants used by EnhancerImpl.
Enhancement context used in tests
utility class to use in bytecode enhancement tests
EntitiesAtRevisionAssociationQuery<Q extends org.hibernate.envers.query.internal.impl.AuditQueryImplementor>
An
AuditAssociationQuery implementation for
EntitiesAtRevisionQuery and EntitiesModifiedAtRevisionQuery query types.Configuration of the user entities: property mapping of the entities, relations, inheritance.
In comparison to
EntitiesAtRevisionQuery this query returns an empty collection if an entity
of a certain type has not been changed in a given revision.Base class for actions relating to insert/update/delete of an entity
instance.
An exception indicating that an
EntityAction was vetoed.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
SingleIdEntityLoaderSupport implementation based on using a single
array parameter to pass the
entire batch of ids.An
EntityBatchLoader using one or more SQL queries, which each initialize up
to EntityBatchLoaderInPredicate.getSqlBatchSize() entities using a SQL IN predicate restriction -
e.g., ... where id in (?,?,...).Stateful binder responsible for interpreting information about an
Entity class
and producing a PersistentClass mapping model object.Represents a JPA callback on the entity itself
Notifies
RevisionInfoGenerator about changes made in the current revision.An entity-valued collection-part.
Utility class that caches the SQL AST needed to read the discriminator value
associated with the provided
EntityPersister and returns the
resolved concrete entity type.Runtime representation of an entity that may or may not be audited.
An
EntityCopyObserver implementation that allows multiple representations of
the same persistent entity to be merged and provides logging of the entity copies that
are detected.An
EntityCopyObserver implementation that allows multiple representations of
the same persistent entity to be merged.An observer for detection of multiple entity representations for a persistent entity being merged.
Looks for the configuration property "hibernate.event.merge.entity_copy_observer" and registers
the matching
EntityCopyObserverFactory based on the configuration value.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
The action for performing an entity deletion.
Details about the discriminator for an entity hierarchy.
SqmPath specialization for an entity discriminatorSqmPathSource implementation for entity discriminator
Extension to the JPA
EntityType contract.Information about the current state of a managed entity instance with respect
to its persistent state.
Defines a context for maintaining the relation between an entity associated with the
Session ultimately owning this EntityEntryContext instance and that
entity's corresponding EntityEntry.Used in building the
EntityEntryContext.reentrantSafeEntityEntries() entriesNavigation methods for extra state objects attached to
EntityEntry.Contains optional state from
EntityEntry.Contract to build
EntityEntrySpecialization of Fetch for entity-valued fetches
An eager entity fetch performed as a subsequent (n+1) select
Processing for JPA entity graphs from XML
A collection of
EntityGraph utilities.State used as part of applying entity graphs to
Hibernate
DomainResult / Fetch load graphs.Details of a particular traversal within the entity graph
Helper for dealing with entity inheritance hierarchies in
hbm.xml
processing.Models the source-agnostic view of an entity hierarchy.
Models an entity hierarchy as defined by
hbm.xml documentsHolder 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.The action for performing entity insertions when entity is using IDENTITY column identifier generation
A
BeforeTransactionCompletionProcess implementation to verify and
increment an entity version as party of before-transaction-completion
processing.Common interface for all entity mappings (root entity and sub-entity mappings).
Initializer implementation for initializing entity references.
The action for performing an entity insertion, for entities not defined to use IDENTITY generation.
Contract for instantiating entity values
Support for instantiating entity values as dynamic-map representation
Support for instantiating entity values as POJO representation using
bytecode optimizer
Support for instantiating entity values as POJO representation
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.hibernate-testing implementation of a few JUnit5 contracts to support SessionFactory-based testing,
including argument injection (or see
SessionFactoryScopeAware)Contract for something that can build a SessionFactory.
The keystone in EntityManagerFactoryScopeExtension support.
The thing that actually manages lifecycle of the EntityManagerFactory related to a test class.
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.
Concurrent Map implementation of mappings entity name -> EntityPersister.
Renders entities and query parameters to a nicely readable string.
Used for specifying restrictions on a property of an audited entity.
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.
Standard ReturnEntity impl
Mapping of a row-id
EntitySelectFetchInitializer<Data extends EntitySelectFetchInitializer.EntitySelectFetchInitializerData>
Contract describing source of information related to mapping an entity.
Entity-related statistics.
Entity related statistics
Descriptor for the mapping of a table relative to an entity
Extension of standard
RevisionListener that notifies whenever an entity instance has been
added, modified or removed within current revision boundaries.Base for types which map associations to persistent entities.
Indicates that a reference to an entity, that is, a given entity name
or Java class object, did not resolve to a known mapped entity type.
Implementation of
EntityType.Used to uniquely key an entity instance in relation to a particular session
by some unique property reference, as opposed to identifier.
The action for performing entity updates.
Fetchable which is entity-valued
A
BeforeTransactionCompletionProcess impl to verify an entity
version as part of before-transaction-completion processing.Describes the mapping of an entity's version
Describes a Java
enum type.Represents an
enum type for databases like MySQL and H2.Deprecated, for removal: This API element is subject to removal in a future version.
Use the built-in support for enums
JAXB marshalling for
EnumTypeConverts an
Envelope to a PolygonHooks up Envers event listeners.
Marker interface for Envers listeners for duplication handling.
Event listener duplication strategy for envers
Sad when you need helpers for generating loggers...
Indicates an error happened during the Envers mapping boot process.
The jboss-logging
MessageLogger for the hibernate-envers module.Metadata building context for Hibernate Envers
Envers-specific collection recreation event listener
Envers-specific entity (post) deletion event listener
Envers-specific entity (post) insertion event listener
Envers-specific entity (post) update event listener
Envers-specific collection removal event listener
Envers-specific collection update event listener
Envers-specific entity (pre) update event listener.
Provides central access to Envers' configuration.
ServiceContributor implementation pushing the EnversService into
the registry
Provides central access to Envers' configuration.
Configuration property names.
Provides access to configuration properties passed in
Properties objects.Composite for the things related to Hibernate's event system.
Callback for
EventEngineContributorIntegration contract for contributing event types and listeners to the Hibernate event system.
Contract for a groups of events listeners for a particular event type.
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.Standard implementation of EventListenerRegistry
Defines a contract for reporting and monitoring low-level events
involving interactions between the session and the database or second-level cache.
Enumeration of the recognized types of events, including meta-information about each.
Enumerates event types that can result in generation of a new value.
For convenience, enumerates the possible combinations of
EventType.Most databases don't have a function like
every() or any().Defines an event class for the evicting of an entity.
Defines the contract for handling of evict events generated from a session.
Evict any collections referenced by the object from the session cache.
Contract for how CommandAcceptanceException errors should be handled (logged, ignored, etc).
A pluggable strategy for defining how the
Synchronization registered by Hibernate handles
exceptions.Indicates that a package or top-level type should be ignored
by the Hibernate annotation processor.
An operation which may be scheduled for later execution.
Something we want to perform with protection to time it out.
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 classJAXB marshalling for the ExecuteUpdateResultCheckStyle enum
A context for execution of SQL statements expressed via
SQL AST and JdbcOperation
Indicates an exception performing execution
Parameter object representing options for schema management tool execution
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.Annotation that can be used, in conjunction with
ExpectedExceptionExtension,
to indicate that a specific test is expected to fail in a particular way
(throw the specified exception) as its "success condition".TestExecutionExceptionHandler used in conjunction with
ExpectedException
to support annotating tests with a specific exception that indicates a
success (we are expecting that exception in that tested condition).SqlStringGenerationContext implementation with support for overriding the
default catalog and schema
An
ArchiveDescriptor for exploded (directory) archives.Contract for entities (in the ERD sense) which can be exported via
CREATE, ALTER, etcIdentifies metamodel objects that can produce
Exportable relational stuff.Defines a contract for exporting of database objects (tables, sequences, etc)
for use in SQL
CREATE and DROP scripts.Models an expression at the SQL AST level.
A wrapper around a basic
Expression that produces a BasicResult as domain result.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.
Defines an extension to the standard JUnit
FrameworkMethod information about a test method.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.Used in mapping dynamic models to specify from which other entity an entity extends.
Information extracted from
DatabaseMetaData regarding what the JDBC driver reports as
being supported or not.Standard implementation of
ExtractedDatabaseMetaDataANSI 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.Deprecated.
It would be nice to be able to eliminate this completely
Deprecated, for removal: This API element is subject to removal in a future version.
Use JUnit 5 and
FailureExpected instead.Marks a test method or class as being expected to fail.
JUnit 5 extension used to support
FailureExpected handlingA work unit that handles "fake" bidirectional one-to-many relations (mapped with
@OneToMany+@JoinColumn and
@ManyToOne+@Column(insertable=false, updatable=false).BeanInstanceProducer implementation based on direct instantiation.Internal component.
Specifies the default fetching method for the annotated association.
Models an individual fetch override within a
FetchProfile.Contract for fetches including entity, collection and composite.
Any mapping with an outer-join attribute
Parts of the domain model that can be fetched.
Describes source for attributes which can be fetched.
Container of
Fetchable referencesResponsible for building a single
Fetch instance.FetchBuilder specialization for basic mappings
hbm.xml specific handling for FetchCharacteristicsSingularAssociationThe kind of fetch to use for the
FETCH clause.Describes the mapping for a fetch as part of a
NamedResultSetMappingDescriptorImplementation of ScrollableResults which can handle collection fetches.
A
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
Memento describing a basic-valued fetch.
Enumerates methods for fetching an association from the database.
Represents an association fetching strategy.
Exception for
NotFoundAction.EXCEPTION.Represents an aggregated
FetchTiming and FetchStyle valueContract for things that can be the parent of a fetch
Defines a fetch profile, by specifying its
FetchProfile.name(), together
with a list of fetch strategy overrides.The runtime representation of a Hibernate
fetch profile
defined in annotations.
A mapping model object representing a
FetchProfile.An individual association fetch within the given profile.
Overrides the fetching strategy for a particular association in
the named fetch profile being defined.
Commonality between entities and collections as something that can be affected by fetch profiles.
Create
FetchProfile references from FetchProfile referencesOverrides 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
JAXB marshalling for
FetchTypeAn InputStreamAccess implementation based on a File reference
Specifies that an entity or collection is affected by a named
filter declared using
@FilterDef, and allows the
default filter condition
to be overridden for the annotated entity or collection role.Allows control over an enabled filter at runtime.
Defines mapping elements to which filters may be applied.
Declares a filter, specifying its FilterDef.name(), optionally,
a default condition, and its
parameter names and types, if it has
parameters.
Represents the definition of a
filter.Global registration of a filter definition
Array of filter definitions.
Commonality for filter annotations
Utility methods for dealing with filters.
Implementation of FilterImpl.
Base class for
XMLEventReaders that want to modify or remove events from the reader stream.Specifies that the join table of a collection is affected by a
named filter declared using
FilterDef, and allows the
default filter condition
to be overridden for the annotated entity or collection role.Add multiple
@FilterJoinTable to a collection.Collection of
FilterPredicate.FilterFragmentPredicate sub-predicates, each
representing one enabled filter restriction.Things that can have associated
Filter declarations.Add multiple
@Filters.Defines the source of filter information.
Identifies a method of an abstract class or interface as defining
the signature of a finder method, with an implementation
generated automatically by the Hibernate Metamodel Generator.
First level cache for versioned entities, versions reader-scoped.
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.
JAXB marshalling for the
FlushMode enum.JAXB marshalling for
FlushModeDeprecated.
use
QueryFlushModeHelper to deal with conversions between
FlushModeType and FlushMode.Process collections reachable from an entity.
Deprecated, for removal: This API element is subject to removal in a future version.
This remains around as an implementation detail of
hbm.xml mappings.A mapping model object representing a foreign key constraint.
Additional contract for things which describe foreign keys.
Descriptor for foreign-keys
Represents directionality of the foreign key constraint
Algorithms related to foreign key constraint transparency
Delegate for handling nullifying ("null"ing-out) non-cascaded associations
Specifies the sort of foreign key reference given in a
JoinColumn annotation.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.Represents the understood types or styles of formatting.
Formatter contract
Specifies an expression written in native SQL that is used to read the value of
an attribute instead of storing the value in a
Column.An implementation of
Selection that represents a formula.Exception indicating that a formula mapping was encountered where it is not currently supported
A SQL
FOR UPDATE clause.Deprecated, for removal: This API element is subject to removal in a future version.
Use
Column.secondPrecision() which was introduced
in JPA 3.2The SQL AST from-clause node
Access to TableGroup indexing.
FromClauseAccess implementation used while building
ResultSetMapping references.
An index of various FROM CLAUSE resolutions.
ImplicitDiscriminatorStrategy implementation using entity full-names.
Dialect support information for primary key functional dependency analysis
within
GROUP BY and ORDER BY clauses.Composite annotation for functional tests that require
a functioning EntityManagerFactory.
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.Envers specific FunctionContributor
Represents a function used in an order-by fragment
Models a function expression at the SQL AST level.
An audit query criterion that defines a predicate where both sides are a function.
A the key vor a SpatialFunction
The kind of function e.g.
A mini-"type system" for HQL function parameters.
An audit query criterion that defines a predicate that is a comparison between a function
and an audit property expression.
Support for
SqmFunctionDescriptors that ultimately want
to perform SQL rendering themselves.Describes 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.
For
GeneratedColumn.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.A fairly generic
OnExecutionGenerator which marks a property as generated in the
database with semantics given explicitly by a @Generated annotation.Simple implementation of
ResultBuilder for retrieving generated basic values.A container for database generated values
retrieved by the mutation operation.
Factory and helper methods for
GeneratedValuesMutationDelegate framework.Standard implementation for
GeneratedValues using IdentityHashMap.Simple implementation of
JdbcValuesMappingProducer used when reading
generated values from a mutation statement.Each implementation defines a strategy for retrieving values
generated by
the database after execution of a mutation statement.
Responsible for retrieving database-generated
attribute values after an
insert or update statement is executed.A
ArgumentsValidator that validates the array type is compatible with the element type.A
ArgumentsValidator that validates the array type is compatible with the element type.Standard generate_series function.
Describes a schema generation target
A
GenerationTarget which exports DDL directly to the database.A
GenerationTarget that writes DDL to scripts.A
GenerationTarget that writed DDL to System.out.Represents the timing of
value generation
in XML mappings.Deprecated, 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.JAXB marshalling for
GenerationTimingJAXB marshalling for
GenerationTypeDescribes the generation of values of a certain field or property of an entity.
Helper for dealing with generators defined via annotations
Responsible for configuring and instantiating
Generators.Access to information useful during Generator creation and initialization.
Instantiates a
Generator.Responsible for setting up the parameters which are passed to
Configurable.configure(GeneratorCreationContext, Properties)
when a Configurable generator is instantiated.Exposes the default catalog and schema to the
generator creation process.
Handles interpretation of old
hbm.xml-style generator strategy names.A 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.Deprecated.
Use
GeolatteSpatialCriteriaBuilder insteadDescriptor for geolatte-geom
Geometrys.Deprecated.
Use
GeolatteSpatialCriteriaBuilder insteadDelegate for dealing with generated values using the JDBC3 method
Statement.getGeneratedKeys().Support for extracting values directly through `getObject` JDBC driver calls.
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.
Strategy based on ANSI SQL's definition of a "global temporary table".
Strategy based on ANSI SQL's definition of a "global temporary table".
Strategy based on ANSI SQL's definition of a "global temporary table".
A container for
AttributeNode references.Defines a graph, where each vertex has a representation, which identifies uniquely a value.
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.Commonality between the builders for results and fetches.
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.
This implementation executes a single
DatabaseMetaData.getTables(String, String, String, String[]) call
to retrieve all the database table in order to determine if all the Entity have a mapped database tables.Deprecated.
use
UuidGeneratorH2 requires a very special emulation, because
unnest is pretty much useless,
due to https://github.com/h2database/h2database/issues/1815.Implement the array fill function by using
system_range.H2 requires a very special emulation, because
unnest is pretty much useless,
due to https://github.com/h2database/h2database/issues/1815.H2 requires a very special emulation, because
unnest is pretty much useless,
due to https://github.com/h2database/h2database/issues/1815.H2 requires a very special emulation, because
unnest is pretty much useless,
due to https://github.com/h2database/h2database/issues/1815.H2 requires a very special emulation, because
unnest is pretty much useless,
due to https://github.com/h2database/h2database/issues/1815.H2 requires a very special emulation, because
unnest is pretty much useless,
due to https://github.com/h2database/h2database/issues/1815.H2 requires a very special emulation, because
unnest is pretty much useless,
due to https://github.com/h2database/h2database/issues/1815.H2 requires a very special emulation, because
unnest is pretty much useless,
due to https://github.com/h2database/h2database/issues/1815.H2 requires a very special emulation, because
unnest is pretty much useless,
due to https://github.com/h2database/h2database/issues/1815.H2 requires a very special emulation, because
unnest is pretty much useless,
due to https://github.com/h2database/h2database/issues/1815.A SQL dialect for H2.
Identity column support for H2 2+ versions
Deprecated, for removal: This API element is subject to removal in a future version.
Use
H2JsonJdbcType insteadH2 generate_series function.
Descriptor for GeoDB Geometries.
A utility class to serialize from/to H2GIS WKB's.
H2 json_arrayagg function.
H2 requires binding JSON via
setBytes methods.Factory for
H2JsonArrayJdbcType.H2 json_exists function.
H2 requires binding JSON via
setBytes methods.Standard json_objectagg function that uses no returning clause.
H2 json_query function.
H2 json_table function.
H2 json_value function.
A SQL AST translator for H2.
H2 unnest function.
Sequence support for
H2Dialect.Sequence support for
H2Dialect.H2 xmlconcat function.
H2 xmlelement function.
H2 xmlforest function.
H2 xmlpi function.
An SQL dialect for the SAP HANA Platform and Cloud.
HANA generate_series function.
SAP HANA json_arrayagg function.
SAP HANA json_array function.
SAP HANA json_exists function.
SAP HANA json_objectagg function.
SAP HANA json_object function.
HANA json_table function.
HANA json_value function.
Sequence support for
HANADialect.Utility class that extracts some initial configuration from the database for
HANADialect.Deprecated.
Spatial dialects are no longer needed
An SQL AST translator for HANA.
HANA unnest function.
HANA xmltable function.
Simply as a matter of code structuring it is often worthwhile to put all of the execution code into a separate
handler (executor) class.
A StAX EventReader for
hbm.xml files to add namespaces in documents
not containing namespaces.Access to contextual information specific to a
hbm.xml mapping.MetadataSourceProcessor implementation for processing
hbm.xml mapping documents.Boot-time descriptor of a result set mapping as defined in an
hbm.xml file
either implicitly or explicitlyLogging for HBM transformation
Centralized utility functionality
Helper methods.
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.
Hibernate extension to the Jakarta Persistence
PersistenceConfiguration
contract.The best-ever implementation of a JPA
PersistenceProvider.Main annotation processor.
Interface implemented directly by entity proxies, exposing
access to the associated
LazyInitializer.The standard Hibernate implementation of
SchemaManagementTool
for performing schema management.Hibernate Spatial specific configuration settings.
Use Hibernate metadata to ignore cascade on entities.
Source-agnostic descriptor for explicit user-supplied Hibernate type information
Performs basic syntax highlighting for SQL using ANSI escape codes.
Utility class to map Hibernate properties to HikariCP configuration properties.
HikariCP Connection provider for Hibernate.
Optimizer which applies a 'hilo' algorithm in memory to achieve
optimization.
Collects all available hints for use the Jakarta Persistence hint system
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.Leverages ANTLR to build a parse tree from an HQL query.
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.
The logger interface for the Hibernate Spatial module.
Implement the array fill function by using
sequence_array.HSQLDB has a special syntax.
HSQLDB has a special syntax.
HSQLDB array_remove function.
HSQLDB array_set function.
HSQLDB has a special syntax.
A SQL dialect for HSQLDB (HyperSQL) 2.6.1 and above.
HSQLDB json_arrayagg function.
HSQLDB json_array function.
HSQLDB json_object function.
Sequence support for
HSQLDialect.A SQL AST translator for HSQL.
IdGeneratorResolver for handling generators assigned to id-bag mappings
EmbeddableMappingType implementation describing an
IdClassEmbeddableRepresentationStrategy for an IdClass mapping
Extension to the JPA
IdentifiableType contract.Common contract between Entity and MappedSuperclass sources.
Models an identifier (name), which may or may not be quoted.
Common contract for an identifier.
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 identifiersA mapping model object representing a collection with a synthetic "identifier" column,
that is, a surrogate key.
A criterion that expresses that the id of an entity is equal or not equal to some specified value.
Thrown by an
IdentifierGenerator implementation class when
ID generation fails.A classic extension point from the very earliest days of Hibernate,
this interface is no longer the only way to generate identifiers.
Identifies generators which potentially aggregate other
PersistentIdentifierGenerator generators.Models the definition of an identifier generator
Factory and helper methods for
IdentifierGenerator framework.Helper for handling
Identifier instances.Builder for
IdentifierHelper instances.Loads an entity by its primary identifier.
Standard implementation of load-by-id
Deprecated, for removal: This API element is subject to removal in a future version.
No direct replacement; see
EntityIdentifierMappingA contract for identifier relations between persisted entities
All attributes stored here are stored in their non-key form, see IdMetadataGenerator.
Contract describing source of identifier information for the entity.
Additional contract describing the source of an identifier mapping whose
nature is
EntityIdentifierNature.AGGREGATED_COMPOSITE.Additional contract describing the source of an identifier mapping whose nature is
EntityIdentifierNature.NON_AGGREGATED_COMPOSITE.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.A
Map where keys are compared by object identity,
rather than equals().Set implementation that use == instead of equals() as its comparison
mechanism.
Marker interface for second passes which bind id generators
SecondPass implementing delayed resolution of id-generators associated with an entity.
Meta-annotation used to mark another annotation as providing configuration
for a custom identifier generator.
Base contract for all identifier mappers.
Generates metadata for primary identifiers (ids) of versions entities.
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.
An immutable variant of the
BitSet class with some additional operations.An
EntityEntry implementation for immutable entities.Factory for the safe approach implementation of
EntityEntry.Controls for 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.
Because
ImplicitNamingStrategy often requires
access info from PersistentClass, we sometimes need to wait until the proper PersistentClass
is bound to the in-flight metadata, which means a SecondPass (in this version still using
second passes).Common implicit name source traits for all constraint naming: FK, UK, index
A naming strategy specifically for determining the implicit naming of
tables and sequences relating to enhanced identifier-generators.
Context for determining the implicit name of an entity's discriminator column.
Used in cases where we have no explicit AnyDiscriminatorValue
mapping which matches.
Context for determining the implicit name of an entity's primary table
Builder for implicit ResultSet mapping defined inline as part of a named native query
Context for determining the implicit name of an entity's identifier
column.
Context for determining the implicit name of a "join column" (think
JoinColumn).Context for determining the implicit name for a join table.
Used as a SettingProvider to enable backwards compatibility regarding
plural
List mappings when no OrderColumn,
ListIndexBase,
CollectionId or other annotations hinting at
the classification to use.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 entityModels the ResultSet mapping defined inline as part of a named native query definition
Context for determining the implicit name of an entity's tenant identifier
column.
For
ManyToOne and OneToOne
associations mapped to a JoinTable with no explicitly-specified
table name, we need to defer creation of the
Table object.Marks an arbitrary class as available for use in HQL queries by its unqualified name.
A
ModifiedColumnNamingStrategy that adds modified columns with the following rules:
For basic types, prioritizes audit annotation naming followed by physical column name appended with suffix.
For associations with single column foreign keys, behaves like basic types.
For associations with multiple column foreign keys, prioritizes audit annotation naming followed by using property name.
For embeddables, behaves like associations with multiple column foreign keys
Comparator for things that cannot be compared (in a way we know about).
An
IdentifierGenerator that returns a long, constructed by counting
from the maximum primary key value obtained by querying the table or tables at startup.Marks the annotated Java element as incubating, potentially
recursively.
A mapping model object representing an index on a relational database table.
Commonality for annotations which define indexes
An
OrderColumn annotationA consumer, like
BiConsumer, accepting 2 values and an index.Indexed collections include Lists, Maps, arrays and
primitive arrays.
A consumer, like
Consumer, accepting a value and its index.Describes a plural attribute that is indexed.
Provides access to information about existing index in the database
Deprecated, for removal: This API element is subject to removal in a future version.
Moved to
DialectThis implementation executes one
DatabaseMetaData.getTables(String, String, String, String[]) call
for each Entity in order to determine if a corresponding database table exists.Descriptor for
InetAddress handling.BasicValue.Resolution resolver for cases where no explicit
type info was supplied.
Defines the ability to perform post-creation processing for collection mappings.
Defines the ability to perform post-creation processing for entity mappings.
An in-flight representation of
Metadata while it is being built.The implementation of the in-flight
metadata collector contract.
Contract for extracting information about objects in the database schema(s).
Implementation of the InformationExtractor contract which uses the standard JDBC
DatabaseMetaData
API for extraction.A SQL
IN expression.Some extra data to the inheritance position of a class.
The inheritance type for a given entity hierarchy
JAXB marshalling for
InheritanceTypeA general SQL command to be used while initializing a schema.
An event that occurs when a collection wants to be
initialized
Defines the contract for handling of collection initialization events
generated by a session.
Defines a multi-step process for initializing entity, collection and
composite state.
Provides access to information about the owner/parent of a fetch
in relation to the current "row" being processed.
Producer for
Initializer based on a FetchParent.Internal helper to keep track of the various
Initializer instances being used during RowReader processing:
different types of initializers need to be invoked in different orders,
so rather than having to identify the order of initializers again during
the processing of each row we keep separated lists of initializers defined
upfront and then reuse these sets for the scope of the whole resultset's
processing.
Marker interface for optimizer which wishes to know the user-specified initial value.
Annotation to allow services to request injection of other services.
DeleteHandler for the in-line strategy
Support for multi-table SQM mutation operations which select the matching id values from the database back into
the VM and uses that list of values to produce a restriction for the mutations.
Describes in-line view source information.
Represents the InnoDB storage engine.
MatchingIdRestrictionProducer producing a restriction based on an in-values-list predicate.
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.Handler for dealing with multi-table SQM INSERT queries.
Delegate for dealing with generated values where the dialect supports
returning the generated column directly from the mutation statement.
Coordinates the logical insertion of collection entries which are not yet persistent.
A tri-predicate for including / excluding collection entries
from iterative processing inside
InsertRowsCoordinator.insertRows(org.hibernate.collection.spi.PersistentCollection<?>, java.lang.Object, org.hibernate.persister.collection.mutation.InsertRowsCoordinator.EntryFilter, org.hibernate.engine.spi.SharedSessionContractImplementor).OneToMany insert coordinator if the element is a
UnionSubclassEntityPersister.todo (6.2) - Would much prefer to split insert-values and
insert-select into individual contracts - something like
`InsertStatement` and `InsertSelectStatement` e.g.
Specialization of MutationStatement for inserts
Emulates the ANSI SQL-standard
overlay() function using insert()
substring(), and concat().ConverterDescriptor implementation for cases where we are handed
the AttributeConverter instance to use.
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.
Indicates a problem performing a dynamic instantiation
Marks the canonical constructor to be used for instantiation of an embeddable.
Strategy for instantiating a managed type
Java type descriptor for the Java
Instant type.Descriptor for handling Instant directly through the JDBC driver
Descriptor for
Integer handling.Descriptor for
INTEGER handling.Descriptor for
int[] handling.Defines a common API for dealing with data of integral data type.
Used in place of
TimestampaddFunction for databases which don't
support fractional seconds in the timestampadd() function.Indicates a problem integrating Hibernate and the Bean Validation spec.
Contract for extensions that integrate with Hibernate.
An object that provides a list of
Integrators to the JPA persistence provider.Allows user code to inspect and/or change entity property values before they are
written to the database, or after they are read from the database.
Marks the annotated Java element as forming part of the internal
implementation of Hibernate, meaning that clients should expect absolutely
no guarantees with regard to the binary stability from release to release.
Represents a generic unhandled problem which occurred while translating
HQL/JPQL.
Deprecated, for removal: This API element is subject to removal in a future version.
This enum still has exactly one member, and was
placed in a package from which it has no usages.
Specialized
JdbcWrapper contract for wrapped objects that can additionally be invalidatedThrown by
GraphParser to indicate textual entity graph representation parsing errors.Indicates a problem parsing the mapping document at a given
Origin.Thrown when a mapping is found to be invalid.
Indicates that an annotations was attached to a method incorrectly.
The inverse part of a "non-aggregated" composite identifier.
Contract for performing work in a manner that isolates it from any current transaction.
An
ArchiveDescriptor implementation leveraging the JarFile API for processing.Optional contract for ArchiveDescriptorFactory implementations to implement
to be able to adjust
<jar-file/> URL's defined in persistence.xml
files.An
ArchiveDescriptor that works on archives accessible through a JarInputStream.An ArchiveDescriptor implementation for handling archives whose url reported a JAR protocol (i.e., jar://).
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
Applies a filter defined by hbm-filter-def usage
Java class for anonymous complex type
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
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".
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
org.hibernate.FetchMode enum values
See `@org.hibernate.annotations.PolymorphismType`
See `@org.hibernate.annotations.Polymorphism`
public @interface PropertyRef {
String value();
}
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`
org.hibernate.FetchMode enum values
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`
JtaPlatform definition for JBoss Application Server.
Return a standalone JTA transaction manager for JBoss (Arjuna) Transactions or WildFly transaction client
Known to work for org.jboss.jbossts:jbossjta:4.9.0.GA as well as WildFly 11+
StorageAccess implementation wrapping a JCache
Cache reference.Sub-system logging related to JDBC batch execution
Models the function return when the JdbcOperationQueryCall represents a call to a database
function.
Models the actual call, allowing iterative building of the parts.
Controls extracting values from OUT/INOUT parameters.
Standard implementation of JdbcCallParameterExtractor
Controls extracting values from REF_CURSOR parameters.
Provides centralized access to JDBC connections.
Implementation of JdbcConnectionAccess for use in cases where we
leverage a ConnectionProvider for access to JDBC Connections.
Implementation of JdbcConnectionAccess for cases where we are provided
a JDBC Connection to use.
A
JDBCException indicating a problem communicating with the
database (can also include incorrect JDBC setup).Access to JDBC context for schema tooling activity.
Coordinates JDBC-related activities.
Standard implementation of
JdbcCoordinator.Models a JDBC data type.
Descriptor for
Date handling.Initial look at this concept we keep talking about with merging information from
DatabaseMetaData
and DialectActs as a wrapper to another
SqmFunctionDescriptor, rendering the
standard JDBC escape sequence {fn f(x, y)} around the invocation
syntax generated by its delegate.Acts as an observer for various events regarding JDBC interactions and doing one or more of -
delegating to StatisticsImplementor
delegating to SessionEventListenerManager
logging
Wraps a
SQLException arising from the JDBC driver.Descriptor for a table insert originating from a flush
Represents a literal in the SQL AST.
A formatter object for rendering values of a given Java type
as SQL literals of a certain JDBC/SQL type.
JdbcLiteralFormatter
implementation for handling binary literalsJdbcLiteralFormatter
implementation for handling boolean literalsJdbcLiteralFormatter
implementation for handling character dataJdbcLiteralFormatter
implementation for handling numeric dataJdbcLiteralFormatter
implementation for handling date/time literalsJdbcLiteralFormatter
implementation for handling UUID valuesThe strategy to use for applying locks to a
JdbcOperationQuerySelect.Sub-system logging related to JDBC interactions
Describes the mapping for things which can be expressed in a SQL query.
Container for one-or-more JdbcMappings
Determines how JDBC metadata is read by the schema management tooling.
Executor for model-mutation operations
JdbcOperation extension for model mutations stemming from
persistence context flushesA JDBC operation to perform.
Unifying contract for any SQL statement we want to execute via JDBC.
An anonymous call block (sometimes called an anonymous procedure) to be executed
on the database.
Basic contract for an insert operation
Standard 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
Standard implementation of JdbcParameterBindings
Access to the mapping between an SqmParameter and all of its JDBC parameters
The collection
Standard implementation of JdbcParameters
Conceptually similar to a List of JdbcParameters, but exposing a
read-only immutable contract.
Concrete builder for resource-local
TransactionCoordinator instances.An implementation of
TransactionCoordinator based on managing a
transaction through the JDBC Connection via JdbcResourceTransaction.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.
Standard JdbcSelectExecutor implementation used by Hibernate,
through
JdbcSelectExecutorStandardImpl.INSTANCEProvides access to services related to JDBC operations.
Standard implementation of the
JdbcServices contractStandard initiator for the standard
JdbcServices service
TODO : should this maybe be a SessionFactory service?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.
Registers the base
JdbcType instances.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
Access to
JdbcValueDescriptor valuesDescriptor for JDBC value within an operation.
Standard
JdbcValueDescriptor implementationProvides unified access to query results (JDBC values - see
RowProcessingState.getJdbcValue(org.hibernate.sql.ast.spi.SqlSelection) whether they come from
query cache or ResultSet.An
AbstractJdbcValues implementation for cases where we had a cache hit.The "resolved" form of
JdbcValuesMappingProducer providing access
to resolved JDBC results (SqlSelection) descriptors and resolved
domain results (DomainResult) descriptors.JdbcValuesMapping implementation used while building
ResultSetMapping references.
Producer for JdbcValuesMapping references.
Pluggable contract for providing custom
JdbcValuesMappingProducer implementations.Initiator for
JdbcValuesMappingProducerProviderStandardStandard
JdbcValuesMappingProducerProvider implementationHibernate's standard ResultSetMappingDescriptor implementation for cases
where Hibernate itself creates the mappings.
The "resolved" form of
JdbcValuesMapping providing access
to resolved (DomainResultAssembler) descriptors and resolved
initializer (Initializer) descriptors.Access to information about the underlying JDBC values
such as type, position, column name, etc
AbstractJdbcValues implementation for a JDBC ResultSet as the sourceEssentially 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.
Specifies the URL to the Jira issue associated with a test.
Grouping annotation for `@Jira`
Identifies the JIRA issue associated with a test.
Grouping annotation for `@JiraKey`
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.
Standard initiator for the standard
JndiService serviceContract that represents a secondary table join that is part of an entity hierarchy.
A mapping model object representing some sort of auxiliary table, for
example, an association table,
a secondary table, or a
table belonging to a joined subclass.
Deprecated, for removal: This API element is subject to removal in a future version.
Contract for entity mappings that support secondary table joins.
An implementation of
AbstractCollectionMetadataGenerator that builds collection metadata
and association mappings where the association uses a join column mapping.XML -> AnnotationUsage support for JaxbColumnJoined:
<join-column/>
<primary-key-join-column/>
<map-key-join-column/>
A mapping model object that represents a subclass in a "joined" or
"table per subclass"
inheritance hierarchy.
An
EntityPersister implementing the normalized
InheritanceType.JOINED inheritance
mapping strategy for an entity and its inheritance hierarchy.A persistent entity mapping that uses joined table(s) to store the hierarchy of entity types.
Specifies a join condition based on an arbitrary native SQL formula
instead of a column name.
Enumerates the possible kinds of join in HQL and ANSI SQL.
JTA platform implementation for JOnAS
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
needStandard implementation of
JpaAttributeConverter.Deprecated.
This is no longer implemented by any listener
The target for cast.
Specialization of
JpaJoin for Collection typed attribute joinsEncapsulates settings controlling whether Hibernate complies strictly
with certain debatable strictures of the JPA specification.
Marker interface for exceptions describing JPA compliance violations.
A
BeanLifecycleStrategy to use when JPA compliance is required
(i.e.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.
Parser for JPA XML descriptors (persistence.xml and referenced mapping files).
JPA-style event listener with support for resolving callback methods from
XML
or from annotation.
JPA defines 2 ways events callbacks can happen...
API extension to the JPA
Expression contractAPI extension to the JPA
From contractContract for expressions which model a SQL function call.
A special expression for the
json_exists function.The base for
json_exists function nodes.The behavior of the json exists expression when a JSON processing error occurs.
A special expression for the
json_query function.The base for
json_query function nodes.The behavior of the json query expression when a JSON path does not resolve for a JSON document.
The behavior of the json query expression when a JSON processing error occurs.
The kind of wrapping to apply to the results of the query.
A special expression for the definition of columns within the
json_table function.A special expression for the
json_table function.The behavior of the json exists expression when a JSON processing error occurs.
A special expression for the
json_value function.The base for
json_value function nodes.The behavior of the json value expression when a JSON path does not resolve for a JSON document.
The behavior of the json value expression when a JSON processing error occurs.
Extensions to the JPA-defined metamodel of
persistent Java types.
Deprecated, for removal: This API element is subject to removal in a future version.
SPI extending
JpaMetamodel.Transforms the version attribute and namespace of the JPA configuration files (persistence.xml and orm.xml) to
the default.
StAX EVentReader which handles a few oddities specific to JPA
orm.xml
Mainly we handle the namespace change.Contract for things that need to be aware of JPA
orm.xml-defined persistence-unit-defaults.Represents the
persistence-unit-defaults to be appliedAPI extension to the JPA
Path contractCommon contract for the forms of criteria that are "queryable" - can be
converted into a
Query.A query group i.e.
Models a query part i.e.
Models a
SELECT query.Represents the search order for a recursive CTE (common table expression).
Commonality between a JPA
JpaCriteriaQuery and JpaSubQuery,
mainly in the form of delegation to JpaQueryStructureAPI extension to the JPA
Selection contractA set returning function criteria.
Enumerates SPI-related settings that are specific to the use of Hibernate
as a JPA
PersistenceProvider.Enumerated setting used to control whether Hibernate looks for and populates
JPA static metamodel models of application's domain model.
JPA ties the notion of
SourceDescriptor and TargetDescriptor
together: meaning that a SourceDescriptor is specific to a given TargetDescriptor.API extension to the JPA
TupleElement contractA tuple of values.
Common contract for window parts used in window and aggregate functions.
Common contract for a
JpaWindow frame specification.A special expression for the
xmlelement function.A special node for column defined for a
xmltable function.A special expression for the
xmltable function.JtaPlatform implementation for JRun4 ASStandard json_arrayagg function.
Standard json_array function.
Specialized type mapping for
JSON_ARRAY and the JSON ARRAY SQL data type.Factory for
JsonArrayJdbcType.A
FunctionReturnTypeResolver that resolves a JSON encoded array type based on the arguments,
which are supposed to be of the element type.Specialized type mapping for
JSON_ARRAY and the JSON SQL data type.Factory for
JsonArrayJdbcType.Specialized type mapping for
JSON and the JSON SQL data type.Standard json_exists function.
A Helper for serializing and deserializing JSON, based on an
EmbeddableMappingType.Specialized type mapping for
JSON and the JSON SQL data type.Standard json_objectagg function.
Standard json_object function.
Standard json_query function.
Standard json_table function.
Standard json_value function.
A
ConnectionProvider implementation intended for testing Hibernate/JTA interaction.An isolation delegate for JTA environments.
A
Service that defines how Hibernate interacts with JTA on a certain
platform.Indicates a problem interacting with the underlying JTA platform.
Indicates problems accessing TransactionManager or UserTransaction through the JtaPlatform
Standard initiator for the standard
JtaPlatformA
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.An implementation of
CurrentSessionContext which scopes the notion
of a current session to a JTA transaction.JTA transaction sync used for cleanup of the internal session map.
Utility for dealing with JTA statuses.
Contract used to centralize
Synchronization handling logic.Adapter for abstracting the physical means of interacting with JTA transactions.
JtaTransactionAdapter for coordinating with the JTA TransactionManager
JtaTransactionAdapter for coordinating with the JTA UserTransaction
Concrete builder for JTA-based TransactionCoordinator instances.
An implementation of TransactionCoordinator based on managing a transaction through the JTA API (either TM or UT)
Special implementation of CallableStatementSupport for the jTDS driver.
Descriptor for JTS
Geometrys.Deprecated.
Use
JTSSpatialCriteriaBuilder insteadContract for declaring a column name of a foreign key.
Contract that defines an attribute that can participate in a key.
Manipulation of SQM query tree for key-based pagination.
A consumer, like
BiConsumer, accepting a key and a value (Map entry e.g.)Support for pagination based on a unique key of the result
set instead of the
offset.Support for pagination based on a unique key of the result
set instead of the
offset.Internal contract for a collection of SqmFunctionDescriptors, together with their key
A mapping model
Value which may be treated as an identifying key of a
relational database table.Descriptor for an attribute which is enabled for bytecode lazy fetching
Interceptor that loads attributes lazily
Information about the bytecode lazy attributes for an entity
Information about a particular bytecode lazy attribute grouping.
Specifies the fetch group for a persistent attribute of an entity
class.
This is an internal data structure designed for very specific needs;
it will most often be used as a replacement for EnumMap, although
the focus on the Enum aspect is modelled as an int primitive:
think of using the ordinals of an Enum to simulate the EnumMap.
The most general abstraction over collections which may be fetched lazily.
Indicates an attempt to access unfetched data outside the context
of an open stateful
Session.Handles fetching of the underlying entity for a proxy.
Contract for controlling how lazy properties get initialized.
Deprecated.
Prefer the form of these methods defined on
BytecodeLazyAttributeInterceptor insteadThe purpose of this table group is to defer creating the actual table group until it is really needed.
A
LimitHandler for DB2.DB2 10.5 xmlexists function.
DB2 10.5 xmlquery function.
Specialized FetchBuilder implementations which handle building fetches defined via:
hbm.xml definitions
calls to NativeQuery.addFetch(java.lang.String, java.lang.String, java.lang.String), and friends
Slight variation from
HiLoOptimizer, maintaining compatibility with the values generated by the
legacy Hibernate hilo based generators.A
LimitHandler for HSQL prior to 2.0.A
ModifiedColumnNamingStrategy that adds modified columns with the following rules:
If an audit annotation modified column name is supplied, use it directly with no suffix.
If no audit annotation modified column name is present, use the property name appended with suffix.
This is the default Envers modified column naming behavior.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.
Paging limits
Limited set of CollectionClassification
used in mapping a dynamic model.
JAXB marshalling for JPA's
AccessTypeContract 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.Initializes a map.
Represents a JPA callback using a dedicated listener
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.CollectionInitializer for PersistentList loading
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).
Context for loader-access objects.
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
Builder for SQL AST trees used by
Loader implementations.Helper used when generating the database-snapshot select query
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.
Represents a collection currently being loaded.
Common contract for SQL AST based loading
Centralize all options which can influence the SQL query needed to load an
entity.
Provides callback access into the context in which the LOB is to be created.
The callback contract for making use of the JDBC
Connection.Utilities for LOB creation
Contract for creating various LOB references.
Builds
LobCreator instances based on the capabilities of the environment.Strategy for how dialects need
LOB values to be merged.Enumeration of the JDBC LOB locator types
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.
Helper for resolving XML Schema references locally.
Wraps an exception thrown from a "local synchronization" (one registered in the SynchronizationRegistry).
Strategy based on ANSI SQL's definition of a "local temporary table" (local to each db session).
Strategy based on ANSI SQL's definition of a "local temporary table" (local to each db session).
Strategy based on ANSI SQL's definition of a "local temporary table" (local to each db session).
Java type descriptor for the
LocalTime type.Descriptor for handling LocalTime directly through the JDBC driver
When Hibernate loads an XSD we fully expect that to be resolved from our
jar file via ClassLoader resource look-up.
Emulates the ANSI SQL-standard
position() function using locate().A
JDBCException indicating a problem acquiring a lock
on the database.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.
Helper to deal with conversions (both directions) between
LockMode and
LockModeType.A concurrent safe EnumMap<LockMode>, suitable to
lazily associate values to the enum keys.
Helper to deal with conversions between
LockModeType and LockMode.JAXB marshalling for
LockModeTypeContains 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.A
Logger implementation which delegates to Log4J2 but makes it possible
to test for events being logged (not logged).Marker interface for user types which want to perform custom
logging of their corresponding values
Must specify one of
Logger.loggerNameClass() or Logger.loggerName()Helper for logging collection, entity and embeddable information.
Injects the ability to watch multiple for log messages being triggered.
Manages all of the MessageKeyWatcher defined by LoggingInspectionsScope
ParameterResolver implementation for resolving
LoggingInspectionsScope ParameterResolverRepresents a continuous logical connection to the database to the database via JDBC.
SPI contract for
LogicalConnection.Represents a
LogicalConnection where we manage obtaining and releasing the Connection as needed.Test helper to listen for logging events.
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.Abstract support (template pattern) for
ManagedBeanRegistry implementationsHibernate'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.Reads rows without producing a result.
Represents a
CurrentSessionContext the notion of a contextual session
is managed by some external entity (generally some form of interceptor, etc).This is a helper to encapsulate an optimal strategy to execute type checks
for interfaces which attempts to avoid the performance issues tracked
as JDK-8180450;
the problem is complex and explained better on the OpenJDK tracker;
we'll focus on a possible solution here.
This interface has been introduced to mitigate JDK-8180450.
Sadly, using
Sadly, using
BiConsumer will trigger a type pollution issue because of generics type-erasure:
BiConsumer's actual parameters types on the lambda implemention's
BiConsumer.accept(T, U) are stealthy enforced via checkcast, messing up with type check cached data.Helper for handling managed types defined in mapping XML, in either
metadata-complete or override mode
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.
Entity-valued collection-part mapped through a join table.
A mapping model object representing a many-to-one association.
Represents a plural attribute mapping of a
many-to-one or key-many-to-one.ColumnAndFormulaSource implementation handling many-to-one attribute mappings.
PropertySource implementation handling many-to-one attribute mappings.
A many-to-one association to an entity.
A mapping model object representing a collection of type
Map.For efficient lookup based on Class types as key,
a ClassValue should be used; however it requires
lazy association of values; this helper wraps
a plain HashMap but optimises lookups via the ClassValue.
Initializes a map.
Descriptor for
Map.Entry.Represents an immediate initialization of some sort (join, select, batch, sub-select)
of a persistent Map valued attribute.
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.
Acts as a virtual Member definition for dynamic (Map-based) models.
A mapping model object representing a mapped superclass
of an entity class.
Extension of the JPA
MappedSuperclassType contractImplementation of
MappedSuperclassType.Used to model
hbm.xml entity mapping where attributes come fromHibernate extension to the JPA
MapAttribute descriptorDeprecated.
Responsible for coordinating binding of mapping XML documents into
JAXB representations, producing
Binding references.Used in building the AuditConfiguration to allow callbacks for generated audit entities.
Describes an audit mapping context.
Declares operations used by implementors of
Type that are common to
"compiled" mappings held at runtime by a SessionFactory
and "uncompiled" mappings held by a Configuration.Values to use as defaults in the absence of certain mapping information.
Aggregates together information about a mapping document.
StAX EVentReader for reading `mapping.xml` streams
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.
Identifies specific mapping features used by a
DomainModelDescriptor.Descriptor for a mapping (XML) file.
Access to information about the runtime relational O/R mapping model.
Implementation of the JPA-defined contract
Metamodel.Logger used during mapping-model creation
Explicitly defined to better control (for now) the args
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
MapsIdStorageAccess impl wrapping a simple data Map (ConcurrentMap)
Factory for
MariaDBCastingJsonArrayJdbcType.A SQL dialect for MariaDB 10.5 and above.
MariaDB json_arrayagg function.
MariaDB json_array_append function.
MariaDB json_array function.
MariaDB json_objectagg function.
MariaDB json_query function.
MariaDB json_value function.
Sequence support for
MariaDBDialect.A SQL AST translator for MariaDB.
Deprecated.
This is a legacy of very ancient versions of Hibernate.
Strategy (pattern) for producing the restriction used when mutating a
particular table in the group of tables
Helper used to generate the SELECT for selection of an entity's identifier, here specifically intended to be used
as the SELECT portion of a multi-table SQM mutation
A strategy for matching strings using "like".
Indicates a problem resolving a member from ClassDetails
Contract for how we resolve the
Member for a give attribute context.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.
JdbcMutationOperation implementation for MERGE handlingMessageHelper methods for rendering log messages relating to managed
entities and collections typically used in log statements and exception
messages.
Injects the ability to watch for a log messages being triggered.
MessageIdWatcher implementation
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.Root
MetadataBuildingContext.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.Defines a context for storing information during the building of the
MappingMetamodelImpl.Container for configuration data collected during binding the metamodel.
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.RuntimeException used for errors during meta model generation.A data holder for a middle relation component (which is either the collection element or index):
- component mapper used to map the component to and from versions entities
- an index, which specifies in which element of the array returned by the query for reading the collection the data
of the component is
A class holding information about ids, which form a virtual "relation" from a middle-table.
A middle table component mapper which assigns a Map-type's element as part
of the data-portion of the mapping rather than the identifier.
A
MiddleComponentMapper specifically for MapKeyEnumerated.A component mapper for the @MapKey mapping: the value of the map's key is the id of the entity.
A component mapper for the @MapKey mapping with the name parameter specified: the value of the map's key
is a property of the entity.
A mapper for reading and writing a property straight to/from maps.
An implementation of
AbstractCollectionMetadataGenerator that builds collection metadata
and association mappings where the association uses a middle table mapping.Most databases don't have a function like
every() or any().Indicates that a column defined as part of a SQL ResultSet mapping was not part
of the query's ResultSet
Responsible for coordinating the binding of all information inside entity tags (
<class/>, etc).Helper functionality related to model mutations
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
Simple helper class to streamline hibernate-models interactions.
A TypePool suitable for loading user's classes,
potentially in parallel operations.
Defines a naming strategy for applying modified columns to the audited entity metamodel.
Marks a property which holds entity names that have been modified during each revision.
Returns modified entity names from a persisted revision info entity.
Contract for
PropertyMapper implementations to expose whether they contain any property
that uses PropertyData.isUsingModifiedFlag().PropertyNameGetter for modified flags
Multi mapper for dynamic components (it knows that component is a map, not a class)
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.
Standard MultiIdEntityLoader
Encapsulation of the options for loading multiple entities by id
When the number of ids to initialize exceeds a certain threshold, IN-predicate based
multi-key loaders will break
the initialization into "chunks".
Loader specialization for loading multiple loadable
references by primary, foreign or natural key.
Logging related to loading a loadable
by multiple "keys".
Strategy for determining an optimal size for loading by multiple keys.
Class responsible for extracting SQL statements from import script.
Base contract for options for multi-load operations
Loader for entities by multiple natural-ids
Standard MultiNaturalIdLoader implementation
MultiNaturalIdLoader implementation using SQL IN predicate to specify the ids
Batch support for natural-id multi loading
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
Specialized BaseSqmToSqlAstConverter implementation used during conversion
of an SQM mutation query tree representing into the various SQL AST trees
needed to perform that operation.
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.A service initiator for the
MultiTenantConnectionProvider service.Specifies a
MutabilityPlan for a basic value mapping.Describes the mutability aspects of a given Java type.
Something that exposes a MutabilityPlan
Deprecated.
Please get rid of it: such collections should be immutable.
Support for mutable boolean references, generally used from within
anon inner classes, lambdas, etc
A builder that generates a Serializable Object to be used as a key into the query results cache.
An
EntityEntry implementation for mutable entities.Factory for the safe approach implementation of
EntityEntry.A more performant version of
AtomicInteger in cases
where we do not have to worry about concurrency.A more performant version of
AtomicLong in cases
where we do not have to worry about concurrency.Mutability plan for mutable objects
Mutable object reference.
A mutable (as in non-`@Immutable`) value.
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
Initiator for the
MutationExecutorService serviceStandard
MutationExecutorGrouping of table mutations for the given target for
the given type of mutation
Builder (pattern) for
TableMutation referencesMutationGroup for cases where we have no mutations.
MutationGroup implementation for cases where we have a
single table operation
Standard MutationGroup implementation for cases with multiple table mutations
Mutation 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 "hibernate.dialect.storage_engine=innodb" environment variable or JVM system property instead.
Deprecated.
Spatial Dialects are no longer needed
Deprecated.
Use "hibernate.dialect.storage_engine=innodb" environment variable or JVM system property instead.
Deprecated.
Spatial Dialects are no longer needed
Factory for
MySQLCastingJsonArrayJdbcType.A SQL dialect for MySQL 8 and above.
Descriptor for MySQL Geometries.
MySQL json_arrayagg function.
MySQL json_array function.
MySQL json_exists function.
MySQL json_objectagg function.
MySQL json_object function.
MySQL json_query function.
MySQL json_table function.
MySQL json_value function.
Utility class that extract some initial configuration from the database
for
MySQLDialect and related dialects.Deprecated.
SpatialDialects are no longer needed in Hibernate 6
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
NamedObjectRepositoryCommonality for annotations that are named within a repeatable container.
Mainly this is used to support legacy sequence exporting.
Used to locate named CDI beans.
Represents a "memento" (disconnected, externalizable form) of a ProcedureCall
Implementation of NamedCallableQueryMemento
A "disconnected" copy of the metadata for a parameter, that can be used in ProcedureCallMementoImpl.
Models a @NamedEntityGraph
Boot-time descriptor of a named HQL query, as defined in
annotations or xml
Definition of a named query, defined in the mapping metadata.
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
Keeps details of a named native SQL query
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
Holds all the information needed from a named procedure call declaration in order to create a
ProcedureCallImplA 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.
Standard
NamedResultSetMappingMemento implementationProvides a standard implementation that supports the majority of the HQL
functions that are translated to SQL.
Provides a standard implementation that supports the majority of the HQL
functions that are translated to SQL.
Represents a reference to a "named" table in a query's from clause.
Enumerated values representing the level of support for catalog and schema.
Represents a namespace (named schema/catalog pair) with a Database and manages objects defined within.
Helper contract for dealing with naming strategies.
Indicates if and how a database supports the use of nationalized
character data (Unicode).
Specifies that the annotated character data should be stored with
nationalization support.
Manages a mapping between nationalized and non-nationalized variants of JDBC types.
Generator that picks a strategy based on the dialect.
Generator that picks a strategy based on the dialect.
Access the values defining a native non-select query
Within the context of an active session,
an instance of this type represents an executable query written in the
native SQL dialect of the underlying database.
Allows access to further control how collection returns are mapped back
from result sets.
Allows access to further control how join fetch returns are mapped back
from result sets.
Simple unification interface for all returns from the various
addXYZ()
methods.A
NativeQuery.ResultNode which can be a query result.Allows access to further control how properties within a root or join
fetch are mapped back from the result set.
Allows access to further control how root returns are mapped back from
result sets.
A
TupleTransformer 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.
Defines a key for caching natural identifier resolutions into the second level cache.
Contract for managing transactional and concurrent access to cached naturalId
data.
Specialized DomainDataCachingConfig describing the requested
caching config for the natural-id data of a particular entity (hierarchy)
Loads an entity by its natural identifier, which may be a
composite value comprising more than one attribute of the
entity.
Loader for
NaturalId handlingOptions for loading by natural-id
Logging related to natural-id operations
Mapping for an entity's natural-id, if one is defined.
Loads multiple instances of a given entity type at once, by
specifying a list of natural id values.
A ternary boolean enum for describing the mutability aspects of an
attribute as a natural id.
Standard support for
NaturalIdDataAccess
using the AccessType.NONSTRICT_READ_WRITE access type.Standard support for
NaturalIdDataAccess
using the AccessType.READ_ONLY access type.Standard support for
NaturalIdDataAccess
using the AccessType.READ_WRITE access type.Manages the cached resolutions related to natural-id (to and from identifier)
Statistics pertaining to the execution of queries which resolve a natural
id lookup against the database.
NaturalId cache statistics of a specific entity
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.
This is in all practical terms a
Map<NavigablePath, Initializer>
but wrapping a HashMap to keep the client code readable as we need
to:
have a way to log all initializers
prevent type pollution from happening on Initializer retrieval
I also consider it good practice to only expose the minimal set of
operations the client actually needs.A compound path which represents a
ModelPart
and uniquely identifies it with the runtime metamodel.Descriptor for
NCHAR handling.Marker interface for non-contextually created
NClob instances.Descriptor for
NClob handling.Descriptor for
NCLOB handling.Manages aspects of proxying
NClobs for non-contextual creation, including proxy creation and
handling proxy invocations.Model a column which is relative to a base expression e.g.
An identifier mapper that is meant to support nested
Embeddable instances
inside an existing EmbeddedId identifier hierarchy.Sequence support for dialects which support the common
Oracle-style syntax
seqname.nextval.A form of
BatchKeyAccess for cases where batching is not wanted, which is
signified by a BatchKey of nullIndicates a condition where a second-level cache implementation was expected to be available, but
none was found on the classpath.
Factory used if no caching enabled in config...
Common contract for all nodes in the order-by fragment AST
Adapts the JPA CriteriaBuilder to generate SQM nodes.
The non-configured form of JTA platform.
Support for non-aggregated composite values
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
A "non-aggregated" composite identifier.
LobCreator implementation using non-contextual or local creation, meaning that we generate the LOB
references ourselves as opposed to delegating to the JDBC connection.Deprecated, for removal: This API element is subject to removal in a future version.
No direct replacement
Tracks non-nullable transient entities that would cause a particular entity insert to fail.
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.small low memory class to keep track of the number of elements in a collection
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.Exception indicating that the given class is not known as a CDI bean - triggers
fallback handling
When applied to a field, indicates that this field should not be audited.
Indicates that a many to one,
one to one, or
many to many association
maps to a column holding foreign keys, but without a foreign key
constraint, and which may therefore violate referential integrity.
Specifies how Hibernate should handle the case of an orphaned foreign
key with no associated row in the referenced table.
Indicates that the test tests functionality that has not been implemented yet.
Deprecated, for removal: This API element is subject to removal in a future version.
By definition, something "not yet implemented" is something we are actively seeking to remove
JUnit 5 extension used to support
NotImplementedYet handlingIndicates 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.
Exception indicating an attempt to access the CDI BeanManager before it is ready for use
Are the columns forced to null, not null or not forced
Implements the algorithm for validating property values for illegal null values
Descriptor for binding nulls with Types.NULL
Nullness restriction - IS (NOT)? NULL
Utility class for the Nullness Checker.
Utility class for the Nullness Checker.
The order of null.
Defines the possible null handling modes.
Deprecated.
Use Jakarta Persistence Nulls instead.
Indicates an attempt to register a null synchronization.
The base for generate_series function implementations that use a static number source.
Handles conversion to/from
Boolean as 0 (false) or 1 (true)Descriptor for
NUMERIC handling.Descriptor for
NVARCHAR handling.Oracle 8i had no
coalesce() function,
so we emulate it using chained nvl()s.Descriptor for
Object[] handling, usually used for tuples.Thrown when the user tries to do something illegal with a deleted object.
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.
Source for database object names (identifiers).
Thrown when
Session.find(Class, Object) fails to select a row
with the given primary key (identifier value).Descriptor for binding objects, but binding nulls with Types.VARBINARY
Descriptor for binding objects, but binding nulls with Types.NULL
Descriptor for binding objects, but binding nulls with the resolved parameter type
JtaPlatform implementation for the OC4J (Oracle) AS.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.Selects data from an audit entity.
Selects data from a relation middle-table only.
A mapping model object representing a many-to-one association.
order( id, ...
A table group for one-to-many plural attributes.
A mapping model object representing a many-to-one association.
Property mapper for not owning side of
OneToOne relation.Property mapper for
OneToOne with PrimaryKeyJoinColumn relation.We have to handle
OneToOne associations
in a second pass.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.Deprecated, for removal: This API element is subject to removal in a future version.
No replacement with JUnit 5 at the moment.
Deprecated, for removal: This API element is subject to removal in a future version.
No replacement with JUnit 5 at the moment.
When a transient entity is passed to lock(), we must inspect all its collections and
associate any uninitialized PersistentCollections with this session
associate any initialized PersistentCollections with this session, using the
existing snapshot
throw an exception for each "new" collection
When an entity is passed to replicate(), and there is an existing row, we must
inspect all its collections and
associate any uninitialized PersistentCollections with this session
associate any initialized PersistentCollections with this session, using the
existing snapshot
execute a collection removal (SQL DELETE) for each null collection property
or "new" collection
When an entity is passed to update(), we must inspect all its collections and
1.
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.
Handles conversion to/from Hibernate's OptimisticLockStyle enum during
JAXB processing.
JAXB marshalling for
OptimisticLockStyleEnumerates the possible optimistic lock checking strategies.
Commonality between sequence-based and table-based generators
Performs optimization on an optimizable identifier generator.
Factory for
Optimizer instances.Legacy "upsert" handling, conditionally using INSERT, UPDATE and DELETE
statements as required for optional secondary tables.
A
LimitHandler for databases which support the
ANSI SQL standard syntax FETCH FIRST m ROWS ONLY
and OFFSET n ROWS FETCH NEXT m ROWS ONLY.Oracle concatenation function for array and an element.
Oracle concatenation function for arrays.
Oracle array_fill function.
Oracle array_get function.
Descriptor for
ARRAY handling.Factory for
OracleArrayJdbcType.Oracle array_remove function.
Oracle array_remove_index function.
Oracle array_replace function.
Oracle array_set function.
Oracle array_slice function.
Oracle array_to_string function.
Oracle array_trim function.
Standard implementation of
CallableStatementSupport.A SQL dialect for Oracle 19c and above.
Represents a named
enum type on Oracle 23ai+.The following class provides some convenience methods for accessing JdbcType instance,
that are loaded into the app class loader, where they have access to the JDBC driver classes.
Oracle json_arrayagg function.
Oracle json_array_append function.
Specialized type mapping for
JSON and the BLOB SQL data type for Oracle.Oracle json_array function.
Oracle json_array_insert function.
Specialized type mapping for
JSON and the JSON SQL data type for Oracle.Factory for
OracleJsonArrayJdbcType and OracleJsonArrayBlobJdbcType.Specialized type mapping for
JSON and the BLOB SQL data type for Oracle.Oracle json_insert function.
Specialized type mapping for
JSON and the JSON SQL data type for Oracle.Oracle json_mergepatch function.
Oracle json_objectagg function.
Oracle json_object function.
Oracle json_remove function.
Oracle json_replace function.
Oracle json_set function.
Oracle json_table function.
Oracle json_value function.
Descriptor for
TABLE handling.Factory for
OracleNestedTableJdbcType.Represents a named
enum type on Oracle 23ai+.Sequence support for
OracleDialect.Utility class that extract some initial configuration from the database for
OracleDialect.Deprecated.
A SpatialDialect is no longer required.
Deprecated.
A SpatialDialect is no longer required.
A SQL AST translator for Oracle.
Custom
TruncFunction for Oracle which uses emulation when truncating datetimes to secondsThe Oracle specific JDBC type code.
Oracle unnest function.
Factory for
OracleXmlArrayJdbcType.Oracle xmltable function.
A rule for sorting a query result set.
Contact to define if a plural attribute source is orderable or not.
Represents the translation result.
Envers specific FunctionContributor
Responsible for performing the translation of the order-by fragment associated
with an order set or map.
A specialization of the map type, with (resultset-based) ordering.
Revision number generator has to produce values in ascending order (gaps may occur).
Describes a sequence that supports ordered sequences.
Models an ordered set-aggregate function expression at the SQL AST level.
A specialization of the set type, with (resultset-based) ordering.
Contract for anything that can be a sort expression
This class provides an empty implementation of
OrderingParserListener,
which can be extended to create a listener which only needs to handle a subset
of the available methods.This class provides an empty implementation of
OrderingParserVisitor,
which can be extended to create a visitor which only needs to handle a subset
of the available methods.This interface defines a complete listener for a parse tree produced by
OrderingParser.This interface defines a complete generic visitor for a parse tree produced
by
OrderingParser.An individual sort specification in an order-by fragment
Represents an
enum type for databases like MySQL and H2.The HQL
ordinal() function returns the ordinal value of an enumDescriptor regarding an ordinal parameter.
Describes the origin of an XML document.
Used for specifying restrictions on the identifier.
JtaPlatform implementation for OrionCommon 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.
Represents a "nested level" in the mapping defaults stack.
Allows wrapping another ClassFileLocator to add the ability to define
resolution overrides for specific resources.
Marker interface for valued model parts that have a declaring/owner type.
Descriptor for a package (as indicated by a package-info.class file).
EnhancementSelector based on package name
Identifies a page of query results by page size
and page number.
A pair of objects.
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.
The standard ParameterMarkerStrategy based on the standard JDBC
? markerAccess to known information about the parameters for a query.
Encapsulates metadata about parameters encountered within a query.
Thrown to indicate a misuse of a parameter
JAXB marshalling for
ParameterModeThe single available method
ParameterParser.parse(java.lang.String, org.hibernate.query.sql.spi.ParameterRecognizer, boolean) is responsible for parsing a
native query string and recognizing tokens defining named of ordinal
parameters and providing callbacks about each recognition.Indicates a problem during parameter recognition via
ParameterRecognizerDefines the "callback" process of recognizing native query parameters.
Parameters of a query, built using
QueryBuilder.The style/strategy of parameter registration used in a particular procedure call definition.
Indicates Hibernate is unable to determine the type details for a parameter.
Describes how a parameter is used in a mutation statement
Reference the property as a pointer back to the owner (generally the owning entity).
Describes the information gleaned from a
<persistence-unit/>
element in a persistence.xml file whether parsed directly by
Hibernate or passed to us by an EE container as an instance of
PersistenceUnitInfo.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.
Delegate for handling function "templates".
A
PersistEvent represents a persist operation
applied to a single entity.PersistenceUnitDescriptor wrapper around PersistenceConfiguration
Represents the state of "stuff" Hibernate is tracking, including (not exhaustive):
entities
collections
snapshots
proxies
Settings related to persistence-units
Abstraction for dealing with
<persistence-unit/> information
specified in the persistence.xml file, which might be:
passed by the Jakarta EE container as an instance of
PersistenceUnitInfo, or,
in an SE environment, parsed by Hibernate itself.Implementation of
PersistenceUnitInfo for testing use.Implementation of
PersistenceUnitInfo for testing use.TODO : javadoc
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.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.Cache hierarchy and member resolution, taking care to not leak
references to Class instances.
Used by Hibernate to parse
persistence.xml files in SE environments.A dummy collection wrapper for an array.
Hibernate extension to the JPA
Attribute contractThe base contract for interceptors that can be injected into
enhanced entities for the purpose of intercepting attribute access
An unordered, un-keyed collection that can contain the same element
multiple times.
A mapping model object that represents an entity class.
Defines a graph, where the vertexes are all persistent classes, and there is an edge from
p.c.
Persistent collections are treated as value objects by Hibernate.
Data describing the change of a single object in a persistent collection (when the object was added, removed or
modified in the collection).
A unique identifier for a collection work unit.
Contract for a persisted entity mapping.
Utility class meant to help facilitate the instantiation of
PersistentEntity implementations.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 source of data on persistent properties of a class or component.
A persistent wrapper for a
Set.A persistent wrapper for a
SortedMap.A persistent wrapper for a
SortedSet.This is a strategy that mimics temporary tables for databases which do not support
temporary tables.
This is a strategy that mimics temporary tables for databases which do not support
temporary tables.
This is a strategy that mimics temporary tables for databases which do not support
temporary tables.
Given an entity or collection mapping, resolve the appropriate persister class to use.
Contract for creating persister instances (both
EntityPersister and CollectionPersister varieties).The standard Hibernate
PersisterFactory implementationAn 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.
An old-style query might pass positional numbers of Query parameters as strings.
A pessimistic locking strategy where
LockMode.PESSIMISTIC_READ
is obtained via a select statement.A pessimistic locking strategy where a lock is obtained via
an update statement.
A pessimistic locking strategy where
LockMode.PESSIMISTIC_WRITE
lock is obtained via a select statement.A pessimistic locking strategy where a lock is obtained via
an update statement.
Type Descriptor for the Postgis Geography type
Type Descriptor for the Postgis Geometry type
Type Descriptor for the Postgis Geography type
Type Descriptor for the Postgis Geometry type
The following class provides some convenience methods for accessing JdbcType instance,
that are loaded into the app class loader, where they have access to the JDBC driver classes.
Enumerates valid combinations of
ConnectionAcquisitionMode and
ConnectionReleaseMode.Provides access to manage "transactionality" via the JDBC
Connection.A set of rules for determining the physical names of objects in a relational
database schema from the logical names specified by the object/relational
mappings.
Converts
camelCase or MixedCase logical names to snake_case.Standard implementation of the
PhysicalNamingStrategy contract.Contract for an attribute that represents multiple values.
A "parameter object" for creating a plural attribute
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
Allows callback after creation of the attribute mapping.
Attribute metadata contract for a plural attribute.
Describes the nature of the collection itself as declared by the metadata.
Represents the collection as a DomainPath
Defines the index of a persistent list/array
Extension of the JPA-defined
PluralAttribute interface.Variation of
PooledOptimizer which interprets the incoming database
value as the lo value, rather than the hi value.Variation of
PooledOptimizer which interprets the incoming database
value as the lo value, rather than the hi value, as well as using thread local
to cache the generation state.Optimizer which uses a pool of values, storing the next low value of the range
in the database.
An event that occurs after a collection is recreated
Called after recreating a collection
An event that occurs after a collection is removed
Called after removing a collection
An event that occurs after a collection is updated
Called after updating a collection
Called after an entity delete is committed to the datastore.
Called after an entity insert is committed to the datastore.
Called after an entity update is committed to the datastore.
Occurs after deleting an item from the datastore
Called after deleting an item from the datastore
The standard PostDeleteEventListener implementation
Deprecated.
Deprecated.
A SpatialDialect is no longer required.
Deprecated.
A SpatialDialect is no longer required.
Deprecated.
A SpatialDialect is no longer required.
An SQL dialect for Postgres Plus
PostgreSQL variant of the function to properly return
null when the array argument is null.PostgreSQL variant of the function to properly return
null when one of the arguments is null.Special array constructor function that also applies a cast to the array literal,
based on the inferred result type.
Custom casting for the array fill function.
Descriptor for
ARRAY handling.Factory for
PostgreSQLArrayJdbcType.PostgreSQL variant of the function.
PostgreSQL variant of the function.
PostgreSQL array_trim emulation, since the function was only introduced in version 14.
PostgreSQL implementation of CallableStatementSupport.
Factory for
PostgreSQLCastingJsonArrayJdbcType.A SQL dialect for PostgreSQL 12 and above.
Represents a named
enum type on PostgreSQL.PostgreSQL json_arrayagg function.
PostgreSQL json_array_append function.
PostgreSQL json_array function.
PostgreSQL json_array_insert function.
Factory for
PostgreSQLCastingJsonArrayJdbcType.Factory for
PostgreSQLCastingJsonArrayJdbcType.PostgreSQL json_exists function.
PostgreSQL json_insert function.
PostgreSQL json_mergepatch function.
PostgreSQL json_objectagg function.
PostgreSQL json_object function.
PostgreSQL json_query function.
PostgreSQL json_remove function.
PostgreSQL json_replace function.
PostgreSQL json_set function.
PostgreSQL json_table function.
PostgreSQL json_value function.
PostgreSQL doesn't support min/max for uuid yet,
but since that type is comparable we want to support this operation.
Represents a named
enum type on PostgreSQL.Sequence support for
PostgreSQLDialect.A SQL AST translator for PostgreSQL.
Custom
TruncFunction for PostgreSQL which uses the dialect-specific function for numeric truncationPostgreSQL only supports the two-argument
trunc and round functions
with the following signatures:
trunc(numeric, integer)
round(numeric, integer)
PostgreSQL unnest function.
PostgreSQL xmlquery function.
Occurs after inserting an item in the datastore
Called after inserting an item in the datastore
The counterpart to
IdentifierGenerator for values generated by the database.Occurs after an entity instance is fully loaded.
Occurs after an entity instance is fully loaded.
Occurs after the datastore is updated
Called after updating the datastore
Occurs after the datastore is updated
Called after updating the datastore
This is just a stub, since we don't yet have a
@PostUpsert callbackAn 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
PreparedStatementDescribes a particular
PreparedStatement within a groupGrouping of
PreparedStatement references.PreparedStatementGroup
implementation for cases where we have just a single operationA group of
PreparedStatementDetails references related to multi-table
entity mappings.This
ConnectionProvider extends any other ConnectionProvider that would be used by default taken the current configuration properties, and it
intercept the underlying PreparedStatement method calls.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.
Helper for primitive/wrapper utilities.
Describes a particular primitive/wrapper combo
Defines support for executing database stored procedures and functions.
Standard implementation of
ProcedureCallSpecialization of the
Outputs contract providing access to the stored procedure's registered
output parameters.Implementation of ProcedureResult.
Describes an input value binding for any IN/INOUT parameters.
Implementation of the
ProcedureParameterBinding contract.Optional
Type contract for implementations that are aware of how to extract values from
store procedure OUT/INOUT parameters.SPI extension for ProcedureParameter
Specialized ParameterMetadataImplementor for callable queries implementing
expandable parameter registrations
Optional
Type contract for implementations enabled
to set store procedure OUT/INOUT parameters values by name.Implementation of the
Mock objects based on standard
annotation processor APIs.A mapping model object representing a property or field of an entity
or embeddable class.
PropertyAccess for accessing the wrapped property via get/set pair, which may be nonpublic.Indicates a problem while building a
PropertyAccess.PropertyAccess for accessing the wrapped property via get/set pair, which may be nonpublic.PropertyAccess for handling non-aggregated composites.A
PropertyAccess for byte code enhanced entities.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.
A
PropertyAccess based on mix of getter method or field.PropertyAccess implementation that deals with an underlying Map
as the container, using Map.get(java.lang.Object) and Map.put(K, V).A
PropertyAccess based on mix of getter/setter method and/or field.Describes a strategy for accessing a persistent attribute,
for example: field, JavaBean-style property, or whatever.
Defines a strategy for accessing property values via a get/set pair, which may be nonpublic.
Defines a strategy for accessing property values via a CompositeUserType.
A
PropertyAccessStrategy that deals with non-aggregated composites.Defines a strategy for accessing property values via a get/set pair, which may be nonpublic.
Defines a strategy for accessing property values directly via a field, which may be non-public.
A PropertyAccessStrategy that selects between available getter method or field.
A PropertyAccessStrategy that selects between available getter/setter method and/or field.
Contract for resolving the
PropertyAccessStrategy to use.Standard implementation of PropertyAccessStrategyResolver
The boot-time representation of an audited property.
Describes an attribute with a property access.
A stateful binder responsible for creating
Property objects.Access to the members of a class which define a persistent attribute
as defined by the JPA specification and AccessType.
Details about an attribute as we process the boot model.
The runtime representation of an audited property.
Deprecated, for removal: This API element is subject to removal in a future version.
No direct replacement
An audit query criterion where a function is compared to a property.
Property holder abstract property containers from their direct implementation
This factory is here to build a PropertyHolder and prevent .mapping interface adding
Retrieve all inferred data from an annotated element
Provides a function to get the name of a property, which is used in a query, to apply some restrictions on it.
Indicates that an expected getter or setter method could not be
found on a class.
Allows to specify the target of a foreign-key using a "target attribute" as opposed to
join column(s).
Thrown when the (illegal) value of a property can not be persisted.
ManagedBean implementation for cases where we have been handed an actual
instance to use.A service provided as-is.
Helper for handling checks to see whether Hibernate is the requested
PersistenceProvider.A proxy configuration allows the definition of an interceptor object that decides on the behavior of a proxy.
An interceptor object that is responsible for invoking a proxy's method.
A static interceptor that guards against method calls before the interceptor is set.
Contract for runtime, proxy-based lazy initialization proxies.
An interface for factories of
proxy factory instances.Most commonly the
ProxyFactoryFactory will depend directly on the chosen BytecodeProvider,
however by registering them as two separate services we can allow to override either one
or both of them.Most of this code was originally an internal detail of
PojoEntityTuplizer,
then extracted to make it easier for integrators to initialize a custom
ProxyFactory.Reassociates uninitialized proxies with the session
Specialized "intermediate" SemanticPathPart for processing domain model paths.
Specialized consumer for processing domain model paths occurring as part
of a join predicate.
Models the qualified name of a database object.
Parses a qualified name.
Contract for rendering qualified object names for use in queries, etc.
Standard implementation of
QualifiedObjectNameFormatter which uses information reported
by DatabaseMetaData to render qualified names.Within the context of an active session,
an instance of this type represents an executable query, either:
a query written in HQL,
a named query written in HQL or native SQL, or
a criteria query.
An error that occurs binding an argument to a query parameter.
Responsible for reading named queries defined in annotations and registering
NamedQueryDefinition objects.A class for incrementally building a HQL query.
Configures the layout for the entity or collection data in a query cache.
QueryCachePutManager implementation for cases where we will be putting
Query results into the cache.
Constants used in JPQL queries.
Aggregation and encapsulation of the components Hibernate uses
to execute queries (HQL, Criteria and native)
Aggregation and encapsulation of the components Hibernate uses
to execute queries (HQL, Criteria and native)
User configuration options related to the
QueryEngine.A problem occurred translating a Hibernate query to SQL due to illegal query
syntax, an operation which is not well-typed, an unresolvable reference to
an entity or attribute, an unknown named query, or any similar problem.
Enumerates the possible flush modes for execution of a
Query.Builds query generators, for reading collection middle tables, along with any related entities.
Deprecated, for removal: This API element is subject to removal in a future version.
Moved to
DialectDeprecated.
Use
AvailableHints insteadCache for various parts of translating or interpreting queries.
Standard QueryInterpretationCache implementation
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.
The standard implementation of
QueryParameterBinding.Manages all the parameter bindings for a particular query.
Manages the group of QueryParameterBinding 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.
QueryParameter impl for named-parameters in HQL, JPQL or Criteria queries.
QueryParameter impl for positional-parameters in HQL, JPQL or Criteria queries.
A special table group for a sub-queries.
A table reference for a query part.
Common contract for select and mutation query plans
Processing of queries from XML
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.
The standard implementation of the Hibernate QueryCache interface.
Defines the contract for a cache region that stores query results.
Bind query
Handles splitting queries containing unmapped polymorphic references.
Query implementation based on an SQMStatistics relating to a particular query written in HQL or SQL.
Query statistics (HQL and SQL)
Thrown when a database query timeout occurs.
Indicates a mismatch between the expected and actual result types of a query.
If a collection is extra lazy and has queued ops, we still need to
process them.
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
FloatJdbcTypeAbstract superclass of visitors that reattach collections.
Contract for JDBC REF_CURSOR support.
Service initiator for the
RefCursorSupport serviceSpecialized CacheEntry for storing direct references to entity instances.
Utility class for various reflection operations.
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.
Initiator for the
RegionFactory service.A registered conversion.
The JTA
Synchronization Hibernate registers when needed for JTA callbacks.Centralized binding of columns and formulas.
Unifying interface for
ColumnSource and DerivedValueSource.Contract for a container of
RelationalValueSource references.Implementations of this interface provide a method to generate queries on a
relation table (a table used for mapping relations).
Defines the actions on how to handle
EntityNotFoundException cases when a relation
between two entities (audited or not) cannot be found in the data store.Type of a relation between two entities.
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 deprecatedA general purpose constructor which accepts the session.
Enumeration of the built-in ways that Hibernate can represent the
application's domain model.
Indicates that the annotated test class/method should only
be run when the indicated Dialect is being used.
Deprecated, for removal: This API element is subject to removal in a future version.
Use JUnit 5 and
RequiresDialect instead.Annotation used to indicate that a test should be run only when the current dialect supports the
specified feature.
Deprecated, for removal: This API element is subject to removal in a future version.
Use JUnit 5 and
RequiresDialectFeature instead.Annotation used to indicate that a test should be run only when the current dialect supports the
specified feature.
Deprecated, for removal: This API element is subject to removal in a future version.
Use JUnit 5 and
RequiresDialects instead.JtaPlatform implementation for ResinUsed 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
Adapts ClassLoading as a ResourceStreamLocator
Things that can have
SQLRestriction,
and/or Filter applied to them.Specialized TableMutation implementation for mutations which
define a where-clause
Specialized
TableMutationBuilder implementation for building mutations
which have a where clause.A restriction (predicate) to be applied to a query
Responsible for building a single
DomainResult.ResultBuilder specialization for cases involving scalar results.
ResultBuilder specialization for cases involving embeddable results.
ResultBuilder specialization for cases involving entity results.
ResultBuilder specialization for cases involving dynamic-instantiation results.
Deprecated.
Use an
Expectation class instead.JAXB marshalling for
ExecuteUpdateResultCheckStyleDefines 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
Implementation of
ResultMementoBasic for scalar (basic) results.Consumes
JdbcValues and returns the consumed values in whatever form this
consumer returns, generally a List or a ScrollableResultsAccess to a JDBC
ResultSet and information about it.JdbcValuesMappingProducer implementation based on a graph of ResultBuilder
and FetchBuilder reference.
ResultSetMapping implementation used while building
ResultSetMapping references.
Responsible for processing the
ResultSetMapping defined by a
NativeSelectQueryDefinition and
preprocessing it for consumption by SQLQueryParser.Context ("parameter object") used in resolving a
NamedResultSetMappingMementoImplSqlSelection implementation used while building
ResultSetMapping references.
Models a return that is a result set.
Standard implementation of the
ResultSetReturn contractDeprecated.
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.
Marks an entity to be created whenever a new revision is generated.
Gets a revision number from a persisted revision info entity.
An implementation of this class, having a no-arg constructor, should be passed as an argument to the
RevisionEntity annotation.Marks a property which will hold the number of the revision in a revision entity, see
RevisionListener.Used for specifying restrictions on the revision number, corresponding to an audit entity.
Used for specifying restrictions on a property of the revision entity, which is associated with an audit entity.
RevisionsOfEntityAssociationQuery<Q extends org.hibernate.envers.query.internal.impl.AuditQueryImplementor>
An
AuditAssociationQuery implementation for RevisionsOfEntityQuery.Marks a property which will hold the timestamp of the revision in a revision entity, see
RevisionListener.Type of the revision.
Used for specifying restrictions on the revision number, corresponding to an audit entity.
A hibernate type for the
RevisionType enum.A mapping model object that represents the root class in an entity class
inheritance hierarchy.
Extends the JPA-defined
EntityGraph with additional operations.Implementation of the JPA-defined
EntityGraph interface.Integration version of the
RootGraph contract.Base set of defaults for all mappings
A persistent entity mapping that represents the root entity of an entity hierarchy.
SequencePart implementation used to translate the root of a path
Contract for things that can produce the
TableGroup that is a root of a
from-clauseSpecifies that a
rowid-like column or pseudo-column should be
used as the row locator in CRUD operations for an entity,
instead of the primary key of the table.Descriptor for
ROWID handling.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
Standard RowProcessingState implementation
Coordinates the process of reading a single result values row
Defines transformation of a raw row in the domain query result row.
RowTransformer used when an array is explicitly specified as the return type
Verifies that the first object in each row is
assignable to the query result type.
RowTransformer instantiating an arbitrary classRowTransformer generating a JPA
TupleRowTransformer instantiating a ListRowTransformer instantiating a MapReturns the first object in each row.
Returns the first object in each row, if there
is exactly one item in the selection list, or
the whole row otherwise.
An adapter for treating a
TupleTransformer as a RowTransformerEntry 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.JtaPlatform implementation for SAP NetWeaverAn event class for saveOrUpdate()
Describes the environment in which the scan will occur.
Defines the contract for Hibernate to be able to scan for classes, packages and resources inside a
persistence unit.
Support for scanning various sources to detect
managed resources
for a persistence unit.Coordinates the process of executing
Scanner (if enabled)
and applying the resources (classes, packages and mappings) discovered.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.
Basic implementation of
SchemaCreator.Service delegate for handling schema dropping.
Basic implementation of
SchemaDropper.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.
Implementation of
SchemaManager, backed by a SessionFactoryImplementor
and SchemaManagementToolCoordinator.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.
Basic implementation of
SchemaTruncator.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.
A script source input that aggregates over multiple other
ScriptSourceInput.ScriptSourceInput implementation for File references.
ScriptSourceInput implementation for explicitly given Readers.
ScriptSourceInput implementation for URL references.
Used in cases where a specified source cannot be found
Contract for hiding the differences between a passed
Writer,
File or URL in terms of how we write output scripts.ScriptTargetOutput implementation for writing to supplied File references
ScriptTargetOutput implementation for writing to supplied URL references
ScriptTargetOutput implementation for supplied Writer references.
A result iterator that allows moving around within the results by
arbitrary increments.
Standard ScrollableResults implementation.
Specifies the type of JDBC scrollable result set
to use underneath a
ScrollableResults.Descriptor for the Oracle Spatial SDO_GEOMETRY type
ValueExtractor for SDO_GEOMETRY
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.
Consumer used to visit selectable (column/formula) mappings
Mapping of a selectable (column/formula)
A container for multiple selectable (column, formula) mappings.
The path for a selectable.
The SELECT CLAUSE in the SQL AST.
A generator that
selects the just-inserted row to determine the
column value assigned by the database.A contract for a selection, can be a column or a formula.
Within the context of an active session,
an instance of this type represents an executable selection query, that is,
a
select.Strategies for referring to a select item.
A locking strategy where an optimistic lock is obtained via a select
statement.
General contract for performing execution of a query returning results.
Contract for an entity to report that it tracks the dirtiness of its own state,
as opposed to needing Hibernate to perform state-diff dirty calculations.
Extension to MutationOperation for cases where the operation wants to
handle execution itself.
Representation of an aggregate function call in the SQL AST for impls that know how to
render themselves.
A self rendering object that is part of a WITH clause, like a function.
Representation of a function call in the SQL AST for impls that know how to
render themselves.
Representation of an aggregate function call in the SQL AST for impls that know how to
render themselves.
Represents a self rendering expression i.e.
Represents a self rendering expression that renders a SQL fragment.
Representation of a window function call in the SQL AST for impls that know how to
render themselves.
Represents an error in the semantics (meaning) of a HQL/JPQL query.
Responsible for producing an SQM using visitation over an HQL parse tree generated by
ANTLR via
HqlParseTreeBuilder.Support for walking a Semantic Query Model (SQM) tree
Models a database
SEQUENCE.Global registration of a sequence generator
Extension of standard
SequenceIdRevisionEntity that allows tracking entity names changed in each revision.Extension of standard
SequenceIdRevisionMapping that allows tracking entity names changed in each revision.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.
For now we only collect sequence name.
Describes the strategy for handling the mismatch between a database sequence configuration and
the one defined by the entity mapping.
Represents an individual identifier in a dot-identifier sequence
Describes a sequence.
Generates identifier values based on a sequence-style database structure.
A set of operations providing support for sequences in a
certain
SQL dialect.Manages aspects of proxying
Blobs to add serializability.Manages aspects of proxying
Clobs to add serializability.Descriptor for general
Serializable handling.Manages aspects of proxying
NClobs to add serializability.A type that maps between a
VARBINARY and Serializable classes.Thrown when a property cannot be serialized/deserialized
Assists with the serialization process and performs additional
functionality based on serialization.
Marker interface for services.
Models a binding for a particular service.
Contract for contributing services.
Indicates a problem processing service dependencies.
Indicates a problem with a service.
Base contract for an initiator of a service.
Indicates a problem generating a service proxy
A registry of services.
A Java service loadable via
ServiceLoaderA Hibernate Service registration
Allows services to be injected with the
ServiceRegistry during configuration phase.JUnit extension used to manage the StandardServiceRegistry used by a test including
creating the StandardServiceRegistry and releasing it afterwards
Composite annotation for applying extensions needed for managing
a StandardServiceRegistry as part of the test lifecycle.
Additional integration contracts for a service registry.
ServiceRegistry useful in testing
The main runtime interface between a Java application and Hibernate.
Allows creation of a new
Session with specific options.Defines the internal contract between the
SessionBuilder and
other parts of Hibernate.Class responsible for evicting audit data entries that have been stored in the session level cache.
A wrapper class that delegates all method invocations to a delegate instance of
SessionImplementor.Implemented by custom listeners that respond to low-level events
involving interactions between the
Session and the database
or second-level cache.Thrown when the user calls a method of a
Session that is
in an inappropriate state for the given call (for example, the
session is closed or disconnected).A
SessionFactory represents an "instance" of Hibernate: it maintains
the runtime metamodel representing persistent entities, their attributes,
their associations, and their mappings to relational database tables, along
with configuration that
affects the runtime behavior of Hibernate, and instances of services that
Hibernate needs to perform its duties.The contract for building a
SessionFactory given a specified set of options.An extension point for integrators that wish to hook into the process of how a SessionFactory
is built.
Additional SPI contract for
SessionFactoryBuilder, mainly intended for
implementors of SessionFactoryBuilderFactory.Allows bootstrapping Hibernate ORM using a custom
SessionFactoryBuilderImplementor.Base delegating implementation of the
SessionFactory and
SessionFactoryImplementor contracts for intended for easier
implementation of SessionFactory.hibernate-testing implementation of a few JUnit5 contracts to support SessionFactory-based testing,
including argument injection (or see
SessionFactoryScopeAware)Composite annotation for functional tests that require a functioning SessionFactory.
Concrete implementation of the
SessionFactory API.Defines the internal contract between the
SessionFactory and the internal
implementation of Hibernate.Allows reaction to basic
SessionFactory lifecycle events.Aggregator of special options used to build the
SessionFactory.In-flight state of
SessionFactoryOptions during SessionFactoryBuilder
processing.Contract for something that can build a SessionFactory.
A registry of all
SessionFactory instances for the same classloader as this class.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.Acts as a service in the
StandardServiceRegistryImpl whose
function is to act as a factory for SessionFactoryServiceRegistryImpl implementations.Concrete implementation of the
Session API.Defines the "internal contract" between
Session and other parts of Hibernate
including implementors of Type, EntityPersister,
and CollectionPersister.This helper class allows decorating a Session instance, while the
instance itself is lazily provided via a
Supplier.Information about the first-level (session) cache for a particular
instance of
Session.A mapping model object representing a collection of type
List.A plural attribute that represents a
set.Support for binding values directly through `setObject` JDBC driver calls.
The SQL set operators.
Hibernate extension to the JPA
SetAttribute descriptorSupport for
SqmSetReturningFunctionDescriptors that ultimately want
to perform SQL rendering themselves.Pluggable strategy for resolving a function return type for a specific call.
Pluggable strategy for resolving a function return type for a specific call.
The contract for setting the value of a persistent attribute on its container/owner.
Field-based implementation of Setter
A setting for use in other annotations to define settings for various things.
Annotation to allow providing settings whose values can be
types other than String.
Contract for providing a value
A special connection provider that is shared across test runs for better performance.
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.An extension of SessionCreationOptions for cases where the Session to be created shares
some part of the "transaction context" of another Session.
A wrapper class that delegates all method invocations to a delegate instance of
SharedSessionContractImplementor.Descriptor for
Short handling.ImplicitDiscriminatorStrategy implementation using entity full-names.
Descriptor for
short[] handling.A simple implementation of
AbstractAuxiliaryDatabaseObject in which the
CREATE and DROP strings are provided up front.Factory that does not fill in the entityName or role
small low memory class to keep track of the number of elements in a collection
Simple version of DatabaseVersion
Describes any non-collection type
small low memory class to keep track of changed fields
Simple implementation of FromClauseAccess
An audit query criterion that compares a function call with a scalar value.
Represents a simple identifier mapping.
A simple identifier builder contract.
Loads an entity by its natural identifier.
NaturalIdLoader for simple natural-ids
Single-attribute NaturalIdMapping implementation
Simple ResourceLocator impl using its own ClassLoader to locate the resource
A SQL
SELECT statement with no table joins.A simple implementation of StrategyRegistration.
Generates increasing identifiers (in a single VM only).
A simple second pass that just creates the foreign key
A mapping model object that represents any value that maps to columns.
Loader for loading a single entity by primary or unique key
Defines a plan for loading a single entity - by id, by uk, etc
A load plan for loading an array of state by a single restrictive part.
Loader for loading an entity by a single identifier value.
Implementation of SingleIdEntityLoader for cases where the application has
provided the select load query
Standard implementation of
SingleIdEntityLoader.Describes a plan for loading an entity by identifier.
An implementation of an identifier mapper for a single basic attribute property.
Class responsible for extracting SQL statements from import script.
An
ImplicitDatabaseObjectNamingStrategy using a single structure for all
implicit names:
"hibernate_sequence" for sequences
"hibernate_sequences" for tables
TODO: diff
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.
Contract for an attribute that represents a singular value.
Subclass used to simplify instantiation of singular attributes representing an entity's
identifier.
Subclass used to simply instantiation of singular attributes representing an entity's
version.
Mapping for a singular (non-collection) attribute.
Attribute metadata contract for a non-plural attribute.
Describes possible natures of a singular attribute.
Source-agnostic description of information needed to bind a singular attribute.
Describes an
<any/> mappingRepresents the binding source for a singular attribute that is "embedded"
or "composite".
Further contract for sources of singular associations (
one-to-one and many-to-one).Extension of the JPA-defined
SingularAttribute interface.Models size restrictions/requirements on a column's data type.
Deprecated, for removal: This API element is subject to removal in a future version.
Implementation of SizeSource
Deprecated, for removal: This API element is subject to removal in a future version.
Use JUnit 5 and
DisabledOnOs
or DisabledIf.Simple boolean assertion
Indicates that the annotated test class/method should be skipped
when the indicated Dialect is being used.
Deprecated, for removal: This API element is subject to removal in a future version.
Use JUnit 5 and
SkipForDialect instead.Grouping annotation for
SkipForDialectDeprecated, for removal: This API element is subject to removal in a future version.
Use JUnit 5 and
SkipForDialectGroup instead.Well-known-location lookup for the test-skip log...
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.
Helper for dealing with
SoftDeleteMetadata about the indicator column for entities and collections enabled
for soft delete
SoftDeleteMapping implementation
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.
small low memory class to keep track of changed fields
similar to BasicTracker but where the array is kept ordered to reduce the cost of verifying duplicates
Initializes SortedMap collection with proper Comparator
Initializes SortedSet collection with proper Comparator
Deprecated, for removal: This API element is subject to removal in a future version.
use
CurrentTimestamp insteadDescribes a source for schema create, drop and migrate actions.
Deprecated.
because both
Source and hbm.xml are deprecated, though this
implementation is instructiveSpecifies 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.
A marker interface for spatial (geometric/geographic) types.
An extended
HibernateCriteriaBuilder with spatial functionalityDeprecated.
SpatialDialects are no longer needed since Hibernate 6.0
Deprecated.
To be replaced by
CommonSpatialFunctionManages initialization of the hibernate-spatial integration
Deprecated.
Will be removed in 6
Central service for spatial integration
The hints explicitly defined by the Jakarta Persistence specification
which are available for both queries and loading.
Much the same as OrmAnnotationDescriptor except for
special cases where we do care about annotations on the annotation type
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.
Implementation of ProcessingState used on its own as the impl for
DML statements and as the base for QuerySpec state
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 warningsA
SQLExceptionConverter implementation
that does conversion based on the SQLException subtype hierarchy
defined by JDBC 4.Unifying contract for things that are capable of being an expression in
the SQL AST.
Resolution of a SqlSelection reference for a given SqlSelectable.
Defines an interpolated alias occurring in a SQL
filter condition.
Predicate based on a SQL fragment
A function to pass through a SQL fragment.
Specialization of
JDBCException indicating that the SQL sent to the
database server was invalid, either due to a syntax error, unrecognized name,
or similar problem.MultiKeyLoader implementation based on SQL IN predicate
Specifies a custom SQL DML statement to be used in place of the default SQL
generated by Hibernate when an entity or collection row is inserted in the
database.
A grouping of
SQLInserts.Specifies a restriction written in native SQL to add to the generated SQL
when querying the join table
of a collection.
Order a collection using an expression or list of expression written
in native SQL.
Substitutes escape sequences of form
{alias},
{alias.field}, and {alias.*} in a
native SQL query.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).
A
LimitHandler compatible with SQL Server 2012 which
introduced support for the ANSI SQL standard syntax
OFFSET m ROWS FETCH NEXT n ROWS ONLY, though this syntax
is considered part of the ORDER BY clause, and with the
wrinkle that both ORDER BY and the OFFSET clause
are required.Factory for
SQLServerCastingXmlArrayJdbcType.Custom
TruncFunction for SQL Server versions before 16,
which uses the custom SqlServerConvertTruncFunction.DateTruncConvertEmulationA dialect for Microsoft SQL Server 2012 and above.
SQL Server doesn't have a function like
every() or any().SQL Server behaves strangely when the first argument to format is of the type time, so we cast to datetime.
SQL Server generate_series function.
Type descriptor for the SQL Server 2008 Geography type.
Type descriptor for the SQL Server 2008 Geometry type.
SQL Server json_arrayagg function.
SQL Server json_array_append function.
SQL Server json_array function.
SQL Server json_array_insert function.
SQL Server json_exists function.
SQL Server json_insert function.
SQL Server json_objectagg function.
SQL Server json_object function.
SQL Server json_query function.
SQL Server json_remove function.
SQL Server json_replace function.
SQL Server json_set function.
SQL Server json_table function.
SQL Server json_value function.
Sequence support for
SQLServerDialect.This
ConnectionProvider extends any other ConnectionProvider that would be used by default taken the current configuration properties, and it
just sets the READ_COMMITTED_SNAPSHOT isolation level for SQL Server.Deprecated.
A SpatialDialect is no longer required.
A SQL AST translator for SQL Server.
SQL Server unnest function.
SQL Server xmlagg function.
SQL Server xmlconcat function.
SQL Server xmlelement function.
SQL Server xmlexists function.
SQL Server xmlforest function.
SQL Server xmlpi function.
SQL Server xmlquery function.
SQL Server xmltable function.
A
SQLExceptionConverter implementation which performs conversion based
on the underlying SQLState.Deprecated.
use
SQLStatementInspector insteadCentralize logging for SQL statements.
The
SqlStatementLogger is accessible via JdbcServices,
but during service initialization, it might be needed before the JdbcServices service is
initialized.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.
A
JdbcType with a fixed SQL type name.Models the type of a thing that can be used as an expression in a SQL query
Defines a list of constant type codes used to identify generic SQL types.
Specifies a custom SQL DML statement to be used in place of the default SQL
generated by Hibernate when an entity or collection row is updated in the
database.
A grouping of
SQLUpdates.A SQM aggregate function.
Models any aliased expression.
Models a reference to a
SqmAliasedNode
used in the order-by or group-by clause by either position or alias,
though the reference is normalized here to a positional refModels a join based on a mapped attribute reference.
Represents an expression whose type is boolean, and can therefore be used as a predicate.
Represents the
SIZE() function.Specialization of
SqmFrom for sub-query correlationsThe context in which all SQM creations occur.
Options for semantic analysis
State related to SQM creation, like
SqmCreationState, but specific
to its "current processing" - which generally means specific to each statement
and sub-queryModels the state pertaining to the creation of a single SQM.
Acts as a JPA
CriteriaBuilder by
using SQM nodes as the JPA Criteria nodesStuff and things
In some cases it is useful to be able to handle UPDATE or DELETE SQM trees
using a single contract.
QuerySpecProcessingState implementation for DML statements
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.
ExecutionContext adapter delegating to a DomainQueryExecutionContext
Specialization for attributes that that can be used in creating SQM joins
todo (6.0) : should we define this for entities as well to handle cross joins and "entity joins"?
- the result type would need to change to just SqmJoin...
Represents a canonical join type.
Acts as the per-use wrapper for a JpaCriteriaParameter (
CriteriaBuilder.parameter(java.lang.Class<T>)).Special expression for the json_exists function that also captures special syntax elements like error behavior and passing variables.
Describes how a
null should be treated in a JSON document.Specifies if a
json_objectagg may aggregate duplicate keys.Special expression for the json_query function that also captures special syntax elements like error and empty behavior.
Special expression for the json_value function that also captures special syntax elements like error and empty behavior.
Represents a literal value in the sqm, e.g.
1
'some string'
some.JavaClass.CONSTANT
some.JavaEnum.VALUE
etc
Represents a reference to an embeddable type as a literal.
Represents a reference to an entity type as a literal.
Represents the reference to a Map attribute's
Map.Entry entries
in a select clauseHelper for dealing with Hibernate's "mapping model" while processing an SQM which is defined
in terms of the JPA/SQM metamodel
Represents 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.Initiator for SqmMultiTableMutationStrategyProvider service
Standard SqmMultiTableMutationStrategyProvider implementation
A named expression.
Represents a named query parameter in the SQM tree.
Contract for predicates that have a negated form, e.g.
Base contract for any SQM AST node.
A SQM ordered set-aggregate function.
Models a parameter expression declared in the query.
Entity type expression based on a parameter - `TYPE( :someParam )`
Models a reference to a part of the application's domain model as part of an SQM tree.
Interpretation of a
SqmPath as part of the translation to SQL AST.Registry for SqmPath references providing the ability to access them
in multiple ways - by alias, by NavigablePath, etc
Container for indexing needed while building an SQM tree.
Represents any part of the domain model which can be used to create a
SqmPath node.Generic
SemanticQueryWalker that applies the provided
Consumer to all paths encountered during visitation.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.
Models the state related to parsing a sqm spec.
Identifies 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.
A SQM set-returning function
A factory for SQM nodes representing invocations of a certain
named set-returning function.
The basic SQM statement contract for top-level statements
Specialized SemanticQueryWalker (SQM visitor) for producing SQL AST.
Information obtained from the interpretation of an SqmStatement
Factory for various
SqmTranslatorsA TREAT form of SqmCrossJoin
Helper for dealing with SQM tree creation
Logger used to log information about the creation of an SQM tree.
Printer for an SQM tree - for debugging purpose
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
Helper utilities for dealing with SQM
Optional contract for SqmNode implementations that can be visited
by a SemanticQueryWalker.
Unified contract for things that can contain a SqmWhereClause.
A SQM window function.
Special expression for the json_query function that also captures special syntax elements like error and empty behavior.
Special expression for the xmlelement function that also captures special syntax elements like xmlattributes.
Stack implementation exposing useful methods for Hibernate needs.
A specialized
StaleStateException that carries information about
the particular entity instance that was the source of the failure.Thrown when a version number or timestamp check failed, indicating that
the
Session contained stale data (when using long transactions
with versioning).Standard implementation of ArchiveDescriptorFactory
CollectionSemantics implementation for arrays
CollectionSemantics for bags
References to common
BasicTypeReference instancesA BasicType adapter targeting partial portability to 6.0's type
system changes.
Standard
BatchLoaderFactory implementationMarker for Hibernate defined converters of Boolean-typed domain values
Standard representation of entity cached data using the "disassembled state".
Standard implementation of
CallableStatementSupport.Standard implementation of CollectionSemanticsResolver
Marker for Hibernate supplied converter classes.
Standard set of setting converters.
The standard
DialectResolver implementationMarker interface for standard EmbeddableInstantiator implementations.
Standard non-JPA implementation of EntityNotFoundDelegate, throwing the
Hibernate-specific
ObjectNotFoundException.An
Exporter for foreign key constraints.Standard implementation of
HqlTranslator.CollectionSemantics implementation for id-bags
Implementation of ScanEnvironment leveraging a JPA deployment descriptor.
Hibernate's standard CollectionSemantics for Lists
LobCreator implementation using Connection.createBlob(),
Connection.createClob() and Connection.createNClob() to
create the LOB references.
CollectionSemantics for maps
Standard
MutationExecutorService implementationThe 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.Standard implementation of
RefCursorSupportStandard implementation of ResourceLocator delegating to the ClassLoaderService
Contract for an initiator of services that target the standard
ServiceRegistry.Central definition of the standard set of service initiators defined by Hibernate.
Specialization of the
ServiceRegistry contract mainly for type safety.Builder for standard
ServiceRegistry instances.Standard Hibernate implementation of the standard service registry.
Central definition of the standard set of initiators defined by Hibernate for the
SessionFactoryServiceRegistryThe final phase of query translation.
Standard implementation of SqlAstTranslatorFactory
A
SQLExceptionConverter that delegates to a chain of
SQLExceptionConversionDelegate.Simplified API allowing users to contribute
SqmFunctionDescriptors
to HQL.The standard translator for SQM to SQL ASTs.
Standard implementation of the SqmTranslatorFactory
A general-purpose stack impl supporting null values.
The basic implementation of
Cleaner.A
TableMigrator that only knows how to add new columns.Standard Hibernate implementation of the QueryCacheFactory interface.
An
Exporter for unique constraints.Lifecycle contract for services which wish to be notified when it is time to start.
A stateful implementation of the
PersistenceContext contract, meaning that we maintain this
state throughout the life of the persistence context.A command-oriented API often used for performing bulk operations against
the database.
Allows creation of a new
StatelessSession with specific options.Concrete implementation of the
StatelessSession API.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.Tracks and logs certain session-level metrics.
Exposes statistics collected from all sessions belonging to a given
SessionFactory.Factory for custom implementations of
StatisticsImplementor.Implementation of
Statistics based on the java.util.concurrent package.A service SPI for collecting statistics about various events occurring at runtime.
Utilities useful when dealing with stats.
Decorates a ConcurrentHashMap implementation to make sure the methods are being
used correctly for the purpose of Hibernate's statistics.
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.
Provides the
AgroalConnectionProvider to the
StrategySelector service.Provides the
C3P0ConnectionProvider to the
StrategySelector service.Makes the JCache RegionFactory available to the Hibernate
StrategySelector service
under a number of keys.Provides the
HikariCPConnectionProvider to the
StrategySelector service.Makes the JCache RegionFactory available to the Hibernate
StrategySelector service
under a number of keys.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.
Builder for
StrategySelector instances.Standard implementation of the
StrategySelector contract.Implementation of
BinaryStream backed by an InputStream.SecondPass implementing delayed resolution of id-generators associated with an entity
using strict JPA resolution - based mainly on global resolution of generator names,
along with support for UUID and String member types with AUTO.
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.
A mapper which maps from a parent mapper and a "main" one, but adds only to the "main".
Common interface for all sub-entity mappings.
Extends the JPA-defined
Subgraph with additional operations.Implementation of the JPA-defined
Subgraph interface.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
Used to annotate classes which define sub-system style logging where
loggers are hierarchically defined around functionalities rather than
class and package names
Resolve according to JPA spec 4.8.5
JtaPlatform implementation for Sun ONE Application Server 7 and aboveSybase ASE supports the
xmlextract() function which is used to implement aggregate support.A SQL dialect for Sybase Adaptive Server Enterprise 16 and above.
Sybase ASE generate_series function.
A SQL AST translator for Sybase ASE.
Sybase ASE unnest function.
Sybase ASE xmltable function.
Sybase implementation of CallableStatementSupport.
Superclass for all Sybase dialects.
Specialized
GetGeneratedKeysDelegate which appends the database
specific clause which signifies to return generated IDENTITY values
to the end of the insert statement.A SQL AST translator for Sybase.
A SQM to SQL AST translator for Sybase ASE.
Custom
TruncFunction for Sybase which uses a dialect-specific emulation function for datetimesManages funneling JTA Synchronization callbacks back into the Hibernate transaction engine.
Manages callbacks from the
Synchronization registered by Hibernate.Extension of SynchronizationCallbackCoordinatorNonTrackingImpl that adds checking of whether a rollback comes from
a thread other than the application thread (thread used to register the Synchronization)
Defines "inflow" for JTA transactions from the perspective of Hibernate's registered JTA Synchronization
back into the TransactionCoordinator by means of the SynchronizationCallbackCoordinator.
Manages a registry of (local) JTA
Synchronization instancesProvides access to a
TransactionSynchronizationRegistry for use by TransactionSynchronizationRegistry-based
JtaSynchronizationStrategy implementations.Implementation of the
JtaSynchronizationStrategy contract based on using a
TransactionSynchronizationRegistrySPI contract for
SynchronizationRegistry implementors.The standard implementation of the
SynchronizationRegistry contract.Specifies a table or tables that hold state mapped by the annotated
entity or collection.
Represents the abstract notion of a query whose results are affected by the data stored
in a given set of named query spaces.
Represents a syntax error in a HQL/JPQL query.
Models a property which does not actually exist in the model.
A mapping model object representing a relational database table.
Stateful binder responsible for producing instances of
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
Deletion defined using custom sql-delete
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 simple walker that checks if a predicate contains qualifiers.
TableGroup implementation used while building
ResultSetMapping references.
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
Provides access to information about existing schema objects (tables, sequences etc) of existing database.
Models an insert into a model (entity or collection) table,
triggered from flush
TableMutationBuilder implementation for insert statements.Standard TableInsertBuilder
Insertion defined using custom sql-insert
The commonalities between
TableGroupJoin and TableReferenceJoin.Describes a table as far as Hibernate understands it from mapping details
Details for the mutation of a table
An object that produces an
alter table statements
needed to update the definition of a table.Describes the mutation of a model table (mapped by an entity or collection)
triggered from flush.
Generalized contract for building
TableMutation instancesOptional contract implemented by some subtypes of
PersistentClass.Represents a reference to a table (derived or physical) in a query's from clause.
Represents a join to a
TableReference; roughly equivalent to a SQL join.Functional contract for producing the join-predicate related to a
TableReferenceJoin.Represents a Set of TableMapping(s); table mappings are
identified by an ordered unique id: the order in which
they are updated within the scope of a particular persister.
Contract describing source of table information
Models a table mapping source.
Contract describing source of "table specification" information.
Describes a table used to mimic sequence behavior
Models an update to a model (entity or collection) table,
triggered from flush
TableMutationBuilder implementation for update statements.Standard TableUpdateBuilder implementation
Update defined using custom sql-update
A skipped update
Deprecated, for removal: This API element is subject to removal in a future version.
use annotation members of JPA association mapping
annotations, for example,
OneToMany.targetEntity()Used in mapping dynamic models to specify the java-type of an attribute, mainly for
basic,
id,
embedded and
embedded-id attributes.
Describes the target(s) of schema create, drop and migrate actions.
Describes the allowable targets (SPI wise) for schema management actions.
Defines when the lookup in the current thread context
ClassLoader should be
done according to the other ones.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.
JAXB marshalling for
TemporalTypeA 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.
Sets up filters associated with a
TenantId fieldIndicates that tenant identifiers did not match in cases where
CurrentTenantIdentifierResolver.validateExistingCurrentSessions()
returns true and there is a mismatch found.A generator that produces the current tenant identifier
to be assigned to the
TenantId property.Indicates an attempt to dereference a terminal path
(usually a path referring to something of basic type)
A
LoggerProvider for JBoss Logger.Metadata about various types of callback methods on a given test class.
A test-specific implementation of the JtaPlatform contract for testing JTA-based functionality.
A
CurrentSessionContext impl which scopes the notion of current
session by the current thread of execution.Transaction sync used for cleanup of the internal session map.
Selects data from a relation middle-table and a two related versions entity.
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.Descriptor for
TIMESTAMP handling.Tracks invalidation of "query spaces" (tables) for the purpose of
determining if a cached query result set is stale.
TimestampsRegionAccess implementation for cases where query results caching
(or second level caching overall) is disabled.
Standard implementation of TimestampsCache
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.This
ConnectionProvider extends any other ConnectionProvider that would be used by default taken the current configuration properties, and it
just sets a default TimeZone which is different than the current default one.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 than we were expecting to be.
A mapping model object representing an association where the target side has cardinality one.
Enable a proper set of the FK columns in respect with the id column order
Allow the correct implementation of the default EJB3 values which needs both
sides of the association to be resolved
Generates metadata for to-one relations (reference-valued properties).
A
LimitHandler for Transact SQL and similar
databases which support the syntax SELECT TOP n.Topological sorting of a graph - based on DFS.
Extension of standard
RevisionMapping that allows tracking entity names changed in each revision.Represents a resource-local transaction, where resource-local is interpreted
by Hibernate to mean any transaction under the control of Hibernate.
Models the coordination of all transaction related flows.
Provides the means for resource-local transactions (as transaction drivers) to control the
underlying "physical transaction" currently associated with the
TransactionCoordinator.Builder for
TransactionCoordinator instances.Access to options that are specific to each
TransactionCoordinator instance.StandardServiceInitiator for initiating the TransactionCoordinatorBuilder service.
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.Methods used by
SessionFactory to manage transactions.Thrown when user code causes the end of a transaction that is
being managed by the
SessionFactory.Provides access to a
TransactionManager for use by TransactionManager-based
JtaSynchronizationStrategy implementations.Observer of internal transaction events.
Indicates a call to
TransactionCoordinator.explicitJoin() that requires an
active transaction where there currently is none.A
JDBCException indicating a transaction failed because it could not be placed into a serializable ordering
among all of the currently-executing transactionsEnumeration of statuses in which a transaction facade (
Transaction) might be.Hibernate transaction function without return value
Hibernate transaction function
JDBC transaction function
JDBC transaction function without return value
JPA transaction function
JPA transaction function without return value
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.Generalized error while performing
hbm.xml transformationDeprecated.
since
ResultTransformer is deprecatedThrown when the user passes a transient instance to a
Session
method that expects a persistent instance.Thrown when a property cannot be persisted because it is an association
with a transient unsaved entity instance.
Access to information needed while translating a collection's order-by fragment
An implementation of
NavigablePath with special handling for treated paths.Indicates a problem with a TREAT usage
ANSI SQL-standard
trim() function, which has a funny syntax
involving a TrimSpec, and portability is achieved using
Dialect.trimPattern(TrimSpec, boolean).Variations of the
trim() function.A triple of objects.
Handles conversion to/from
Boolean as 'T' or 'F'Custom function that manages both numeric and datetime truncation
Implementation of the JPA TupleElement contract
Implementation of the JPA Tuple contract
Metadata about the tuple structure.
Describes any structural type without a direct java type representation.
Selects data from a relation middle-table and a related non-audited entity.
Selects data from a relation middle-table and a related versions entity.
Functionality relating to the Hibernate two-phase loading process, that may be reused by persisters
that do not use the Loader framework
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.Functions for typechecking comparison expressions and assignments in the SQM tree.
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.Envers specific TypeContributor
Deprecated, for removal: This API element is subject to removal in a future version.
Consider using discovery instead to
dynamically locate contributors.
Models the information pertaining to a custom type definition supplied by the user.
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.
Contract for a type specification mapping.
Utility class.
Enumerates the unary prefix operators.
A mapping model object that represents a subclass in a "union" or
"table per concrete class"
inheritance hierarchy.
An
EntityPersister implementing the
InheritanceType.TABLE_PER_CLASS
mapping strategy for an entity and its inheritance hierarchy.A persistent entity mapping that uses the table-per-class inheritance strategy.
Commonality for annotations which define unique-constraints
Unique columns and unique keys both use unique constraints in most dialects.
Dialect-level delegate responsible for applying unique constraints in DDL.
A mapping model object representing a unique key
constraint on a relational database table.
Useful metadata representing a unique key within a Persister
Uses a unique key of the inserted entity to locate the newly inserted row.
Indicates that an unknown AccessType external name was encountered
or that an AccessType was requested that the underlying cache provider
does not support.
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.
We encountered a reference to an entity by name which we cannot resolve
Indicates an attempt was made to refer to an unknown entity name or class.
Indicates a request against an unknown filter name.
Occurs when a named query is requested, and there is no known
HQL or native SQL query registered under the given name.
Indicates an attempt to access the parameter for an unknown column
Indicates an attempt to find an unknown query parameter or an attempt to
bind a value to an unknown query parameter
Indicates a failure to resolve an element of a path expression in HQL/JPQL.
Indicates that the persister to use is not known and could not be determined.
Indicates a request against an unknown fetch profile name.
Indicates that an unknown service was requested from the registry.
Indicates a request for named ResultSet mapping which could not be found
Thrown when a
TableReference cannot be resolved
for a table-name.Standard unnest function.
A numeric literal coming from an HQL query, which needs special handling
Thrown when Hibernate could not resolve an object by id, especially when
loading an association.
Tracks unresolved entity insert actions.
Denotes that a setting is considered unsafe.
Helper for dealing with unsaved value handling
The base contract for determining transient status versus detached status.
Unstructured CacheEntry format (used to store entities and collections).
The expected behavior when encountering a class that cannot be enhanced,
in particular when attribute names don't match field names.
How to handle features in the transformed `hbm.xml` which are not supported
in the `mapping.xml` XSD
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)
Handler for dealing with multi-table SQM UPDATE queries.
A locking strategy where a lock is obtained via an update statement.
UpdateRowsCoordinator implementation for cases with a separate collection table
OneToMany update coordinator if the element is a
UnionSubclassEntityPersister.Specifies that the annotated field of property is a generated update timestamp.
The timestamp is regenerated every time an entity instance is updated in the database.
Contains an aggregated analysis of the values for an update mutation
to determine behavior such as skipping tables which contained no changes,
etc.
JdbcMutationOperation implementation for UPSERT handlingDescriptor for
URL handling.Acts as the
MessageLogger and
MessageBundle for messages related to
processing URLs.A custom type for mapping user-written classes which implement
PersistentCollection.Handles
CompositeUserTypes.A mapping model object representing a named relational database array type.
A mapping model object representing a relational database UDT.
A mapping model object which represents a user defined type.
Model used mostly by tests referenced by the
documentation project.An implementation of the
ConnectionProvider interface that simply throws an
exception when a connection is requested, the assumption being that the application
is responsible for handing the connection to use to the session.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
Utilities used to implement procedure call support.
Deprecated.
see
UUIDGeneratorSpecifies that an entity identifier is generated as an
IETF RFC 4122 UUID.
Deprecated.
use
UuidGenerator and
UuidGenerator insteadRepresents a kind of UUID, that is, what RFC 4122 calls a "version".
JAXB marshalling for
UuidGenerator.StyleDeprecated.
This remains around as an implementation detail of
hbm.xml mappings.Descriptor for
UUID handling.Specialized type mapping for
UUID and the UUID SQL data type.Represents a specific algorithm for producing UUID values.
Implements UUID Version 6 generation strategy as defined by the RFC 9562.
Implements UUID Version 7 generation strategy as defined by the RFC 9562.
The entry point for HQL validation.
Duplicates the
jakarta.validation enumeration.An audit strategy implementation that persists and fetches audit information using a validity
algorithm, based on the start-revision and end-revision of a row in the audit table schema.
Deprecated.
use
ValidityAuditStrategy instead.A mapping model object which represents something that's persisted "by value",
instead of "by reference", that is, anything with no primary key.
Provides access to the values for a managed type (currently just embeddables).
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.
A contract for defining the meta information about a
ValueDescribes a ModelPart that is also a ValueMapping (and therefore also a SelectableMappings).
Contract for extracting values from a JDBC
ResultSet or
from output the parameters of a CallableStatement.Meta-annotation used to mark another annotation as providing configuration
for a custom value generation strategy.
This enum defines how values passed to JPA Criteria API are handled.
The snippet that generates the initialization value.
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 Meta Model Generator version.
Information about the version of Hibernate.
Utilities for dealing with optimistic locking values.
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
EntityVersionMappingParameter bind specification used for optimistic lock version seeding (from insert statements).
A strategy for determining if a version value is a version of
a new transient instance or a previously persistent transient instance.
A graph vertex - stores its representation, neighbours, start and end time in (D|B)FS.
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.An extension to the
SingleIdMapper implementation that supports the use case of an @IdClass
mapping that contains an entity association where the @IdClass stores the primary key of the
associated entity rather than the entity object itself.Embeddable describing the virtual-id aspect of a non-aggregated composite id
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.
JtaPlatform implementation for WeblogicJTA platform implementation intended for use with WebSphere Application Server (WAS).
JTA platform implementation for WebSphere (versions 4, 5.0 and 5.1)
JTA platform implementation intended for use with WebSphere Liberty and OpenLiberty
Things which can have
SQLRestriction
declarations - entities and collectionsReturn a standalone JTA transaction manager for WildFly transaction client
Known to work for WildFly 13+
Models 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.
Visitor patter dispatcher.
Visitor pattern visitor.
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.
Wrap collections in a Hibernate collection wrapper.
Thrown when loading an entity (by identifier) results in a value that
cannot be treated as the subclass type requested by the caller.
Standard xmlagg function.
Helper for creating annotation from equivalent JAXB
Specialized type mapping for
XML_ARRAY and the XML ARRAY SQL data type.Factory for
XmlArrayJdbcType.Specialized type mapping for
XML_ARRAY and the XML ARRAY SQL data type.Factory for
XmlAsStringArrayJdbcType.Specialized type mapping for
SQLXML and the XML SQL data type.Standard xmlconcat function.
A helper for consuming orm.xml mappings.
Context for a specific XML mapping file
Standard xmlelement function.
Provides meta-information about XML elements.
Standard xmlexists function.
Standard xmlforest function.
A Helper for serializing and deserializing XML, based on an
EmbeddableMappingType.An error using XML infrastructure (jaxp, stax, etc).
Specialized type mapping for
SQLXML and the XML SQL data type.Holds the XML binder and a classloader used for binding mappings.
Collects XML-based meta information about an annotated type (entity, embeddable or mapped superclass).
Provides common functionality used for XML parsing.
Custom exception for all sorts of XML parsing related exceptions.
Standard xmlpi function.
Performs pre-processing across XML mappings to collect data
that makes additional steps easier and more efficient
Common helper utilities for handling mapping XML processing
Collected XML override mappings we can apply wholesale after
processing metadata-complete mappings and annotations.
Tuple of an override descriptor (
managedType) along with the JAXB root it came fromProcesses XML mappings - applying metadata-complete mappings and collecting
override mappings for later processing.
Standard xmlquery function.
Generally indicates a problem locating an XML resource
An XML document containing O/R mapping metadata, either:
a JPA
orm.xml file, or
a Hibernate .hbm.xml file.Helper for building and handling
XmlSource references.Note, copied from the uPortal project by permission of author.
Standard xmltable function.
Representation of a locally resolved XSD
Indicates an issue finding or loading an XSD schema.
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.