All Classes Interface Summary Class Summary Enum Summary Exception Summary Annotation Types Summary
| Class |
Description |
| AbstractArchiveDescriptor |
Base support for ArchiveDescriptor implementors.
|
| AbstractArchiveDescriptorFactory |
|
| AbstractArrayJavaType<T,E> |
|
| AbstractAttribute |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| AbstractAttributeKey |
|
| AbstractAuxiliaryDatabaseObject |
|
| AbstractBagSemantics<E> |
|
| AbstractCachedDomainDataAccess |
|
| AbstractCacheTransactionSynchronization |
|
| AbstractCdiBeanContainer |
|
| AbstractClassJavaType<T> |
|
| AbstractCollectionDataAccess |
|
| AbstractCollectionEvent |
Defines a base class for events involving collections.
|
| AbstractCollectionPersister |
Base implementation of the QueryableCollection interface.
|
| AbstractColumnReferenceQualifier |
|
| AbstractCommonQueryContract |
|
| AbstractCompositionAttribute |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| AbstractCurrentSessionContext |
|
| AbstractDataSourceBasedMultiTenantConnectionProviderImpl |
|
| AbstractDelegatingMetadata |
|
| AbstractDelegatingMetadataBuilderImplementor<T extends MetadataBuilderImplementor> |
|
| AbstractDelegatingMetadataBuildingOptions |
|
| AbstractDelegatingSessionBuilder |
Base class for SessionBuilder implementations that wish to implement only parts of that contract themselves
while forwarding other method invocations to a delegate instance. |
| AbstractDelegatingSessionBuilderImplementor |
Base class for SessionBuilderImplementor implementations that wish to implement only parts of that contract
themselves while forwarding other method invocations to a delegate instance. |
| AbstractDelegatingSessionFactoryBuilder<T extends SessionFactoryBuilder> |
Convenience base class for custom implementors of SessionFactoryBuilder, using delegation
|
| AbstractDelegatingSessionFactoryBuilderImplementor<T extends SessionFactoryBuilderImplementor> |
|
| AbstractDelegatingSessionFactoryOptions |
|
| AbstractDelegatingSharedSessionBuilder |
Base class for SharedSessionBuilder implementations that wish to implement only parts of that contract
themselves while forwarding other method invocations to a delegate instance. |
| AbstractDelegatingWrapperOptions |
|
| AbstractDomainDataRegion |
|
| AbstractDomainDataRegion.Destructible |
Optional interface caching implementors can implement in their
CachedDomainDataAccess impls to automatically have them destroyed
when this region is destroyed
|
| AbstractDomainType<J> |
|
| AbstractEmbeddableInitializer |
|
| AbstractEntityBasedAttribute |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| AbstractEntityDataAccess |
|
| AbstractEntityInitializer |
|
| AbstractEntityPersister |
Basic functionality for persisting an entity via JDBC, using either generated or custom SQL.
|
| AbstractEntityPersister.CacheEntryHelper |
Consolidated these onto a single helper because the 2 pieces work in tandem.
|
| AbstractEntityResultGraphNode |
AbstractFetchParent sub-class for entity-valued graph nodes
|
| AbstractEvent |
Defines a base class for Session generated events.
|
| AbstractFetchBuilderContainer<T extends AbstractFetchBuilderContainer<T>> |
|
| AbstractFetchParent |
|
| AbstractFetchParentAccess |
Base support for FetchParentAccess implementations.
|
| AbstractHANADialect |
An abstract base class for SAP HANA dialects.
|
| AbstractHANADialect.HANABlobType |
|
| AbstractIdentifiableType<J> |
|
| AbstractInterceptor |
|
| AbstractJavaType<T> |
Abstract adapter for Java type descriptors.
|
| AbstractJdbcLiteralFormatter<T> |
|
| AbstractJdbcMutation |
|
| AbstractJdbcOperationQuery |
Executable JDBC command
|
| AbstractJpaSelection<T> |
|
| AbstractJpaTupleElement<T> |
|
| AbstractLazyInitializer |
Convenience base class for lazy initialization handlers.
|
| AbstractLazyLoadInterceptor |
|
| AbstractLimitHandler |
|
| AbstractLobCreator |
Convenient base class for proxy-based LobCreator for handling wrapping.
|
| AbstractManagedType<J> |
Commonality for Hibernate's implementations of the JPA ManagedType
contract. |
| AbstractMapSemantics<MKV extends Map<K,V>,K,V> |
|
| AbstractMultiTenantConnectionProvider |
|
| AbstractMutationCoordinator |
Base support for coordinating mutations against an entity
|
| AbstractMutationHandler |
|
| AbstractMutationStatement |
|
| AbstractNamedQueryBuilder<T extends AbstractNamedQueryBuilder<T>> |
|
| AbstractNamedQueryDefinition |
|
| AbstractNamedQueryMemento |
|
| AbstractNamedQueryMemento.AbstractBuilder<T extends AbstractNamedQueryMemento.AbstractBuilder> |
|
| AbstractNaturalIdDataAccess |
|
| AbstractNegatableSqmPredicate |
|
| AbstractNonIdentifierAttribute |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| AbstractNonLazyEntityFetch |
Support for non-lazy EntityFetch implementations - both joined and subsequent-select
|
| AbstractNoOffsetLimitHandler |
Superclass for LimitHandlers that don't support
offsets at all. |
| AbstractOptimizer |
Common support for Optimizer implementations. |
| AbstractParameterDescriptor<T> |
|
| AbstractPersistentCollection<E> |
|
| AbstractPersistentCollection.DelayedOperation<E> |
Contract for operations which are part of a collection's operation queue.
|
| AbstractPersistentCollection.LazyInitializationWork<T> |
TBH not sure why this is public
|
| AbstractPersistentCollection.ValueDelayedOperation<E> |
|
| AbstractPostgreSQLJsonPGObjectType |
|
| AbstractPostgreSQLStructJdbcType |
Implementation for serializing/deserializing an embeddable aggregate to/from the PostgreSQL component format.
|
| AbstractPreDatabaseOperationEvent |
Represents an operation we are about to perform against the database.
|
| AbstractPredicate |
|
| AbstractPropertyMapping |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| AbstractQuery<R> |
|
| AbstractQueryParameter<T> |
|
| AbstractReadWriteAccess |
|
| AbstractReadWriteAccess.Item |
Wrapper type representing unlocked items.
|
| AbstractReadWriteAccess.Lockable |
Interface type implemented by all wrapper objects in the cache.
|
| AbstractReadWriteAccess.SoftLockImpl |
Wrapper type representing locked items.
|
| AbstractRegion |
|
| AbstractRegionFactory |
|
| AbstractRestrictedTableMutation<O extends MutationOperation> |
|
| AbstractRestrictedTableMutationBuilder<O extends MutationOperation,M extends RestrictedTableMutation<O>> |
Specialization of TableMutationBuilder for mutations which contain a
restriction.
|
| AbstractReturningDelegate |
Abstract InsertGeneratedIdentifierDelegate implementation where
the underlying strategy causes the generated identifier to be returned as
an effect of performing the insert statement. |
| AbstractReturningWork<T> |
An abstract implementation of ReturningWork that accepts a WorkExecutor
visitor for executing a discrete piece of work and returning a result. |
| AbstractScannerImpl |
|
| AbstractScannerImpl.ArchiveContextImpl |
|
| AbstractScannerImpl.ArchiveDescriptorInfo |
|
| AbstractSelectingDelegate |
Abstract InsertGeneratedIdentifierDelegate implementation where
the underlying strategy requires a subsequent select after the
insert to determine the generated identifier. |
| AbstractSelectionQuery<R> |
|
| AbstractSelectLockingStrategy |
Base LockingStrategy implementation to support implementations
based on issuing SQL SELECT statements |
| AbstractSerializableProxy |
|
| AbstractSetSemantics<SE extends Set<E>,E> |
|
| AbstractSimpleLimitHandler |
Superclass for simple LimitHandlers that don't
support specifying an offset without a limit. |
| AbstractSingleColumnStandardBasicType<T> |
TODO : javadoc
|
| AbstractSqlAstTranslator<T extends JdbcOperation> |
|
| AbstractSqlAstTranslator.ForUpdateClause |
|
| AbstractSqlAstTranslator.LockStrategy |
|
| AbstractSqlAstTranslator.SubQueryRelationalRestrictionEmulationRenderer<X extends Expression> |
|
| AbstractSqlAstWalker |
A simple walker that checks for aggregate functions.
|
| AbstractSQLExceptionConversionDelegate |
|
| AbstractSqmAttributeJoin<O,T> |
Models a join based on a mapped attribute reference.
|
| AbstractSqmDmlStatement<E> |
|
| AbstractSqmExpression<T> |
|
| AbstractSqmFrom<O,T> |
Convenience base class for SqmFrom implementations
|
| AbstractSqmFunctionDescriptor |
|
| AbstractSqmInsertStatement<T> |
Convenience base class for InsertSqmStatement implementations.
|
| AbstractSqmJoin<O,T> |
|
| AbstractSqmNode |
Base implementation of a criteria node.
|
| AbstractSqmParameter<T> |
Common support for SqmParameter impls
|
| AbstractSqmPath<T> |
|
| AbstractSqmPluralJoin<O,C,E> |
|
| AbstractSqmPredicate |
|
| AbstractSqmQualifiedJoin<O,T> |
|
| AbstractSqmRestrictedDmlStatement<T> |
|
| AbstractSqmSelectQuery<T> |
|
| AbstractSqmSelfRenderingFunctionDescriptor |
|
| AbstractSqmSimplePath<T> |
|
| AbstractSqmSpecificPluralPartPath<T> |
|
| AbstractSqmStatement<T> |
|
| AbstractStandardBasicType<T> |
Convenience base class for BasicType implementations. |
| AbstractStatement |
|
| AbstractTableDelete |
|
| AbstractTableGroup |
|
| AbstractTableInsert |
|
| AbstractTableInsertBuilder |
Base support for TableInsertBuilder implementations
|
| AbstractTableMutation<O extends MutationOperation> |
|
| AbstractTableMutationBuilder<M extends TableMutation<?>> |
Base support for TableMutationBuilder implementations
|
| AbstractTableReference |
|
| AbstractTableUpdate<O extends MutationOperation> |
Base support for TableUpdate implementations
|
| AbstractTableUpdateBuilder<O extends MutationOperation> |
Base support for TableUpdateBuilder implementations
|
| AbstractTemporalJavaType<T> |
|
| AbstractTransactSQLDialect |
An abstract base class for Sybase and MS SQL Server dialects.
|
| AbstractTransactSQLIdentityColumnSupport |
|
| AbstractType |
Abstract superclass of the built in Type hierarchy.
|
| AbstractUpdateRowsCoordinator |
|
| AbstractUUIDGenerator |
Deprecated.
|
| AbstractWork |
An abstract implementation of Work that accepts a WorkExecutor
visitor for executing a discrete piece of work. |
| AccessCallback |
|
| AccessedDataClassification |
|
| AccessType |
Enumerates various access strategies for accessing entity values.
|
| AccessType |
Enumerates the policies for managing concurrent access to the shared
second-level cache.
|
| AccessTypeMarshalling |
|
| Action |
|
| ActionQueue |
Responsible for maintaining the queue of actions related to events.
|
| ActionQueue.TransactionCompletionProcesses |
Wrapper class allowing to bind the same transaction completion process queues in different sessions.
|
| ActivationContext |
Defines the context needed to call the TypeSafeActivator.
|
| Adapter1 |
|
| Adapter1 |
|
| Adapter10 |
|
| Adapter11 |
|
| Adapter12 |
|
| Adapter13 |
|
| Adapter14 |
|
| Adapter15 |
|
| Adapter16 |
|
| Adapter17 |
|
| Adapter18 |
|
| Adapter2 |
|
| Adapter2 |
|
| Adapter3 |
|
| Adapter3 |
|
| Adapter4 |
|
| Adapter4 |
|
| Adapter5 |
|
| Adapter5 |
|
| Adapter6 |
|
| Adapter6 |
|
| Adapter7 |
|
| Adapter7 |
|
| Adapter8 |
|
| Adapter8 |
|
| Adapter9 |
|
| Adapter9 |
|
| AdditionalJaxbMappingProducer |
Deprecated.
|
| AdditionalMappingContributions |
|
| AdditionalMappingContributor |
Contract allowing pluggable contributions of additional mapping objects.
|
| AdjustableBasicType<J> |
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. |
| AdjustableJdbcType |
Extension contract for JdbcType implementations that understand how to
adjust themselves relative to where/how they are used (e.g.
|
| AfterLoadAction |
An action to be performed after an entity has been loaded.
|
| AfterTransactionCompletionProcess |
Contract representing some process that needs to occur during after transaction completion.
|
| AggregateColumn |
|
| AggregateColumnAssignmentHandler |
Handler for assignments to sub-columns of an aggregate column, which require a special write expression.
|
| AggregateColumnWriteExpression |
|
| AggregatedIdentifierMapping |
An "aggregated" composite identifier, which is another way to say that the
identifier is represented as an embeddable. |
| AggregateFunctionChecker |
A simple walker that checks for aggregate functions.
|
| AggregateFunctionExpression |
Models an aggregate function expression at the SQL AST level.
|
| AggregateJdbcType |
|
| AggregateSupport |
A set of operations providing support for aggregate column types
in a certain SQL dialect. |
| AggregateSupport.AggregateColumnWriteExpression |
The actual write expression for an aggregate column
which gives access to the value expressions for the respective selectable mapping.
|
| AggregateSupport.WriteExpressionRenderer |
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.
|
| AggregateSupportImpl |
|
| AggregateWindowEmulationQueryTransformer |
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.
|
| Alias |
An alias generator for SQL identifiers.
|
| AliasCollector |
A simple walker that checks for aggregate functions.
|
| AliasCollisionException |
|
| AliasedExpression |
A wrapper for an expression that also renders an alias.
|
| AliasResolver |
|
| AliasToBeanConstructorResultTransformer<T> |
Deprecated.
|
| AliasToBeanResultTransformer<T> |
Deprecated.
|
| AliasToEntityMapResultTransformer |
Deprecated.
|
| AlterTableUniqueDelegate |
A UniqueDelegate which uses alter table commands to create and drop
the unique constraint. |
| AlterTableUniqueIndexDelegate |
A UniqueDelegate which uses create unique index commands when necessary. |
| AnnotationBasedGenerator<A extends Annotation> |
|
| AnnotationException |
An exception that occurs while reading mapping annotations.
|
| AnnotationValueGeneration<A extends Annotation> |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| AnonymousTupleBasicEntityIdentifierMapping |
|
| AnonymousTupleBasicValuedModelPart |
|
| AnonymousTupleEmbeddableValuedModelPart |
|
| AnonymousTupleEmbeddedEntityIdentifierMapping |
|
| AnonymousTupleEntityValuedModelPart |
|
| AnonymousTupleNonAggregatedEntityIdentifierMapping |
|
| AnonymousTupleSimpleSqmPathSource<J> |
|
| AnonymousTupleSqmAssociationPathSource<O,J> |
|
| AnonymousTupleSqmPathSource<J> |
|
| AnonymousTupleTableGroupProducer |
The table group producer for an anonymous tuple type.
|
| AnonymousTupleType<T> |
|
| ANSISequenceSupport |
ANSI SQL compliant sequence support, for dialects which
support the ANSI SQL syntax next value for seqname.
|
| AnsiSqlKeywords |
Maintains the set of ANSI SQL keywords
|
| Any |
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.
|
| Any |
|
| Any |
|
| Any.KeyValue |
|
| Any.MetaValue |
|
| AnyDiscriminator |
A simplified way to specify the type of the discriminator in an Any
mapping, using the JPA-defined DiscriminatorType. |
| AnyDiscriminatorSource |
Source information about the discriminator for an ANY mapping
|
| AnyDiscriminatorValue |
Specifies the mapping of a single any-valued
discriminator value to its corresponding entity type. |
| AnyDiscriminatorValues |
|
| AnyKeyJavaClass |
Specifies the Java class to use for the foreign key handling
related to an Any mapping. |
| AnyKeyJavaType |
Form of JavaType used to describe the foreign-key part of an ANY mapping. |
| AnyKeyJdbcType |
Form of JdbcType used to
describe the foreign key part of an Any mapping. |
| AnyKeyJdbcTypeCode |
Form of JdbcTypeCode used to describe the foreign key
part of an Any mapping. |
| AnyKeySource |
|
| AnyMappingDomainType<J> |
Models Hibernate's ANY mapping (reverse discrimination) as a JPA domain model type
|
| AnyMappingSource |
Base description for all discriminated associations ("any mappings"), including
<any/>, <many-to-any/>, etc.
|
| AnyType |
Handles "any" mappings
|
| AnyType.ObjectTypeCacheEntry |
Used to externalize discrimination per a given identifier.
|
| AppliedGraph |
Contract for anything a fetch/load graph can be applied
|
| ArchiveContext |
Describes the context for visiting the entries within an archive
|
| ArchiveDescriptor |
Models a logical archive, which might be
a jar file
a zip file
an exploded directory
etc
|
| ArchiveDescriptorFactory |
Contract for building ArchiveDescriptor instances.
|
| ArchiveEntry |
Represent an entry in the archive.
|
| ArchiveEntryHandler |
Handler for archive entries, based on the classified type of the entry
|
| ArchiveException |
Indicates a problem accessing or visiting the archive
|
| ArgumentsValidator |
Validates the arguments provided to an HQL function invocation.
|
| ArgumentTypesValidator |
Typechecks the arguments of HQL functions based on the assigned JDBC types.
|
| Array |
An array mapping has a primary key consisting of the key columns + index column.
|
| ArrayJavaType<T> |
Descriptor for T[] handling.
|
| ArrayJdbcType |
Descriptor for ARRAY handling. |
| ArrayMutabilityPlan<T> |
A mutability plan for arrays.
|
| ArrayType |
A type for persistent arrays.
|
| AssemblerCreationState |
|
| AssertionFailure |
Indicates failure of an assertion: a possible bug in Hibernate.
|
| Assignable |
|
| Assigned |
|
| Assignment |
|
| Association |
Models the association of a given fetch.
|
| Association |
Commonality for an association, mainly details relative to the foreign-key
|
| AssociationAttribute |
JAXB binding interface for association attributes (to-one and plural mappings)
|
| AssociationKey |
Identifies a named association belonging to a particular
entity instance.
|
| AssociationKey |
Used as part of circularity detection
|
| AssociationSource |
|
| AssociationType |
A type that represents some kind of association between entities.
|
| Attribute |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| AttributeAccessor |
|
| AttributeAnalysis |
Results of analyzing an attribute in terms of
handling update operations |
| AttributeAnalysis.DirtynessStatus |
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.
|
| AttributeBinder<A extends Annotation> |
Allows a user-written annotation to drive some customized model binding.
|
| AttributeBinderType |
Associates a user-defined annotation with an AttributeBinder,
allowing the annotation to drive some custom model binding. |
| AttributeClassification |
|
| AttributeContainer |
Identifies a mapping model object which may have attributes
(fields or properties). |
| AttributeConverterInfo |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| AttributeMapping |
|
| AttributeMapping |
Describes an attribute at the mapping model level.
|
| AttributeMappingsList |
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). |
| AttributeMappingsMap |
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). |
| AttributeMappingsMap.Builder |
|
| AttributeMetadata |
|
| AttributeNode<J> |
Hibernate extension to the JPA entity-graph AttributeNode contract.
|
| AttributeNodeImplementor<J> |
Integration version of the AttributeNode contract
|
| AttributePath |
An attribute path is, generally speaking, the path of attribute names back
to a "root" (which is either an entity or a persistent collection).
|
| AttributeRole |
An attribute role is, generally speaking, the path of attribute names back
to a "root" (which is either an entity or a persistent collection).
|
| AttributesContainer |
JAXB binding interface for commonality between things which contain attributes.
|
| AttributeSource |
Contract for sources of persistent attribute descriptions.
|
| AttributeSource |
|
| AttributeSourceContainer |
|
| AutoApplicableConverterDescriptor |
Contract for handling auto-apply checks for JPA AttributeConverters
|
| AutoFlushEvent |
Defines an event class for the auto-flushing of a session.
|
| AutoFlushEventListener |
Defines the contract for handling of session auto-flush events.
|
| AuxiliaryDatabaseObject |
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.
|
| AuxiliaryDatabaseObject.Expandable |
Additional, optional interface for AuxiliaryDatabaseObjects
that want to allow expansion of allowable dialects via mapping.
|
| AvailableHints |
Combined set of Hibernate and Jakarta Persistence hints.
|
| AvailableSettings |
Enumerates the configuration properties supported by Hibernate, including
properties defined by the JPA specification.
|
| AvgFunction |
|
| Backref |
|
| Bag |
Specifies that an attribute of type List is semantically
a bag,
that is, that the order of the list elements is not significant, and should
not be persistent. |
| Bag |
A mapping model object representing a collection of type Collection which may
contain duplicates. |
| BagPersistentAttribute<D,E> |
|
| BagSemantics<BE extends Collection<E>,E> |
|
| BagType |
|
| BaselineAttributeInformation |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| BaselineAttributeInformation.Builder |
|
| BaseSemanticQueryWalker |
Base support for an SQM walker
|
| BaseSessionEventListener |
A no-op implementation of SessionEventListener.
|
| BaseSqmToSqlAstConverter<T extends Statement> |
|
| BaseSqmToSqlAstConverter.AdditionalInsertValues |
|
| BaseSqmToSqlAstConverter.DelegatingSqmAliasedNodeCollector |
|
| BaseSqmToSqlAstConverter.SqmAliasedNodeCollector |
|
| BaseSqmToSqlAstConverter.SqmAliasedNodePositionTracker |
|
| BaseUserTypeSupport<T> |
|
| BasicArrayType<T> |
A type that maps between ARRAY and T[] |
| BasicBinder<J> |
|
| BasicCollectionJavaType<C extends Collection<E>,E> |
Descriptor for handling persistent collections.
|
| BasicCollectionPersister |
|
| BasicCollectionType<C extends Collection<E>,E> |
A type that maps between ARRAY and Collection<T> |
| BasicDialectResolver |
Intended as support for custom resolvers which match a single db name (with optional version info).
|
| BasicDomainType<J> |
Hibernate extension to the JPA BasicType contract. |
| BasicEntityIdentifierMapping |
Mapping for a simple, single-column identifier
|
| BasicEntityPropertyMapping |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| BasicExtractor<J> |
|
| BasicFetch<T> |
Fetch for a basic-value
|
| BasicJavaType<T> |
|
| BasicJdbcLiteralFormatter<T> |
|
| BasicLazyInitializer |
Lazy initializer for plain Java objects.
|
| BasicPluralJavaType<T> |
Descriptor for a basic plural Java type.
|
| BasicPluralType<C,E> |
A basic plural type.
|
| BasicProxyFactory |
A proxy factory for "basic proxy" generation.
|
| BasicResult<T> |
DomainResult for a basic-value
|
| BasicResultAssembler<J> |
|
| BasicResultGraphNode<J> |
DomainResult for basic values
|
| BasicSelectingDelegate |
Delegate for dealing with IDENTITY columns where the dialect requires an
additional command execution to retrieve the generated IDENTITY value
|
| BasicSQLExceptionConverter |
|
| BasicType<T> |
Marker interface for basic types.
|
| BasicTypeReference<T> |
A basic type reference.
|
| BasicTypeRegistration |
|
| BasicTypeRegistry |
|
| BasicValue |
|
| BasicValue.Resolution<J> |
Resolved form of BasicValue as part of interpreting the
boot-time model into the run-time model |
| BasicValueConverter<D,R> |
|
| BasicValuedFetchBuilder |
|
| BasicValuedMapping |
Any basic-typed ValueMapping.
|
| BasicValuedModelPart |
Describes a ModelPart which is a basic value, either
a Basic attribute
a basic-valued collection part
|
| Batch |
Represents a batch of statements to be executed together.
|
| BatchBuilder |
A builder for Batch instances. |
| BatchedTooManyRowsAffectedException |
|
| BatchFailedException |
Indicates a failed batch entry (-3 return).
|
| BatchFetchQueue |
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
|
| BatchFetchStyle |
Deprecated.
|
| BatchKey |
Unique key for batch identification.
|
| BatchKeyAccess |
Provides access to a BatchKey as part of creating an executor. |
| BatchLoader |
Commonality for loading a loadable in "batch" (more than one key at a time) |
| BatchLoaderFactory |
|
| BatchObserver |
An observer contract for batch events.
|
| BatchSize |
Specifies a maximum batch size for batch fetching of the annotated
entity or collection.
|
| BeanContainer |
Represents a backend "bean container" - CDI, Spring, etc
|
| BeanContainer.LifecycleOptions |
|
| BeanInstanceProducer |
Contract for producing a bean instance
|
| BeanLifecycleStrategy |
Models how the lifecycle for a bean should be managed.
|
| BeanValidationEventListener |
Event listener used to enable Bean Validation for insert/update/delete events.
|
| BeanValidationIntegrator |
|
| BeforeExecutionGenerator |
A generator that is called to produce a value just before a row is written to the database.
|
| BeforeTransactionCompletionProcess |
Contract representing some process that needs to occur during before transaction completion.
|
| BetweenPredicate |
|
| BiDirectionalFetch |
|
| BigDecimalJavaType |
|
| BigIntegerJavaType |
|
| BigIntJdbcType |
Descriptor for BIGINT handling. |
| BinaryArithmeticExpression |
|
| BinaryArithmeticOperator |
Enumeration of standard binary arithmetic operators
|
| BinaryJdbcType |
Descriptor for BINARY handling. |
| BinaryStream |
Wraps a binary stream to also provide the length which is needed when binding.
|
| Bindable |
Contract for things at the domain mapping level that can be bound
into a JDBC PreparedStatement. |
| Bindable.JdbcValuesBiConsumer<X,Y> |
Functional interface for consuming the JDBC values, along with two values of type X and Y.
|
| Bindable.JdbcValuesConsumer |
Functional interface for consuming the JDBC values.
|
| BindableMappingDescriptor |
Common type for things that can get be bound to a Binding for
mapping documents. |
| BindableType<J> |
Types that can be used to handle binding Query parameters |
| Binder<T> |
Contract for performing JAXB binding.
|
| Binder |
|
| Binding<T> |
Represents a JAXB binding, as well as keeping information about the origin
of the processed XML
|
| Binding |
|
| BindingGroup |
Group of all parameter bindings for a table. |
| BlobImplementer |
Marker interface for non-contextually created Blob instances.. |
| BlobJavaType |
Descriptor for Blob handling. |
| BlobJavaType.BlobMutabilityPlan |
|
| BlobJdbcType |
Descriptor for BLOB handling. |
| BlobProxy |
Manages aspects of representing Blob objects. |
| BooleanDecoder |
Utility for decoding boolean representations.
|
| BooleanExpressionPredicate |
|
| BooleanJavaType |
|
| BooleanJdbcType |
|
| BooleanPrimitiveArrayJavaType |
Descriptor for boolean[] handling.
|
| BootLogging |
Logging related to Hibernate bootstrapping
|
| BootQueryLogging |
|
| Bootstrap |
Entry into the bootstrap process.
|
| BootstrapContext |
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. |
| BootstrapServiceRegistry |
Provides the most basic services such as class loading.
|
| BootstrapServiceRegistryBuilder |
|
| Builders |
|
| BuiltInPropertyAccessStrategies |
|
| BulkInsertionCapableIdentifierGenerator |
Specialized contract for IdentifierGenerator implementations capable of being used in conjunction
with HQL insert statements. |
| ByteArrayJavaType |
Descriptor for Byte[] handling, which disallows null elements.
|
| ByteBuddyInterceptor |
|
| ByteBuddyProxyFactory |
|
| ByteBuddyProxyHelper |
|
| BytecodeEnhancementMetadata |
Encapsulates bytecode enhancement information about a particular entity.
|
| BytecodeInterceptorLogging |
Logging related to bytecode enhancement interceptors
|
| BytecodeLazyAttributeInterceptor |
|
| BytecodeLogging |
|
| BytecodeProvider |
Contract for providers of bytecode services to Hibernate.
|
| ByteJavaType |
Descriptor for Byte handling. |
| Cache |
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. |
| Cache |
An API for directly querying and managing the second level cache.
|
| CacheableDataStatistics |
|
| CacheAccessTypeMarshalling |
|
| CacheConcurrencyStrategy |
Identifies policies for managing concurrent access to the shared
second-level cache.
|
| CachedDomainDataAccess |
Base contract for accessing the underlying cached data for a particular
Navigable of the user's domain model in a transactionally ACID manner.
|
| CachedNaturalIdValueSource |
The type of action from which the cache call is originating.
|
| CacheEntry |
A cached instance of a persistent class
|
| CacheEntryStructure |
Strategy for how cache entries are "structured" for storing into the cache.
|
| CacheException |
Something went wrong in the cache.
|
| CacheImplementor |
An SPI supported by any Hibernate service that provides an
implementation of the Cache API. |
| CacheInitiator |
Initiator for second level cache support
|
| CacheKeysFactory |
A factory for keys into the second-level cache.
|
| CacheMode |
|
| CacheModeMarshalling |
|
| CacheModeType |
Deprecated.
|
| CacheRegionDefinition |
Models the definition of caching settings for a particular region.
|
| CacheRegionDefinition.CacheRegionType |
|
| CacheRegionStatistics |
Second-level cache statistics of a specific region.
|
| CacheTransactionSynchronization |
|
| CacheUtils |
|
| Caching |
Deprecated.
|
| CalendarDateJavaType |
Descriptor for Calendar handling, but just for the date (month, day, year) portion. |
| CalendarJavaType |
|
| CalendarJavaType.CalendarMutabilityPlan |
|
| CalendarTimeJavaType |
Descriptor for Calendar handling, but just for the time portion. |
| CallableStatementSupport |
|
| Callback |
Represents a JPA event callback (the method).
|
| Callback |
Callback to allow SQM interpretation to trigger certain things within ORM.
|
| CallbackDefinition |
|
| CallbackException |
|
| CallbackRegistry |
Registry of Callbacks by entity and type
|
| CallbackRegistryConsumer |
Contract for injecting the registry of Callbacks into event listeners.
|
| CallbackType |
|
| CamelCaseToUnderscoresNamingStrategy |
Originally copied from Spring Boot as this strategy is popular there
(original name is SpringPhysicalNamingStrategy).
|
| CannotBecomeEntityGraphException |
|
| CannotContainSubGraphException |
Indicates an attempt was made to add a (key)? sub-graph to an
attribute type that does not support (key)? sub-graphs.
|
| Cascade |
Specifies the persistence operations that should cascade
to associated entity instances.
|
| CascadeStyle |
A contract for defining the aspects of cascading various persistence actions.
|
| CascadeStyles |
|
| CascadeStyles.BaseCascadeStyle |
|
| CascadeStyles.MultipleCascadeStyle |
|
| CascadeStyleSource |
Describes sources which define cascading.
|
| CascadeType |
Enumerates the persistence operations which may be cascaded from
one entity instance to associated entity instances.
|
| CascadingAction<T> |
A session action that may be cascaded from parent entity to its children
|
| CascadingActions |
|
| CascadingActions.BaseCascadingAction<T> |
|
| CascadingFetchProfile |
|
| CaseLeastGreatestEmulation |
Some databases don't have a function like least() or greatest(),
and on those platforms we emulate the function using case.
|
| CaseSearchedExpression |
|
| CaseSearchedExpression.WhenFragment |
|
| CaseSimpleExpression |
|
| CaseSimpleExpression.WhenFragment |
|
| CastFunction |
|
| CastingConcatFunction |
|
| CastStrEmulation |
The HQL str() function is now considered a synonym for cast(x as String).
|
| CastTarget |
|
| CastType |
Defines the set of basic types which should be
accepted by the cast() function on every
platform.
|
| CfgXmlAccessService |
Allows access to any cfg.xml files specified for bootstrapping.
|
| CharacterArrayJavaType |
Descriptor for Character[] handling, which disallows null elements.
|
| CharacterJavaType |
|
| CharacterStream |
Wraps a character stream (reader) to also provide the length (number of characters) which is needed
when binding.
|
| CharBooleanConverter |
|
| CharJdbcType |
Descriptor for CHAR handling. |
| Check |
Specifies a check constraint to be included in the generated DDL.
|
| CheckConstraint |
Represents a table or column level check constraint.
|
| Checks |
|
| ChrLiteralEmulation |
A chr implementation that translates integer literals to string literals.
|
| ClassDescriptor |
Descriptor for a class file.
|
| ClassDescriptor.Categorization |
|
| ClassFileArchiveEntryHandler |
Defines handling and filtering for class file entries within an archive
|
| ClassJavaType |
Descriptor for Class handling. |
| ClassLoaderAccess |
During the process of building the metamodel, access to the ClassLoader is
strongly discouraged. |
| ClassLoaderService |
A service for interacting with class loaders.
|
| ClassLoaderService.Work<T> |
|
| ClassLoadingException |
Indicates a problem performing class loading.
|
| ClassMetadata |
Deprecated.
|
| ClassTransformer |
|
| Clause |
Used to indicate which query clause we are currently processing
|
| Cleaner |
An object that produces the SQL required to truncate the tables in a schema.
|
| ClearEvent |
|
| ClearEventListener |
|
| ClobImplementer |
Marker interface for non-contextually created Clob instances.. |
| ClobJavaType |
Descriptor for Clob handling. |
| ClobJavaType.ClobMutabilityPlan |
MutabilityPlan for Clob values
|
| ClobJdbcType |
Descriptor for CLOB handling. |
| ClobProxy |
Manages aspects of proxying Clobs for non-contextual creation, including proxy creation and
handling proxy invocations. |
| ClockHelper |
Helper for determining the correct clock for precision
|
| CloseableIterator<T> |
Unification of Iterator and AutoCloseable
|
| CoalesceIfnullEmulation |
|
| CockroachDBIdentityColumnSupport |
|
| CockroachDialect |
|
| CockroachSqlAstTranslator<T extends JdbcOperation> |
A SQL AST translator for Cockroach.
|
| CoercingResultAssembler<J> |
A BasicResultAssembler which does type coercion to handle cases
where the expression type and the expected result JavaType are different
(e.g. |
| CoercionException |
|
| CoercionHelper |
Helper for type coercions.
|
| CoercionHelper.Coercer<T> |
|
| Collation |
|
| Collection |
A mapping model object representing a collection.
|
| CollectionAttribute |
JAXB binding interface for plural attributes
|
| CollectionBatchLoader |
BatchLoader specialization for collection fetching |
| CollectionCacheEntry |
Cacheable representation of persistent collections
|
| CollectionClassification |
Classifications of the plurality.
|
| CollectionDataAccess |
Contract for managing transactional and concurrent access to cached collection
data.
|
| CollectionDataCachingConfig |
Specialized DomainDataCachingConfig describing the requested
caching config for a particular persistent collection's data
|
| CollectionEntry |
We need an entry to tell us all about the current state
of a collection with respect to its persistent state
|
| CollectionId |
Describe an identifier column for a bag.
|
| CollectionIdentifierDescriptor |
Descriptor for the collection identifier.
|
| CollectionIdJavaType |
Form of JavaType for describing the id of an id-bag mapping. |
| CollectionIdJdbcType |
Form of JdbcType for describing the id of an id-bag mapping. |
| CollectionIdJdbcTypeCode |
Form of JdbcTypeCode for describing the id of an id-bag mapping. |
| CollectionIdMutability |
Form of Mutability for describing the id of an id-bag mapping |
| CollectionIdSource |
|
| CollectionIdType |
Form of Type for describing the id of an id-bag mapping. |
| CollectionInitializer |
Initializer implementation for initializing collections (plural attributes)
|
| CollectionInitializerProducer |
|
| CollectionJavaType<C> |
Extension of the general JavaType for "collection types"
|
| CollectionKey |
Uniquely identifies a collection instance in a particular session.
|
| CollectionLoader |
A loader (initialization) for collections
|
| CollectionLoadingLogger |
|
| CollectionMappingType<C> |
MappingType descriptor for the collection Java type (List, Set, etc)
|
| CollectionMetadata |
Deprecated.
|
| CollectionMutationTarget |
|
| CollectionNonStrictReadWriteAccess |
|
| CollectionOperationCoordinator |
Base contract for coordination of collection mutation operations
|
| CollectionPart |
Hibernate understands mapping a collection into 4 parts
The key - the foreign-key defining the association to the owner
The element - for Map's 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
|
| CollectionPart.Nature |
|
| CollectionPartPath |
Represents a part of a `CollectionPart` (element or index descriptor) as a DomainPath
|
| CollectionPersister |
A strategy for persisting a mapped collection role.
|
| CollectionReadOnlyAccess |
|
| CollectionReadWriteAccess |
|
| CollectionResultGraphNode |
|
| CollectionSemantics<CE,E> |
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.
|
| CollectionSemanticsResolver |
Resolve the collection semantics for the given mapped collection.
|
| CollectionStatistics |
Collection-related statistics.
|
| CollectionTableGroup |
A table group for collection tables of plural attributes.
|
| CollectionTableMapping |
|
| CollectionTracker |
Interface to be implemented by collection trackers that hold the expected size od collections, a simplified Map<String, int>.
|
| CollectionTransactionAccess |
|
| CollectionType |
Names a custom collection type for a persistent collection.
|
| CollectionType |
A type that handles Hibernate PersistentCollections (including arrays).
|
| CollectionTypeRegistration |
Allows to register a UserCollectionType
to use as the default for the specified classification of collection. |
| CollectionTypeRegistrations |
|
| Column |
A mapping model object representing a column
of a relational database table. |
| ColumnAliasExtractor |
|
| ColumnBindingDefaults |
|
| ColumnDefault |
Specifies that a column has a default value specified in DDL.
|
| ColumnDefaultsBasicImpl |
|
| ColumnInformation |
Provides access to information about existing table columns
|
| ColumnOrderingStrategy |
|
| ColumnOrderingStrategyLegacy |
A no-op implementation.
|
| ColumnOrderingStrategyStandard |
Standard implementation that orders columns by size and name following roughly this ordering:
order by max(physicalSizeBytes, 4), physicalSizeBytes > 2048, name
|
| ColumnOrderingStrategyStandard.ColumnComparator |
|
| ColumnOrderingStrategyStandard.TemporaryTableColumnComparator |
|
| ColumnReference |
Represents a column-reference used in an order-by fragment
|
| ColumnReference |
Models a reference to a Column in a SQL AST
|
| ColumnReferenceQualifier |
|
| Columns |
Support an array of columns.
|
| ColumnsAndFormulasSourceContainer |
|
| ColumnSource |
Contract for source information pertaining to a physical column definition specific to a particular attribute
context.
|
| ColumnTransformer |
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.
|
| ColumnTransformers |
Plural annotation for @ColumnTransformer.
|
| ColumnTypeInformation |
Provides access to information about existing table columns
|
| ColumnValueBinding |
Represents the binding of a value to a column.
|
| ColumnValueBindingBuilder |
|
| ColumnValueBindingList |
|
| ColumnValueParameter |
Parameter descriptor specific to mutations.
|
| ColumnValueParameterList |
|
| ColumnValuesTableMutationBuilder |
|
| ColumnWriteFragment |
Models a column's value expression within the SQL AST.
|
| CommandAcceptanceException |
Indicates a problem accepting/executing a schema management command.
|
| Comment |
Specifies a comment that will be included in generated DDL.
|
| Comments |
|
| CommonFunctionFactory |
Enumeratoes common function template definitions.
|
| CommonQueryContract |
|
| ComparableExecutable |
We frequently need the union type of Executable, Comparable of ComparableExecutable, Serializable;
this interface represents such union; this helps to simplify several generic signatures.
|
| ComparisonOperator |
Defines the comparison operators.
|
| ComparisonPredicate |
|
| ComparisonRestriction |
A binary-comparison restriction
|
| ComparisonRestriction.Operator |
|
| Compatibility |
|
| CompleteFetchBuilder |
|
| CompleteFetchBuilderBasicPart |
|
| CompleteFetchBuilderEmbeddableValuedModelPart |
CompleteFetchBuilder for embeddable-valued ModelParts
|
| CompleteFetchBuilderEntityValuedModelPart |
CompleteFetchBuilder for entity-valued ModelParts
|
| CompleteRestriction |
For a complete predicate.
|
| CompleteResultBuilder |
|
| CompleteResultBuilderBasicModelPart |
CompleteResultBuilder for basic-valued ModelParts
|
| CompleteResultBuilderBasicValued |
Nominal extension to ResultBuilder for cases involving scalar results
|
| CompleteResultBuilderBasicValuedConverted<O,R> |
ResultBuilder for scalar results defined via:
JPA ColumnResult
`<return-scalar/>` as part of a `<resultset/>` stanza in `hbm.xml`
|
| CompleteResultBuilderBasicValuedStandard |
ResultBuilder for scalar results defined via:
JPA ColumnResult
`<return-scalar/>` as part of a `<resultset/>` stanza in `hbm.xml`
|
| CompleteResultBuilderCollection |
|
| CompleteResultBuilderCollectionStandard |
|
| CompleteResultBuilderEntityJpa |
CompleteResultBuilderEntityValued implementation specific to JPA.
|
| CompleteResultBuilderEntityStandard |
|
| CompleteResultBuilderEntityValued |
|
| CompleteResultBuilderInstantiation |
|
| Component |
|
| Component.StandardGenerationContextLocator |
|
| Component.ValueGenerationPlan |
|
| ComponentArrayComparator |
Comparator for component arrays.
|
| ComponentType |
Handles "component" mappings
|
| CompositeElementPropertyMapping |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| CompositeIdentifierMapping |
Mapping for a composite identifier
|
| CompositeIdentifierSource |
Common contract for composite identifiers.
|
| CompositeNestedGeneratedValueGenerator |
For composite identifiers, defines a number of "nested" generations that
need to happen to "fill" the identifier property(s).
|
| CompositeNestedGeneratedValueGenerator.GenerationContextLocator |
Contract for declaring how to locate the context for sub-value injection.
|
| CompositeNestedGeneratedValueGenerator.GenerationPlan |
Contract for performing the actual sub-value generation, usually injecting it into the
determined context |
| CompositeOwner |
|
| CompositeTracker |
|
| CompositeType |
|
| CompositeType |
Represents a composite type, a type which itself has typed attributes.
|
| CompositeTypeImplementor |
|
| CompositeTypeRegistration |
|
| CompositeTypeRegistrations |
|
| CompositeUserType<J> |
This 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. |
| CompositeValueGenerationException |
|
| ConcatPipeFunction |
A concat function with a pattern for clob arguments.
|
| ConfigParameterContainer |
|
| Configurable |
|
| Configurable |
Allows the service to request access to the configuration properties for configuring itself.
|
| Configuration |
A convenience API making it easier to bootstrap an instance of Hibernate.
|
| ConfigurationService |
Provides access to the initial user-provided configuration values.
|
| ConfigurationService.Converter<T> |
Simple conversion contract for converting an untyped object to a specified type.
|
| ConfigXsdSupport |
Support for XSD handling related to Hibernate's `cfg.xml` and
JPA's `persistence.xml`.
|
| ConnectionAcquisitionMode |
Indicates the manner in which JDBC connections
are acquired. |
| ConnectionObserver |
An observer of logical connection events.
|
| ConnectionObserverAdapter |
|
| ConnectionProvider |
A contract for obtaining JDBC connections and, optionally, for pooling connections.
|
| ConnectionReleaseMode |
Enumerates various policies for releasing JDBC connections. |
| Constraint |
A mapping model object representing a constraint on a relational database table.
|
| ConstraintModeMarshalling |
|
| ConstraintViolationException |
A JDBCException indicating that the requested DML operation
resulted in violation of a defined integrity constraint. |
| ContainedBean<B> |
|
| ContainedBeanImplementor<B> |
|
| Contributable |
Parts of the mapping model which are associated with a
contributor (ORM, Envers, etc). |
| ContributableDatabaseObject |
Database objects (table, sequence, etc) which are associated with
a contributor (ORM, Envers, etc) and
can be selectively exported per contributor |
| ContributableMatcher |
|
| Conversion |
A conversion of a duration to a given temporal unit,
as a result of applying the 'by unit' operator.
|
| ConversionContext |
|
| ConversionException |
Indicates a problem converting an SQM tree to a SQL AST
|
| ConvertedBasicArrayType<T> |
A converted basic array type.
|
| ConvertedBasicCollectionType<C extends Collection<E>,E> |
A converted basic array type.
|
| ConvertedBasicType<J> |
|
| ConverterAutoApplyHandler |
|
| ConverterDescriptor |
Boot-time descriptor of a JPA AttributeConverter
|
| ConverterRegistration |
|
| ConverterRegistrations |
|
| ConverterRegistry |
|
| CorrelatedPluralTableGroup |
A table group for correlated plural attributes.
|
| CorrelatedTableGroup |
|
| CountFunction |
|
| CreateTableUniqueDelegate |
A UniqueDelegate which includes the unique constraint in the create table
statement, except when called during schema migration. |
| CreationTimestamp |
Specifies that the annotated field of property is a generated creation timestamp.
|
| CreationTimestampGeneration |
Deprecated.
|
| CriteriaBuilderExtension |
|
| CteColumn |
Information about a column in the CTE table
|
| CteContainer |
The consumer part of a CTE statement - the select or insert or delete or update that uses
the CTE
|
| CteMaterialization |
The kind of materialization that should be used for a CTE.
|
| CteSearchClauseKind |
The kind of CTE search clause.
|
| CteStatement |
A statement using a CTE
|
| CteTable |
Describes the table definition for the CTE - its name amd its columns
|
| CteTableGroup |
|
| CteTupleTableGroupProducer |
The table group producer for a CTE tuple type.
|
| CurrencyJavaType |
|
| CurrentFunction |
A "function" with no parameters that returns the current date, time, or timestamp.
|
| CurrentSessionContext |
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. |
| CurrentTenantIdentifierResolver |
A callback registered with the SessionFactory that is
responsible for resolving the current tenant identifier. |
| CurrentTimestamp |
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. |
| CustomCollectionType |
A custom type for mapping user-written classes that implement PersistentCollection
|
| CustomEntityDirtinessStrategy |
During a flush cycle, Hibernate needs to determine which of the entities associated with a Session
are dirty, meaning modified. |
| CustomEntityDirtinessStrategy.AttributeChecker |
Responsible for identifying when attributes are dirty.
|
| CustomEntityDirtinessStrategy.AttributeInformation |
|
| CustomEntityDirtinessStrategy.DirtyCheckContext |
A callback to drive dirty checking.
|
| CustomIdGeneratorCreationContext |
|
| CustomSql |
Models the information for custom SQL execution defined as part of
the mapping for a primary or secondary table.
|
| CustomSqlMutation<O extends JdbcMutationOperation> |
|
| CustomType<J> |
Adapts UserType to the generic Type interface, in order
to isolate user code from changes in the internal Type contracts. |
| CustomVersionOneStrategy |
Applies a version 1 (time-based) generation strategy (using ip address rather than mac address) but applies them in a
different layout.
|
| Database |
|
| Database |
A list of relational database systems for which Hibernate can resolve a Dialect. |
| DatabaseIdentifier |
Models an identifier (name), retrieved from the database.
|
| DatabaseInformation |
Provides access to information about existing schema objects (tables, sequences etc) of existing database.
|
| DatabaseMetaDataDialectResolutionInfoAdapter |
An implementation of DialectResolutionInfo that delegates calls to a wrapped DatabaseMetaData. |
| DatabaseSnapshotContributor |
Contract for model-parts which contribute to their container's
state array for database snapshots
|
| DatabaseStructure |
Encapsulates definition of the underlying data structure backing a
sequence-style generator.
|
| DatabaseVersion |
Details about the underlying database, as understood by a Dialect.
|
| DataException |
Extends JDBCException indicating that evaluation of the
valid SQL statement against the given data resulted in some
illegal operation, mismatched types or incorrect cardinality. |
| DataHelper |
A help for dealing with BLOB and CLOB data
|
| DataSourceBasedMultiTenantConnectionProviderImpl |
|
| DateJavaType |
Descriptor for Date handling. |
| DateJavaType.DateMutabilityPlan |
|
| DateJdbcType |
Descriptor for DATE handling. |
| DateTimeUtils |
Utilities for dealing with date/times
|
| DateTruncEmulation |
Emulation of trunc(datetime, temporal_unit) function that leverages
formatting the datetime to string and back to truncate it
|
| DB2390IdentityColumnSupport |
Deprecated.
|
| DB2400Dialect |
Deprecated.
|
| DB2400V7R3Dialect |
Deprecated.
|
| DB2AggregateSupport |
|
| DB2Dialect |
A SQL dialect for DB2 for LUW (Linux, Unix, and Windows) version 10.5 and above. |
| DB2FormatEmulation |
DB2's varchar_format() can't handle quoted literal strings in
the format pattern.
|
| DB2IdentityColumnSupport |
|
| DB2iDialect |
A SQL dialect for DB2 for IBM i version 7.1 and above, previously known as "DB2/400".
|
| DB2iSequenceSupport |
|
| DB2iSqlAstTranslator<T extends JdbcOperation> |
A SQL AST translator for DB2i.
|
| DB2LimitHandler |
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. |
| DB2PositionFunction |
DB2's position() function always requires a code unit before version 11.
|
| DB2SequenceSupport |
|
| DB2SqlAstTranslator<T extends JdbcOperation> |
A SQL AST translator for DB2.
|
| DB2StructJdbcType |
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.
|
| DB2SubstringFunction |
DB2's substring() function requires a code unit and substr() can't optionally take it,
so we render substr() by default.
|
| DB2zDialect |
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".
|
| DB2zIdentityColumnSupport |
|
| DB2zSequenceSupport |
|
| DB2zSqlAstTranslator<T extends JdbcOperation> |
A SQL AST translator for DB2z.
|
| DdlTransactionIsolator |
Provides access to a Connection that is isolated from any
"current transaction" with the designated purpose of performing DDL
commands. |
| DdlType |
Descriptor for a DDL column type.
|
| DdlTypeRegistry |
|
| DecimalJdbcType |
|
| DefaultComponentSafeNamingStrategy |
Deprecated.
|
| DefaultEnhancementContext |
default implementation of EnhancementContext.
|
| DefaultNamingStrategy |
Deprecated.
|
| DefaultUniqueDelegate |
Deprecated.
|
| DelayedDropAction |
Memento representing the dropping of a schema as part of create-drop
hbm2ddl.auto handling.
|
| DelayedDropRegistry |
Callback to allow the built DelayedDropAction, if indicated, to be registered
back with the SessionFactory (or the thing that will manage its later execution).
|
| DelayedDropRegistryNotAvailableImpl |
Implementation of DelayedDropRegistry for cases when the delayed-drop portion of
"create-drop" is not valid.
|
| DelayedFetchBuilderBasicPart |
|
| DelegatingQueryOptions |
|
| DelegatingTableGroup |
|
| Delete |
A SQL DELETE statement.
|
| DeleteContext |
|
| DeleteCoordinator |
Coordinates the deleting of an entity.
|
| DeleteEvent |
Defines an event class for the deletion of an entity.
|
| DeleteEventListener |
Defines the contract for handling of deletion events generated from a session.
|
| DeleteOrUpsertOperation |
|
| DeleteRowsCoordinator |
Coordinates the deletion of entries removed from the collection -
For collections with a collection-table, deletes rows from the
collection table.
|
| DeleteRowsCoordinatorNoOp |
DeleteRowsCoordinator implementation for cases where deletion is not enabled
|
| DeleteRowsCoordinatorStandard |
|
| DeleteRowsCoordinatorTablePerSubclass |
|
| DeleteStatement |
|
| DeleteStatement.DeleteStatementBuilder |
|
| DenormalizedTable |
|
| DependantBasicValue |
|
| DependantValue |
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). |
| DeprecatedCollectionStuff |
Deprecated.
|
| DeprecatedEntityStuff |
Deprecated.
|
| DerbyDialect |
|
| DerbyLimitHandler |
A LimitHandler for Apache Derby, which
fully supports the ANSI SQL standard syntax
FETCH FIRST m ROWS ONLY and
OFFSET n ROWS FETCH NEXT m ROWS ONLY. |
| DerbyLpadEmulation |
A derby implementation for lpad.
|
| DerbyRpadEmulation |
A derby implementation for rpad.
|
| DerbySequenceSupport |
|
| DerbySqlAstTranslator<T extends JdbcOperation> |
A SQL AST translator for Derby.
|
| DerivedTableReference |
|
| DerivedValueSource |
Contract describing source of a derived value (formula).
|
| Dialect |
Represents a dialect of SQL implemented by a particular RDBMS.
|
| Dialect.SizeStrategy |
Pluggable strategy for determining the Size to use for
columns of a given SQL type. |
| DialectDelegateWrapper |
A wrapper of Dialect, to allow decorating some selected methods
without having to extend the original class.
|
| DialectFactory |
A factory for generating Dialect instances.
|
| DialectLogging |
Logging related to Hibernate dialects
|
| DialectOverride |
Allows certain annotations to be overridden in a given SQL Dialect. |
| DialectOverride.Check |
Specializes a Check
in a certain dialect. |
| DialectOverride.Checks |
|
| DialectOverride.ColumnDefault |
|
| DialectOverride.ColumnDefaults |
|
| DialectOverride.DiscriminatorFormula |
|
| DialectOverride.DiscriminatorFormulas |
|
| DialectOverride.FilterDefOverrides |
|
| DialectOverride.FilterDefs |
|
| DialectOverride.FilterOverrides |
|
| DialectOverride.Filters |
Specializes Filters
in a certain dialect. |
| DialectOverride.Formula |
Specializes a Formula
in a certain dialect. |
| DialectOverride.Formulas |
|
| DialectOverride.GeneratedColumn |
|
| DialectOverride.GeneratedColumns |
|
| DialectOverride.JoinFormula |
|
| DialectOverride.JoinFormulas |
|
| DialectOverride.OrderBy |
Specializes an OrderBy
in a certain dialect. |
| DialectOverride.OrderBys |
|
| DialectOverride.OverridesAnnotation |
Marks an annotation type as a dialect-specific override for
some other annotation type.
|
| DialectOverride.Version |
Identifies a database version.
|
| DialectOverride.Where |
Specializes a Where
in a certain dialect. |
| DialectOverride.Wheres |
|
| DialectResolutionInfo |
Exposes information about the database and JDBC driver that can be used in resolving the appropriate Dialect
to use.
|
| DialectResolutionInfoSource |
Contract for the source of DialectResolutionInfo.
|
| DialectResolver |
Contract for determining the Dialect to use based on information about the database / driver. |
| DialectSelector |
|
| DirectAccessRegion |
Specialized Region whose data is accessed directly,
without the need for key/item wrapping. |
| DirectAccessRegionTemplate |
Bridge between DirectAccessRegion and StorageAccess
|
| DirtyCheckEvent |
Defines an event class for the dirty-checking of a session.
|
| DirtyCheckEventListener |
Defines the contract for handling of session dirty-check events.
|
| Discriminatable |
|
| Discriminatable |
Things that have a discriminator associated with it.
|
| DiscriminatedAssociation |
JAXB binding interface for discriminated association based attributes (any and many-to-any)
|
| DiscriminatedAssociation.Discriminator |
JAXB binding interface for describing the discriminator of a discriminated association
|
| DiscriminatedAssociation.Key |
|
| DiscriminatedAssociationModelPart |
A discriminated association.
|
| DiscriminatorConverter<O,R> |
Conversion of discriminator values between the entity name/Class domain form and
its generally CHARACTER or INTEGER based relational form
|
| DiscriminatorFormula |
Specifies an expression written in native SQL as the discriminator for an
entity inheritance hierarchy.
|
| DiscriminatorHelper |
Operations needed by persisters for working with discriminators.
|
| DiscriminatorMapping |
Mapping of a discriminator value to the corresponding entity-name
|
| DiscriminatorMapping |
|
| DiscriminatorMetadata |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| DiscriminatorOptions |
Optional annotation used in conjunction with the JPA-defined
DiscriminatorColumn annotation to
express Hibernate-specific discriminator properties. |
| DiscriminatorSource |
Contract for sources of information about a mapped discriminator.
|
| DiscriminatorSqmPath<T> |
Commonality between entity and any discriminators
|
| DiscriminatorType<O> |
|
| DiscriminatorType<T> |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| DiscriminatorTypeMarshalling |
|
| DiscriminatorValueDetails |
Details for a particular discriminator value.
|
| Distinct |
|
| DmlTargetColumnQualifierSupport |
Indicates the level of qualifier support used by
the dialect when referencing a column.
|
| DomainDataCachingConfig |
Configuration for a specific type of data to be stored in the
region
|
| DomainDataRegion |
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. |
| DomainDataRegionBuildingContext |
|
| DomainDataRegionConfig |
Configuration for a named region for caching domain data.
|
| DomainDataRegionImpl |
|
| DomainDataRegionTemplate |
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. |
| DomainDataStorageAccess |
|
| DomainPath |
Represents a domain-path (model part path) used in an order-by fragment
|
| DomainPathContinuation |
A path relative to either a CollectionPartPath (element/index DomainPath) or another DomainPathContinuation
|
| DomainQueryExecutionContext |
Context for execution of Query" |
| DomainResult<J> |
Represents a result value in the domain query results.
|
| DomainResultAssembler<J> |
Responsible for "assembling" a result for inclusion in the domain query
result.
|
| DomainResultCreationException |
|
| DomainResultCreationState |
|
| DomainResultCreationStateImpl |
|
| DomainResultGraphNode |
Marker for all object types that can be part of a result mapping
|
| DomainResultGraphPrinter |
Printer for DomainResult graphs
|
| DomainType<J> |
Describes any type that occurs in the application's domain model.
|
| DotIdentifierConsumer |
Consumes the parts of a path.
|
| DotIdentifierSequence |
A compound name.
|
| DoubleJavaType |
Descriptor for Double handling. |
| DoubleJdbcType |
Descriptor for DOUBLE handling. |
| DoublePrimitiveArrayJavaType |
Descriptor for double[] handling.
|
| DowncastLocation |
|
| DuplicateMappingException |
Raised whenever a duplicate for a certain type occurs,
such as a duplicate class, table, or property name.
|
| DuplicateMappingException.Type |
Enumeration of the types of things that can be duplicated.
|
| DuplicationStrategy |
|
| DuplicationStrategy.Action |
The enumerated list of actions available on duplication match
|
| DuplicationStrategyImpl |
|
| Duration |
A duration expressed in terms of a given temporal unit.
|
| DurationJavaType |
Descriptor for Duration, which is represented internally
as ( long seconds, int nanoseconds), approximately
28 decimal digits of precision. |
| DurationUnit |
|
| DynamicFetchBuilder |
|
| DynamicFetchBuilderContainer |
|
| DynamicFetchBuilderLegacy |
|
| DynamicFetchBuilderStandard |
|
| DynamicInsert |
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.
|
| DynamicInstantiationNature |
Represents the type of instantiation to be performed.
|
| DynamicInstantiationResult<R> |
|
| DynamicMapInstantiator |
Deprecated.
|
| DynamicModelJavaType |
JavaType for dynamic models
|
| DynamicParameterizedType |
|
| DynamicParameterizedType.ParameterType |
|
| DynamicResultBuilder |
ResultBuilder specialization for results added through the Hibernate-specific
NativeQuery result definition methods. |
| DynamicResultBuilderAttribute |
DynamicResultBuilder based on a named mapped attribute
|
| DynamicResultBuilderBasic |
|
| DynamicResultBuilderBasicConverted<O,R> |
A ResultBuilder for explicitly converted scalar results
|
| DynamicResultBuilderBasicStandard |
Standard DynamicResultBuilder for basic values.
|
| DynamicResultBuilderEntity |
|
| DynamicResultBuilderEntityCalculated |
An entity-valued DynamicResultBuilder for cases when the user has not supplied
specific column to attribute mappings.
|
| DynamicResultBuilderEntityStandard |
|
| DynamicResultBuilderInstantiation<J> |
|
| DynamicUpdate |
Specifies that SQL update statements for the annotated entity
are generated dynamically, and only include columns which are actually
being updated.
|
| EffectiveEntityGraph |
Think of this as the composite modeling of a graph
and the semantic.
|
| ElementPropertyMapping |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| EmbeddableAggregateJavaType<T> |
Java type for embeddable aggregates, which allows resolving a recommended JdbcType. |
| EmbeddableDomainType<J> |
|
| EmbeddableInitializer |
Special initializer contract for embeddables
|
| EmbeddableInstantiator |
Specifies a custom instantiator for a specific embedded
|
| EmbeddableInstantiator |
Contract for instantiating embeddable values.
|
| EmbeddableInstantiatorRegistration |
Registers a custom instantiator implementation to be used
for all references to a particular Embeddable. |
| EmbeddableInstantiatorRegistrations |
|
| EmbeddableLoadingLogger |
|
| EmbeddableMapping |
Unifying contract for consuming JAXB types which describe an embeddable (in JPA terms).
|
| EmbeddableMappingType |
Describes an embeddable - the actual type
|
| EmbeddableRepresentationStrategy |
Describes the representation of a particular embeddable type.
|
| EmbeddableResult<T> |
DomainResult specialization for embeddable-valued results
|
| EmbeddableResultGraphNode |
|
| EmbeddableSource |
Represents the binding source for an "embeddable" (in JPA terms)
or "composite" (in legacy Hibernate terms).
|
| EmbeddableSourceContributor |
Contract for things that can contain EmbeddableSource definitions.
|
| EmbeddableValuedFetchable |
|
| EmbeddableValuedModelPart |
Describes the mapping of an embeddable (composite).
|
| EmbeddedAttributeMapping |
Unifying contract for any JAXB types which describe an embedded (in JPA terms).
|
| EmbeddedComponentType |
|
| EmbeddedDomainType<J> |
Deprecated.
|
| EmptyInterceptor |
Deprecated.
|
| EnhancedSetterImpl |
A specialized Setter implementation for handling setting values into
a bytecode-enhanced Class.
|
| EnhancedSetterMethodImpl |
A specialized Setter implementation for handling setting values into a bytecode-enhanced Class
using a setter method.
|
| EnhancedUserType<J> |
A custom type that may function as an identifier or discriminator type
|
| EnhancementAsProxyLazinessInterceptor |
|
| EnhancementContext |
The context for performing an enhancement.
|
| EnhancementContextWrapper |
|
| EnhancementException |
An exception indicating some kind of problem performing bytecode enhancement.
|
| EnhancementHelper |
|
| EnhancementHelper.InheritanceChecker |
|
| EnhancementInfo |
Provides basic information about the enhancement done to a class.
|
| Enhancer |
Class responsible for performing enhancement.
|
| EnhancerConstants |
Constants used during enhancement.
|
| EntityAssociationMapping |
Commonality between `many-to-one`, `one-to-one` and `any`, as well as entity-valued collection elements and map-keys
|
| EntityBasedAssociationAttribute |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| EntityBasedBasicAttribute |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| EntityBasedCompositionAttribute |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| EntityBatchLoader<T> |
BatchLoader specialization for entity fetching |
| EntityCopyObserver |
An observer for detection of multiple entity representations for a persistent entity being merged.
|
| EntityCopyObserverFactory |
|
| EntityDataAccess |
Contract for managing transactional and concurrent access to cached entity
data.
|
| EntityDataCachingConfig |
Specialized DomainDataCachingConfig describing the requested
caching config for a particular entity hierarchy's state data
|
| EntityDiscriminatorMapping |
Details about the discriminator for an entity hierarchy.
|
| EntityDomainType<J> |
|
| EntityEntry |
Information about the current state of a managed entity instance with respect
to its persistent state.
|
| EntityEntryExtraState |
Navigation methods for extra state objects attached to EntityEntry. |
| EntityEntryFactory |
|
| EntityFetch |
Specialization of Fetch for entity-valued fetches
|
| EntityGraphQueryHint |
Deprecated.
|
| EntityGraphs |
|
| EntityGraphTraversalState |
State used as part of applying entity graphs to
Hibernate DomainResult / Fetch load graphs. |
| EntityGraphTraversalState.FetchStrategy |
|
| EntityGraphTraversalState.TraversalResult |
Details of a particular traversal within the entity graph
|
| EntityHierarchySource |
Models the source-agnostic view of an entity hierarchy.
|
| EntityIdentifierMapping |
Describes the mapping of an entity's identifier.
|
| EntityIdentifierMapping.Nature |
The style of identifier used.
|
| EntityIdentifierNature |
Describes the possible natures of an entity-defined identifier.
|
| EntityIdentifierNavigablePath |
Specialized implementation of NavigablePath for handling special cases
pertaining to entity identifiers. |
| EntityInfo |
Common interface for all entity mappings (root entity and sub-entity mappings).
|
| EntityInitializer |
Initializer implementation for initializing entity references.
|
| EntityInstantiator |
Contract for instantiating entity values
|
| EntityJavaType<T> |
Uses object identity for equals/hashCode as we ensure that internally.
|
| EntityKey |
Uniquely identifies of an entity instance in a particular Session by identifier.
|
| EntityLoader |
Specialization of Loader for loading entities of a type
|
| EntityLoadingLogging |
|
| EntityManagerFactoryBuilder |
|
| EntityMappingType |
Mapping of an entity
|
| EntityMappingType.ConstraintOrderedTableConsumer |
|
| EntityMetamodel |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| EntityMultiLoader<T> |
Commonality for multi-loading an entity |
| EntityMutationTarget |
|
| EntityNameResolver |
An object capable of determining the entity name for a given entity instance.
|
| EntityNameUse |
Describes the kind of entity name use.
|
| EntityNameUse.UseKind |
|
| EntityNaming |
|
| EntityNamingSource |
Naming information about an entity.
|
| EntityNamingSourceContributor |
|
| EntityNonStrictReadWriteAccess |
|
| EntityNotFoundDelegate |
Delegate to handle the scenario of an entity not found by a specified id.
|
| EntityOrMappedSuperclass |
JAXB binding interface for commonality between entity and mapped-superclass mappings
|
| EntityPersister |
|
| EntityReadOnlyAccess |
|
| EntityReadWriteAccess |
|
| EntityRepresentationStrategy |
|
| EntityResult |
Specialization of DomainResult for entity-valued results
|
| EntityResultGraphNode |
Represents a reference to an entity either as a return, fetch, or collection element or index.
|
| EntityResultImpl |
|
| EntityRowIdMapping |
Mapping of a row-id
|
| EntitySource |
Contract describing source of information related to mapping an entity.
|
| EntityStatistics |
Entity-related statistics.
|
| EntityTableMapping |
Descriptor for the mapping of a table relative to an entity
|
| EntityTableMapping.KeyColumn |
|
| EntityTableMapping.KeyMapping |
|
| EntityTableMapping.KeyValueConsumer |
|
| EntityTransactionalAccess |
|
| EntityType |
Base for types which map associations to persistent entities.
|
| EntityTypeLiteral |
|
| EntityUniqueKey |
Used to uniquely key an entity instance in relation to a particular session
by some unique property reference, as opposed to identifier.
|
| EntityValuedFetchable |
Fetchable which is entity-valued
|
| EntityValuedModelPart |
Entity-valued model part
ManyToOne
OneToOne
entity-valued collection element
entity-valued Map key
|
| EntityVersionMapping |
Describes the mapping of an entity's version
|
| EnumJavaType<T extends Enum<T>> |
Describes a Java enum type.
|
| EnumType<T extends Enum<T>> |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| EnumTypeMarshalling |
|
| EnumValueConverter<O extends Enum<O>,R> |
|
| Environment |
Provides access to configuration properties passed in Properties objects. |
| EventActionWithParameter<T,U,X> |
|
| EventEngine |
Composite for the things related to Hibernate's event system.
|
| EventEngineContributions |
|
| EventEngineContributor |
Integration contract for contributing event types and listeners to the Hibernate event system.
|
| EventListenerGroup<T> |
Contract for a groups of events listeners for a particular event type.
|
| EventListenerRegistrationException |
Indicates a problem registering an event listener.
|
| EventListenerRegistry |
|
| EventSource |
|
| EventType<T> |
Enumeration of the recognized types of events, including meta-information about each.
|
| EventType |
Enumerates event types that can result in generation of a new value.
|
| EventTypeSets |
For convenience, enumerates the possible combinations of EventType. |
| Every |
|
| EveryAnyEmulation |
Most databases don't have a function like every() or any().
|
| EvictEvent |
Defines an event class for the evicting of an entity.
|
| EvictEventListener |
Defines the contract for handling of evict events generated from a session.
|
| ExceptionConverter |
|
| ExceptionHandler |
Contract for how CommandAcceptanceException errors should be handled (logged, ignored, etc).
|
| Executable |
An operation which may be scheduled for later execution.
|
| ExecutableList<E extends ComparableExecutable> |
|
| ExecutableList.Sorter<ComparableExecutable> |
|
| ExecuteUpdateResultCheckStyle |
For persistence operations (INSERT, UPDATE, DELETE) what style of
determining results (success/failure) is to be used.
|
| ExecutionContext |
A context for execution of SQL statements expressed via
SQL AST and JdbcOperation
|
| ExecutionException |
Indicates an exception performing execution
|
| ExecutionOptions |
Parameter object representing options for schema management tool execution
|
| ExistsPredicate |
|
| Expectation |
Defines an expected DML operation outcome.
|
| Expectations |
|
| Expectations.BasicExpectation |
|
| Expectations.BasicParamExpectation |
|
| Exportable |
Contract for entities (in the ERD sense) which can be exported via CREATE, ALTER, etc
|
| ExportableColumn |
|
| ExportableColumn.ColumnIterator |
|
| ExportableColumn.ValueImpl |
|
| ExportableProducer |
Identifies metamodel objects that can produce Exportable relational stuff. |
| Exporter<T extends Exportable> |
Defines a contract for exporting of database objects (tables, sequences, etc)
for use in SQL CREATE and DROP scripts.
|
| Expression |
Models an expression at the SQL AST level.
|
| ExpressionReplacementWalker |
A walker that allows to replace expressions.
|
| ExtendedBeanManager |
This contract and the nested LifecycleListener contract represent the changes
we'd like to propose to the CDI spec.
|
| ExtendedBeanManager.LifecycleListener |
Contract for things interested in receiving notifications of
BeanManager lifecycle events.
|
| ExtendedSelfDirtinessTracker |
A self dirtiness tracker that declares additional methods that are intended for
internal communication.
|
| ExtendedStatisticsSupport |
Optional contract for a Region defining support for extra statistic information. |
| ExtractedDatabaseMetaData |
Information extracted from DatabaseMetaData regarding what the JDBC driver reports as
being supported or not. |
| ExtractFunction |
|
| ExtractionContext |
Defines a context for performing extraction including providing access to information about ongoing extraction as
well as to delegates needed in performing extraction.
|
| ExtractionContext.DatabaseObjectAccess |
|
| ExtractionContext.EmptyExtractionContext |
|
| ExtractionContext.ResultSetProcessor<T> |
|
| ExtractionTool |
|
| ExtractUnit |
|
| FakeSqmToSqlAstConverter |
|
| FallbackContainedBean<B> |
|
| Fetch |
Specifies the default fetching strategy for the annotated association.
|
| Fetch |
Models an individual fetch override within a profile.
|
| Fetch |
Contract for fetches including entity, collection and composite.
|
| Fetch.Style |
The type or style of fetch.
|
| Fetchable |
Any mapping with an outer-join attribute
|
| Fetchable |
Parts of the domain model that can be fetched.
|
| FetchableAttribute |
JAXB binding interface for EAGER/LAZY
|
| FetchableAttributeSource |
Describes source for attributes which can be fetched.
|
| FetchableContainer |
|
| FetchBuilder |
Responsible for building a single DomainResult instance as part of
the overall mapping of native / procedure query results. |
| FetchCharacteristics |
|
| FetchCharacteristicsPluralAttribute |
|
| FetchCharacteristicsSingularAssociation |
|
| FetchClauseType |
The kind of fetch to use for the FETCH clause.
|
| FetchDescriptor |
|
| FetchLimitHandler |
A LimitHandler for databases which support the ANSI
SQL standard syntax FETCH FIRST m ROWS ONLY but not
OFFSET n ROWS. |
| FetchList |
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). |
| FetchMemento |
|
| FetchMemento.Parent |
The parent node for the fetch
|
| FetchMementoBasic |
|
| FetchMode |
Enumerates strategies for fetching an association from the database.
|
| FetchMode |
Represents an association fetching strategy.
|
| FetchNotFoundException |
|
| FetchOptions |
|
| FetchParent |
Contract for things that can be the parent of a fetch
|
| FetchParentAccess |
Provides access to information about the owner/parent of a fetch
in relation to the current "row" being processed.
|
| FetchProfile |
|
| FetchProfile |
The runtime representation of a Hibernate
fetch profile
defined in annotations. |
| FetchProfile |
|
| FetchProfile.Fetch |
Defines an individual association fetch within the given profile.
|
| FetchProfile.FetchOverride |
Overrides the fetching strategy pf a particular association
in the named fetch profile being defined.
|
| FetchProfiles |
Collects together multiple fetch profiles.
|
| FetchStyle |
Enumeration of values describing how fetching should occur.
|
| FetchStyleAccess |
Access to a FetchStyle
|
| FetchTiming |
Enumeration of values describing when fetching should occur.
|
| FetchTimingAccess |
Access to a FetchTiming
|
| FetchTypeMarshalling |
|
| Filter |
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. |
| Filter |
Allows control over an enabled filter at runtime.
|
| Filterable |
Defines mapping elements to which filters may be applied.
|
| FilterDef |
|
| FilterDefinition |
Represents the definition of a filter. |
| FilterDefs |
Array of filter definitions.
|
| FilterJoinTable |
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. |
| FilterJoinTables |
Add multiple @FilterJoinTable to a collection.
|
| FilterKey |
Deprecated.
|
| FilterPredicate |
|
| FilterPredicate.FilterFragmentParameter |
|
| FilterPredicate.FilterFragmentPredicate |
|
| FilterRestrictable |
Things that can have associated Filter declarations. |
| Filters |
Add multiple @Filters.
|
| FilterSource |
Defines the source of filter information.
|
| FkDomainPathContinuation |
|
| FloatJavaType |
Descriptor for Float handling. |
| FloatJdbcType |
Descriptor for FLOAT handling. |
| FloatPrimitiveArrayJavaType |
Descriptor for float[] handling.
|
| FlushEntityEvent |
|
| FlushEntityEventListener |
|
| FlushEvent |
Defines an event class for the flushing of a session.
|
| FlushEventListener |
Defines the contract for handling of session flush events.
|
| FlushMode |
Represents a flushing strategy.
|
| FlushModeMarshalling |
|
| FlushModeType |
|
| ForeignGenerator |
Deprecated.
|
| ForeignKey |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| ForeignKey |
A mapping model object representing a foreign key constraint. |
| ForeignKeyContributingSource |
Additional contract for things which describe foreign keys.
|
| ForeignKeyDescriptor |
Descriptor for foreign-keys
|
| ForeignKeyDescriptor.Nature |
|
| ForeignKeyDescriptor.Side |
|
| ForeignKeyDirection |
Represents directionality of the foreign key constraint
|
| ForeignKeyInformation |
|
| ForeignKeyInformation.ColumnReferenceMapping |
|
| Format |
Represents the format pattern for a date/time format expression
|
| FormatFunction |
A format function with support for composite temporal expressions.
|
| FormatFunction.FormatSqmFunction<T> |
|
| FormatMapper |
A mapper for mapping objects to and from a format.
|
| Formula |
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. |
| Formula |
A mapping model object representing a SQL formula
which is used as a "derived" Column in an entity mapping. |
| ForUpdateFragment |
A SQL {FOR UPDATE} clause.
|
| FrameExclusion |
|
| FrameKind |
|
| FrameMode |
|
| FromClause |
The SQL AST from-clause node
|
| FromClauseAccess |
Access to TableGroup indexing.
|
| FromClauseAccessImpl |
|
| FromClauseIndex |
An index of various FROM CLAUSE resolutions.
|
| FunctionArgumentTypeResolver |
Pluggable strategy for resolving a function argument type for a specific call.
|
| FunctionContributions |
|
| FunctionContributor |
|
| FunctionExpression |
Represents a function used in an order-by fragment
|
| FunctionExpression |
Models a function expression at the SQL AST level.
|
| FunctionKind |
The kind of function e.g.
|
| FunctionParameterType |
A mini-"type system" for HQL function parameters.
|
| FunctionRenderingSupport |
|
| FunctionReturn<T> |
Describes the function return for ProcedureCalls that represent calls to
a function ("{? = call ...} syntax) rather that a proc ({call ...} syntax)
|
| FunctionReturnImplementor<T> |
|
| FunctionReturnTypeResolver |
Pluggable strategy for resolving a function return type for a specific call.
|
| FunctionTableGroup |
A special table group for a table valued functions.
|
| FunctionTableReference |
A table reference for a table valued function.
|
| Generated |
Specifies that the value of the annotated property is generated by the
database.
|
| 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.
|
| GenerationTime |
Deprecated.
|
| GenerationTiming |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| GenerationTimingMarshalling |
|
| GenerationTypeMarshalling |
|
| GenerationTypeStrategy |
Delegate for defining how to handle the various types of
GenerationType possibilities. |
| GenerationTypeStrategyRegistration |
|
| Generator |
Describes the generation of values of a certain field or property of an entity.
|
| GeneratorCreationContext |
|
| GeneratorCreator |
|
| GeneratorDefinitionResolver |
Access to resolve IdentifierGeneratorDefinition instances
|
| GeneratorType |
Deprecated.
|
| GenericGenerator |
Defines a named identifier generator, usually an instance of the interface
IdentifierGenerator. |
| GenericGenerators |
Array of generic generator definitions.
|
| GenericJDBCException |
|
| GetGeneratedKeysDelegate |
|
| Getter |
The contract for getting the value of a persistent attribute from its container/owner.
|
| GetterFieldImpl |
Field-based implementation of Getter
|
| GetterMethodImpl |
|
| Graph<J> |
|
| GraphHelper |
Helper containing utilities useful for graph handling
|
| GraphImplementor<J> |
Integration version of the Graph contract
|
| GraphLanguageLexer |
|
| GraphLanguageParser |
|
| GraphLanguageParser.AttributeListContext |
|
| GraphLanguageParser.AttributeNodeContext |
|
| GraphLanguageParser.AttributePathContext |
|
| GraphLanguageParser.AttributeQualifierContext |
|
| GraphLanguageParser.GraphContext |
|
| GraphLanguageParser.SubGraphContext |
|
| GraphLanguageParser.SubTypeContext |
|
| GraphLanguageParserBaseListener |
This class provides an empty implementation of GraphLanguageParserListener,
which can be extended to create a listener which only needs to handle a subset
of the available methods. |
| GraphLanguageParserBaseVisitor<T> |
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. |
| GraphLanguageParserListener |
|
| GraphLanguageParserVisitor<T> |
This interface defines a complete generic visitor for a parse tree produced
by GraphLanguageParser. |
| GraphNode<J> |
|
| GraphNodeImplementor<J> |
Integration version of the GraphNode contract
|
| GraphParser |
|
| GraphSemantic |
|
| GroupByConstantRenderingStrategy |
Strategies for rendering a constant in a group by.
|
| GroupBySummarizationRenderingStrategy |
Strategies for rendering summarization function like rollup and cube in a group by.
|
| GroupedPredicate |
|
| GroupsPerOperation |
|
| GroupsPerOperation.Operation |
|
| GUIDGenerator |
Deprecated.
|
| H2Dialect |
|
| H2Dialect.OrdinalParameterMarkerStrategy |
|
| H2DurationIntervalSecondJdbcType |
|
| H2FinalTableIdentityColumnSupport |
Identity column support for H2 2+ versions
|
| H2FormatJsonJdbcType |
Specialized type mapping for JSON that utilizes the custom
'? format json' write expression for H2.
|
| H2IdentityColumnSupport |
|
| H2IdentityColumnSupport.InsertValuesHandler |
|
| H2SqlAstTranslator<T extends JdbcOperation> |
A SQL AST translator for H2.
|
| H2V1SequenceSupport |
|
| H2V2SequenceSupport |
|
| HANACloudColumnStoreDialect |
Deprecated.
|
| HANAColumnStoreDialect |
An SQL dialect for the SAP HANA column store.
|
| HANAIdentityColumnSupport |
|
| HANARowStoreDialect |
An SQL dialect for the SAP HANA row store.
|
| HANASequenceSupport |
|
| HANASqlAstTranslator<T extends JdbcOperation> |
A SQL AST translator for HANA.
|
| HbmResultSetMappingDescriptor |
Boot-time descriptor of a result set mapping as defined in an hbm.xml file
either implicitly or explicitly
|
| HbmResultSetMappingDescriptor.CollectionResultDescriptor |
|
| HbmResultSetMappingDescriptor.EntityResultDescriptor |
|
| HbmResultSetMappingDescriptor.HbmFetchDescriptor |
|
| HbmResultSetMappingDescriptor.HbmFetchParent |
|
| HbmResultSetMappingDescriptor.HbmFetchParentMemento |
|
| HbmResultSetMappingDescriptor.JoinDescriptor |
|
| HbmResultSetMappingDescriptor.PropertyFetchDescriptor |
|
| HbmResultSetMappingDescriptor.ScalarDescriptor |
|
| HbmTransformationLogging |
Logging for HBM transformation
|
| HbmXmlTransformer |
Transforms a JAXB binding of a hbm.xml file into a unified orm.xml representation
|
| HbmXmlTransformer.Options |
|
| Helper |
|
| Hibernate |
Various utility functions for working with proxies and lazy collection references.
|
| Hibernate.CollectionInterface<C> |
Operations for obtaining references to persistent collections of a certain type.
|
| HibernateCriteriaBuilder |
|
| HibernateCriteriaBuilderDelegate |
|
| HibernateError |
Marks a group of exceptions that generally indicate an internal Hibernate error or bug.
|
| HibernateException |
The base type for exceptions thrown by Hibernate.
|
| HibernateHints |
List of Hibernate-specific (extension) hints available to query,
load, and lock scenarios.
|
| HibernatePersistenceProvider |
|
| HibernateProxy |
Interface implemented directly by entity proxies, exposing
access to the associated LazyInitializer. |
| HibernateTraversableResolver |
Use Hibernate metadata to ignore cascade on entities.
|
| HibernateTypeSource |
Source-agnostic descriptor for explicit user-supplied Hibernate type information
|
| HiLoOptimizer |
Optimizer which applies a 'hilo' algorithm in memory to achieve
optimization.
|
| HqlInterpretation |
|
| HqlInterpretationException |
Base of exception hierarchy for exceptions stemming from
producing SQM AST trees
|
| HqlLexer |
|
| HqlLogging |
|
| HqlParser |
|
| HqlParser.AdditionExpressionContext |
|
| HqlParser.AdditiveOperatorContext |
|
| HqlParser.AggregateFunctionContext |
|
| HqlParser.AndPredicateContext |
|
| HqlParser.AnyFunctionContext |
|
| HqlParser.AssignmentContext |
|
| HqlParser.BarePrimaryExpressionContext |
|
| HqlParser.BetweenPredicateContext |
|
| HqlParser.BinaryLiteralContext |
|
| HqlParser.BooleanExpressionPredicateContext |
|
| HqlParser.BooleanLiteralContext |
|
| HqlParser.CaseExpressionContext |
|
| HqlParser.CaseListContext |
|
| HqlParser.CaseOtherwiseContext |
|
| HqlParser.CastFunctionContext |
|
| HqlParser.CastTargetContext |
|
| HqlParser.CastTargetTypeContext |
|
| HqlParser.CollateFunctionContext |
|
| HqlParser.CollationContext |
|
| HqlParser.CollectionFunctionMisuseContext |
|
| HqlParser.CollectionSizeFunctionContext |
|
| HqlParser.CollectionValueNavigablePathContext |
|
| HqlParser.ComparisonOperatorContext |
|
| HqlParser.ComparisonPredicateContext |
|
| HqlParser.ConcatenationExpressionContext |
|
| HqlParser.CrossJoinContext |
|
| HqlParser.CteAttributesContext |
|
| HqlParser.CteContext |
|
| HqlParser.CubeContext |
|
| HqlParser.CurrentDateFunctionContext |
|
| HqlParser.CurrentTimeFunctionContext |
|
| HqlParser.CurrentTimestampFunctionContext |
|
| HqlParser.CycleClauseContext |
|
| HqlParser.DateContext |
|
| HqlParser.DateLiteralContext |
|
| HqlParser.DateOrTimeFieldContext |
|
| HqlParser.DateTimeContext |
|
| HqlParser.DatetimeFieldContext |
|
| HqlParser.DateTimeLiteralContext |
|
| HqlParser.DayContext |
|
| HqlParser.DayFieldContext |
|
| HqlParser.DeleteStatementContext |
|
| HqlParser.ElementAggregateFunctionContext |
|
| HqlParser.EntityIdExpressionContext |
|
| HqlParser.EntityIdReferenceContext |
|
| HqlParser.EntityNameContext |
|
| HqlParser.EntityNaturalIdExpressionContext |
|
| HqlParser.EntityNaturalIdReferenceContext |
|
| HqlParser.EntityTypeExpressionContext |
|
| HqlParser.EntityTypeReferenceContext |
|
| HqlParser.EntityVersionExpressionContext |
|
| HqlParser.EntityVersionReferenceContext |
|
| HqlParser.EntityWithJoinsContext |
|
| HqlParser.EveryFunctionContext |
|
| HqlParser.ExistsCollectionPartPredicateContext |
|
| HqlParser.ExistsPredicateContext |
|
| HqlParser.ExplicitTupleInListContext |
|
| HqlParser.ExpressionContext |
|
| HqlParser.ExpressionOrPredicateContext |
|
| HqlParser.ExtractFieldContext |
|
| HqlParser.ExtractFunctionContext |
|
| HqlParser.FetchClauseContext |
|
| HqlParser.FilterClauseContext |
|
| HqlParser.FormatContext |
|
| HqlParser.FormatFunctionContext |
|
| HqlParser.FrameClauseContext |
|
| HqlParser.FrameEndContext |
|
| HqlParser.FrameExclusionContext |
|
| HqlParser.FrameStartContext |
|
| HqlParser.FromClauseContext |
|
| HqlParser.FromDurationExpressionContext |
|
| HqlParser.FromRootContext |
|
| HqlParser.FunctionContext |
|
| HqlParser.FunctionExpressionContext |
|
| HqlParser.GeneralizedLiteralContext |
|
| HqlParser.GeneralizedLiteralTextContext |
|
| HqlParser.GeneralizedLiteralTypeContext |
|
| HqlParser.GeneralPathExpressionContext |
|
| HqlParser.GeneralPathFragmentContext |
|
| HqlParser.GenericFunctionArgumentsContext |
|
| HqlParser.GenericFunctionContext |
|
| HqlParser.GenericFunctionNameContext |
|
| HqlParser.GenericTemporalLiteralTextContext |
|
| HqlParser.GroupByClauseContext |
|
| HqlParser.GroupByExpressionContext |
|
| HqlParser.GroupedExpressionContext |
|
| HqlParser.GroupedPredicateContext |
|
| HqlParser.HavingClauseContext |
|
| HqlParser.HourContext |
|
| HqlParser.IdentifierContext |
|
| HqlParser.IndexAggregateFunctionContext |
|
| HqlParser.IndexedPathAccessFragmentContext |
|
| HqlParser.InListContext |
|
| HqlParser.InPredicateContext |
|
| HqlParser.InsertStatementContext |
|
| HqlParser.InstantFunctionContext |
|
| HqlParser.InstantiationArgumentContext |
|
| HqlParser.InstantiationArgumentExpressionContext |
|
| HqlParser.InstantiationArgumentsContext |
|
| HqlParser.InstantiationContext |
|
| HqlParser.InstantiationTargetContext |
|
| HqlParser.IsEmptyPredicateContext |
|
| HqlParser.IsNullPredicateContext |
|
| HqlParser.JdbcDateLiteralContext |
|
| HqlParser.JdbcTimeLiteralContext |
|
| HqlParser.JdbcTimestampLiteralContext |
|
| HqlParser.JoinContext |
|
| HqlParser.JoinPathContext |
|
| HqlParser.JoinRestrictionContext |
|
| HqlParser.JoinSubqueryContext |
|
| HqlParser.JoinTargetContext |
|
| HqlParser.JoinTypeContext |
|
| HqlParser.JpaCollectionJoinContext |
|
| HqlParser.JpaNonstandardFunctionContext |
|
| HqlParser.JpaNonstandardFunctionNameContext |
|
| HqlParser.JpaSelectObjectSyntaxContext |
|
| HqlParser.LikeEscapeContext |
|
| HqlParser.LikePredicateContext |
|
| HqlParser.LimitClauseContext |
|
| HqlParser.ListaggFunctionContext |
|
| HqlParser.LiteralContext |
|
| HqlParser.LiteralExpressionContext |
|
| HqlParser.LocalDateFunctionContext |
|
| HqlParser.LocalDateTimeContext |
|
| HqlParser.LocalDateTimeFunctionContext |
|
| HqlParser.LocalDateTimeLiteralContext |
|
| HqlParser.LocalTimeFunctionContext |
|
| HqlParser.MapEntrySelectionContext |
|
| HqlParser.MapKeyNavigablePathContext |
|
| HqlParser.MemberOfPredicateContext |
|
| HqlParser.MinuteContext |
|
| HqlParser.MonthContext |
|
| HqlParser.MultiplicationExpressionContext |
|
| HqlParser.MultiplicativeOperatorContext |
|
| HqlParser.NakedIdentifierContext |
|
| HqlParser.NamedParameterContext |
|
| HqlParser.NegatedPredicateContext |
|
| HqlParser.NestedQueryExpressionContext |
|
| HqlParser.NthSideClauseContext |
|
| HqlParser.NullsClauseContext |
|
| HqlParser.NullsPrecedenceContext |
|
| HqlParser.NumericLiteralContext |
|
| HqlParser.OffsetClauseContext |
|
| HqlParser.OffsetContext |
|
| HqlParser.OffsetDateTimeContext |
|
| HqlParser.OffsetDateTimeFunctionContext |
|
| HqlParser.OffsetDateTimeLiteralContext |
|
| HqlParser.OffsetDateTimeWithMinutesContext |
|
| HqlParser.OffsetWithMinutesContext |
|
| HqlParser.OnOverflowClauseContext |
|
| HqlParser.OrderByClauseContext |
|
| HqlParser.OrderByFragmentContext |
|
| HqlParser.OrderedQueryContext |
|
| HqlParser.OrPredicateContext |
|
| HqlParser.OverClauseContext |
|
| HqlParser.OverlayFunctionContext |
|
| HqlParser.OverlayFunctionLengthArgumentContext |
|
| HqlParser.OverlayFunctionReplacementArgumentContext |
|
| HqlParser.OverlayFunctionStartArgumentContext |
|
| HqlParser.OverlayFunctionStringArgumentContext |
|
| HqlParser.PadCharacterContext |
|
| HqlParser.PadFunctionContext |
|
| HqlParser.PadLengthContext |
|
| HqlParser.PadSpecificationContext |
|
| HqlParser.ParameterContext |
|
| HqlParser.ParameterExpressionContext |
|
| HqlParser.ParameterOrIntegerLiteralContext |
|
| HqlParser.ParameterOrNumberLiteralContext |
|
| HqlParser.ParamInListContext |
|
| HqlParser.PartitionClauseContext |
|
| HqlParser.PathContext |
|
| HqlParser.PathContinuationContext |
|
| HqlParser.PersistentCollectionReferenceInListContext |
|
| HqlParser.PositionalParameterContext |
|
| HqlParser.PositionFunctionContext |
|
| HqlParser.PositionFunctionPatternArgumentContext |
|
| HqlParser.PositionFunctionStringArgumentContext |
|
| HqlParser.PredicateContext |
|
| HqlParser.PrimaryExpressionContext |
|
| HqlParser.QueryContext |
|
| HqlParser.QueryExpressionContext |
|
| HqlParser.QueryOrderContext |
|
| HqlParser.QuerySpecExpressionContext |
|
| HqlParser.RollupContext |
|
| HqlParser.RootEntityContext |
|
| HqlParser.RootSubqueryContext |
|
| HqlParser.SearchClauseContext |
|
| HqlParser.SearchedCaseListContext |
|
| HqlParser.SearchedCaseWhenContext |
|
| HqlParser.SearchSpecificationContext |
|
| HqlParser.SearchSpecificationsContext |
|
| HqlParser.SecondContext |
|
| HqlParser.SelectClauseContext |
|
| HqlParser.SelectExpressionContext |
|
| HqlParser.SelectionContext |
|
| HqlParser.SelectionListContext |
|
| HqlParser.SelectStatementContext |
|
| HqlParser.SetClauseContext |
|
| HqlParser.SetOperatorContext |
|
| HqlParser.SetQueryGroupContext |
|
| HqlParser.SignOperatorContext |
|
| HqlParser.SimpleCaseListContext |
|
| HqlParser.SimpleCaseWhenContext |
|
| HqlParser.SimplePathContext |
|
| HqlParser.SimplePathElementContext |
|
| HqlParser.SimpleQueryGroupContext |
|
| HqlParser.SortDirectionContext |
|
| HqlParser.SortExpressionContext |
|
| HqlParser.SortSpecificationContext |
|
| HqlParser.StandardFunctionContext |
|
| HqlParser.StatementContext |
|
| HqlParser.SubqueryContext |
|
| HqlParser.SubqueryExpressionContext |
|
| HqlParser.SubqueryInListContext |
|
| HqlParser.SubstringFunctionContext |
|
| HqlParser.SubstringFunctionLengthArgumentContext |
|
| HqlParser.SubstringFunctionStartArgumentContext |
|
| HqlParser.SyntacticDomainPathContext |
|
| HqlParser.SyntacticPathExpressionContext |
|
| HqlParser.TargetEntityContext |
|
| HqlParser.TargetFieldsContext |
|
| HqlParser.TemporalLiteralContext |
|
| HqlParser.TimeContext |
|
| HqlParser.TimeLiteralContext |
|
| HqlParser.TimeZoneFieldContext |
|
| HqlParser.ToDurationExpressionContext |
|
| HqlParser.ToOneFkExpressionContext |
|
| HqlParser.ToOneFkReferenceContext |
|
| HqlParser.TreatedNavigablePathContext |
|
| HqlParser.TrimCharacterContext |
|
| HqlParser.TrimFunctionContext |
|
| HqlParser.TrimSpecificationContext |
|
| HqlParser.TruncFunctionContext |
|
| HqlParser.TupleExpressionContext |
|
| HqlParser.UnaryExpressionContext |
|
| HqlParser.UnaryNumericLiteralExpressionContext |
|
| HqlParser.UpdateStatementContext |
|
| HqlParser.ValuesContext |
|
| HqlParser.ValuesListContext |
|
| HqlParser.VariableContext |
|
| HqlParser.WeekFieldContext |
|
| HqlParser.WhereClauseContext |
|
| HqlParser.WithClauseContext |
|
| HqlParser.WithinGroupClauseContext |
|
| HqlParser.YearContext |
|
| HqlParser.ZonedDateTimeContext |
|
| HqlParser.ZonedDateTimeLiteralContext |
|
| HqlParser.ZoneIdContext |
|
| HqlParserBaseListener |
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. |
| HqlParserBaseVisitor<T> |
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. |
| HqlParserListener |
This interface defines a complete listener for a parse tree produced by
HqlParser. |
| HqlParserVisitor<T> |
This interface defines a complete generic visitor for a parse tree produced
by HqlParser. |
| HQLSelect |
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.
|
| HqlTranslator |
Main entry point into building semantic queries.
|
| HSQLDialect |
|
| HSQLIdentityColumnSupport |
|
| HSQLSequenceSupport |
|
| HSQLSqlAstTranslator<T extends JdbcOperation> |
A SQL AST translator for HSQL.
|
| HypotheticalSetFunction |
|
| HypotheticalSetWindowEmulation |
|
| IdentifiableDomainType<J> |
|
| IdentifiableTypeSource |
Common contract between Entity and MappedSuperclass sources.
|
| Identifier |
Models an identifier (name), which may or may not be quoted.
|
| IdentifierAttribute |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| IdentifierBag |
A bag with a generated (surrogate) key.
|
| IdentifierBagType |
|
| IdentifierCaseStrategy |
An enumeration of the way DatabaseMetaData might store and return identifiers
|
| IdentifierCollection |
A mapping model object representing a collection with a synthetic "identifier" column,
that is, a surrogate key.
|
| IdentifierGeneratingInsert |
Nothing more than a distinguishing subclass of Insert used to
indicate intent. |
| IdentifierGenerationException |
|
| IdentifierGenerator |
A classic extension point from the very earliest days of Hibernate,
this interface is no longer the only way to generate identifiers.
|
| IdentifierGeneratorAggregator |
|
| IdentifierGeneratorCreator |
|
| IdentifierGeneratorDefinition |
|
| IdentifierGeneratorDefinition.Builder |
|
| IdentifierGeneratorFactory |
|
| IdentifierGeneratorHelper |
|
| IdentifierGeneratorHelper.BasicHolder |
|
| IdentifierGeneratorHelper.BigDecimalHolder |
|
| IdentifierGeneratorHelper.BigIntegerHolder |
|
| IdentifierGeneratorStrategyProvider |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| IdentifierHelper |
|
| IdentifierHelperBuilder |
Builder for IdentifierHelper instances.
|
| IdentifierLoadAccess<T> |
Loads an entity by its primary identifier.
|
| IdentifierProperty |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| IdentifierSource |
Contract describing source of identifier information for the entity.
|
| IdentifierSourceAggregatedComposite |
|
| IdentifierSourceNonAggregatedComposite |
|
| IdentifierSourceSimple |
Additional contract describing the source of an identifier mapping whose nature is
simple. |
| IdentifierValue |
A strategy for determining if an identifier value is an identifier of
a new transient instance or a previously persistent transient instance.
|
| IdentityColumnSupport |
A set of operations providing support for identity columns
in a certain SQL dialect. |
| IdentityColumnSupportImpl |
|
| IdentityGenerator |
An OnExecutionGenerator that handles IDENTITY/"autoincrement"
columns on those databases which support them. |
| IdGenerator |
Deprecated.
|
| IdGeneratorStrategyInterpreter |
Deprecated.
|
| IdGeneratorStrategyInterpreter.GeneratorNameDeterminationContext |
|
| IdGeneratorType |
Meta-annotation used to mark another annotation as providing configuration
for a custom identifier generator. |
| IdGenFactoryLogging |
Logging related to IdentifierGeneratorFactory
|
| IllegalIdentifierException |
Indicates an attempted use of a name that was deemed illegal
|
| IllegalMutationQueryException |
|
| IllegalNamedQueryOptionsException |
Indicates a named-query has specified options that are not legal
|
| IllegalQueryOperationException |
Indicates an attempt to perform some operation on a Query that is illegal
based on its state, e.g., attempt to call Query.executeUpdate() on a
SELECT query. |
| IllegalSelectQueryException |
|
| Immutability |
|
| Immutable |
Marks an entity, collection, or attribute of an entity as immutable.
|
| ImmutableEntityUpdateQueryHandlingMode |
This enum defines how Immutable entities are handled when
executing a bulk update statement. |
| ImmutableMutabilityPlan<T> |
Mutability plan for immutable objects
|
| ImplicitAnyDiscriminatorColumnNameSource |
Context for determining the implicit name for an ANY mapping's discriminator
column.
|
| ImplicitAnyKeyColumnNameSource |
Context for determining the implicit name for an ANY mapping's key
column.
|
| ImplicitAttributeFetchBuilder |
FetchBuilder used when an explicit mapping was not given
|
| ImplicitBasicColumnNameSource |
Context for determining the implicit name related to basic values.
|
| ImplicitCollectionTableNameSource |
Context for determining the implicit name for a collection table.
|
| ImplicitConstraintNameSource |
Common implicit name source traits for all constraint naming: FK, UK, index
|
| ImplicitDatabaseObjectNamingStrategy |
A naming strategy specifically for determining the implicit naming of
tables and sequences relating to enhanced identifier-generators.
|
| ImplicitDiscriminatorColumnNameSource |
Context for determining the implicit name of an entity's discriminator column.
|
| ImplicitEntityNameSource |
Context for determining the implicit name of an entity's primary table
|
| ImplicitFetchBuilder |
|
| ImplicitFetchBuilderBasic |
|
| ImplicitFetchBuilderDiscriminatedAssociation |
|
| ImplicitFetchBuilderEmbeddable |
|
| ImplicitFetchBuilderEntity |
|
| ImplicitFetchBuilderEntityPart |
|
| ImplicitFetchBuilderPlural |
|
| ImplicitForeignKeyNameSource |
|
| ImplicitHbmResultSetMappingDescriptorBuilder |
Builder for implicit ResultSet mapping defined inline as part of a named native query
|
| ImplicitIdentifierColumnNameSource |
Context for determining the implicit name of an entity's identifier
column.
|
| ImplicitIndexColumnNameSource |
|
| ImplicitIndexNameSource |
|
| ImplicitJoinColumnNameSource |
Context for determining the implicit name of a "join column" (think
JoinColumn). |
| ImplicitJoinColumnNameSource.Nature |
|
| ImplicitJoinTableNameSource |
Context for determining the implicit name for a join table.
|
| ImplicitMapKeyColumnNameSource |
Context for determining the implicit name of a column used to back the key
of a Map. |
| ImplicitModelPartResultBuilder |
|
| ImplicitModelPartResultBuilderBasic |
|
| ImplicitModelPartResultBuilderEmbeddable |
|
| ImplicitModelPartResultBuilderEntity |
|
| ImplicitNameSource |
Common contract for all implicit naming sources
|
| ImplicitNamingStrategy |
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. |
| ImplicitNamingStrategyComponentPathImpl |
An ImplicitNamingStrategy implementation which uses full composite paths
extracted from AttributePath, as opposed to just the terminal property part.
|
| ImplicitNamingStrategyJpaCompliantImpl |
|
| ImplicitNamingStrategyLegacyHbmImpl |
Implements the original legacy naming behavior.
|
| ImplicitNamingStrategyLegacyJpaImpl |
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.
|
| ImplicitPrimaryKeyJoinColumnNameSource |
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).
|
| ImplicitResultClassBuilder |
|
| ImplicitTenantIdColumnNameSource |
Context for determining the implicit name of an entity's tenant identifier
column.
|
| ImplicitUniqueKeyNameSource |
|
| Imported |
Marks an arbitrary class as available for use in HQL queries by its unqualified name.
|
| ImprovedNamingStrategy |
Deprecated.
|
| InArrayPredicate |
|
| IncomparableComparator |
Comparator for things that cannot be compared (in a way we know about).
|
| IncrementGenerator |
An IdentifierGenerator that returns a long, constructed by counting
from the maximum primary key value obtained by querying the table or tables at startup. |
| Incubating |
Marks the annotated Java element as incubating, potentially
recursively.
|
| Index |
Deprecated.
|
| Index |
A mapping model object representing an index on a relational database table. |
| IndexBackref |
|
| IndexColumn |
Deprecated.
|
| IndexedBiConsumer<T,U> |
Deprecated.
|
| IndexedCollection |
Indexed collections include Lists, Maps, arrays and
primitive arrays.
|
| IndexedConsumer<T> |
Deprecated.
|
| IndexInformation |
Provides access to information about existing index in the database
|
| IndexQueryHintHandler |
Adds an INDEX query hint as follows:
SELECT *
FROM TEST
USE INDEX (hint1, hint2)
WHERE X=1
|
| InetAddressJavaType |
|
| InFlightMetadataCollector |
An in-flight representation of Metadata while it is being built. |
| InFlightMetadataCollector.CollectionTypeRegistrationDescriptor |
|
| InFlightMetadataCollector.DelayedPropertyReferenceHandler |
|
| InFlightMetadataCollector.DuplicateSecondaryTableException |
|
| InFlightMetadataCollector.EntityTableXref |
|
| InformationExtractor |
Contract for extracting information about objects in the database schema(s).
|
| InFragment |
A SQL IN expression.
|
| InheritanceType |
The inheritance type for a given entity hierarchy
|
| InheritanceTypeMarshalling |
|
| InitCommand |
A general SQL command to be used while initializing a schema.
|
| InitializeCollectionEvent |
An event that occurs when a collection wants to be
initialized
|
| InitializeCollectionEventListener |
Defines the contract for handling of collection initialization events
generated by a session.
|
| Initializer |
Defines a multi-step process for initializing entity, collection and
composite state.
|
| InitializerProducerBuilder |
|
| InitialValueAwareOptimizer |
Marker interface for optimizer which wishes to know the user-specified initial value.
|
| InjectService |
Annotation to allow services to request injection of other services.
|
| InLineViewSource |
Describes in-line view source information.
|
| InListPredicate |
|
| InnoDBStorageEngine |
Represents the InnoDB storage engine.
|
| InputStreamAccess |
Contract for building InputStreams, especially in on-demand situations
|
| Insert |
A SQL INSERT statement.
|
| InsertCoordinator |
Coordinates the insertion of an entity.
|
| InsertCoordinator.InsertValuesAnalysis |
|
| InsertGeneratedIdentifierDelegate |
Each implementation defines a strategy for retrieving a primary key
generated by
the database from the database after execution of an insert
statement. |
| InsertReturningDelegate |
Delegate for dealing with IDENTITY columns where the dialect supports
returning the generated IDENTITY value directly from the insert statement.
|
| InsertRowsCoordinator |
Coordinates the logical insertion of collection entries which are not yet persistent.
|
| InsertRowsCoordinator.EntryFilter |
|
| InsertRowsCoordinatorNoOp |
|
| InsertRowsCoordinatorStandard |
|
| InsertRowsCoordinatorTablePerSubclass |
|
| InsertSelectIdentityInsert |
Specialized IdentifierGeneratingInsert which appends the database
specific clause which signifies to return generated IDENTITY values
to the end of the insert statement. |
| InsertSelectStatement |
todo (6.2) - Would much prefer to split insert-values and
insert-select into individual contracts - something like
`InsertStatement` and `InsertSelectStatement` e.g.
|
| InsertStatement |
Specialization of MutationStatement for inserts
|
| InsertSubstringOverlayEmulation |
Emulates the ANSI SQL-standard overlay() function using insert()
substring(), and concat().
|
| InstantAsTimestampJdbcType |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| InstantAsTimestampWithTimeZoneJdbcType |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| InstantiationException |
Thrown if Hibernate can't instantiate a class at runtime.
|
| Instantiator |
Marks the canonical constructor to be used for instantiation of an embeddable.
|
| Instantiator |
Strategy for instantiating a managed type
|
| Instantiator |
Deprecated.
|
| InstantJavaType |
Java type descriptor for the Java Instant type. |
| InstantJdbcType |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| InSubQueryPredicate |
|
| IntegerJavaType |
|
| IntegerJdbcType |
|
| IntegerPrimitiveArrayJavaType |
Descriptor for int[] handling.
|
| IntegralDataTypeHolder |
Defines a common API for dealing with data of integral data type.
|
| IntegralTimestampaddFunction |
Used in place of TimestampaddFunction for databases which don't
support fractional seconds in the timestampadd() function. |
| IntegrationException |
Indicates a problem integrating Hibernate and the Bean Validation spec.
|
| Integrator |
Contract for extensions that integrate with Hibernate.
|
| IntegratorProvider |
An object that provides a list of Integrators to the JPA persistence provider. |
| IntegratorService |
|
| Interceptor |
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.
|
| Internal |
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.
|
| InterpretationException |
Represents a general uncaught problem performing the interpretation.
|
| IntervalType |
The different types of intervals that SQL defines.
|
| InvalidatableWrapper<T> |
Specialized JdbcWrapper contract for wrapped objects that can additionally be invalidated |
| InvalidGraphException |
Thrown by GraphParser to indicate textual entity graph representation parsing errors. |
| InvalidMappingException |
Indicates a problem parsing the mapping document at a given Origin. |
| InvalidMappingException |
Thrown when a mapping is found to be invalid.
|
| InverseDistributionFunction |
|
| InverseDistributionWindowEmulation |
|
| IsolationDelegate |
Contract for performing work in a manner that isolates it from any current transaction.
|
| JacksonIntegration |
|
| JacksonJsonFormatMapper |
|
| JacksonXmlFormatMapper |
|
| JakartaJsonIntegration |
|
| JarFileEntryUrlAdjuster |
Optional contract for ArchiveDescriptorFactory implementations to implement
to be able to adjust <jar-file/> URL's defined in persistence.xml
files.
|
| JavaObjectType |
|
| JavaServiceLoadable |
Marker annotation identifying integration points which Hibernate supports loading as a
Java service. |
| JavaType |
Specify an explicit BasicJavaType to use for a particular
column mapping. |
| JavaType<T> |
Descriptor for the Java side of a value mapping.
|
| JavaType.CoercionContext |
|
| JavaTypeBaseline |
|
| JavaTypeBaseline.BaselineTarget |
The target of the baseline registrations
|
| JavaTypeBasicAdaptor<T> |
|
| JavaTypeDescriptor |
|
| JavaTypeDescriptorResolvable |
|
| JavaTypedExpressible<T> |
Contract for something that has an associated JavaType
|
| JavaTypeHelper |
|
| JavaTypeRegistration |
|
| JavaTypeRegistrations |
|
| JavaTypeRegistry |
|
| JaxbAssociationOverride |
|
| JaxbAttributeOverride |
|
| JaxbAttributes |
Entity-defined attributes
This element contains the entity field or property mappings.
|
| JaxbBasic |
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`
|
| JaxbCacheInclusionType |
Java class for cache-inclusion-type.
|
| JaxbCaching |
Corresponds to the org.hibernate.annotations.Cache annotation.
|
| JaxbCascadeType |
See `@jakarta.persistence.CascadeType`
See `@org.hibernate.annotations.Cascade`
|
| JaxbCfgCacheUsageEnum |
Java class for CacheUsageEnum.
|
| JaxbCfgCollectionCacheType |
Java class for CollectionCacheType complex type.
|
| JaxbCfgConfigPropertyType |
Java class for ConfigPropertyType complex type.
|
| JaxbCfgEntityCacheType |
Java class for EntityCacheType complex type.
|
| JaxbCfgEventListenerGroupType |
Java class for EventListenerGroupType complex type.
|
| JaxbCfgEventListenerType |
Java class for EventListenerType complex type.
|
| JaxbCfgEventTypeEnum |
Java class for EventTypeEnum.
|
| JaxbCfgHibernateConfiguration |
Java class for anonymous complex type.
|
| JaxbCfgHibernateConfiguration.JaxbCfgSecurity |
Java class for anonymous complex type.
|
| JaxbCfgHibernateConfiguration.JaxbCfgSecurity.JaxbCfgGrant |
Java class for anonymous complex type.
|
| JaxbCfgHibernateConfiguration.JaxbCfgSessionFactory |
Java class for anonymous complex type.
|
| JaxbCfgMappingReferenceType |
Java class for MappingReferenceType complex type.
|
| JaxbCollectionTable |
See `@jakarta.persistence.CollectionTable`
|
| JaxbColumn |
See `@jakarta.persistence.Column`
See `@org.hibernate.annotations.Comment`
See `@org.hibernate.annotations.Check`
See `@org.hibernate.annotations.ColumnDefault`
See `@org.hibernate.annotations.ColumnTransformer`
|
| JaxbColumnResult |
See `@jakarta.persistence.ColumnResult`
|
| JaxbConstructorResult |
See `@jakarta.persistence.ConstructorResult`
|
| JaxbConvert |
See `@jakarta.persistence.Convert`
|
| JaxbConverter |
See `@jakarta.persistence.Converter`
See `@jakarta.persistence.AttributeConverter
|
| JaxbCustomLoader |
The loader element allows specification of a named query to be used for fetching
an entity or collection
|
| JaxbCustomSql |
Java class for custom-sql complex type.
|
| JaxbDatabaseObject |
Java class for database-object complex type.
|
| JaxbDatabaseObject.JaxbDefinition |
Java class for anonymous complex type.
|
| JaxbDatabaseObjectScope |
Java class for database-object-scope complex type.
|
| JaxbDiscriminatorColumn |
See `@jakarta.persistence.DiscriminatorColumn`
See `@org.hibernate.annotations.DiscriminatorOptions`
|
| JaxbElementCollection |
See `jakarta.persistence.ElementCollection`
See `jakarta.persistence.OrderBy`
See `jakarta.persistence.OrderColumn`
See `@org.hibernate.annotations.AttributeAccessor`
See `@org.hibernate.annotations.OptimisticLock`
See `@org.hibernate.annotations.SortComparator`
See `@org.hibernate.annotations.SortNatural`
See `@jakarta.persistence.Lob`
See `@jakarta.persistence.Temporal`
See `@jakarta.persistence.Enumerated`
See `@jakarta.persistence.Convert`
See `@org.hibernate.annotations.Nationalized`
|
| JaxbEmbeddable |
See `@jakarta.persistence.Embeddable`
|
| JaxbEmbeddableAttributes |
Describes the features available for mapping attributes of embeddables
|
| JaxbEmbedded |
See `@jakarta.persistence.Embedded`
See `@org.hibernate.annotations.AttributeAccessor`
See `@org.hibernate.annotations.OptimisticLock`
|
| JaxbEmbeddedId |
See `@jakarta.persistence.EmbeddedId`
See `@org.hibernate.annotations.AttributeAccessor`
|
| JaxbEmptyType |
Java class for emptyType complex type.
|
| JaxbEntity |
See jakarta.persistence.Entity
Defines the settings and mappings for an entity.
|
| JaxbEntityListener |
See `@jakarta.persistence.PrePersist`
See `@jakarta.persistence.PreRemove`
See `@jakarta.persistence.PreUpdate`
See `@jakarta.persistence.PostPersist`
See `@jakarta.persistence.PostRemove`
See `@jakarta.persistence.PostUpdate`
See `@jakarta.persistence.PostLoad`
|
| JaxbEntityListeners |
See `@jakarta.persistence.EntityListeners`
|
| JaxbEntityMappings |
The entity-mappings element is the root element of a mapping
file.
|
| JaxbEntityResult |
See `@jakarta.persistence.EntityResult`
|
| JaxbFetchProfile |
Java class for fetch-profile complex type.
|
| JaxbFetchProfile.JaxbFetch |
Java class for anonymous complex type.
|
| JaxbFieldResult |
See `@jakarta.persistence.FieldResult`
|
| JaxbFilterDef |
Specifies a filter definition.
|
| JaxbFilterDef.JaxbFilterParam |
Used to identify all bind parameters in the condition elemement
|
| JaxbForeignKey |
See `@jakarta.persistence.ForeignKey`
|
| JaxbGeneratedValue |
See `@jakarta.persistence.GeneratedValue`
|
| JaxbGenericIdGenerator |
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).
|
| JaxbHbmAnyAssociationType |
A discriminated association where the discriminator is part of the
association, not the associated entity (compared to discriminator subclass)
|
| JaxbHbmAnyDiscriminator |
Describes the discriminator of a discriminated association (any, many-to-any),
including the mapping of discriminator values to matching entity name
|
| JaxbHbmAnyDiscriminatorValueMapping |
Maps a discriminator value to its corresponding entity name.
|
| JaxbHbmAnyKey |
Describes the "foreign key" of a discriminated association (any, many-to-any).
|
| JaxbHbmAnyMapping |
See `@org.hibernate.annotations.Any`
|
| JaxbHbmAnyValueMappingType |
Defines the mapping of a discriminator value to a concrete entity in an any or
any-to-many mapping.
|
| JaxbHbmArrayType |
Java class for ArrayType complex type.
|
| JaxbHbmAuxiliaryDatabaseObjectType |
Java class for AuxiliaryDatabaseObjectType complex type.
|
| JaxbHbmAuxiliaryDatabaseObjectType.JaxbHbmDefinition |
Java class for anonymous complex type.
|
| JaxbHbmBagCollectionType |
Java class for BagCollectionType complex type.
|
| JaxbHbmBaseVersionAttributeType |
Type definition that acts as a base for concrete definitions of mapped
attributes that can function as the basis of optimistic locking.
|
| JaxbHbmBasicAttributeType |
Java class for BasicAttributeType complex type.
|
| JaxbHbmBasicCollectionElementType |
Declares the element type of a collection where the element is of basic type
|
| JaxbHbmCacheInclusionEnum |
Java class for CacheInclusionEnum.
|
| JaxbHbmCacheType |
Java class for CacheType complex type.
|
| JaxbHbmClassRenameType |
Java class for ClassRenameType complex type.
|
| JaxbHbmCollectionIdType |
Java class for CollectionIdType complex type.
|
| JaxbHbmColumnType |
The column element is an alternative to column attributes and required for
mapping associations to classes with composite ids.
|
| JaxbHbmCompositeAttributeType |
A component is a user-defined class, persisted along with its containing entity
to the table of the entity class.
|
| JaxbHbmCompositeCollectionElementType |
A composite element allows a collection to hold instances of an arbitrary
class, without the requirement of joining to an entity table.
|
| JaxbHbmCompositeIdType |
A composite key may be modelled by a java class with a property for each
key column.
|
| JaxbHbmCompositeIndexType |
Describes the key of a java.util.Map which is a composite.
|
| JaxbHbmCompositeKeyBasicAttributeType |
A property embedded in a composite identifier or map index (always not-null).
|
| JaxbHbmCompositeKeyManyToOneType |
A many-to-one association embedded in a composite identifier or map index
(always not-null, never cascade).
|
| JaxbHbmConfigParameterContainer |
Java class for ConfigParameterContainer complex type.
|
| JaxbHbmConfigParameterType |
Java class for ConfigParameterType complex type.
|
| JaxbHbmCustomSqlDmlType |
Java class for CustomSqlDmlType complex type.
|
| JaxbHbmDialectScopeType |
Java class for DialectScopeType complex type.
|
| JaxbHbmDiscriminatorSubclassEntityType |
Subclass declarations are nested beneath the root class declaration to achieve
polymorphic persistence with the table-per-hierarchy mapping strategy.
|
| JaxbHbmDynamicComponentType |
A dynamic-component maps columns of the database entity to a java.util.Map
at the Java level
|
| JaxbHbmEntityBaseDefinition |
Java class for EntityBaseDefinition complex type.
|
| JaxbHbmEntityDiscriminatorType |
Polymorphic data requires a column holding a class discriminator value.
|
| JaxbHbmFetchProfileType |
Java class for FetchProfileType complex type.
|
| JaxbHbmFetchProfileType.JaxbHbmFetch |
Java class for anonymous complex type.
|
| JaxbHbmFetchStyleEnum |
Java class for FetchStyleEnum.
|
| JaxbHbmFetchStyleWithSubselectEnum |
Java class for FetchStyleWithSubselectEnum.
|
| JaxbHbmFilter |
Applies a filter defined by hbm-filter-def usage
|
| JaxbHbmFilter.JaxbAliases |
Java class for anonymous complex type.
|
| JaxbHbmFilterAliasMappingType |
Java class for filter-alias-mapping-type complex type.
|
| JaxbHbmFilterDefinitionType |
Java class for FilterDefinitionType complex type.
|
| JaxbHbmFilterParameterType |
Java class for FilterParameterType complex type.
|
| JaxbHbmFilterType |
FILTER element; used to apply a filter.
|
| JaxbHbmGeneratorSpecificationType |
Generators generate unique identifiers.
|
| JaxbHbmHibernateMapping |
Java class for anonymous complex type.
|
| JaxbHbmIdBagCollectionType |
Java class for IdBagCollectionType complex type.
|
| JaxbHbmIdentifierGeneratorDefinitionType |
Java class for IdentifierGeneratorDefinitionType complex type.
|
| JaxbHbmIndexManyToAnyType |
Java class for index-many-to-any-type complex type.
|
| JaxbHbmIndexManyToManyType |
Describes the key of a java.util.Map which is an FK-association.
|
| JaxbHbmIndexType |
Describes the index of an indexed collection.
|
| JaxbHbmJoinedSubclassEntityType |
Joined subclasses are used for the normalized table-per-subclass mapping strategy
See the note on the class element regarding vs. |
| JaxbHbmKeyType |
Declares the column name of a foreign key.
|
| JaxbHbmLazyEnum |
Java class for LazyEnum.
|
| JaxbHbmLazyWithExtraEnum |
Java class for LazyWithExtraEnum.
|
| JaxbHbmLazyWithNoProxyEnum |
Java class for LazyWithNoProxyEnum.
|
| JaxbHbmListIndexType |
Java class for ListIndexType complex type.
|
| JaxbHbmListType |
Java class for ListType complex type.
|
| JaxbHbmLoaderType |
The loader element allows specification of a named query to be used for fetching
an entity or collection
|
| JaxbHbmManyToAny |
See `@org.hibernate.annotations.ManyToAny`
|
| JaxbHbmManyToAnyCollectionElementType |
A "many to any" defines a polymorphic association to any table
with the given identifier type.
|
| JaxbHbmManyToManyCollectionElementType |
Java class for ManyToManyCollectionElementType complex type.
|
| JaxbHbmManyToOneType |
Java class for ManyToOneType complex type.
|
| JaxbHbmMapKeyBasicType |
Describes the key of a java.util.Map where the key is a basic (JPA term) type
|
| JaxbHbmMapKeyCompositeType |
Describes the key of a java.util.Map where the key is a composite type
|
| JaxbHbmMapKeyManyToManyType |
Describes the key of a java.util.Map where the key is an association (FK)
|
| JaxbHbmMapType |
Java class for MapType complex type.
|
| JaxbHbmMultiTenancyType |
Java class for multi-tenancy-type complex type.
|
| JaxbHbmNamedNativeQueryType |
The sql-query element declares a named SQL query string
|
| JaxbHbmNamedQueryType |
Java class for NamedQueryType complex type.
|
| JaxbHbmNativeQueryCollectionLoadReturnType |
Java class for NativeQueryCollectionLoadReturnType complex type.
|
| JaxbHbmNativeQueryJoinReturnType |
Java class for NativeQueryJoinReturnType complex type.
|
| JaxbHbmNativeQueryPropertyReturnType |
Java class for NativeQueryPropertyReturnType complex type.
|
| JaxbHbmNativeQueryPropertyReturnType.JaxbHbmReturnColumn |
Java class for anonymous complex type.
|
| JaxbHbmNativeQueryReturnType |
Defines a return component for a sql-query.
|
| JaxbHbmNativeQueryReturnType.JaxbHbmReturnDiscriminator |
Java class for anonymous complex type.
|
| JaxbHbmNativeQueryScalarReturnType |
Java class for NativeQueryScalarReturnType complex type.
|
| JaxbHbmNaturalIdCacheType |
Java class for NaturalIdCacheType complex type.
|
| JaxbHbmNaturalIdType |
A natural-id element allows declaration of the unique business key
|
| JaxbHbmNestedCompositeElementType |
Java class for nested-composite-element-type complex type.
|
| JaxbHbmNotFoundEnum |
Java class for NotFoundEnum.
|
| JaxbHbmOnDeleteEnum |
Java class for OnDeleteEnum.
|
| JaxbHbmOneToManyCollectionElementType |
Java class for OneToManyCollectionElementType complex type.
|
| JaxbHbmOneToOneType |
Java class for OneToOneType complex type.
|
| JaxbHbmOuterJoinEnum |
Java class for OuterJoinEnum.
|
| JaxbHbmParentType |
The parent element maps a property of the component class as a pointer back to
the owning entity.
|
| JaxbHbmPolymorphismEnum |
Java class for PolymorphismEnum.
|
| JaxbHbmPrimitiveArrayType |
Java class for PrimitiveArrayType complex type.
|
| JaxbHbmPropertiesType |
properties declares that the contained properties form an alternate key.
|
| JaxbHbmQueryParamType |
The query-param element is used only by tools that generate
finder methods for named queries
|
| JaxbHbmResultSetMappingType |
The resultset element declares a named resultset mapping definition for SQL queries
|
| JaxbHbmRootEntityType |
Root entity mapping.
|
| JaxbHbmSecondaryTableType |
A join allows some properties of a class to be persisted to a second table
|
| JaxbHbmSetType |
Java class for SetType complex type.
|
| JaxbHbmSimpleIdType |
Declares the id type, column and generation algorithm for an entity class.
|
| JaxbHbmSubclassEntityBaseDefinition |
Java class for SubclassEntityBaseDefinition complex type.
|
| JaxbHbmSynchronizeType |
Java class for synchronize-type complex type.
|
| JaxbHbmTimestampAttributeType |
Optimistic locking attribute based on a (last-updated) timestamp.
|
| JaxbHbmTimestampSourceEnum |
Java class for TimestampSourceEnum.
|
| JaxbHbmToolingHintContainer |
Describes an XSD base type for any complex type that can contain "tooling hints".
|
| JaxbHbmToolingHintType |
is used to assign meta-level attributes to a class
or property.
|
| JaxbHbmTuplizerType |
TUPLIZER element; defines tuplizer to use for a component/entity for a given entity-mode
|
| JaxbHbmTypeDefinitionType |
Java class for TypeDefinitionType complex type.
|
| JaxbHbmTypeSpecificationType |
Declares the type of the containing property (overrides an eventually existing type
attribute of the property).
|
| JaxbHbmUnionSubclassEntityType |
Union subclasses are used for the table-per-concrete-class mapping strategy
See the note on the class element regarding vs. |
| JaxbHbmUnsavedValueCompositeIdEnum |
Java class for UnsavedValueCompositeIdEnum.
|
| JaxbHbmUnsavedValueTimestampEnum |
Java class for UnsavedValueTimestampEnum.
|
| JaxbHbmUnsavedValueVersionEnum |
Java class for UnsavedValueVersionEnum.
|
| JaxbHbmVersionAttributeType |
Optimistic locking attribute based on an incrementing value.
|
| JaxbHqlImport |
Java class for hql-import complex type.
|
| JaxbId |
See `@jakarta.persistence.Id`
See `@org.hibernate.annotations.AttributeAccessor`
|
| JaxbIdClass |
See `@jakarta.persistence.IdClass`
|
| JaxbIndex |
See `jakarta.persistence.Index`
|
| JaxbInheritance |
See `@jakarta.persistence.Inheritance`
|
| JaxbJoinColumn |
See `@jakarta.persistence.JoinColumn`
|
| JaxbJoinTable |
See `@jakarta.persistence.JoinTable`
|
| JaxbLob |
See `jakarta.persistence.Lob`
|
| JaxbLogger |
|
| JaxbManyToMany |
See `@jakarta.persistence.ManyToMany`
See `@org.hibernate.annotations.SortComparator`
See `@org.hibernate.annotations.SortNatural`
See `@org.hibernate.annotations.AttributeAccessor`
|
| JaxbManyToOne |
See `@jakarta.persistence.ManyToOne`
See `@org.hibernate.annotations.AttributeAccessor`
See `@org.hibernate.annotations.OnDelete
|
| JaxbMapKey |
See `@jakarta.persistence.MapKey`
|
| JaxbMapKeyClass |
See `@jakarta.persistence.MapKeyClass`
|
| JaxbMapKeyColumn |
See `@jakarta.persistence.MapKeyColumn`
|
| JaxbMapKeyJoinColumn |
See `@jakarta.persistence.MapKeyJoinColumn`
|
| JaxbMappedSuperclass |
See `@jakarta.persistence.MappedSuperclass`
|
| JaxbMultiTenancy |
See `@org.hibernate.annotations.TenantId`
|
| JaxbNamedAttributeNode |
|
| JaxbNamedEntityGraph |
|
| JaxbNamedNativeQuery |
|
| JaxbNamedQuery |
|
| JaxbNamedStoredProcedureQuery |
|
| JaxbNamedSubgraph |
|
| JaxbNationalized |
See `@org.hibernate.annotations.Nationalized`
|
| JaxbNaturalId |
See `@org.hibernate.annotations.NaturalId`
|
| JaxbOneToMany |
|
| JaxbOneToOne |
|
| JaxbOrderColumn |
|
| JaxbPersistenceUnitDefaults |
These defaults are applied to the persistence unit as a whole
unless they are overridden by local annotation or XML
element settings.
|
| JaxbPersistenceUnitMetadata |
Metadata that applies to the persistence unit and not just to
the mapping file in which it is contained.
|
| JaxbPluralFetchMode |
Java class for plural-fetch-mode.
|
| JaxbPostLoad |
|
| JaxbPostPersist |
|
| JaxbPostRemove |
|
| JaxbPostUpdate |
|
| JaxbPrePersist |
|
| JaxbPreRemove |
|
| JaxbPreUpdate |
|
| JaxbPrimaryKeyJoinColumn |
|
| JaxbQueryHint |
|
| JaxbQueryParamType |
Used only by tools to generate finder methods for named queries
|
| JaxbSecondaryTable |
|
| JaxbSequenceGenerator |
|
| JaxbSingularFetchMode |
Java class for singular-fetch-mode.
|
| JaxbSqlResultSetMapping |
|
| JaxbStoredProcedureParameter |
|
| JaxbSynchronizedTable |
Java class for synchronized-table complex type.
|
| JaxbTable |
|
| JaxbTableGenerator |
|
| JaxbTenantId |
See `@org.hibernate.annotations.TenantId`
See `@org.hibernate.annotations.TenantId`
|
| JaxbTransient |
|
| JaxbUniqueConstraint |
|
| JaxbVersion |
|
| JaxbXmlFormatMapper |
|
| JaxbXmlFormatMapper.CollectionWrapper |
|
| JaxbXmlFormatMapper.MapWrapper |
|
| JdbcBatchLogging |
Sub-system logging related to JDBC batch execution
|
| JdbcBindingLogging |
|
| JdbcCallFunctionReturn |
Models the function return when the JdbcOperationQueryCall represents a call to a database
function.
|
| JdbcCallParameterExtractor<T> |
Controls extracting values from OUT/INOUT parameters.
|
| JdbcCallParameterRegistration |
|
| JdbcCallRefCursorExtractor |
|
| JdbcConnectionAccess |
Provides centralized access to JDBC connections.
|
| JDBCConnectionException |
A JDBCException indicating a problem communicating with the
database (can also include incorrect JDBC setup). |
| JdbcCoordinator |
Coordinates JDBC-related activities.
|
| JdbcDataType |
|
| JdbcDateJavaType |
Descriptor for Date handling. |
| JdbcDateJavaType.DateMutabilityPlan |
|
| JdbcDeleteMutation |
|
| JdbcEnvironment |
|
| JdbcEscapeFunctionDescriptor |
Acts as a wrapper to another SqmFunctionDescriptor, rendering the
standard JDBC escape sequence {fn f(x, y)} around the invocation
syntax generated by its delegate. |
| JDBCException |
|
| JdbcExtractingLogging |
|
| JdbcInsertMutation |
Descriptor for a table insert originating from a flush
|
| JdbcLiteral<T> |
Represents a literal in the SQL AST.
|
| JdbcLiteralFormatter<T> |
|
| JdbcLockStrategy |
|
| JdbcLogging |
Sub-system logging related to JDBC interactions
|
| JdbcMapping |
Describes the mapping for things which can be expressed in a SQL query.
|
| JdbcMappingContainer |
Container for one-or-more JdbcMappings
|
| JdbcMetadaAccessStrategy |
|
| JdbcMutationExecutor |
Executor for model-mutation operations
|
| JdbcMutationOperation |
JdbcOperation extension for model mutations stemming from
persistence context flushes
|
| JdbcObserver |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| JdbcOperation |
A JDBC operation to perform.
|
| JdbcOperationQuery |
Unifying contract for any SQL statement we want to execute via JDBC.
|
| JdbcOperationQueryAnonBlock |
An anonymous call block (sometimes called an anonymous procedure) to be executed
on the database.
|
| JdbcOperationQueryCall |
|
| JdbcOperationQueryDelete |
|
| JdbcOperationQueryInsert |
Basic contract for an insert operation
|
| JdbcOperationQueryMutation |
Specialization of JdbcOperation for cases which mutate
table state (i.e.
|
| JdbcOperationQueryMutationNative |
Executable JDBC command
|
| JdbcOperationQuerySelect |
Executable JDBC command
|
| JdbcOperationQueryUpdate |
|
| JdbcParameter |
|
| JdbcParameterBinder |
Performs parameter value binding to a JDBC PreparedStatement.
|
| JdbcParameterBinding |
|
| JdbcParameterBindings |
Access to all the externalized JDBC parameter bindings
|
| JdbcParameterBySqmParameterAccess |
Access to the mapping between an SqmParameter and all of its JDBC parameters
|
| JdbcParameters |
The collection
|
| JdbcParametersList |
Conceptually similar to a List of JdbcParameters, but exposing a
read-only immutable contract.
|
| JdbcParametersList.Builder |
|
| JdbcParametersList.JdbcParametersListMulti |
|
| JdbcParametersList.JdbcParametersListSingleton |
|
| JdbcResourceTransaction |
Models access to the resource transaction of the underlying JDBC resource.
|
| JdbcResourceTransactionAccess |
|
| JdbcSelectExecutor |
An executor for JdbcSelect operations.
|
| JdbcServices |
Provides access to services related to JDBC operations.
|
| JdbcSessionContext |
Provides the "JDBC session" with contextual information it needs during its lifecycle.
|
| JdbcSessionOwner |
|
| JdbcTimeJavaType |
Descriptor for Time handling. |
| JdbcTimeJavaType.TimeMutabilityPlan |
|
| JdbcTimestampJavaType |
|
| JdbcTimestampJavaType.TimestampMutabilityPlan |
|
| JdbcType |
Specifies an explicit JdbcType to use for a particular column mapping.
When applied to a Map-valued attribute, describes the Map value. |
| JdbcType |
Descriptor for the SQL/JDBC side of a value mapping.
|
| JdbcTypeCode |
Specifies the JDBC type-code to use for the column mapping.
When applied to a Map-valued attribute, describes the Map value.
|
| JdbcTypeFamilyInformation |
Information pertaining to JDBC type families.
|
| JdbcTypeFamilyInformation.Family |
|
| JdbcTypeIndicators |
A parameter object that helps determine the SQL/JDBC type
recommended by the JDBC spec (explicitly or implicitly) for a given Java type. |
| JdbcTypeJavaClassMappings |
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 4.0 Specification_
Eventually, the plan is to have Dialect and
DatabaseMetaData.getTypeInfo() contribute this information. |
| JdbcTypeNameMapper |
(Badly named) helper for dealing with standard JDBC types as defined by Types |
| JdbcTypeRecommendationException |
|
| JdbcTypeRegistration |
|
| JdbcTypeRegistrations |
|
| JdbcTypeRegistry |
|
| JdbcUpdateMutation |
Describes the update of a single table
|
| JdbcValueBindings |
The JDBC values for a mutation
|
| JdbcValueDescriptor |
Descriptor for JDBC value within an operation.
|
| JdbcValues |
|
| JdbcValuesMapping |
|
| JdbcValuesMappingImpl |
Implementation of JdbcValuesMapping for native / procedure queries
|
| JdbcValuesMappingProducer |
Producer for JdbcValuesMapping references.
|
| JdbcValuesMappingProducerProvider |
|
| JdbcValuesMetadata |
Access to information about the underlying JDBC values
such as type, position, column name, etc
|
| JdbcValuesSourceProcessingOptions |
Essentially processing options only for entity loading
|
| JdbcValuesSourceProcessingState |
Provides a context for processing the processing of the complete
set of rows from a JdbcValuesSource.
|
| JdbcWrapper<T> |
Generic contract for wrapped JDBC objects.
|
| JndiException |
An exception indicating trouble accessing JNDI
|
| JndiNameException |
Indicates a problem with a given JNDI name being deemed as not valid.
|
| JndiService |
Service providing simplified access to JNDI related features needed by Hibernate.
|
| Join |
|
| Joinable |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| JoinColumnOrFormula |
|
| JoinColumnsOrFormulas |
Specifies a composite join condition involving one or more formulas
and, optionally, one or more columns. |
| JoinedSubclass |
A mapping model object that represents a subclass in a "joined" or
"table per subclass"
inheritance hierarchy. |
| JoinedSubclassEntityPersister |
|
| JoinedSubclassEntitySource |
|
| JoinFormula |
Specifies a join condition based on an arbitrary native SQL formula
instead of a column name. |
| JpaAttributeConverter<O,R> |
|
| JpaAttributeConverterCreationContext |
|
| JpaBootstrapSensitive |
Defines an event listener that is sensitive to whether a native or jpa bootstrap was performed
|
| JpaCallbackSource |
|
| JpaCoalesce<T> |
|
| JpaCollectionJoin<O,T> |
|
| JpaCompliance |
Encapsulates settings controlling whether Hibernate complies strictly
with certain debatable strictures of the JPA specification.
|
| JpaComplianceViolation |
Marker interface for exceptions describing JPA compliance violations.
|
| JpaCompoundSelection<T> |
|
| JpaCriteriaBase |
|
| JpaCriteriaDelete<T> |
|
| JpaCriteriaInsertSelect<T> |
A representation of SqmInsertSelectStatement at the
org.hibernate.query.criteria level, even though JPA does
not define support for insert-select criteria. |
| JpaCriteriaNode |
Base contract for nodes making up the criteria tree
|
| JpaCriteriaParameter<T> |
|
| JpaCriteriaQuery<T> |
|
| JpaCriteriaUpdate<T> |
|
| JpaCrossJoin<T> |
|
| JpaCteContainer |
Common contract for criteria parts that can hold CTEs (common table expressions).
|
| JpaCteCriteria<T> |
A CTE (common table expression) criteria.
|
| JpaCteCriteriaAttribute |
|
| JpaCteCriteriaType<T> |
A CTE (common table expression) criteria type.
|
| JpaDerivedFrom<T> |
|
| JpaDerivedJoin<T> |
|
| JpaDerivedRoot<T> |
|
| JpaDmlCriteria<E> |
|
| JpaEntityJoin<T> |
|
| JpaExpression<T> |
|
| JpaFetch<O,T> |
|
| JpaFetchParent<O,T> |
|
| JpaFrom<O,T> |
API extension to the JPA From contract |
| JpaFunction<T> |
Contract for expressions which model a SQL function call.
|
| JpaInPredicate<T> |
|
| JpaJoin<O,T> |
Consolidates the Join and Fetch hierarchies since that is how we implement them. |
| JpaJoinedFrom<O,T> |
Exists within the hierarchy mainly to support "entity joins".
|
| JpaListJoin<O,T> |
Specialization of JpaJoin for List typed attribute joins |
| JpaManipulationCriteria<E> |
|
| JpaMapJoin<O,K,V> |
Specialization of JpaJoin for Map typed attribute joins |
| JpaMetamodel |
Extensions to the JPA-defined metamodel of
persistent Java types. |
| JpaMetamodelImplementor |
|
| JpaOrder |
|
| JpaOrmXmlPersistenceUnitDefaultAware |
Contract for things that need to be aware of JPA orm.xml-defined persistence-unit-defaults.
|
| JpaOrmXmlPersistenceUnitDefaultAware.JpaOrmXmlPersistenceUnitDefaults |
Represents the persistence-unit-defaults to be applied
|
| JpaParameterExpression<T> |
|
| JpaPath<T> |
API extension to the JPA Path contract |
| JpaPluralJoin<O,C,E> |
Specialization of JpaJoin for Set typed attribute joins |
| JpaPredicate |
|
| JpaQueryableCriteria<T> |
Common contract for the forms of criteria that are "queryable" - can be
converted into a Query. |
| JpaQueryGroup<T> |
A query group i.e.
|
| JpaQueryPart<T> |
Models a query part i.e.
|
| JpaQueryStructure<T> |
Models a SELECT query.
|
| JpaRoot<T> |
|
| JpaSearchedCase<T> |
|
| JpaSearchOrder |
Represents the search order for a recursive CTE (common table expression).
|
| JpaSelectCriteria<T> |
|
| JpaSelection<T> |
|
| JpaSetJoin<O,T> |
Specialization of JpaJoin for Set typed attribute joins |
| JpaSettings |
Enumerates SPI-related settings that are specific to the use of Hibernate
as a JPA PersistenceProvider. |
| JpaSimpleCase<C,R> |
|
| JpaSubQuery<T> |
|
| JpaTargetAndSourceDescriptor |
|
| JpaTuple |
Hibernate extension to the Jakarta Persistence Tuple
contract |
| JpaTupleElement<T> |
|
| JpaWindow |
Common contract for window parts used in window and aggregate functions.
|
| JpaWindowFrame |
Common contract for a JpaWindow frame specification. |
| JsonAsStringJdbcType |
Specialized type mapping for JSON and the JSON SQL data type.
|
| JsonBJsonFormatMapper |
|
| JsonHelper |
|
| JsonJdbcType |
Specialized type mapping for JSON and the JSON SQL data type.
|
| JtaPlatform |
A Service that defines how Hibernate interacts with JTA on a certain
platform. |
| JtaPlatformException |
Indicates a problem interacting with the underlying JTA platform.
|
| JtaPlatformProvider |
|
| JtaPlatformResolver |
A Service defining a strategy for obtaining a JtaPlatform
in configurations where the application did not explicitly specify one. |
| Junction |
|
| Junction.Nature |
|
| KeyValue |
A mapping model Value which may be treated as an identifying key of a
relational database table. |
| LazyAttributeDescriptor |
Descriptor for an attribute which is enabled for bytecode lazy fetching
|
| LazyAttributeLoadingInterceptor |
Interceptor that loads attributes lazily
|
| LazyAttributesMetadata |
Information about the bytecode lazy attributes for an entity
|
| LazyCollection |
Deprecated.
|
| LazyCollectionOption |
Deprecated.
|
| LazyFetchGroupMetadata |
Information about a particular bytecode lazy attribute grouping.
|
| LazyGroup |
Specifies the fetch group for a persistent attribute of an entity
class.
|
| LazyInitializable |
The most general abstraction over collections which may be fetched lazily.
|
| LazyInitializationException |
Indicates an attempt to access unfetched data outside the context
of an open stateful Session. |
| LazyInitializer |
Handles fetching of the underlying entity for a proxy.
|
| LazyPropertyInitializer |
Contract for controlling how lazy properties get initialized.
|
| LazyPropertyInitializer.InterceptorImplementor |
Deprecated.
|
| LazyTableGroup |
The purpose of this table group is to defer creating the actual table group until it is really needed.
|
| LazyTableGroup.ParentTableGroupUseChecker |
|
| LazyToOne |
Deprecated.
|
| LazyToOneOption |
Deprecated.
|
| LegacyDB2LimitHandler |
|
| LegacyDB2SequenceSupport |
Deprecated.
|
| LegacyFetchResolver |
|
| LegacyHiLoAlgorithmOptimizer |
Slight variation from HiLoOptimizer, maintaining compatibility with the values generated by the
legacy Hibernate hilo based generators. |
| LegacyHSQLLimitHandler |
|
| LegacyNamingStrategy |
Naming strategy which implements the behavior of older versions of
Hibernate, for the most part.
|
| LegacyOracleLimitHandler |
|
| LegacySpecHints |
Deprecated.
|
| Length |
Defines a list of useful constant values that may be used
to specify long column lengths in the JPA
Column annotation. |
| LengthFunction |
A length function with separate patterns for string and clob argument.
|
| Lifecycle |
Provides callbacks from the Session to the persistent object.
|
| LifecycleCallback |
JAXB binding interface for lifecycle callbacks.
|
| LifecycleCallbackContainer |
JAXB binding interface for commonality between things which
allow callback declarations.
|
| LikePredicate |
|
| Limit |
Paging limits
|
| LimitHandler |
Contract defining dialect-specific limit and offset handling.
|
| LimitLimitHandler |
Limit handler for MySQL and CUBRID which support the syntax
LIMIT n and LIMIT m, n.
|
| LimitOffsetLimitHandler |
A LimitHandler for databases like PostgreSQL, H2,
and HSQL that support the syntax LIMIT n OFFSET m. |
| List |
A mapping model object representing a collection of type List. |
| ListaggFunction |
|
| ListaggGroupConcatEmulation |
|
| ListaggStringAggEmulation |
|
| ListIndexBase |
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. |
| ListIndexJavaType |
Form of JavaType for describing the column mapping
for the index of a List or array. |
| ListIndexJdbcType |
Form of JdbcType for describing
the column mapping for the index of a List or array. |
| ListIndexJdbcTypeCode |
Form of JdbcTypeCode for describing the column mapping
for the index of a List or array. |
| ListPersistentAttribute<D,E> |
|
| ListResultsConsumer<R> |
ResultsConsumer for creating a List of results
|
| ListResultsConsumer.UniqueSemantic |
Ways this consumer can handle in-memory row de-duplication
|
| ListType |
|
| Literal |
|
| LiteralAsParameter<T> |
A wrapper for a literal to render as parameter through a cast function.
|
| LiteralConsumer |
Pluggable contract for consuming literals encountered in an HQL query.
|
| LiteralNumberFormatException |
|
| Loadable |
|
| Loadable |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| LoadContexts |
Maintains a Stack of processing state related to performing load operations.
|
| LoadedConfig |
Models the information gleaned from parsing a cfg.xml file.
|
| Loader |
Deprecated.
|
| Loader |
Common contract for all value-mapping loaders.
|
| LoaderLogging |
Logging for loaders
|
| LoadEvent |
Defines an event class for the loading of an entity.
|
| LoadEventListener |
Defines the contract for handling of load events generated from a session.
|
| LoadEventListener.LoadType |
|
| LoadingCollectionEntry |
Represents a collection currently being loaded.
|
| LoadingEntityEntry |
Representation of an entity being loaded, containing its state
|
| LoadingLogger |
|
| LoadQueryInfluencers |
Centralize all options which can influence the SQL query needed to load an
entity.
|
| LobCreationContext |
Provides callback access into the context in which the LOB is to be created.
|
| LobCreationContext.Callback<T> |
The callback contract for making use of the JDBC Connection. |
| LobCreator |
Contract for creating various LOB references.
|
| LobCreatorBuilder |
|
| LobHelper |
A factory for instances of Blob and Clob used for writing LOB data. |
| LobMergeStrategy |
Strategy for how dialects need LOB values to be merged.
|
| LobStreamDataHelper |
A help for dealing with BLOB and CLOB data
|
| LobTypeMappings |
|
| LocalDateJavaType |
|
| LocalDateTimeJavaType |
|
| LocaleJavaType |
Descriptor for Locale handling. |
| LocaleJavaType.LocaleComparator |
|
| LocalMetadataBuildingContext |
Specialization of the MetadataBuildingContext contract specific to a given origin.
|
| LocalObjectUuidHelper |
|
| LocalSynchronizationException |
Wraps an exception thrown from a "local synchronization" (one registered in the SynchronizationRegistry).
|
| LocalTimeJavaType |
|
| LocalXsdResolver |
When Hibernate loads an XSD we fully expect that to be resolved from our
jar file via ClassLoader resource look-up.
|
| LocatePositionEmulation |
Emulates the ANSI SQL-standard position() function using locate().
|
| Lockable |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| LockAcquisitionException |
A JDBCException indicating a problem acquiring a lock
on the database. |
| LockEvent |
Defines an event class for the locking of an entity.
|
| LockEventListener |
Defines the contract for handling of lock events generated from a session.
|
| LockingStrategy |
A strategy abstraction for how locks are obtained in the underlying database.
|
| LockingStrategyException |
|
| LockMode |
Instances represent a lock mode for a row of a relational
database table.
|
| LockModeTypeMarshalling |
|
| LockOptions |
Contains a set of options describing how a row of a database table
mapped by an entity should be locked.
|
| LockTimeoutException |
A JDBCException indicating that a lock request
timed out on the database. |
| LoggableUserType |
Marker interface for user types which want to perform custom
logging of their corresponding values
|
| LogicalConnection |
Represents a continuous logical connection to the database to the database via JDBC.
|
| LogicalConnectionImplementor |
|
| LongJavaType |
Descriptor for Long handling. |
| LongNVarcharJdbcType |
|
| LongPrimitiveArrayJavaType |
Descriptor for long[] handling.
|
| LongVarbinaryJdbcType |
|
| LongVarcharJdbcType |
|
| LpadRpadPadEmulation |
|
| Managed |
Contract for classes (specifically, entities and components/embeddables) that are "managed".
|
| ManagedBean<T> |
Generalized contract for a (CDI or Spring) "managed bean" as seen by Hibernate
|
| ManagedBeanRegistry |
|
| ManagedBeanRegistryInitiator |
|
| ManagedComposite |
Specialized Managed contract for component/embeddable classes. |
| ManagedDomainType<J> |
|
| ManagedEntity |
Specialized Managed contract for entity classes. |
| ManagedMappedSuperclass |
Specialized Managed contract for MappedSuperclass classes. |
| ManagedMappingType |
|
| ManagedResources |
Represents the result of the first step of the process of building MetadataSources
reference into a Metadata reference. |
| ManagedType |
Common interface for JAXB bindings representing entities, mapped-superclasses and embeddables (JPA collective
calls these "managed types" in terms of its Metamodel api).
|
| ManagedTypeRepresentationResolver |
Pluggable strategy handling resolution of ManagedTypeRepresentationStrategy to use.
|
| ManagedTypeRepresentationStrategy |
Defines a singular extension point for capabilities pertaining to
a representation mode.
|
| ManyToAny |
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. |
| ManyToOne |
|
| ManyToOneType |
A many-to-one association to an entity.
|
| Map |
A mapping model object representing a collection of type Map. |
| MapEntryJavaType |
|
| MapKeyCompositeType |
|
| MapKeyJavaType |
Form of JavaType for describing the key of a Map |
| MapKeyJdbcType |
Form of JdbcType for describing the key of a Map |
| MapKeyJdbcTypeCode |
|
| MapKeyMutability |
Form of Mutability for describing the key of a Map |
| MapKeyType |
Form of Type for use with map keys. |
| MapLazyInitializer |
Lazy initializer for "dynamic-map" entity representations.
|
| MappedByTableGroup |
|
| MappedSuperclass |
|
| MappedSuperclassDomainType<J> |
|
| MapPersistentAttribute<D,K,V> |
|
| Mapping |
Deprecated.
|
| MappingDefaults |
Values to use as defaults in the absence of certain mapping information.
|
| MappingException |
Indicates a problem parsing a mapping document.
|
| MappingException |
An exception that occurs while reading mapping sources, either
XML or annotations, usually as a result of something screwy in
the O/R mappings.
|
| MappingFileDescriptor |
Descriptor for a mapping (XML) file.
|
| MappingHelper |
|
| MappingMetamodel |
Access to information about the runtime relational O/R mapping model.
|
| MappingMetamodelImplementor |
|
| MappingModelCreationLogging |
Logger used during mapping-model creation
|
| MappingModelExpressible<T> |
Something that can be expressible at the mapping model level.
|
| MappingModelHelper |
|
| MappingNotFoundException |
Indicates that a mapping document could not be found at a given Origin. |
| MappingReference |
Represents a <mapping/> element within a cfg.xml file.
|
| MappingReference.Type |
|
| MappingType |
Common descriptor for types in the mapping model - entities, embeddables, String, Integer, etc
|
| MappingXsdSupport |
Support for XSD handling related to Hibernate's `hbm.xml` and
JPA's `orm.xml`.
|
| MapProxy |
Proxy for "dynamic-map" entity representations.
|
| MapProxyFactory |
|
| MapSemantics<MKV extends Map<K,V>,K,V> |
|
| MapsIdSource |
Describes a relationship annotated with MapsId |
| MapType |
|
| MariaDB103Dialect |
Deprecated.
|
| MariaDB106Dialect |
Deprecated.
|
| MariaDBDialect |
|
| MariaDBSequenceSupport |
|
| MariaDBSqlAstTranslator<T extends JdbcOperation> |
A SQL AST translator for MariaDB.
|
| MergeContext |
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. |
| MergeEvent |
An event class for merge() and saveOrUpdateCopy()
|
| MergeEventListener |
Defines the contract for handling of merge events generated from a session.
|
| MergeOperation |
JdbcMutation implementation for MERGE handling
|
| MessageHelper |
MessageHelper methods for rendering log messages relating to managed
entities and collections typically used in log statements and exception
messages.
|
| MetaAttributable |
Common interface for things that can handle meta attributes.
|
| MetaAttribute |
A meta attribute is a named value or values.
|
| Metadata |
Represents the ORM model as determined by aggregating the provided mapping sources.
|
| MetadataBuilder |
Contract for specifying various overrides to be used in metamodel building.
|
| MetadataBuilderContributor |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| MetadataBuilderFactory |
An extension point for integrators that wish to hook into the process of how a Metadata is built. |
| MetadataBuilderImplementor |
Internal API for MetadataBuilder exposing the building options being collected. |
| MetadataBuilderInitializer |
|
| MetadataBuildingContext |
|
| MetadataBuildingOptions |
|
| MetadataBuildingProcess |
|
| MetadataContributor |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| MetadataImplementor |
|
| MetadataSource |
Enumeration of the known places from which a piece of metadata may come.
|
| MetadataSourceProcessor |
Defines the steps in processing metadata sources.
|
| MetadataSources |
Entry point for working with sources of O/R mapping metadata, either
in the form of annotated classes, or as XML mapping documents.
|
| MetadataSourcesContributor |
|
| MetadataSourceType |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| Metamodel |
Deprecated.
|
| MetamodelImplementor |
Deprecated.
|
| MetaType |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| MinMaxCaseEveryAnyEmulation |
Most databases don't have a function like every() or any().
|
| MissingSqlSelectionException |
Indicates that a column defined as part of a SQL ResultSet mapping was not part
of the query's ResultSet
|
| ModelMutationLogging |
Logging related to entity and collection mutations stemming from persistence-context events
|
| ModelPart |
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.
|
| ModelPart.JdbcValueBiConsumer<X,Y> |
Functional interface for consuming the JDBC values, along with two values of type X and Y.
|
| ModelPart.JdbcValueConsumer |
Functional interface for consuming the JDBC values.
|
| ModelPartContainer |
Access to a group of ModelPart by name or for iteration.
|
| ModelPartReference |
|
| ModelPartReferenceBasic |
|
| ModelPartReferenceCollection |
|
| ModelPartReferenceEmbeddable |
|
| ModelPartReferenceEntity |
|
| ModelPartReferenceMemento |
A ResultMappingMementoNode that is a reference to some part of the user's
domain model
|
| ModelPartResultMemento |
|
| ModelPartResultMementoBasic |
|
| ModelPartResultMementoCollection |
|
| ModelPartResultMementoEntity |
|
| ModeStatsModeEmulation |
|
| ModifiedSubQueryExpression |
|
| ModifiedSubQueryExpression.Modifier |
|
| MultiIdentifierLoadAccess<T> |
|
| MultiIdEntityLoader<T> |
Loader subtype for loading multiple entities by multiple identifier values.
|
| MultiIdLoadOptions |
Encapsulation of the options for loading multiple entities by id
|
| MultiKeyLoader |
Loader specialization for loading multiple loadable
references by primary, foreign or natural key. |
| MultiKeyLoadSizingStrategy |
Strategy for determining an optimal size for loading by multiple keys.
|
| MultiLoadOptions |
Base contract for options for multi-load operations
|
| MultiNaturalIdLoader<E> |
Loader for entities by multiple natural-ids
|
| MultiNaturalIdLoadOptions |
Encapsulation of the options for loading multiple entities by natural-id
|
| MultipatternSqmFunctionDescriptor |
Support for overloaded functions defined in terms of a
list of patterns, one for each possible function arity.
|
| MultipleBagFetchException |
Exception used to indicate that a query is attempting to simultaneously fetch multiple
bags |
| MultiTenancySource |
Describes the source information related to mapping the multi-tenancy of an entity
|
| MultiTenantConnectionProvider |
A specialized Connection provider contract used when the application is using
multi-tenancy support requiring tenant-aware connections. |
| Mutability |
|
| MutabilityPlan<T> |
Describes the mutability aspects of a given Java type.
|
| MutabilityPlanExposer<T> |
Something that exposes a MutabilityPlan
|
| MutableCacheKeyBuilder |
A builder that generates a Serializable Object to be used as a key into the query results cache. |
| MutableJpaCompliance |
|
| MutableMutabilityPlan<T> |
Mutability plan for mutable objects
|
| MutableQueryOptions |
|
| MutatingTableReference |
Specialized TableReference for model mutation operations
|
| MutatingTableReferenceGroupWrapper |
Acts as a TableGroup for DML query operations.
|
| MutationExecutor |
Main contract for performing the mutation.
|
| MutationExecutorService |
Service for creating executors for model mutation operations
|
| MutationGroup |
Grouping of table mutations for the given target for
the given type of mutation
|
| MutationGroupBuilder |
|
| MutationOperation |
Mutation for a specific table as part of a logical mutation on the entity.
|
| MutationOperationGroup |
Group of MutationOperation references for a specific
logical operation (target + type) |
| MutationQuery |
Within the context of an active session,
an instance of this type represents an executable mutation query, that is,
an insert, update, or delete. |
| MutationStatement |
Specialization of Statement for mutation (DML) statements
|
| MutationStatementPreparer |
|
| MutationTarget<T extends TableMapping> |
Target of mutations from persistence context events
|
| MutationType |
The type of mutation
|
| MyISAMStorageEngine |
Represents the MyISAM storage engine.
|
| MySQL57Dialect |
Deprecated.
|
| MySQL8Dialect |
Deprecated.
|
| MySQLCastingJsonJdbcType |
|
| MySQLDialect |
|
| MySQLIdentityColumnSupport |
|
| MySQLServerConfiguration |
|
| MySQLSqlAstTranslator<T extends JdbcOperation> |
A SQL AST translator for MySQL.
|
| MySQLStorageEngine |
This interface defines how various MySQL storage engines behave in regard to Hibernate functionality.
|
| NameableQuery |
Contract for Query impls that can be converted to a named query memento to be
stored in the NamedObjectRepository |
| NamedAuxiliaryDatabaseObject |
Mainly this is used to support legacy sequence exporting.
|
| NamedCallableQueryDefinition |
Named query mapping for callable queries
|
| NamedCallableQueryDefinition.ParameterMapping |
|
| NamedCallableQueryMemento |
Represents a "memento" (disconnected, externalizable form) of a ProcedureCall
|
| NamedCallableQueryMemento.ParameterMemento |
|
| NamedEntityGraphDefinition |
|
| NamedFunctionDescriptorBuilder |
|
| NamedHqlQueryDefinition |
Boot-time descriptor of a named HQL query, as defined in
annotations or xml
|
| NamedHqlQueryDefinition.Builder |
|
| NamedNativeQueries |
|
| NamedNativeQuery |
Declares a named query written in native SQL.
|
| NamedNativeQueryDefinition |
Boot-time descriptor of a named native query, as defined in
annotations or xml
|
| NamedNativeQueryDefinitionBuilder |
|
| NamedNativeQueryMemento |
Descriptor for a named native query in the runtime environment
|
| NamedNativeQueryMemento.Builder |
Delegate used in creating named HQL query mementos.
|
| NamedObjectRepository |
Repository for references to named things related to queries.
|
| NamedParameterDescriptor<T> |
Descriptor regarding a named parameter.
|
| NamedParametersNotSupportedException |
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.
|
| NamedProcedureCallDefinition |
Boot-time descriptor of a named procedure/function query, as defined in
annotations or xml
|
| NamedQueries |
|
| NamedQuery |
Declares a named query written in HQL or JPQL.
|
| NamedQuery |
|
| NamedQueryDefinition |
Common attributes shared across the mapping of named HQL, native
and "callable" queries defined in annotations, orm.xml and hbm.xml
|
| NamedQueryMemento |
The runtime representation of named queries.
|
| NamedQueryMemento.ParameterMemento |
|
| NamedResultSetMappingDescriptor |
Models the "boot view" of a ResultSet mapping used in the mapping
of native and procedure queries.
|
| NamedResultSetMappingMemento |
Used to keep information about named result mappings defined by the
application which can then be applied to native-sql and stored-procedure
queries.
|
| NamedSqmFunctionDescriptor |
Provides a standard implementation that supports the majority of the HQL
functions that are translated to SQL.
|
| NamedSqmQueryMemento |
|
| NamedTableReference |
Represents a reference to a "named" table in a query's from clause.
|
| NameQualifierSupport |
Enumerated values representing the level of support for catalog and schema.
|
| Namespace |
Represents a namespace (named schema/catalog pair) with a Database and manages objects defined within.
|
| Namespace.ComparableHelper |
|
| Namespace.Name |
|
| NameSpaceTablesInformation |
|
| NamingHelper |
|
| NamingStrategy |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| NamingStrategyHelper |
Helper contract for dealing with naming strategies.
|
| NationalizationSupport |
Indicates if and how a database supports the use of nationalized
character data (Unicode).
|
| Nationalized |
Specifies that the annotated character data should be stored with
nationalization support.
|
| NationalizedTypeMappings |
Manages a mapping between nationalized and non-nationalized variants of JDBC types.
|
| NativeNonSelectQueryDefinition |
Access the values defining a native non-select query
|
| NativeNonSelectQueryPlan |
|
| NativeQuery<T> |
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. |
| NativeQuery.CollectionReturn |
Allows access to further control how collection returns are mapped back
from result sets.
|
| NativeQuery.FetchReturn |
Allows access to further control how join fetch returns are mapped back
from result sets.
|
| NativeQuery.InstantiationResultNode<J> |
|
| NativeQuery.ResultNode |
Simple unification interface for all returns from the various addXYZ()
methods.
|
| NativeQuery.ReturnableResultNode |
|
| NativeQuery.ReturnProperty |
Allows access to further control how properties within a root or join
fetch are mapped back from the result set.
|
| NativeQuery.RootReturn |
Allows access to further control how root returns are mapped back from
result sets.
|
| NativeQueryImplementor<R> |
|
| NativeQueryInterpreter |
Service contract for dealing with native queries.
|
| NativeQueryInterpreterInitiator |
|
| NativeQueryLogging |
|
| NativeQueryNonScalarRootReturn |
Commonality for non-scalar root returns for a native query result mapping
|
| NativeQueryPlan |
|
| NativeQueryReturn |
Shared contract between the various types of returns definable in HBM.
|
| NativeQueryTupleTransformer |
|
| NativeSelectQueryDefinition<R> |
Access the values defining a native select query
|
| NativeSelectQueryPlan<T> |
|
| NaturalId |
Specifies that a field or property of an entity class is part of
the natural id of the entity.
|
| NaturalId |
JAXB binding interface for natural-id definitions
|
| NaturalIdCache |
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.
|
| NaturalIdDataAccess |
Contract for managing transactional and concurrent access to cached naturalId
data.
|
| NaturalIdDataCachingConfig |
Specialized DomainDataCachingConfig describing the requested
caching config for the natural-id data of a particular entity (hierarchy)
|
| NaturalIdLoadAccess<T> |
Loads an entity by its natural identifier.
|
| NaturalIdLoader<T> |
|
| NaturalIdLoadOptions |
Options for loading by natural-id
|
| NaturalIdLogging |
Logging related to natural-id operations
|
| NaturalIdMapping |
Mapping for an entity's natural-id, if one is defined.
|
| NaturalIdMultiLoadAccess<T> |
Defines the ability to load multiple entities by simple natural-id simultaneously.
|
| NaturalIdMutability |
A ternary boolean enum for describing the mutability aspects of an
attribute as a natural id.
|
| NaturalIdNonStrictReadWriteAccess |
|
| NaturalIdReadOnlyAccess |
|
| NaturalIdReadWriteAccess |
|
| NaturalIdResolutions |
Manages the cached resolutions related to natural-id (to and from identifier)
|
| NaturalIdStatistics |
Statistics pertaining to the execution of queries which resolve a natural
id lookup against the database.
|
| NaturalIdTransactionalAccess |
|
| NaturalIdUniqueKeyBinder |
|
| NavigablePath |
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.
|
| NavigablePath.FullPathCalculator |
Effectively a tri-function
|
| NavigablePath.RelativePathCollector |
|
| NavigableRole |
A compound path which represents a ModelPart
and uniquely identifies it with the runtime metamodel. |
| NCharJdbcType |
Descriptor for NCHAR handling. |
| NClobImplementer |
Marker interface for non-contextually created java.sql.NClob instances..
|
| NClobJavaType |
Descriptor for NClob handling. |
| NClobJavaType.NClobMutabilityPlan |
|
| NClobJdbcType |
Descriptor for NCLOB handling. |
| NClobProxy |
Manages aspects of proxying java.sql.NClobs for non-contextual creation, including proxy creation and
handling proxy invocations.
|
| NegatedPredicate |
|
| NextvalSequenceSupport |
Sequence support for dialects which support the common
Oracle-style syntax seqname.nextval.
|
| NoAttributeConverter<O,R> |
Deprecated.
|
| NoCacheRegionFactoryAvailableException |
Indicates a condition where a second-level cache implementation was expected to be available, but
none was found on the classpath.
|
| Node |
Common contract for all nodes in the order-by fragment AST
|
| NodeBuilder |
Adapts the JPA CriteriaBuilder to generate SQM nodes.
|
| NoMoreOutputsException |
|
| NoMoreReturnsException |
|
| NonAggregatedCompositeSimplePath<T> |
|
| NonAggregatedIdentifierMapping |
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. |
| NonAggregatedIdentifierMapping.IdentifierValueMapper |
Think of an AttributeConverter for id values to account for representation
difference between virtual and id-class mappings
|
| NonClassFileArchiveEntryHandler |
Defines handling and filtering for all non-class file (package-info is also a class file...) entries within an archive
|
| NonContextualLobCreator |
LobCreator implementation using non-contextual or local creation, meaning that we generate the LOB
references ourselves as opposed to delegating to the JDBC Connection. |
| NonDurableConnectionObserver |
Additional optional contract for connection observers to indicate that
they should be released when the physical connection is released.
|
| NonIdentifierAttribute |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| NonSelectInterpretationsKey |
QueryInterpretations key for non-select NativeQuery instances
|
| NonSelectQueryPlan |
|
| NonTransientException |
Marker interface for exceptions thrown during mapping-model creation which
are not transient errors - they will never succeed
|
| NonUniqueDiscoveredSqlAliasException |
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. |
| NonUniqueObjectException |
This exception is thrown when an operation would break session-scoped identity.
|
| NonUniqueResultException |
|
| NoopLimitHandler |
Handler not supporting query LIMIT clause.
|
| NoopOptimizer |
An optimizer that performs no optimization.
|
| NoSequenceSupport |
An instance of SequenceSupport support indicating that
the SQL dialect does not support sequences. |
| NoSuchParameterException |
|
| NotFound |
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. |
| NotFoundAction |
Specifies how Hibernate should handle the case of an orphaned foreign
key with no associated row in the referenced table.
|
| NotIndexedCollectionException |
Indicates an attempt to use a non-indexed collection as indexed.
|
| NotInstrumentedException |
Indicates a condition where an instrumented/enhanced class was expected, but the class was not
instrumented/enhanced.
|
| NullJdbcType |
Descriptor for binding nulls with Types.NULL
|
| NullnessPredicate |
|
| NullnessRestriction |
Nullness restriction - IS (NOT)? NULL
|
| NullOrdering |
The order of null.
|
| NullPrecedence |
Defines precedence of null values within ORDER BY clause.
|
| NullServiceException |
|
| NullSqmExpressible |
|
| NullSynchronizationException |
Indicates an attempt to register a null synchronization.
|
| NullType |
|
| NumericBooleanConverter |
Handles conversion to/from Boolean as 0 (false) or 1 (true)
|
| NumericJdbcType |
|
| NVarcharJdbcType |
|
| NvlCoalesceEmulation |
Oracle 8i had no coalesce() function,
so we emulate it using chained nvl()s.
|
| ObjectArrayJavaType |
Descriptor for Object[] handling, usually used for tuples.
|
| ObjectDeletedException |
Thrown when the user tries to do something illegal with a deleted object.
|
| ObjectFactory |
This object contains factory methods for each
Java content interface and Java element interface
generated in the org.hibernate.boot.jaxb.cfg.spi package.
|
| ObjectFactory |
This object contains factory methods for each
Java content interface and Java element interface
generated in the org.hibernate.boot.jaxb.hbm.spi package.
|
| ObjectFactory |
This object contains factory methods for each
Java content interface and Java element interface
generated in the org.hibernate.boot.jaxb.mapping package.
|
| ObjectJavaType |
|
| ObjectJdbcType |
|
| ObjectNameNormalizer |
Provides centralized normalization of how database object names are handled.
|
| ObjectNotFoundException |
|
| ObjectNullAsBinaryTypeJdbcType |
Descriptor for binding objects, but binding nulls with Types.VARBINARY
|
| ObjectNullAsNullTypeJdbcType |
Descriptor for binding objects, but binding nulls with Types.NULL
|
| ObjectNullResolvingJdbcType |
Descriptor for binding objects, but binding nulls with the resolved parameter type
|
| OffsetDateTimeJavaType |
|
| OffsetFetchLimitHandler |
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. |
| OffsetTimeJavaType |
|
| OnDelete |
Specifies an on delete action for a foreign key constraint.
|
| OnDeleteAction |
Enumerates the possible actions for the on delete clause
of a foreign key constraint.
|
| OnDeleteActionMarshalling |
|
| OneToMany |
|
| OneToManyPersister |
|
| OneToManyTableGroup |
A table group for one-to-many plural attributes.
|
| OneToOne |
|
| OneToOneType |
A one-to-one association to an entity
|
| OnExecutionGenerator |
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.
|
| OperationProducer |
|
| OperationResultChecker |
Used to check the results of a statement execution
|
| OptimisticEntityLockException |
Represents an error trying to apply an optimistic LockingStrategy to an entity |
| OptimisticForceIncrementLockingStrategy |
An optimistic locking strategy that verifies that the version
has not changed and then forces an increment of the version,
just before committing the transaction.
|
| OptimisticLock |
Specifies whether mutating the annotated attribute should trigger an increment
to the version of the entity instance. |
| OptimisticLocking |
Specifies how optimistic lock checking works for the annotated entity.
|
| OptimisticLockingStrategy |
An optimistic locking strategy that simply verifies that the
version has not changed, just before committing the transaction.
|
| OptimisticLockStyle |
Describes how an entity should be optimistically locked.
|
| OptimisticLockStyleMarshalling |
|
| OptimisticLockType |
Enumerates the possible optimistic lock checking strategies.
|
| OptimizableGenerator |
Commonality between sequence-based and table-based generators
|
| Optimizer |
Performs optimization on an optimizable identifier generator.
|
| OptimizerFactory |
|
| OptionalTableUpdateOperation |
Legacy "upsert" handling, conditionally using INSERT, UPDATE and DELETE
statements as required for optional secondary tables.
|
| Oracle12cDialect |
Deprecated.
|
| Oracle12cGetGeneratedKeysDelegate |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| Oracle12cIdentityColumnSupport |
|
| Oracle12LimitHandler |
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. |
| OracleAggregateSupport |
|
| OracleArrayJdbcType |
Descriptor for ARRAY handling. |
| OracleBooleanJdbcType |
|
| OracleDialect |
|
| OracleJdbcHelper |
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.
|
| OracleJsonBlobJdbcType |
Specialized type mapping for JSON and the BLOB SQL data type for Oracle.
|
| OracleJsonJdbcType |
Specialized type mapping for JSON and the JSON SQL data type for Oracle.
|
| OracleReflectionStructJdbcType |
|
| OracleSequenceSupport |
|
| OracleSqlAstTranslator<T extends JdbcOperation> |
A SQL AST translator for Oracle.
|
| OracleStructJdbcType |
|
| OracleTruncFunction |
Custom TruncFunction for Oracle which uses emulation when truncating datetimes to seconds |
| OracleTypes |
The Oracle specific JDBC type code.
|
| OracleXmlJdbcType |
|
| Orderable |
Contact to define if a plural attribute source is orderable or not.
|
| OrderBy |
Order a collection using an expression written in native SQL.
|
| OrderByComplianceViolation |
|
| OrderByFragment |
Represents the translation result.
|
| OrderByFragmentImpl |
|
| OrderByFragmentTranslator |
Responsible for performing the translation of the order-by fragment associated
with an order set or map.
|
| OrderedMapType |
A specialization of the map type, with (resultset-based) ordering.
|
| OrderedSetAggregateFunctionExpression |
Models an ordered set-aggregate function expression at the SQL AST level.
|
| OrderedSetType |
A specialization of the set type, with (resultset-based) ordering.
|
| OrderingExpression |
Contract for anything that can be a sort expression
|
| OrderingLexer |
|
| OrderingParser |
|
| OrderingParser.CollationSpecificationContext |
|
| OrderingParser.DirectionContext |
|
| OrderingParser.DotIdentifierContext |
|
| OrderingParser.DotIdentifierExpressionContext |
|
| OrderingParser.ExpressionContext |
|
| OrderingParser.FunctionArgumentContext |
|
| OrderingParser.FunctionArgumentsContext |
|
| OrderingParser.FunctionContext |
|
| OrderingParser.FunctionExpressionContext |
|
| OrderingParser.IdentifierContext |
|
| OrderingParser.IdentifierExpressionContext |
|
| OrderingParser.LiteralContext |
|
| OrderingParser.NullsPrecedenceContext |
|
| OrderingParser.OrderByFragmentContext |
|
| OrderingParser.PackagedFunctionContext |
|
| OrderingParser.SimpleFunctionContext |
|
| OrderingParser.SortSpecificationContext |
|
| OrderingParserBaseListener |
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. |
| OrderingParserBaseVisitor<T> |
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. |
| OrderingParserListener |
This interface defines a complete listener for a parse tree produced by
OrderingParser. |
| OrderingParserVisitor<T> |
This interface defines a complete generic visitor for a parse tree produced
by OrderingParser. |
| OrderingSpecification |
An individual sort specification in an order-by fragment
|
| OrdinalParameterDescriptor<T> |
Descriptor regarding an ordinal parameter.
|
| Origin |
Describes the origin of an XML document.
|
| OuterJoinLoadable |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| Output |
|
| OutputableType<J> |
Specialization of DomainType for types that can be used as a
parameter output for a ProcedureCall |
| Outputs |
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.
|
| Over<T> |
|
| Overflow |
|
| OwnedValuedModelPart |
Marker interface for valued model parts that have a declaring/owner type.
|
| PackageDescriptor |
Descriptor for a package (as indicated by a package-info.class file).
|
| PackageInfoArchiveEntryHandler |
Defines handling and filtering for package-info file entries within an archive
|
| ParamDef |
Details about a parameter declared in a FilterDef. |
| Parameter |
Generic parameter (basically a key/value combination) used to parametrize other annotations.
|
| ParameterCollector |
todo (6.0) : how is this different from ParameterCollector?
|
| ParameterDeclarationContext |
Describes the context in which a parameter is declared.
|
| ParameterInterpretation |
|
| ParameterizedType |
Support for parameterizable types.
|
| ParameterMarkerStrategy |
Strategy for generating parameter markers used in preparable SQL strings. |
| ParameterMetadata |
Access to known information about the parameters for a query.
|
| ParameterMetadataImplementor |
|
| ParameterMisuseException |
Thrown to indicate a misuse of a parameter
|
| ParameterModeMarshalling |
|
| ParameterOccurrence |
|
| ParameterRecognitionException |
|
| ParameterRecognizer |
Defines the "callback" the process of recognizing native query parameters.
|
| ParameterStrategy |
The style/strategy of parameter registration used in a particular procedure call definition.
|
| ParameterStrategyException |
|
| ParameterUsage |
Describes how a parameter is used in a mutation statement
|
| ParamLocationRecognizer |
Implements a parameter parser recognizer specifically for the purpose
of journaling parameter locations.
|
| ParamLocationRecognizer.InFlightJpaOrdinalParameterState |
Internal in-flight representation of a recognized named parameter
|
| ParamLocationRecognizer.InFlightNamedParameterState |
Internal in-flight representation of a recognized named parameter
|
| ParamLocationRecognizer.InFlightOrdinalParameterState |
Internal in-flight representation of a recognized named parameter
|
| Parent |
Reference the property as a pointer back to the owner (generally the owning entity).
|
| ParseTreeVisitor |
|
| ParsingException |
The root exception for errors (potential bugs) in the sqm parser code itself, as opposed
to SemanticException which indicates problems with the query itself. |
| PartitionKey |
Identifies a field of an entity that holds the partition key of a table.
|
| PathConsumer |
Represents the translation of an individual part of a path in `@OrderBy` translation
Similar in purpose to DotIdentifierConsumer, but for `@OrderBy` translation |
| PathException |
Indicates an attempt to use a path in an unsupported way
|
| PathResolutionException |
Indicates a problem resolving a domain-path occurring in an order-by fragment
|
| PatternBasedSqmFunctionDescriptor |
Support for HQL functions that have different representations
in different SQL dialects, where the difference can be handled
via a pattern template.
|
| PatternFunctionDescriptorBuilder |
|
| PersistContext |
|
| PersistenceContext |
Represents the state of "stuff" Hibernate is tracking, including (not exhaustive):
entities
collections
snapshots
proxies
|
| PersistenceStandardNamingStrategy |
Deprecated.
|
| PersistenceUnitDescriptor |
Abstraction for dealing with either <persistence-unit/> information whether that comes from
an EE container in the form of PersistenceUnitInfo or in an SE environment
where Hibernate has parsed the persistence.xml file itself. |
| PersistentArrayHolder<E> |
A dummy collection wrapper for an array.
|
| PersistentAttribute |
Common interface for JAXB bindings that represent persistent attributes.
|
| PersistentAttribute<D,J> |
Hibernate extension to the JPA Attribute contract |
| PersistentAttributeInterceptable |
|
| PersistentAttributeInterceptor |
The base contract for interceptors that can be injected into
enhanced entities for the purpose of intercepting attribute access
|
| PersistentBag<E> |
An unordered, un-keyed collection that can contain the same element
multiple times.
|
| PersistentClass |
|
| PersistentClassVisitor |
|
| PersistentCollection<E> |
Persistent collections are treated as value objects by Hibernate.
|
| PersistentIdentifierBag<E> |
An "identifier bag" implements "bag" semantics more efficiently than a
regular bag by adding a synthetic identifier column to the table.
|
| PersistentIdentifierGenerator |
|
| PersistentList<E> |
A persistent wrapper for a List. |
| PersistentMap<K,E> |
A persistent wrapper for a Map. |
| PersistentObjectException |
Thrown when the user passes a persistent instance to a Session
method that expects a transient instance. |
| PersistentSet<E> |
A persistent wrapper for a Set. |
| PersistentSortedMap<K,E> |
|
| PersistentSortedSet<E> |
|
| Persister |
Deprecated.
|
| PersisterClassResolver |
Given an entity or collection mapping, resolve the appropriate persister class to use.
|
| PersisterCreationContext |
Deprecated.
|
| PersisterFactory |
|
| PersistEvent |
An event class for persist()
|
| PersistEventListener |
Defines the contract for handling of create events generated from a session.
|
| PessimisticEntityLockException |
Represents an error trying to apply a pessimistic LockingStrategy to an entity |
| PessimisticForceIncrementLockingStrategy |
A pessimistic locking strategy where a lock is obtained by incrementing
the version immediately, obtaining an exclusive write lock by side effect.
|
| PessimisticLockException |
Thrown when a pessimistic locking conflict occurs.
|
| PessimisticReadSelectLockingStrategy |
A pessimistic locking strategy where a lock is obtained via a
select statements.
|
| PessimisticReadUpdateLockingStrategy |
A pessimistic locking strategy where a lock is obtained via
an update statement.
|
| PessimisticWriteSelectLockingStrategy |
A pessimistic locking strategy where a lock is obtained via a
select statement.
|
| PessimisticWriteUpdateLockingStrategy |
A pessimistic locking strategy where a lock is obtained via
an update statement.
|
| PgJdbcHelper |
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.
|
| PhysicalConnectionHandlingMode |
|
| PhysicalJdbcTransaction |
Provides access to manage "transactionality" via the JDBC Connection. |
| PhysicalNamingStrategy |
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.
|
| PhysicalNamingStrategyStandardImpl |
|
| PluralAttributeElementNature |
Describes the nature of plural attribute elements in terms of relational implications.
|
| PluralAttributeElementSource |
|
| PluralAttributeElementSourceAssociation |
|
| PluralAttributeElementSourceBasic |
Describes the source for the elements of persistent collections (plural
attributes) where the elements are basic types
|
| PluralAttributeElementSourceEmbedded |
Describes the source for the elements of persistent collections (plural
attributes) where the elements are composites/embeddables.
|
| PluralAttributeElementSourceManyToAny |
Describes the source for the elements of persistent collections (plural
attributes) where the elements are defined by Hibernate's any mapping
|
| PluralAttributeElementSourceManyToMany |
Describes the source for the elements of persistent collections (plural
attributes) where the elements are many-to-many association
|
| PluralAttributeElementSourceOneToMany |
Describes the source for the elements of persistent collections (plural
attributes) where the elements are a one-to-many association
|
| PluralAttributeIndexNature |
Describes the nature of plural attribute indexes in terms of relational implications.
|
| PluralAttributeIndexSource |
Highly abstract concept of the index of an "indexed persistent collection".
|
| PluralAttributeInfo |
Commonality between the various forms of plural attribute (collection) mappings: <bag/>, <set/>, etc.
|
| PluralAttributeInfoIdBagAdapter |
Adaptive implementation of the PluralAttributeInfo for <idbag/> mappings which
do not support all the configuration available on other collection mappings. |
| PluralAttributeInfoPrimitiveArrayAdapter |
|
| PluralAttributeKeySource |
Describes the source mapping of plural-attribute (collection) foreign-key information.
|
| PluralAttributeMapKeyManyToAnySource |
|
| PluralAttributeMapKeyManyToManySource |
Additional source information for <map-key-many-to-many/> and
<index-many-to-many/>.
|
| PluralAttributeMapKeySource |
Describes source information about the key of a persistent map.
|
| PluralAttributeMapKeySource.Nature |
|
| PluralAttributeMapKeySourceBasic |
|
| PluralAttributeMapKeySourceEmbedded |
|
| PluralAttributeMapping |
Mapping of a plural (collection-valued) attribute
|
| PluralAttributeMapping.IndexMetadata |
|
| PluralAttributeNature |
Describes the nature of the collection itself as declared by the metadata.
|
| PluralAttributePath |
Represents the collection as a DomainPath
|
| PluralAttributeSequentialIndexSource |
Defines the index of a persistent list/array
|
| PluralAttributeSource |
|
| PluralAttributeSourceArray |
|
| PluralPersistentAttribute<D,C,E> |
Hibernate extension to the JPA PluralAttribute descriptor
todo (6.0) : Create an form of plural attribute (and singular) in the API package (org.hibernate.metamodel.model.domain)
and have this extend it |
| PluralTableGroup |
|
| PojoInstantiator |
Deprecated.
|
| Polymorphism |
Deprecated.
|
| PolymorphismType |
Deprecated.
|
| PolymorphismTypeMarshalling |
|
| PooledLoOptimizer |
Variation of PooledOptimizer which interprets the incoming database
value as the lo value, rather than the hi value. |
| PooledLoThreadLocalOptimizer |
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. |
| PooledOptimizer |
Optimizer which uses a pool of values, storing the next low value of the range
in the database.
|
| PositionalSelectionsNotAllowedException |
|
| PostCollectionRecreateEvent |
An event that occurs after a collection is recreated
|
| PostCollectionRecreateEventListener |
Called after recreating a collection
|
| PostCollectionRemoveEvent |
An event that occurs after a collection is removed
|
| PostCollectionRemoveEventListener |
Called after removing a collection
|
| PostCollectionUpdateEvent |
An event that occurs after a collection is updated
|
| PostCollectionUpdateEventListener |
Called after updating a collection
|
| PostCommitDeleteEventListener |
Called after an entity delete is committed to the datastore.
|
| PostCommitInsertEventListener |
Called after an entity insert is committed to the datastore.
|
| PostCommitUpdateEventListener |
Called after an entity update is committed to the datastore.
|
| PostDeleteEvent |
Occurs after deleting an item from the datastore
|
| PostDeleteEventListener |
Called after deleting an item from the datastore
|
| PostgresPlusDialect |
An SQL dialect for Postgres Plus
|
| PostgreSQL10Dialect |
Deprecated.
|
| PostgreSQLAggregateSupport |
|
| PostgreSQLCastingInetJdbcType |
|
| PostgreSQLCastingIntervalSecondJdbcType |
|
| PostgreSQLCastingJsonJdbcType |
|
| PostgreSQLDialect |
|
| PostgreSQLDriverKind |
|
| PostgreSQLIdentityColumnSupport |
|
| PostgreSQLInetJdbcType |
|
| PostgreSQLIntervalSecondJdbcType |
|
| PostgreSQLJsonPGObjectJsonbType |
|
| PostgreSQLJsonPGObjectJsonType |
|
| PostgreSQLMinMaxFunction |
PostgreSQL doesn't support min/max for uuid yet,
but since that type is comparable we want to support this operation.
|
| PostgreSQLSequenceSupport |
|
| PostgreSQLSqlAstTranslator<T extends JdbcOperation> |
A SQL AST translator for PostgreSQL.
|
| PostgreSQLStructCastingJdbcType |
|
| PostgreSQLStructPGObjectJdbcType |
|
| PostgreSQLTruncFunction |
Custom TruncFunction for PostgreSQL which uses the dialect-specific function for numeric truncation |
| PostgreSQLTruncRoundFunction |
PostgreSQL only supports the two-argument trunc and round functions
with the following signatures:
trunc(numeric, integer)
round(numeric, integer)
|
| PostInsertEvent |
Occurs after inserting an item in the datastore
|
| PostInsertEventListener |
Called after inserting an item in the datastore
|
| PostInsertIdentifierGenerator |
|
| PostInsertIdentityPersister |
A persister that may have an identity assigned by execution of
a SQL INSERT.
|
| PostLoadEvent |
Occurs after an entity instance is fully loaded.
|
| PostLoadEventListener |
Occurs after an entity instance is fully loaded.
|
| PostUpdateEvent |
Occurs after the datastore is updated
|
| PostUpdateEventListener |
Called after updating the datastore
|
| PreCollectionRecreateEvent |
An event that occurs before a collection is recreated
|
| PreCollectionRecreateEventListener |
Called before recreating a collection
|
| PreCollectionRemoveEvent |
An event that occurs before a collection is removed
|
| PreCollectionRemoveEventListener |
Called before removing a collection
|
| PreCollectionUpdateEvent |
An event that occurs before a collection is updated
|
| PreCollectionUpdateEventListener |
Called before updating a collection
|
| PreDeleteEvent |
Represents a pre-delete event, which occurs just prior to
performing the deletion of an entity from the database.
|
| PreDeleteEventListener |
Called before deleting an item from the datastore
|
| Predicate |
Models a predicate in the SQL AST
|
| PredicateCollector |
|
| PredicateContainer |
Something that can contain predicates
|
| PreInsertEvent |
Represents a pre-insert event, which occurs just prior to
performing the insert of an entity into the database.
|
| PreInsertEventListener |
Called before inserting an item in the datastore
|
| PreLoadEvent |
Called before injecting property values into a newly loaded entity instance.
|
| PreLoadEventListener |
Called before injecting property values into a newly
loaded entity instance.
|
| PreparableMutationOperation |
MutationOperation that is capable of being handled as a
JDBC PreparedStatement
Person ( PERSON, PERSON_SUPP )
- PERSON_SUPP is optional secondary table |
| PreparedStatementDetails |
|
| PreparedStatementGroup |
|
| PreUpdateEvent |
Represents a pre-update event, which occurs just prior to
performing the update of an entity in the database.
|
| PreUpdateEventListener |
Called before updating the datastore
|
| PrimaryKey |
A mapping model object representing a primary key constraint.
|
| PrimaryKeyInformation |
Provides access to information about existing primary key for a table
|
| PrimeAmongSecondarySupertypes |
For a full explanation of the purpose of this interface see ManagedTypeHelper.
|
| PrimitiveArray |
A primitive array has a primary key consisting of the key columns + index column.
|
| PrimitiveByteArrayJavaType |
Descriptor for byte[] handling.
|
| PrimitiveCharacterArrayJavaType |
Descriptor for char[] handling.
|
| PrimitiveJavaType<J extends Serializable> |
Additional contract for primitive / primitive wrapper Java types.
|
| ProcedureCall |
Defines support for executing database stored procedures and functions.
|
| ProcedureCallImplementor<R> |
|
| ProcedureOutputs |
Specialization of the Outputs contract providing access to the stored procedure's registered
output parameters. |
| ProcedureParameter<T> |
|
| ProcedureParameterBinding<T> |
Describes an input value binding for any IN/INOUT parameters.
|
| ProcedureParameterBindingImplementor<T> |
|
| ProcedureParameterExtractionAware<T> |
Optional Type contract for implementations that are aware of how to extract values from
store procedure OUT/INOUT parameters. |
| ProcedureParameterImplementor<T> |
SPI extension for ProcedureParameter
|
| ProcedureParameterMetadataImplementor |
|
| ProcedureParameterNamedBinder<J> |
Optional Type contract for implementations enabled
to set store procedure OUT/INOUT parameters values by name. |
| Property |
|
| PropertyAccess |
Defines how a given persistent attribute is accessed by exposing
a Getter and a Setter for the attribute. |
| PropertyAccessBuildingException |
|
| PropertyAccessException |
Indicates a problem reading or writing value from/to a persistent property.
|
| PropertyAccessException |
A problem occurred accessing a property of an instance of a
persistent class by reflection, or via enhanced entities.
|
| PropertyAccessSerializationException |
|
| PropertyAccessStrategy |
Describes a strategy for accessing a persistent attribute,
for example: field, JavaBean-style property, or whatever.
|
| PropertyAccessStrategyResolver |
|
| PropertyBasedMapping |
Describes an attribute with a property access.
|
| PropertyData |
Details about an attribute as we process the boot model. |
| PropertyFactory |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| PropertyFactory.NonIdentifierAttributeNature |
|
| PropertyGeneration |
Deprecated.
|
| PropertyMapping |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| PropertyNotFoundException |
Indicates that an expected getter or setter method could not be
found on a class.
|
| PropertyPath |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| PropertySetterAccessException |
|
| PropertyValueException |
Thrown when the (illegal) value of a property can not be persisted.
|
| ProvidedInstanceManagedBeanImpl<T> |
ManagedBean implementation for cases where we have been handed an actual
instance to use. |
| ProviderChecker |
|
| Proxy |
Deprecated.
|
| ProxyConfiguration |
A proxy configuration allows the definition of an interceptor object that decides on the behavior of a proxy.
|
| ProxyConfiguration.Interceptor |
An interceptor object that is responsible for invoking a proxy's method.
|
| ProxyConfiguration.InterceptorDispatcher |
A static interceptor that guards against method calls before the interceptor is set.
|
| ProxyFactory |
Contract for runtime, proxy-based lazy initialization proxies.
|
| ProxyFactoryFactory |
|
| ProxyFactoryHelper |
Most of this code was originally an internal detail of PojoEntityTuplizer,
then extracted to make it easier for integrators to initialize a custom
ProxyFactory. |
| QualifiedName |
Models the qualified name of a database object.
|
| QualifiedNameImpl |
|
| QualifiedNameParser |
Parses a qualified name.
|
| QualifiedNameParser.NameParts |
|
| QualifiedObjectNameFormatter |
Contract for rendering qualified object names for use in queries, etc.
|
| QualifiedSequenceName |
|
| QualifiedTableName |
|
| QualifiedTypeName |
|
| QuantifiedLeastGreatestEmulation |
|
| Query<R> |
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. |
| Queryable |
Deprecated.
|
| Queryable.Declarer |
|
| QueryableCollection |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| QueryCachePutManager |
|
| QueryEngine |
Aggregation and encapsulation of the components Hibernate uses
to execute queries (HQL, Criteria and native)
|
| QueryEngineOptions |
|
| QueryException |
A problem occurred translating a Hibernate query to SQL
due to invalid query syntax, or some similar problem.
|
| QueryGroup |
|
| QueryHintHandler |
Contract defining how query hints get applied.
|
| QueryHints |
Deprecated.
|
| QueryHints |
Deprecated.
|
| QueryImplementor<R> |
|
| QueryInterpretationCache |
Cache for various parts of translating or interpreting queries.
|
| QueryInterpretationCache.Key |
|
| QueryKey |
A key that identifies a particular query with bound parameter values.
|
| QueryKey.ParameterBindingsMemento |
todo (6.0) : integrate work from original 6.0 branch
|
| QueryLiteral<T> |
Represents a literal in the SQL AST.
|
| QueryLogging |
|
| QueryOptions |
Encapsulates options for the execution of a HQL/Criteria/native query
|
| QueryOptionsAdapter |
|
| QueryParameter<T> |
Represents a parameter defined in the source (HQL/JPQL or criteria) query.
|
| QueryParameterBinding<T> |
/**
The value/type binding information for a particular query parameter.
|
| QueryParameterBindings |
Manages all the parameter bindings for a particular query.
|
| QueryParameterBindingTypeResolver |
A resolver for BindableType based on a parameter value being bound, when no explicit type information is
supplied. |
| QueryParameterBindingValidator |
|
| QueryParameterException |
Parameter invalid or not found in the query.
|
| QueryParameterImplementor<T> |
|
| QueryParameterListBinding<T> |
Represents a "parameter list" binding: aka the binding of a collection of values for a single
query parameter.
|
| QueryPart |
|
| QueryPartTableGroup |
A special table group for a sub-queries.
|
| QueryPartTableReference |
A table reference for a query part.
|
| QueryPlan |
Common contract for select and mutation query plans
|
| QueryPlanCache |
A cache for QueryPlans used (and produced) by the translation
and execution of a query. |
| QueryPlanCache.Key |
|
| QueryProducer |
|
| QueryProducerImplementor |
The internal contract for QueryProducer implementations.
|
| QueryResultsCache |
|
| QueryResultsRegion |
Defines the contract for a cache region that stores query results.
|
| QueryResultsRegionTemplate |
|
| QuerySpacesHelper |
Deprecated.
|
| QuerySpec |
|
| QueryStatistics |
Statistics relating to a particular query written in HQL or SQL.
|
| QueryTimeoutException |
Thrown when a database query timeout occurs.
|
| QueryTransformer |
|
| QueryTypeMismatchException |
Indicates a mismatch between a Query's expected and actual result types
|
| ReaderInputStream |
|
| RealJdbcType |
Deprecated.
|
| RecoverableException |
Deprecated.
|
| RefCursorSupport |
Contract for JDBC REF_CURSOR support.
|
| ReferenceCacheEntryImpl |
Specialized CacheEntry for storing direct references to entity instances.
|
| ReflectionOptimizer |
Represents reflection optimization for a particular class.
|
| ReflectionOptimizer.AccessOptimizer |
Represents optimized entity property access.
|
| ReflectionOptimizer.InstantiationOptimizer |
Represents optimized entity instantiation.
|
| RefreshContext |
|
| RefreshEvent |
Defines an event class for the refreshing of an object.
|
| RefreshEventListener |
Defines the contract for handling of refresh events generated from a session.
|
| Region |
Contract for a named cache "region".
|
| RegionFactory |
Deprecated.
|
| RegionFactory |
|
| RegionFactoryTemplate |
|
| RegionNameQualifier |
|
| RegisteredConversion |
A registered conversion.
|
| RegistryHelper |
|
| RelationalValueSource |
|
| RelationalValueSource.Nature |
|
| RelationalValueSourceContainer |
|
| Remove |
Indicates that the annotated element is planned for removal as part of a
deprecation process.
|
| RemoveCoordinator |
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
|
| RemoveCoordinatorNoOp |
|
| RemoveCoordinatorStandard |
Handles complete removal of a collection by its key
|
| RemoveCoordinatorTablePerSubclass |
|
| Replacer |
|
| ReplicateEvent |
Defines an event class for the replication of an entity.
|
| ReplicateEventListener |
Defines the contract for handling of replicate events generated from a session.
|
| ReplicationMode |
Deprecated.
|
| RepresentationMode |
Enumeration of the built-in ways that Hibernate can represent the
application's domain model.
|
| Resolution |
Used to put natural id values into collections.
|
| Resolvable |
|
| ResolveNaturalIdEvent |
Defines an event class for the resolving of an entity id from the entity's natural-id
|
| ResolveNaturalIdEventListener |
Defines the contract for handling of resolve natural id events generated from a session.
|
| ResourceClosedException |
|
| ResourceLocator |
Abstraction for locating class-path resources
|
| ResourceRegistry |
A registry for tracking JDBC resources.
|
| ResourceStreamLocator |
Abstraction for locating class-path resources
|
| Restrictable |
Things that can have Where,
and/or Filter applied to them. |
| RestrictedTableMutation<O extends MutationOperation> |
Specialized TableMutation implementation for mutations which
define a where-clause
|
| RestrictedTableMutationBuilder<O extends MutationOperation,M extends RestrictedTableMutation<O>> |
|
| Restriction |
A restriction (predicate) to be applied to a query
|
| RestrictionRenderingContext |
|
| ResultBuilder |
Responsible for building a single DomainResult instance as part of
the overall mapping of native / procedure query results. |
| ResultBuilderBasicValued |
Nominal extension to ResultBuilder for cases involving scalar results
|
| ResultBuilderEmbeddable |
|
| ResultBuilderEntityValued |
Specialization of ResultBuilder for building an EntityResult
|
| ResultBuilderInstantiationValued |
Nominal extension to ResultBuilder for cases involving dynamic-instantiation results
|
| ResultCheckStyle |
Enumerates strategies for checking JDBC return codes for custom SQL DML queries.
|
| ResultCheckStyleMarshalling |
|
| ResultColumnReferenceStrategy |
Defines how we need to reference columns in the group-by, having, and order-by
clauses.
|
| ResultContext |
|
| ResultDescriptor |
|
| ResultListTransformer<T> |
Defines some processing performed on the overall result List
of a Query before the result list is returned to the caller. |
| ResultMappingMementoNode |
Any node (result or fetch) in the result graph
|
| ResultMemento |
|
| ResultMementoBasic |
|
| ResultMementoEntity |
|
| ResultMementoInstantiation |
|
| ResultMementoInstantiation.ArgumentMemento |
|
| ResultsConsumer<T,R> |
|
| ResultSetIdentifierConsumer |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| ResultSetMapping |
|
| ResultSetMappingBindingDefinition |
|
| ResultSetMappingContainer |
|
| ResultSetMappingImpl |
|
| ResultSetMappingSqlSelection |
|
| ResultSetOutput |
Models a return that is a result set.
|
| ResultSetReturn |
Contract for extracting ResultSets from Statements, executing the statements,
managing resources, and logging statement calls. |
| ResultsHelper |
|
| ResultsLogger |
|
| ResultTransformer<T> |
Deprecated.
|
| ReturnableType<T> |
Specialization of DomainType for types that can be used as function returns
|
| ReturningWork<T> |
A discrete piece of work making use of a JDBC connection
and returning a result. |
| RootClass |
A mapping model object that represents the root class in an entity class
inheritance hierarchy. |
| RootGraph<J> |
|
| RootGraphImplementor<J> |
Integration version of the RootGraph contract
|
| RootSequencePart |
SequencePart implementation used to translate the root of a path
|
| RootTableGroupProducer |
|
| RowId |
Specifies that a rowid-like column or pseudo-column should be
used as the row locator in SQL update statements for an entity,
instead of the primary key of the table.
|
| RowIdJdbcType |
Descriptor for ROWID handling. |
| RowLockStrategy |
The strategy for rendering which row to lock with the FOR UPDATE OF clause.
|
| RowMutationOperations |
|
| RowMutationOperations.Restrictions |
|
| RowMutationOperations.Values |
|
| RowProcessingState |
State pertaining to the processing of a single "row" of a JdbcValuesSource
|
| RowReader<R> |
Coordinates the process of reading a single result values row
|
| RowReaderMemento |
|
| RowTransformer<T> |
Defines transformation of a raw row in the domain query result row.
|
| RowVersionJavaType |
Descriptor for byte[] handling specifically used for specifically for entity versions/timestamps.
|
| RuntimeMetamodels |
Entry point providing access to the runtime metamodels:
the domain model, our implementation of the
JPA-defined model
of the Java types, and
our relational mapping model of how these
types are made persistent. |
| RuntimeMetamodelsImplementor |
|
| RuntimeModelCreationContext |
|
| SaveOrUpdateEvent |
An event class for saveOrUpdate()
|
| SaveOrUpdateEventListener |
Defines the contract for handling of update events generated from a session.
|
| ScanEnvironment |
Describes the environment in which the scan will occur.
|
| Scanner |
Defines the contract for Hibernate to be able to scan for classes, packages and resources inside a
persistence unit.
|
| ScanOptions |
Options for performing scanning
|
| ScanParameters |
|
| ScanResult |
Defines the result of scanning
|
| SchemaAutoTooling |
|
| SchemaAware |
Common interface for JAXB bindings that understand database schema (tables, sequences, etc).
|
| SchemaCreator |
Service delegate for handling schema creation.
|
| SchemaDropper |
Service delegate for handling schema dropping.
|
| SchemaExtractionException |
|
| SchemaFilter |
Defines a filter for Hibernate's schema tooling.
|
| SchemaFilterProvider |
Used to specify the SchemaFilters to be used by create, drop, migrate and validate
operations on the database schema. |
| SchemaManagementException |
Indicates a problem in performing schema management.
|
| SchemaManagementTool |
Contract for schema management tool integration.
|
| SchemaManagementToolCoordinator |
Responsible for coordinating SchemaManagementTool execution(s) for auto-tooling whether
from JPA or hbm2ddl.auto.
|
| SchemaManagementToolCoordinator.ActionGrouping |
For JPA-style schema-gen, database and script target handing are configured
individually - this tuple allows interpreting the action for both targets
simultaneously
|
| SchemaManager |
|
| SchemaMigrator |
Service delegate for handling schema migration.
|
| SchemaNameResolver |
Contract for resolving the schema of a Connection. |
| SchemaNameResolver |
Contract for resolving the schema of a Connection. |
| SchemaTruncator |
Service delegate for handling schema truncation.
|
| SchemaValidator |
Service delegate for handling schema validations
|
| ScriptSourceInput |
Contract for hiding the differences between a passed Reader, File or URL in terms of how we read input
scripts.
|
| ScriptTargetOutput |
Contract for hiding the differences between a passed Writer, File or URL in
terms of how we write output scripts.
|
| ScrollableResults<R> |
A result iterator that allows moving around within the results by
arbitrary increments.
|
| ScrollableResultsConsumer<R> |
|
| ScrollableResultsImplementor<R> |
|
| ScrollMode |
|
| SearchClauseSpecification |
|
| SecondaryRow |
|
| SecondaryRows |
|
| SecondaryTableContainer |
Common interface for mappings that may contain secondary table (join) mappings.
|
| SecondaryTableSource |
|
| SecondLevelCacheLogger |
|
| SecondPass |
Hibernate builds its build-time model
incrementally, often delaying operations until other pieces of information
are available. |
| SecondPass |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| Selectable |
Models the commonality between a Column and a Formula (computed value). |
| SelectableConsumer |
Consumer used to visit selectable (column/formula) mappings
|
| SelectableConsumer.MutableSelectableMapping |
|
| SelectableMapping |
Mapping of a selectable (column/formula)
|
| SelectableMappings |
A container for multiple selectable (column, formula) mappings.
|
| SelectablePath |
The path for a selectable.
|
| SelectBeforeUpdate |
Deprecated.
|
| SelectClause |
The SELECT CLAUSE in the SQL AST.
|
| SelectGenerator |
A generator that selects the just-inserted row to determine the
column value assigned by the database.
|
| SelectInterpretationsKey |
|
| SelectionQuery<R> |
Within the context of an active session,
an instance of this type represents an executable selection query, that is,
a select. |
| SelectItemReferenceStrategy |
Strategies for referring to a select item.
|
| SelectLockingStrategy |
A locking strategy where a lock is obtained via a select statement.
|
| SelectQueryPlan<R> |
General contract for performing execution of a query returning results.
|
| SelectStatement |
|
| SelfDirtinessTracker |
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.
|
| SelfExecutingUpdateOperation |
Extension to MutationOperation for cases where the operation wants to
handle execution itself.
|
| SelfRenderingAggregateFunctionSqlAstExpression |
Representation of an aggregate function call in the SQL AST for impls that know how to
render themselves.
|
| SelfRenderingExpression |
|
| SelfRenderingFunctionSqlAstExpression |
Representation of a function call in the SQL AST for impls that know how to
render themselves.
|
| SelfRenderingOrderedSetAggregateFunctionSqlAstExpression |
Representation of an aggregate function call in the SQL AST for impls that know how to
render themselves.
|
| SelfRenderingOrderingExpression |
Represents a self rendering expression i.e.
|
| SelfRenderingPredicate |
|
| SelfRenderingSqlFragmentExpression |
Represents a self rendering expression that renders a SQL fragment.
|
| SelfRenderingSqmAggregateFunction<T> |
|
| SelfRenderingSqmFunction<T> |
|
| SelfRenderingSqmOrderedSetAggregateFunction<T> |
|
| SelfRenderingSqmWindowFunction<T> |
|
| SelfRenderingWindowFunctionSqlAstExpression |
Representation of a window function call in the SQL AST for impls that know how to
render themselves.
|
| SemanticException |
Represents an error in the semantics (meaning) of the passed query.
|
| SemanticPathPart |
|
| SemanticQueryWalker<T> |
Support for walking a Semantic Query Model (SQM) tree
|
| SemanticsResolver |
Deprecated.
|
| Sequence |
Models a database SEQUENCE.
|
| Sequence.Name |
|
| SequenceInformation |
Access to information about existing sequences.
|
| SequenceInformationExtractor |
Because JDBC (at least up to and including Java 7, JDBC 4) still does not have support for obtaining information
about sequences from DatabaseMetaData.
|
| SequenceMismatchStrategy |
Describes the strategy for handling the mismatch between a database sequence configuration and
the one defined by the entity mapping.
|
| SequencePart |
Represents an individual identifier in a dot-identifier sequence
|
| SequenceStructure |
Describes a sequence.
|
| SequenceStyleGenerator |
Generates identifier values based on a sequence-style database structure.
|
| SequenceSupport |
A set of operations providing support for sequences in a
certain SQL dialect. |
| SerializableBlobProxy |
Manages aspects of proxying Blobs to add serializability. |
| SerializableClobProxy |
Manages aspects of proxying Clobs to add serializability. |
| SerializableJavaType<T extends Serializable> |
|
| SerializableJavaType.SerializableMutabilityPlan<S extends Serializable> |
|
| SerializableMapProxy |
|
| SerializableNClobProxy |
Manages aspects of proxying java.sql.NClobs to add serializability.
|
| SerializableProxy |
|
| SerializableToBlobType<T extends Serializable> |
|
| SerializableType<T extends Serializable> |
|
| SerializationException |
Thrown when a property cannot be serialized/deserialized
|
| Service |
Marker interface for services.
|
| ServiceBinding<R extends Service> |
Models a binding for a particular service.
|
| ServiceBinding.ServiceLifecycleOwner |
|
| ServiceContributor |
Contract for contributing services.
|
| ServiceException |
Indicates a problem with a service.
|
| ServiceInitiator<R extends Service> |
Base contract for an initiator of a service.
|
| ServiceRegistry |
|
| ServiceRegistryAwareService |
Allows services to be injected with the ServiceRegistry during configuration phase. |
| ServiceRegistryImplementor |
Additional integration contracts for a service registry.
|
| Session |
The main runtime interface between a Java application and Hibernate.
|
| Session.LockRequest |
Deprecated.
|
| SessionAssociableInterceptor |
|
| SessionBuilder |
Allows creation of a new Session with specific options. |
| SessionBuilderImplementor |
Defines the internal contract between the SessionBuilder and
other parts of Hibernate. |
| SessionDelegatorBaseImpl |
A wrapper class that delegates all method invocations to a delegate instance of
SessionImplementor. |
| SessionEventListener |
Implemented by custom listeners that respond to low-level events
involving interactions between the Session and the database
or second-level cache. |
| SessionEventListenerManager |
|
| SessionException |
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). |
| SessionFactory |
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. |
| SessionFactory.TransactionManagementException |
|
| SessionFactoryBasedWrapperOptions |
|
| SessionFactoryBuilder |
|
| SessionFactoryBuilderFactory |
An extension point for integrators that wish to hook into the process of how a SessionFactory
is built.
|
| SessionFactoryBuilderImplementor |
|
| SessionFactoryBuilderService |
|
| SessionFactoryDelegatingImpl |
|
| SessionFactoryImplementor |
Defines the internal contract between the SessionFactory and the internal
implementation of Hibernate. |
| SessionFactoryImplementor.DeserializationResolver<T extends SessionFactoryImplementor> |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| SessionFactoryObserver |
|
| SessionFactoryOptions |
|
| SessionFactoryServiceContributor |
|
| SessionFactoryServiceInitiator<R extends Service> |
|
| SessionFactoryServiceInitiatorContext |
|
| SessionFactoryServiceRegistry |
|
| SessionFactoryServiceRegistryBuilder |
|
| SessionFactoryServiceRegistryFactory |
|
| SessionImplementor |
|
| SessionLazyDelegator |
This helper class allows decorating a Session instance, while the
instance itself is lazily provided via a Supplier.
|
| SessionStatistics |
Information about the first-level (session) cache for a particular
instance of Session. |
| Set |
A mapping model object representing a collection of type List. |
| SetOperator |
The SQL set operators.
|
| SetPersistentAttribute<D,E> |
|
| Setter |
The contract for setting the value of a persistent attribute on its container/owner.
|
| SetterFieldImpl |
Field-based implementation of Setter
|
| SetterMethodImpl |
|
| SetType |
|
| SharedSessionBuilder |
|
| SharedSessionContract |
|
| SharedSessionContractImplementor |
|
| SharedSessionDelegatorBaseImpl |
|
| ShortJavaType |
Descriptor for Short handling. |
| ShortPrimitiveArrayJavaType |
Descriptor for short[] handling.
|
| SimpleAuxiliaryDatabaseObject |
|
| SimpleDatabaseVersion |
Simple version of DatabaseVersion
|
| SimpleDomainType<J> |
Describes any non-collection type
|
| SimpleFromClauseAccessImpl |
Simple implementation of FromClauseAccess
|
| SimpleHqlInterpretationImpl |
|
| SimpleNaturalIdLoadAccess<T> |
Loads an entity by its natural identifier.
|
| SimpleSelect |
A SQL SELECT statement with no table joins.
|
| SimpleStrategyRegistrationImpl<T> |
A simple implementation of StrategyRegistration.
|
| SimpleTimestamper |
Generates increasing identifiers (in a single VM only).
|
| SimpleValue |
A mapping model object that represents any value that maps to columns.
|
| SimpleValueTypeInfo |
|
| SingleEntityLoader<T> |
Loader for loading a single entity by primary or unique key
|
| SingleIdEntityLoader<T> |
Loader for loading an entity by a single identifier value.
|
| SingleNamingStrategy |
|
| SingleTableEntityPersister |
|
| SingleTableSubclass |
A mapping model object that represents a subclass in a
single table
inheritance hierarchy. |
| SingleUniqueKeyEntityLoader<T> |
Loader subtype for loading an entity by a single unique-key value.
|
| SingularAttributeInfo |
|
| SingularAttributeMapping |
Mapping for a singular (non-collection) attribute.
|
| SingularAttributeNature |
Describes possible natures of a singular attribute.
|
| SingularAttributeSource |
Source-agnostic description of information needed to bind a singular attribute.
|
| SingularAttributeSourceAny |
Describes an <any/> mapping
|
| SingularAttributeSourceBasic |
|
| SingularAttributeSourceEmbedded |
Represents the binding source for a singular attribute that is "embedded"
or "composite".
|
| SingularAttributeSourceManyToOne |
|
| SingularAttributeSourceOneToOne |
|
| SingularAttributeSourceToOne |
Further contract for sources of singular associations (one-to-one and many-to-one).
|
| SingularPersistentAttribute<D,J> |
|
| Size |
Models size restrictions/requirements on a column's datatype.
|
| Size.LobMultiplier |
|
| SizeSource |
|
| SkipNullableUniqueDelegate |
A UniqueDelegate that only creates unique constraints on not-null columns, and ignores requests for
uniqueness for nullable columns. |
| SmallIntJdbcType |
|
| SoftLock |
Memento object for use by synchronous concurrency strategies
|
| Sortable |
Contact to define if the source of plural attribute is sortable or not.
|
| SortableValue |
|
| SortComparator |
|
| SortedMapType |
|
| SortedSetType |
|
| SortNatural |
|
| SortOrder |
|
| SortSpecification |
|
| Source |
Deprecated.
|
| SourceColumnAdapter |
|
| SourceColumnAdapterJaxbHbmColumnType |
|
| SourceDescriptor |
Describes a source for schema create, drop and migrate actions.
|
| SourceType |
Specifies the source of a generated value, either the virtual machine,
or the database.
|
| SourceType |
From what type of source did we obtain the data
|
| SourceType |
Enumeration of the various types of sources understood by various SchemaManagementTooling
delegates.
|
| SpannerDialect |
|
| SpannerSqlAstTranslator<T extends JdbcOperation> |
A SQL AST translator for Spanner.
|
| SpecHints |
The hints explicitly defined by the Jakarta Persistence specification
which are available for both queries and loading.
|
| SpecialOneToOneType |
A one-to-one association that maps to specific formula(s)
instead of the primary key column of the owning entity.
|
| SqlAliasBase |
A generator for new incremental SQL aliases based on a stem
|
| SqlAliasBaseConstant |
A SqlAliasBase that always returns the same constant.
|
| SqlAliasBaseGenerator |
Generator for SqlAliasBase instances based on a stem.
|
| SqlAliasBaseImpl |
Standard SqlAliasBase impl
|
| SqlAliasBaseManager |
Helper used in creating unique SQL table aliases for a SQL AST
|
| SqlAliasStemHelper |
|
| SqlAppender |
Access to appending SQL fragments to an in-flight buffer
|
| SqlArrayMultiKeyLoader |
MultiKeyLoader implementation based on a SQL ARRAY valued parameter
|
| SqlAstCreationContext |
The "context" in which creation of SQL AST occurs.
|
| SqlAstCreationState |
Access to stuff used while creating a SQL AST
|
| SqlAstHelper |
|
| SqlAstJoinType |
|
| SqlAstNode |
|
| SqlAstNodeRenderingMode |
|
| SqlAstProcessingState |
Generalized access to state information relative to the "current process" of
creating a SQL AST.
|
| SqlAstQueryPartProcessingState |
SqlAstProcessingState specialization for query parts
|
| SqlAstTranslator<T extends JdbcOperation> |
|
| SqlAstTranslatorFactory |
Factory for obtaining single-use SQL AST translators
|
| SqlAstTranslatorWithMerge<T extends JdbcOperation> |
Base for translators which support a full insert-or-update-or-delete (MERGE) command.
|
| SqlAstTranslatorWithUpsert<T extends JdbcOperation> |
Base SqlAstTranslator for translators which support an insert-or-update (UPSERT) command
|
| SqlAstTreeHelper |
|
| SqlAstTreeLogger |
Dedicated logger for rendering a SQL AST
|
| SqlAstWalker |
|
| SQLDelete |
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.
|
| SQLDeleteAll |
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.
|
| SQLDeletes |
|
| SQLExceptionConversionDelegate |
|
| SQLExceptionConverter |
|
| SqlExceptionHelper |
Helper for handling SQLExceptions in various manners.
|
| SqlExceptionHelper.StandardWarningHandler |
Standard SQLWarning handler for logging warnings
|
| SqlExceptionHelper.WarningHandler |
|
| SqlExceptionHelper.WarningHandlerLoggingSupport |
|
| SqlExecLogger |
|
| SqlExpressible |
Unifying contract for things that are capable of being an expression in
the SQL AST.
|
| SqlExpressionAccess |
|
| SqlExpressionResolver |
Resolution of a SqlSelection reference for a given SqlSelectable.
|
| SqlExpressionResolver.ColumnReferenceKey |
|
| SqlFragmentAlias |
|
| SqlFunction |
A function to pass through a SQL fragment.
|
| SQLGrammarException |
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. |
| SqlInPredicateMultiKeyLoader |
MultiKeyLoader implementation based on SQL IN predicate
|
| SQLInsert |
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.
|
| SQLInserts |
|
| SQLLoadable |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| SQLLoadableCollection |
Deprecated. |
| SqlOmittingQueryOptions |
|
| SqlResultSetMappingDescriptor |
|
| SqlResultSetMappingDescriptor.EntityResultDescriptor |
|
| SqlScriptCommandExtractor |
Contract for extracting statements from source/import/init scripts.
|
| SqlScriptException |
Indicates a problem
|
| SqlScriptLexer |
|
| SqlScriptParser |
|
| SqlScriptParser.CommandBlockContext |
|
| SqlScriptParser.CommandContext |
|
| SqlScriptParser.ScriptContext |
|
| SqlScriptParserBaseListener |
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. |
| SqlScriptParserBaseVisitor<T> |
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. |
| SqlScriptParserListener |
This interface defines a complete listener for a parse tree produced by
SqlScriptParser. |
| SqlScriptParserVisitor<T> |
This interface defines a complete generic visitor for a parse tree produced
by SqlScriptParser. |
| SQLSelect |
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.
|
| SqlSelection |
|
| SqlSelectionExpression |
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).
|
| SqlSelectionProducer |
|
| SQLServer16SequenceSupport |
|
| SQLServer2005LimitHandler |
A LimitHandler compatible with SQL Server 2005 and later
that uses top() and rownumber(). |
| SQLServer2008Dialect |
Deprecated.
|
| SQLServer2012Dialect |
Deprecated.
|
| SQLServer2012LimitHandler |
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. |
| SQLServer2016Dialect |
Deprecated.
|
| SqlServerConvertTruncFunction |
Custom TruncFunction for SQL Server versions < 16 which uses the custom SqlServerConvertTruncFunction.DateTruncConvertEmulation |
| SQLServerDialect |
A dialect for Microsoft SQL Server 2008 and above
|
| SQLServerEveryAnyEmulation |
SQL Server doesn't have a function like every() or any().
|
| SQLServerFormatEmulation |
SQL Server behaves strangely when the first argument to format is of the type time, so we cast to datetime.
|
| SQLServerIdentityColumnSupport |
|
| SQLServerSequenceSupport |
|
| SQLServerSqlAstTranslator<T extends JdbcOperation> |
A SQL AST translator for SQL Server.
|
| SqlStatementLogger |
Centralize logging for SQL statements.
|
| SQLStateType |
|
| SqlStringGenerationContext |
A context provided to methods responsible for generating SQL strings on startup.
|
| SqlTreeCreationException |
Base exception type for problems building a SQL tree.
|
| SqlTreeCreationLogger |
|
| SqlTreePrinter |
Logs a debug representation of the SQL AST.
|
| SqlTuple |
|
| SqlTuple.Builder |
|
| SqlTupleContainer |
|
| SqlTypedMapping |
Models the type of a thing that can be used as an expression in a SQL query
|
| SqlTypes |
Defines a list of constant type codes used to identify generic SQL types.
|
| SQLUpdate |
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.
|
| SQLUpdates |
|
| SqmAggregateFunction<T> |
A SQM aggregate function.
|
| SqmAliasedExpressionContainer<T extends SqmAliasedNode<?>> |
|
| SqmAliasedNode<T> |
Models any aliased expression.
|
| SqmAliasedNodeRef |
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 ref |
| SqmAny<T> |
|
| SqmAnyDiscriminatorValue<T> |
|
| SqmAnyValuedSimplePath<T> |
|
| SqmAssignment<T> |
|
| SqmAttributeJoin<O,T> |
Models a join based on a mapped attribute reference.
|
| SqmBagJoin<O,E> |
|
| SqmBasicValuedSimplePath<T> |
|
| SqmBetweenPredicate |
|
| SqmBinaryArithmetic<T> |
|
| SqmBooleanExpressionPredicate |
Represents an expression whose type is boolean, and can therefore be used as a predicate.
|
| SqmByUnit |
|
| SqmCaseSearched<R> |
|
| SqmCaseSearched.WhenFragment<R> |
|
| SqmCaseSimple<T,R> |
|
| SqmCaseSimple.WhenFragment<T,R> |
|
| SqmCastTarget<T> |
|
| SqmCoalesce<T> |
|
| SqmCollation |
|
| SqmCollectionSize |
Represents the SIZE() function.
|
| SqmComparisonPredicate |
|
| SqmCopyContext |
|
| SqmCorrelatedBagJoin<O,T> |
|
| SqmCorrelatedCrossJoin<T> |
|
| SqmCorrelatedEntityJoin<T> |
|
| SqmCorrelatedListJoin<O,T> |
|
| SqmCorrelatedMapJoin<O,K,V> |
|
| SqmCorrelatedPluralPartJoin<O,T> |
|
| SqmCorrelatedRoot<T> |
|
| SqmCorrelatedRootJoin<T> |
|
| SqmCorrelatedSetJoin<O,T> |
|
| SqmCorrelatedSingularJoin<O,T> |
|
| SqmCorrelation<O,T> |
Specialization of SqmFrom for sub-query correlations |
| SqmCreationContext |
The context in which all SQM creations occur (think SessionFactory).
|
| SqmCreationHelper |
|
| SqmCreationOptions |
Options for semantic analysis
|
| SqmCreationProcessingState |
State related to SQM creation, like SqmCreationState, but specific
to its "current processing" - which generally means specific to each statement
and sub-query |
| SqmCreationState |
Models the state pertaining to the creation of a single SQM.
|
| SqmCrossJoin<T> |
|
| SqmCteContainer |
|
| SqmCteJoin<T> |
|
| SqmCteRoot<T> |
|
| SqmCteStatement<T> |
|
| SqmCteTable<T> |
|
| SqmCteTableColumn |
|
| SqmDeleteOrUpdateStatement<T> |
In some cases it is useful to be able to handle UPDATE or DELETE SQM trees
using a single contract.
|
| SqmDeleteStatement<T> |
|
| SqmDerivedJoin<T> |
|
| SqmDerivedRoot<T> |
|
| SqmDistinct<T> |
|
| SqmDmlStatement<E> |
Common extension of SqmStatement for DML (delete, update and insert-select)
statements.
|
| SqmDurationUnit<T> |
|
| SqmDynamicInstantiation<T> |
Represents a dynamic instantiation (select new XYZ(...) ...) as part of the SQM.
|
| SqmDynamicInstantiationArgument<T> |
Represents an individual argument to a dynamic instantiation.
|
| SqmDynamicInstantiationTarget<T> |
Represents the thing-to-be-instantiated in a dynamic instantiation expression.
|
| SqmElementAggregateFunction<T> |
|
| SqmEmbeddedValuedSimplePath<T> |
|
| SqmEmptinessPredicate |
|
| SqmEntityJoin<T> |
|
| SqmEntityValuedSimplePath<T> |
|
| SqmEnumLiteral<E extends Enum<E>> |
Specialized SQM literal defined by an enum reference.
|
| SqmEvery<T> |
|
| SqmExistsPredicate |
|
| SqmExpressible<J> |
Anything in the application domain model that can be used in an
SQM query as an expression
|
| SqmExpressibleAccessor<T> |
|
| SqmExpression<T> |
The base contract for any kind of expression node in the SQM tree.
|
| SqmExpressionHelper |
|
| SqmExtractUnit<T> |
|
| SqmFieldLiteral<T> |
|
| SqmFkExpression<T> |
Reference to the key-side (as opposed to the target-side) of the
foreign-key of a to-one association.
|
| SqmFormat |
Effectively a query-literal but we want to handle it specially in the SQM to SQL AST conversion
|
| SqmFrom<O,T> |
Models a Bindable's inclusion in the FROM clause.
|
| SqmFromClause |
Contract representing a from clause.
|
| SqmFromClauseContainer |
Unified contract for things that can contain a SqmFromClause.
|
| SqmFunction<T> |
A SQM function
|
| SqmFunctionDescriptor |
A factory for SQM nodes representing invocations of a certain
named function.
|
| SqmFunctionRegistry |
|
| SqmGroupedPredicate |
|
| SqmIndexAggregateFunction<T> |
|
| SqmIndexedCollectionAccessPath<T> |
|
| SqmInListPredicate<T> |
|
| SqmInPredicate<T> |
|
| SqmInsertSelectStatement<T> |
|
| SqmInsertStatement<T> |
The general contract for INSERT statements.
|
| SqmInsertValuesStatement<T> |
|
| SqmInSubQueryPredicate<T> |
|
| SqmJoin<O,T> |
|
| SqmJoinable<O,E> |
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...
|
| SqmJoinType |
Represents a canonical join type.
|
| SqmJpaCompoundSelection<T> |
|
| SqmJpaCriteriaParameterWrapper<T> |
|
| SqmJunctionPredicate |
|
| SqmLikePredicate |
|
| SqmListJoin<O,E> |
|
| SqmLiteral<T> |
Represents a literal value in the sqm, e.g.
1
'some string'
some.JavaClass.CONSTANT
some.JavaEnum.VALUE
etc
|
| SqmLiteralEntityType<T> |
Represents an reference to an entity type as a literal.
|
| SqmLiteralNull<T> |
|
| SqmMapEntryReference<K,V> |
Represents the reference to a Map attribute's Map.Entry entries
in a select clause |
| SqmMapJoin<O,K,V> |
|
| SqmMemberOfPredicate |
|
| SqmModifiedSubQueryExpression<T> |
|
| SqmModifiedSubQueryExpression.Modifier |
|
| SqmMultiTableInsertStrategy |
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.
|
| SqmMultiTableMutationStrategy |
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.
|
| SqmMultiTableMutationStrategyProvider |
|
| SqmNamedParameter<T> |
Represents a named query parameter in the SQM tree.
|
| SqmNegatablePredicate |
Contract for predicates that have a negated form, e.g.
|
| SqmNegatedPredicate |
|
| SqmNode |
Base contract for any SQM AST node.
|
| SqmNullnessPredicate |
|
| SqmOrderByClause |
|
| SqmOrderedSetAggregateFunction<T> |
A SQM ordered set-aggregate function.
|
| SqmOver<T> |
|
| SqmOverflow<T> |
|
| SqmParameter<T> |
Models a parameter expression declared in the query.
|
| SqmParameterizedEntityType<T> |
Entity type expression based on a parameter - `TYPE( :someParam )`
|
| SqmParameterMappingModelResolutionAccess |
|
| SqmPath<T> |
Models a reference to a part of the application's domain model as part of an SQM tree.
|
| SqmPathRegistry |
Registry for SqmPath references providing the ability to access them
in multiple ways - by alias, by NavigablePath, etc
|
| SqmPathSource<J> |
Represents parts of the application's domain model that can be used
to create SqmPath nodes. |
| SqmPathWrapper<W,T> |
SqmPath specialization for an SqmPath that wraps another SqmPath
|
| SqmPluralPartJoin<O,T> |
|
| SqmPluralValuedSimplePath<E> |
An SqmPath for plural attribute paths
|
| SqmPolymorphicRootDescriptor<T> |
Acts as the EntityValuedNavigable for a "polymorphic query" grouping
|
| SqmPositionalParameter<T> |
Models a positional parameter expression
|
| SqmPredicate |
|
| SqmQualifiedJoin<O,T> |
Common contract for qualified/restricted/predicated joins.
|
| SqmQuery |
Query based on an SQM tree.
|
| SqmQuery<T> |
Commonality between a top-level statement and a sub-query
|
| SqmQueryGroup<T> |
A grouped list of queries connected through a certain set operator.
|
| SqmQueryImplementor<R> |
|
| SqmQueryPart<T> |
Defines the ordering and fetch/offset part of a query which is shared with query groups.
|
| SqmQuerySource |
Informational - used to identify the source of an SQM statement.
|
| SqmQuerySpec<T> |
Defines the commonality between a root query and a subquery.
|
| SqmRoot<E> |
|
| SqmSearchClauseSpecification |
|
| SqmSelectableNode<T> |
Defines a SQM AST node that can be used as a selection in the query,
or as an argument to a dynamic-instantiation.
|
| SqmSelectClause |
The semantic select clause.
|
| SqmSelection<T> |
Represents an individual selection within a select clause.
|
| SqmSelectionQuery<R> |
|
| SqmSelectQuery<T> |
|
| SqmSelectStatement<T> |
|
| SqmSelfRenderingExpression<T> |
|
| SqmSetClause |
|
| SqmSetJoin<O,E> |
|
| SqmSimplePath<T> |
Specialization of SqmPath for paths that are not explicitly defined
in the from-clause ( SqmFrom} |
| SqmSingularJoin<O,T> |
|
| SqmSortSpecification |
|
| SqmStar |
|
| SqmStatement<T> |
The basic SQM statement contract for top-level statements
|
| SqmStatement.ParameterResolutions |
|
| SqmSubQuery<T> |
|
| SqmSummarization<T> |
|
| SqmSummarization.Kind |
|
| SqmToDuration<T> |
|
| SqmToSqlAstConverter |
Specialized SemanticQueryWalker (SQM visitor) for producing SQL AST.
|
| SqmTranslation<T extends Statement> |
Information obtained from the interpretation of an SqmStatement
|
| SqmTranslator<T extends Statement> |
|
| SqmTranslatorFactory |
Factory for various
|
| SqmTreatedBagJoin<O,T,S extends T> |
|
| SqmTreatedCrossJoin<T,S extends T> |
|
| SqmTreatedEntityJoin<T,S extends T> |
|
| SqmTreatedListJoin<O,T,S extends T> |
|
| SqmTreatedMapJoin<O,K,V,S extends V> |
|
| SqmTreatedPath<T,S extends T> |
|
| SqmTreatedPluralPartJoin<O,T,S extends T> |
|
| SqmTreatedRoot<T,S extends T> |
|
| SqmTreatedSetJoin<O,T,S extends T> |
|
| SqmTreatedSimplePath<T,S extends T> |
|
| SqmTreatedSingularJoin<O,T,S extends T> |
|
| SqmTreeCreationLogger |
Logger used to log information about the creation of an SQM tree.
|
| SqmTreeTransformationLogger |
|
| SqmTrimSpecification |
Needed to pass TrimSpecification as an SqmExpression when we call out to
SqmFunctionTemplates handling TRIM calls as a function argument.
|
| SqmTuple<T> |
Models a tuple of values, generally defined as a series of values
wrapped in parentheses, e.g.
|
| SqmTypedNode<T> |
Optional contract for SqmNode implementations which are
typed
|
| SqmUnaryOperation<T> |
|
| SqmUpdateStatement<T> |
|
| SqmValues |
|
| SqmVisitableNode |
Optional contract for SqmNode implementations that can be visited
by a SemanticQueryWalker.
|
| SqmWhereClause |
|
| SqmWhereClauseContainer |
Unified contract for things that can contain a SqmWhereClause.
|
| SqmWindow |
|
| SqmWindowFrame |
|
| SqmWindowFunction<T> |
A SQM window function.
|
| StaleObjectStateException |
A specialized StaleStateException that carries information about
the particular entity instance that was the source of the failure. |
| StaleStateException |
Thrown when a version number or timestamp check failed, indicating that
the Session contained stale data (when using long transactions
with versioning). |
| StandardArgumentsValidators |
|
| StandardBasicTypes |
|
| StandardBasicTypeTemplate<J> |
A BasicType adapter targeting partial portability to 6.0's type
system changes.
|
| StandardCacheEntryImpl |
Standard representation of entity cached data using the "disassembled state".
|
| StandardCacheTransactionSynchronization |
|
| StandardConverters |
Standard set of setting converters.
|
| StandardEntityInstanceResolver |
|
| StandardFunctionArgumentTypeResolvers |
|
| StandardFunctionReturnTypeResolvers |
|
| StandardGenerator |
Marker interface for Hibernate-provided implementations of Generator. |
| StandardNamingStrategy |
|
| StandardOptimizerDescriptor |
Enumeration of the standard Hibernate id generation optimizers.
|
| StandardProperty |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| StandardRandomStrategy |
Implements a "random" UUID generation strategy as defined by the UUID.randomUUID() method. |
| StandardServiceInitiator<R extends Service> |
Contract for an initiator of services that target the standard ServiceRegistry. |
| StandardServiceInitiators |
Central definition of the standard set of service initiators defined by Hibernate.
|
| StandardServiceRegistry |
|
| StandardServiceRegistryBuilder |
|
| StandardSqlAstTranslator<T extends JdbcOperation> |
The final phase of query translation.
|
| StandardSqlAstTranslatorFactory |
Standard implementation of SqlAstTranslatorFactory
|
| StandardSQLFunction |
|
| StandardSqmTranslation<T extends Statement> |
|
| StandardSqmTranslatorFactory |
Standard implementation of the SqmTranslatorFactory
|
| StandardTableGroup |
|
| StandardTemporaryTableExporter |
|
| StandardVirtualTableGroup |
|
| Star |
|
| Startable |
Lifecycle contract for services which wish to be notified when it is time to start.
|
| StatelessSession |
A command-oriented API often used for performing bulk operations against
the database.
|
| StatelessSessionBuilder |
|
| Statement |
Base contract for any statement
|
| StatementCreatorHelper |
Helper for creating JDBC statements.
|
| StatementInspector |
Implementors may inspect and even process each SQL command issued
by a session, before a JDBC
statement is prepared. |
| StatementOptions |
Options for the creation of a JDBC statement
|
| StatementPreparer |
|
| StaticUserTypeSupport<T> |
|
| Statistics |
Exposes statistics collected from all sessions belonging to a
particular SessionFactory. |
| StatisticsFactory |
|
| StatisticsImplementor |
A service SPI for collecting statistics about various events that occur at runtime.
|
| Status |
Represents the status of an entity with respect to
this session.
|
| Stoppable |
Lifecycle contract for services which wish to be notified when it is time to stop.
|
| StorageAccess |
A general read/write abstraction over the specific "cache" object from the caching provider.
|
| StrategyCreator<T> |
|
| StrategyRegistration<T> |
Describes the registration of a named strategy implementation.
|
| StrategyRegistrationProvider |
Responsible for providing the registrations of one or more strategy selectors.
|
| StrategyRegistrationProviderList |
|
| StrategySelectionException |
Indicates a problem performing the selection/resolution.
|
| StrategySelector |
Service which acts as a registry for named strategy implementations.
|
| StrictJpaComplianceViolation |
Indicates violations of strict JPQL syntax while strict JPQL syntax checking was enabled.
|
| StrictJpaComplianceViolation.Type |
|
| StringBuilderSqlAppender |
Access to appending SQL fragments to a StringBuilder
|
| StringJavaType |
Descriptor for String handling. |
| Struct |
Specifies the UDT (user defined type) name for the annotated embeddable or embedded.
|
| StructHelper |
|
| StructJdbcType |
|
| StructuredCacheEntry |
Structured CacheEntry format for entities.
|
| StructuredCollectionCacheEntry |
|
| StructuredMapCacheEntry |
Structured CacheEntry format for persistent Maps.
|
| Subclass |
A mapping model object that represents a subclass in an entity class
inheritance hierarchy. |
| SubclassEntitySource |
|
| SubEntityInfo |
Common interface for all sub-entity mappings.
|
| SubGraph<J> |
Hibernate extension to the JPA entity-graph Subgraph contract.
|
| SubGraphImplementor<J> |
Integration version of the SubGraph contract
|
| Subselect |
Maps an immutable and read-only entity to a given SQL select expression.
|
| SubselectFetch |
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
|
| SubselectFetch.RegistrationHandler |
|
| SubselectFetch.StandardRegistrationHandler |
|
| Summarization |
|
| Summarization.Kind |
|
| SybaseASEDialect |
A SQL dialect for Sybase Adaptive Server Enterprise 16 and above. |
| SybaseASESqlAstTranslator<T extends JdbcOperation> |
A SQL AST translator for Sybase ASE.
|
| SybaseDialect |
Superclass for all Sybase dialects.
|
| SybaseDriverKind |
|
| SybaseJConnGetGeneratedKeysDelegate |
Specialized IdentifierGeneratingInsert which appends the database
specific clause which signifies to return generated IDENTITY values
to the end of the insert statement. |
| SybaseJconnIdentityColumnSupport |
|
| SybaseSqlAstTranslator<T extends JdbcOperation> |
A SQL AST translator for Sybase.
|
| SybaseSqmToSqlAstConverter<T extends Statement> |
A SQM to SQL AST translator for Sybase ASE.
|
| SybaseTruncFunction |
Custom TruncFunction for Sybase which uses a dialect-specific emulation function for datetimes |
| SynchronizationRegistry |
|
| SynchronizationRegistryImplementor |
|
| Synchronize |
Specifies a table or tables that hold state mapped by the annotated
entity or collection.
|
| SynchronizeableQuery |
Represents the abstract notion of a query whose results are affected by the data stored
in a given set of named query spaces.
|
| SyntheticProperty |
Models a property which does not actually exist in the model.
|
| Table |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| Table |
A mapping model object representing a relational database table. |
| Table.ForeignKeyKey |
|
| TableAliasResolver |
|
| TableDelete |
Models an update to a model (entity or collection) table,
triggered from flush
|
| TableDeleteBuilder |
|
| TableDeleteBuilderSkipped |
|
| TableDeleteBuilderStandard |
Standard TableDeleteBuilder implementation used when Hibernate
generates the delete statement
|
| TableDetails |
Details about a table
|
| TableDetails.KeyColumn |
Details about a column within the key group
|
| TableDetails.KeyColumnConsumer |
|
| TableDetails.KeyDetails |
Details about the primary key of a table
|
| TableGenerator |
An enhanced version of table-based id generation.
|
| TableGroup |
Group together TableReference references related to a single entity or
collection, along with joins to other TableGroups |
| TableGroupImpl |
A TableGroup created with regards to a SQL ResultSet mapping
|
| TableGroupJoin |
|
| TableGroupJoinProducer |
|
| TableGroupProducer |
Marker interface for anything which produces a TableGroup
|
| TableInclusionChecker |
Used to check if a table should be included in the current execution
|
| TableInformation |
Provides access to information about existing tables in the database
|
| TableInformationContainer |
Common interface for all mappings that contain relational table information
|
| TableInsert |
Models an insert into a model (entity or collection) table,
triggered from flush
|
| TableInsertBuilder |
|
| TableInsertBuilderStandard |
Standard TableInsertBuilder
|
| TableInsertReturningBuilder |
|
| TableJoin |
|
| TableMapping |
Describes a table as far as Hibernate understands it from mapping details
|
| TableMapping.MutationDetails |
|
| TableMutation<O extends MutationOperation> |
Describes the mutation of a model table (mapped by an entity or collection)
triggered from flush.
|
| TableMutationBuilder<M extends TableMutation<?>> |
|
| TableOwner |
|
| TableReference |
Represents a reference to a table (derived or physical) in a query's from clause.
|
| TableReferenceJoin |
Represents a join to a TableReference; roughly equivalent to a SQL join. |
| TableReferenceJoinPredicateProducer |
|
| Tables |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| TableSource |
Contract describing source of table information
|
| TableSpecificationSource |
Contract describing source of "table specification" information.
|
| TableStructure |
Describes a table used to mimic sequence behavior
|
| TableUpdate<O extends MutationOperation> |
Models an update to a model (entity or collection) table,
triggered from flush
|
| TableUpdateBuilder<O extends MutationOperation> |
|
| TableUpdateBuilderSkipped |
|
| TableUpdateBuilderStandard<O extends MutationOperation> |
Standard TableUpdateBuilder implementation
|
| Target |
Deprecated.
|
| TargetColumnAdapterJaxbColumn |
|
| TargetColumnAdapterJaxbJoinColumn |
|
| TargetDescriptor |
Describes the target(s) of schema create, drop and migrate actions.
|
| TargetType |
Describes the allowable targets (SPI wise) for schema management actions.
|
| Template |
Parses SQL fragments specified in mapping documents.
|
| TemplatedViolatedConstraintNameExtractor |
Extracts a violated database constraint name from an error message
by matching the error message against a template.
|
| TemporalJavaType<T> |
Specialized JavaType for temporal types.
|
| TemporalTypeMarshalling |
|
| TemporalUnit |
A temporal field type which can occur as an argument
to extract() or as the unit of a duration
expression.
|
| TemporaryTable |
|
| TemporaryTableColumn |
A column in a IdTable.
|
| TemporaryTableExporter |
An exporter for temporary tables.
|
| TemporaryTableHelper |
|
| TemporaryTableHelper.TemporaryTableCreationWork |
|
| TemporaryTableHelper.TemporaryTableDropWork |
|
| TemporaryTableKind |
Classifies the kinds of temporary table implementations.
|
| TemporaryTableSessionUidColumn |
|
| TempTableDdlTransactionHandling |
Enum describing how creation and dropping of temporary tables should be done in terms of
transaction handling.
|
| TenantId |
Identifies a field of an entity that holds a tenant id
in discriminator-based multitenancy.
|
| TenantIdentifierMismatchException |
|
| TiDBDialect |
|
| TiDBSequenceSupport |
|
| TiDBSqlAstTranslator<T extends JdbcOperation> |
A SQL AST translator for TiDB.
|
| TimeAsTimestampWithTimeZoneJdbcType |
|
| TimeJdbcType |
Descriptor for TIME handling. |
| TimestampaddFunction |
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. |
| TimestampdiffFunction |
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. |
| TimestampGenerators |
Deprecated.
|
| TimestampJdbcType |
|
| TimestampsCache |
Tracks invalidation of "query spaces" (tables) for the purpose of
determining if a cached query result set is stale.
|
| TimestampsCacheFactory |
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"). |
| TimestampsRegion |
Defines the contract for a cache region that stores timestamps.
|
| TimestampsRegionTemplate |
|
| TimestampUtcAsInstantJdbcType |
|
| TimestampUtcAsJdbcTimestampJdbcType |
|
| TimestampUtcAsOffsetDateTimeJdbcType |
|
| TimestampWithTimeZoneJdbcType |
|
| TimeUtcAsJdbcTimeJdbcType |
|
| TimeUtcAsOffsetTimeJdbcType |
|
| TimeWithTimeZoneJdbcType |
|
| TimeZoneColumn |
|
| TimeZoneJavaType |
|
| TimeZoneJavaType.TimeZoneComparator |
|
| TimeZoneStorage |
Specifies how the time zone information of a persistent property or field should be persisted.
|
| TimeZoneStorageStrategy |
Enumerates the possible storage strategies for offset or zoned datetimes.
|
| TimeZoneStorageType |
|
| TimeZoneSupport |
Describes the extent to which a given database supports the SQL
with time zone types.
|
| TinyIntAsSmallIntJdbcType |
|
| TinyIntJdbcType |
|
| ToListResultTransformer |
Deprecated.
|
| ToolingHint |
|
| ToolingHintContainer |
Contract for JAXB bindings which are containers of tooling hints.
|
| ToolingHintContext |
Represents a collection of "tooling hints" (<meta/> mapping info) keyed by a name.
|
| ToolingHintContextContainer |
|
| TooManyRowsAffectedException |
Indicates that more rows were affected then we were expecting to be.
|
| ToOne |
A mapping model object representing an association where the target side has cardinality one.
|
| ToOneAttribute |
|
| TopLimitHandler |
A LimitHandler for Transact SQL and similar
databases which support the syntax SELECT TOP n. |
| Transaction |
Represents a resource-local transaction, where resource-local is interpreted
by Hibernate to mean any transaction under the control of Hibernate.
|
| TransactionCoordinator |
Models the coordination of all transaction related flows.
|
| TransactionCoordinator.TransactionDriver |
Provides the means for resource-local transactions (as transaction drivers) to control the
underlying "physical transaction" currently associated with the TransactionCoordinator.
|
| TransactionCoordinatorBuilder |
|
| TransactionCoordinatorBuilder.Options |
|
| TransactionCoordinatorOwner |
|
| TransactionException |
Indicates that a transaction could not be begun, committed
or rolled back.
|
| TransactionImplementor |
Defines the "internal contract" for an implementation of Transaction. |
| TransactionObserver |
Deprecated.
|
| TransactionObserver |
Observer of internal transaction events.
|
| TransactionRequiredForJoinException |
|
| TransactionStatus |
Enumeration of statuses in which a transaction facade ( Transaction) might be. |
| TransactSQLStrFunction |
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. |
| Transformers |
Deprecated.
|
| TransientObjectException |
Thrown when the user passes a transient instance to a Session
method that expects a persistent instance. |
| TransientPropertyValueException |
Thrown when a property cannot be persisted because it is an association
with a transient unsaved entity instance.
|
| TranslationContext |
Access to information needed while translating a collection's order-by fragment
|
| TreatedNavigablePath |
An implementation of NavigablePath with special handling for treated paths. |
| TrimFunction |
|
| TrimSpec |
|
| TrimSpecification |
|
| TrueFalseConverter |
Handles conversion to/from Boolean as 'T' or 'F'
|
| TruncFunction |
Custom function that manages both numeric and datetime truncation
|
| TruncFunction.DatetimeTrunc |
|
| TruncFunction.TruncArgumentsValidator |
|
| TruthValue |
An enumeration of truth values.
|
| TupleResult<T> |
|
| TupleResultAssembler<J> |
|
| TupleTransformer<T> |
Defines some transformation applied to each result of a Query
before the results are packaged as a List and returned to the caller. |
| TupleType<J> |
Describes any structural type without a direct java type representation.
|
| Tuplizer |
Deprecated.
|
| Type |
Specifies a custom UserType for the annotated attribute mapping. |
| Type |
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. |
| TypeBeanInstanceProducer |
|
| TypeBinder<A extends Annotation> |
Allows a user-written annotation to drive some customized model binding.
|
| TypeBinderType |
Associates a user-defined annotation with a TypeBinder,
allowing the annotation to drive some custom model binding. |
| TypeBootstrapContext |
Provide a way to customize the Type instantiation process. |
| TypeConfiguration |
Each instance defines a set of types available in a given
persistence unit, and isolates them from other configurations. |
| TypeConfigurationAware |
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. |
| TypeContainer |
|
| TypeContributions |
|
| TypeContributor |
|
| TypeContributorList |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| TypeDef |
Deprecated.
|
| TypeDefinition |
Models the information pertaining to a custom type definition supplied by the user.
|
| TypeDefinitionRegistry |
|
| TypeDefinitionRegistry.DuplicationStrategy |
|
| TypeDefinitionRegistryStandardImpl |
|
| TypedParameterValue<J> |
Can be used to bind query parameter values.
|
| TypedTupleTransformer<T> |
Extension to TupleTransformer exposing the transformation target type.
|
| TypedValue |
An ordered pair of a value and its Hibernate type.
|
| TypeHelper |
Certain operations for working with arrays of property values.
|
| TypeInfo |
|
| TypeMismatchException |
Used when a user provided type does not match the expected one.
|
| TypeNullability |
Describes the intrinsic nullability of a data type as reported by the JDBC driver.
|
| TypeRegistration |
Registers a custom user type implementation
to be used by default for all references to a particular class of
basic type. |
| TypeRegistrations |
|
| TypeSearchability |
Describes the searchability of a data type as reported by the JDBC driver.
|
| UnaryArithmeticOperator |
|
| UnaryOperation |
|
| UnfetchedBasicPartResultAssembler<J> |
|
| UnfetchedResultAssembler<J> |
|
| UnionSubclass |
|
| UnionSubclassEntityPersister |
|
| UnionTableGroup |
|
| UnionTableReference |
|
| UniqueConstraintSchemaUpdateStrategy |
Unique columns and unique keys both use unique constraints in most dialects.
|
| UniqueDelegate |
Dialect-level delegate responsible for applying unique constraints in DDL.
|
| UniqueKey |
A mapping model object representing a unique key
constraint on a relational database table. |
| UniqueKeyLoadable |
Deprecated.
|
| UniqueKeySelectingDelegate |
Uses a unique key of the inserted entity to locate the newly inserted row.
|
| UnknownAccessTypeException |
Indicates that an unknown AccessType external name was encountered
or that an AccessType was requested that the underlying cache provider
does not support.
|
| UnknownBasicJavaType<T> |
|
| UnknownEntityException |
Indicates we were not able to resolve a given "path structure" as an entity name.
|
| UnknownEntityTypeException |
Indicates an attempt was made to refer to an unknown entity name or class.
|
| UnknownNamedQueryException |
Indicates a request for a named-query when no query is
registered under that name
|
| UnknownParameterException |
Indicates an attempt to access the parameter for an unknown column
|
| UnknownParameterException |
Indicates an attempt to find an unknown query parameter or an attempt to
bind a value to an unknown query parameter
|
| UnknownPathException |
todo (6.0) : account for this in the "exception conversion" handling
|
| UnknownPersisterException |
Indicates that the persister to use is not known and could not be determined.
|
| UnknownProfileException |
Used to indicate a request against an unknown profile name.
|
| UnknownServiceException |
Indicates that an unknown service was requested from the registry.
|
| UnknownSqlResultSetMappingException |
Indicates a request for named ResultSet mapping which could not be found
|
| UnknownTableReferenceException |
|
| UnknownUnwrapTypeException |
|
| UnloadedClass |
|
| UnloadedField |
|
| UnresolvableObjectException |
Thrown when Hibernate could not resolve an object by id, especially when
loading an association.
|
| UnsavedValueStrategy |
The base contract for determining transient status versus detached status.
|
| UnstructuredCacheEntry |
Unstructured CacheEntry format (used to store entities and collections).
|
| UnsupportedFeatureHandling |
How to handle features in the transformed `hbm.xml` which are not supported
in the `mapping.xml` XSD
|
| UnsupportedLockAttemptException |
This exception is thrown when an invalid LockMode is selected for an entity. |
| UnsupportedMappingException |
|
| UnsupportedOrmXsdVersionException |
Specialized exception indicating that an unsupported orm.xml XSD version was specified
|
| Update |
A SQL UPDATE statement.
|
| UpdateCoordinator |
Coordinates the updating of an entity.
|
| UpdateCoordinatorNoOp |
|
| UpdateCoordinatorStandard |
Coordinates the updating of an entity.
|
| UpdateCoordinatorStandard.DirtinessChecker |
|
| UpdateCoordinatorStandard.InclusionChecker |
|
| UpdateCountOutput |
Models a return that is an update count (count of rows affected)
|
| UpdateLockingStrategy |
A locking strategy where a lock is obtained via an update statement.
|
| UpdateRowsCoordinator |
|
| UpdateRowsCoordinatorNoOp |
|
| UpdateRowsCoordinatorOneToMany |
|
| UpdateRowsCoordinatorStandard |
UpdateRowsCoordinator implementation for cases with a separate collection table
|
| UpdateRowsCoordinatorTablePerSubclass |
|
| UpdateStatement |
|
| UpdateStatement.UpdateStatementBuilder |
|
| UpdateTimestamp |
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.
|
| UpdateTimestampGeneration |
Deprecated.
|
| UpdateValuesAnalysis |
Contains an aggregated analysis of the values for an update mutation
to determine behavior such as skipping tables which contained no changes,
etc.
|
| UpsertOperation |
JdbcMutation implementation for UPSERT handling
|
| UrlJavaType |
Descriptor for URL handling. |
| UserCollectionType |
|
| UserDefinedType |
A mapping model object representing a relational database UDT. |
| UserType<J> |
This interface should be implemented by user-defined custom types
that extend the set of types
defined in org.hibernate.type. |
| UserTypeLegacyBridge |
Convenience UserType implementation which mimics the legacy @Type
annotation which was based on the hbm.xml mapping's string-based type support. |
| UserTypeSupport<T> |
|
| UserVersionType<T> |
A user type that may be used for a version property
|
| UUIDGenerationStrategy |
Deprecated.
|
| UuidGenerator |
Specifies that an entity identifier is generated as an RFC 4122 UUID.
|
| UuidGenerator |
|
| UUIDGenerator |
Deprecated.
|
| UuidGenerator.Style |
|
| UUIDHexGenerator |
Deprecated.
|
| UUIDJavaType |
Descriptor for UUID handling. |
| UUIDJavaType.NoDashesStringTransformer |
|
| UUIDJavaType.PassThroughTransformer |
|
| UUIDJavaType.ToBytesTransformer |
|
| UUIDJavaType.ToStringTransformer |
|
| UUIDJavaType.ValueTransformer |
|
| UUIDJdbcType |
Specialized type mapping for UUID and the UUID SQL data type. |
| ValidationMode |
Duplicates the jakarta.validation enum (because javax validation might not be on the runtime classpath)
|
| Value |
A mapping model object which represents something that's persisted "by value",
instead of "by reference", that is, anything with no primary key.
|
| ValueAccess |
Provides access to the values for a managed type (currently just embeddables).
|
| ValueBinder<X> |
|
| ValueBindJpaCriteriaParameter<T> |
It is a JpaCriteriaParameter created from a value when ValueHandlingMode is equal to BIND
|
| ValueClassification |
At the end of the day, any "value mapping" (id, version, attribute, collection element, etc.)
can be one of a few classifications.
|
| ValuedModelPart |
Describes a ModelPart that is also a ValueMapping (and therefore also a SelectableMappings).
|
| ValueExtractor<X> |
|
| ValueGeneration |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| ValueGenerationType |
|
| ValueGenerator<T> |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| ValueHandlingMode |
This enum defines how values passed to JPA Criteria API are handled.
|
| ValueInclusion |
An enum of the different ways a value might be "included".
|
| ValueMapping |
Describes a mapping related to any part of the app's domain model,
for example, an attribute, an entity identifier, collection elements, etc.
|
| Values |
|
| ValuesAnalysis |
Marker interface for analysis of new/old values.
|
| ValuesTableGroup |
A special table group for a VALUES clause.
|
| ValuesTableReference |
|
| ValueVisitor |
|
| VarbinaryJdbcType |
|
| VarcharJdbcType |
|
| VarcharUUIDJdbcType |
Specialized type mapping for UUID and the UUID SQL data type,
which binds and reads the UUID through JDBC getString/ setString methods. |
| Version |
Information about the version of Hibernate.
|
| VersionAttributeSource |
|
| VersionJavaType<T> |
Additional contract for types which may be used to version (and optimistic lock) data.
|
| VersionProperty |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| VersionValue |
A strategy for determining if a version value is a version of
a new transient instance or a previously persistent transient instance.
|
| ViolatedConstraintNameExtractor |
An object that can extract the name of a violated database constraint
from a SQLException that results from the constraint violation. |
| VirtualModelPart |
Marker interface for parts of the application domain model that do not actually
exist in the model classes.
|
| VirtualTableGroup |
Marker interface for TableGroup impls that are virtual - should not be rendered
into the SQL.
|
| VmValueGeneration |
Deprecated.
|
| Where |
Specifies a restriction written in native SQL to add to the generated
SQL for entities or collections.
|
| WhereJoinTable |
Specifies a restriction written in native SQL to add to the generated SQL
when querying the join table
of a collection. |
| WhereRestrictable |
Things which can have Where
declarations - entities and collections |
| WindowFunctionExpression |
Models a window function expression at the SQL AST level.
|
| Work |
|
| WorkExecutor<T> |
A visitor used for executing a discrete piece of work encapsulated in a
Work or ReturningWork instance. |
| WorkExecutorVisitable<T> |
This interface provides a way to execute unrelated "work" objects using
polymorphism.
|
| Wrapped |
Optional contract for services that wrap stuff that to which it is useful to have access.
|
| WrappedBlob |
Contract for Blob wrappers. |
| WrappedClob |
Contract for Clob wrappers. |
| WrappedNClob |
Contract for NClob wrappers. |
| WrapperArrayHandling |
Possible options for how to handle Byte[] and Character[] basic mappings
encountered in the application domain model.
|
| WrapperOptions |
|
| WrongClassException |
Thrown when loading an entity (by identifier) results in a value that
cannot be treated as the subclass type requested by the caller.
|
| XmlAsStringJdbcType |
Specialized type mapping for SQLXML and the XML SQL data type.
|
| XmlHelper |
|
| XmlJdbcType |
Specialized type mapping for SQLXML and the XML SQL data type. |
| XmlJdbcType.XmlValueBinder<X> |
|
| XmlMappingBinderAccess |
Holds the XML binder and a classloader used for binding mappings.
|
| XmlSource |
An XML document containing O/R mapping metadata, either:
a JPA orm.xml file, or
a Hibernate .hbm.xml file.
|
| XsdDescriptor |
Representation of a locally resolved XSD
|
| YearJavaType |
Describes the Year Java type |
| YesNoConverter |
Handles conversion to/from Boolean as 'Y' or 'N'
|
| ZonedDateTimeJavaType |
|
| ZoneIdJavaType |
Describes the ZoneId Java type. |
| ZoneOffsetJavaType |
|
| ZoneOffsetJavaType.ZoneOffsetComparator |
|