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 |
|
| AbstractAttributeKey |
|
| AbstractAuxiliaryDatabaseObject |
|
| AbstractBagSemantics<E> |
|
| AbstractCachedDomainDataAccess |
|
| AbstractCacheTransactionSynchronization |
|
| AbstractCdiBeanContainer |
|
| AbstractClassJavaType<T> |
Abstract adapter for Java type descriptors.
|
| AbstractCollectionDataAccess |
|
| AbstractCollectionEvent |
Defines a base class for events involving collections.
|
| AbstractCollectionPersister |
Base implementation of the QueryableCollection interface.
|
| AbstractColumnReferenceQualifier |
|
| AbstractCommonQueryContract |
|
| AbstractCompositionAttribute |
A base class for a composite, non-identifier attribute.
|
| AbstractCurrentSessionContext |
|
| AbstractDataSourceBasedMultiTenantConnectionProviderImpl |
|
| AbstractDelegatingMetadata |
|
| AbstractDelegatingMetadataBuilderImplementor<T extends MetadataBuilderImplementor> |
|
| AbstractDelegatingMetadataBuildingOptions |
|
| AbstractDelegatingSessionBuilder<T extends SessionBuilder> |
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<T extends SessionBuilderImplementor> |
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 |
Convenience base class for custom implementors of SessionFactoryOptions, using delegation
|
| AbstractDelegatingSharedSessionBuilder<T extends SharedSessionBuilder> |
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 |
|
| AbstractEntityDataAccess |
|
| AbstractEntityInitializer |
|
| AbstractEntityPersister |
Basic functionality for persisting an entity via JDBC
through 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> |
|
| AbstractJdbcOperation |
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 |
|
| AbstractMutationHandler |
|
| AbstractMutationStatement |
|
| AbstractNamedQueryBuilder<T extends AbstractNamedQueryBuilder<T>> |
|
| AbstractNamedQueryDefinition |
|
| AbstractNamedQueryMemento |
|
| AbstractNamedQueryMemento.AbstractBuilder<T extends AbstractNamedQueryMemento.AbstractBuilder> |
|
| AbstractNaturalIdDataAccess |
|
| AbstractNegatableSqmPredicate |
|
| AbstractNonIdentifierAttribute |
|
| 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> |
NOTE: Consider this contract (and its sub-contracts) as incubating as we transition to 6.0 and SQM
|
| 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> |
|
| AbstractPostInsertGenerator |
|
| AbstractPreDatabaseOperationEvent |
Represents an operation we are about to perform against the database.
|
| AbstractPredicate |
|
| AbstractPropertyHolder |
No idea.
|
| AbstractPropertyMapping |
|
| 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 |
|
| 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 |
|
| AbstractSqmRestrictedDmlStatement<T> |
|
| AbstractSqmSelectQuery<T> |
|
| AbstractSqmSelfRenderingFunctionDescriptor |
|
| AbstractSqmSimplePath<T> |
|
| AbstractSqmSpecificPluralPartPath<T> |
|
| AbstractSqmStatement<T> |
|
| AbstractStandardBasicType<T> |
Convenience base class for BasicType implementations |
| AbstractStatement |
|
| AbstractTableGroup |
|
| AbstractTableReference |
|
| AbstractTemporalJavaType<T> |
|
| AbstractTransactSQLDialect |
An abstract base class for Sybase and MS SQL Server dialects.
|
| AbstractTransactSQLIdentityColumnSupport |
|
| AbstractType |
Abstract superclass of the built in Type hierarchy.
|
| AbstractUUIDGenerator |
The base class for identifier generators that use a UUID algorithm.
|
| AbstractWork |
An abstract implementation of Work that accepts a WorkExecutor
visitor for executing a discrete piece of work. |
| AccessCallback |
|
| AccessedDataClassification |
|
| AccessType |
The types of access strategies available.
|
| AccessType |
Enum defining different access strategies for accessing entity values.
|
| AccessTypeMarshalling |
|
| Action |
The allowable actions in terms of schema tooling.
|
| 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.
|
| AdjustableBasicType<J> |
Extension contract for BasicType implementations that understand how to
adjust themselves relative to where/how they are used (e.g.
|
| AdjustableJdbcType |
Extension contract for JdbcType implementations that understand how to
adjust themselves relative to where/how they are used (e.g.
|
| AfterLoadAction |
|
| AfterTransactionCompletionProcess |
Contract representing some process that needs to occur during after transaction completion.
|
| AggregateFunctionChecker |
A simple walker that checks for aggregate functions.
|
| AggregateFunctionExpression |
Models an aggregate function expression at the SQL AST level.
|
| 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.
|
| AliasGenerator |
TODO : javadoc
|
| AliasResolver |
|
| AliasToBeanConstructorResultTransformer<T> |
Wraps the tuples in a constructor call.
|
| AliasToBeanResultTransformer<T> |
Result transformer that allows to transform a result to
a user specified class which will be populated via setter
methods or fields matching the alias names.
|
| AliasToEntityMapResultTransformer |
ResultTransformer implementation which builds a map for each "row",
made up of each aliased value where the alias is the map key. |
| AnnotatedClassType |
Type of annotation of a class will give its type
|
| AnnotatedColumn |
Wrap state of an EJB3 @Column annotation
and build the Hibernate column mapping element
|
| AnnotatedDiscriminatorColumn |
Discriminator column
|
| AnnotatedJoinColumn |
Wrap state of an EJB3 @JoinColumn annotation
and build the Hibernate column mapping element
|
| AnnotationBinder |
JSR 175 annotation binder which reads the annotations from classes, applies the
principles of the EJB3 spec and produces the Hibernate configuration-time metamodel
(the classes in the org.hibernate.mapping package) |
| AnnotationException |
An exception that occurs while reading mapping annotations.
|
| AnnotationValueGeneration<A extends Annotation> |
|
| 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 discriminated to-one style association pointing to one of several entity types
depending on a local discriminator, as opposed to discriminated inheritance where the
discriminator is kept as part of the entity hierarchy (see Inheritance
and InheritanceType.SINGLE_TABLE for details about discriminated
inheritance mappings). |
| Any |
Boot-time descriptor of a polymorphic association to one-of-several tables.
|
| Any |
|
| Any.KeyValue |
|
| Any.MetaValue |
|
| AnyDiscriminator |
Simplified form for describing the discriminator value mapping as a discrete
set.
|
| AnyDiscriminatorSource |
Source information about the discriminator for an ANY mapping
|
| AnyDiscriminatorValue |
Specifies the mapping for a single any-valued discriminator value
to the corresponding entity
|
| AnyDiscriminatorValues |
Grouping of AnyDiscriminatorValue
|
| 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 |
Contract for visiting an archive, which might be a jar, a zip, 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 a 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.
|
| ArrayBinder |
Bind an Array
|
| 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 |
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 |
Contract for attributes
|
| AttributeAccessor |
|
| AttributeAccessorBinder |
|
| 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 |
Defines an additional contract for PersistentClass/Join in terms of being able to
contain attributes (Property).
|
| AttributeConversionInfo |
|
| AttributeConverterDefinitionCollector |
|
| AttributeConverterInfo |
Delayed information about an AttributeConverter.
|
| AttributeConverterMutabilityPlanImpl<T> |
The standard approach for defining a MutabilityPlan for converted (AttributeConverter)
values is to always assume that they are immutable to make sure that dirty checking,
deep copying and second-level caching all work properly no matter what.
|
| AttributeMapping |
|
| AttributeMapping |
Describes an attribute at the mapping model level.
|
| AttributeMetadata |
|
| AttributeMetadataAccess |
Provides access to details about an attribute specific to a particular
entity in the hierarchy.
|
| 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 |
Auxiliary database objects (i.e., triggers, stored procedures, etc) defined
in the mappings.
|
| AuxiliaryDatabaseObject.Expandable |
Additional, optional interface for AuxiliaryDatabaseObject 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 |
|
| Bag |
A bag permits duplicates, so it has no primary key
|
| BagBinder |
Bind a bag.
|
| BagPersistentAttribute<D,E> |
|
| BagSemantics<BE extends Collection<E>,E> |
|
| BagType |
|
| BaselineAttributeInformation |
|
| BaselineAttributeInformation.Builder |
|
| BaselineSessionEventsListenerBuilder |
|
| BaseNaturalIdLoadAccessImpl<T> |
|
| 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 Collection<T> handling.
|
| 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 identifier
|
| BasicEntityPropertyMapping |
|
| BasicExtractor<J> |
|
| BasicFetch<T> |
Fetch for a basic-value
|
| BasicJavaType<T> |
JavaType specialization for basic values
|
| BasicJdbcLiteralFormatter<T> |
|
| BasicLazyInitializer |
Lazy initializer for POJOs
|
| 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
|
| 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 |
| BasicValueBinder |
|
| BasicValueBinder.Kind |
|
| BasicValueConverter<D,R> |
Support for basic-value conversions.
|
| 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 |
Conceptually models a batch.
|
| 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.
|
| BatchLoadSizingStrategy |
Strategy (pluggable) for determining an optimal size for batch loads.
|
| BatchObserver |
An observer contract for batch events.
|
| BatchSize |
Specifies a 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 |
|
| 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.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 |
|
| BinderHelper |
|
| Binding<T> |
Represents a JAXB binding, as well as keeping information about the origin
of the processed XML
|
| 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 generally available to the process of
bootstrapping a SessionFactory that are expected to be released 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.
|
| ByteBuddyInterceptor |
|
| ByteBuddyProxyFactory |
|
| ByteBuddyProxyHelper |
|
| BytecodeEnhancementMetadata |
Encapsulates bytecode enhancement information about a particular entity.
|
| BytecodeEnhancementMetadataNonPojoImpl |
|
| BytecodeEnhancementMetadataPojoImpl |
|
| ByteCodeHelper |
A helper for reading byte code from various input sources.
|
| BytecodeInterceptorLogging |
Logging related to bytecode enhancement interceptors
|
| BytecodeLazyAttributeInterceptor |
|
| BytecodeLogging |
|
| BytecodeProvider |
Contract for providers of bytecode services to Hibernate.
|
| ByteJavaType |
Descriptor for Byte handling. |
| Cache |
Add caching strategy to a root entity or a collection.
|
| Cache |
An API for directly querying and managing the second level cache.
|
| CacheableDataStatistics |
|
| CacheAccessTypeMarshalling |
|
| CacheConcurrencyStrategy |
Cache concurrency strategy.
|
| 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.
|
| CacheEntityLoaderHelper |
|
| CacheEntityLoaderHelper.EntityStatus |
|
| CacheEntityLoaderHelper.PersistenceContextEntry |
|
| 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 |
|
| CacheMode |
Controls how the session interacts with the second-level cache and query cache.
|
| CacheModeMarshalling |
|
| CacheModeType |
Enumeration for the different interaction modes between the session and
the Level 2 Cache.
|
| 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 |
Models the caching options for an entity, natural-id or collection.
|
| 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 |
|
| CallbackRegistrar |
|
| 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.
|
| CannotForceNonNullableException |
Indicates an internal attempt to mark a column as non-nullable (because its part
of a PK, etc) but we cannot force that column to be non-nullable.
|
| Cascade |
Apply a cascade strategy on an association.
|
| CascadeStyle |
A contract for defining the aspects of cascading various persistence actions.
|
| CascadeStyles |
|
| CascadeStyles.BaseCascadeStyle |
|
| CascadeStyles.MultipleCascadeStyle |
|
| CascadeStyleSource |
Describes sources which define cascading.
|
| CascadeType |
Cascade types (can override default JPA cascades).
|
| 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.
|
| CharacterJavaType |
|
| CharacterStream |
Wraps a character stream (reader) to also provide the length (number of characters) which is needed
when binding.
|
| CharJdbcType |
Descriptor for CHAR handling. |
| Check |
Specifies a check constraint to be included in the generated DDL.
|
| 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 this metamodel, accessing the ClassLoader
is very discouraged.
|
| ClassLoaderAccessDelegateImpl |
A ClassLoaderAccess implementation based on delegation
|
| ClassLoaderAccessLazyImpl |
|
| ClassLoaderService |
A service for interacting with class loaders.
|
| ClassLoaderService.Work<T> |
|
| ClassLoadingException |
Indicates a problem performing class loading.
|
| ClassLoadingStrategyHelper |
|
| ClassMetadata |
Deprecated.
|
| ClassPropertyHolder |
|
| ClassTransformer |
A persistence provider provides an instance of this interface
to the PersistenceUnitInfo.addTransformer method.
|
| Clause |
Used to indicate which query clause we are currently processing
|
| 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 |
Mapping for a collection.
|
| CollectionAttribute |
JAXB binding interface for plural attributes
|
| CollectionBinder |
Base class for binding different types of collections to Hibernate configuration objects.
|
| 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 |
Functional contract to create a CollectionInitializer
|
| 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.
|
| CollectionNonStrictReadWriteAccess |
|
| 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.
|
| CollectionPropertyHolder |
|
| CollectionReadOnlyAccess |
|
| CollectionReadWriteAccess |
|
| CollectionResultGraphNode |
|
| CollectionSecondPass |
Collection second pass
|
| CollectionSemantics<CE,E> |
Describes the semantics of a persistent collection such that Hibernate
understands how to use it - create one, handle elements, etc.
|
| CollectionSemanticsResolver |
Resolve the collection semantics for the given mapped collection
todo (6.0) ...
|
| CollectionStatistics |
Collection-related statistics.
|
| CollectionTableGroup |
A table group for collection tables of plural attributes.
|
| 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. |
| Column |
|
| ColumnAliasExtractor |
|
| ColumnBindingDefaults |
|
| ColumnDefault |
Specifies that a column has a default value specified in DDL.
|
| ColumnDefaultsBasicImpl |
|
| ColumnInformation |
Provides access to information about existing table columns
|
| 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 |
Custom SQL expression used to read the value from and write a value to a column.
|
| ColumnTransformers |
Plural annotation for @ColumnTransformer.
|
| ColumnTypeInformation |
Provides access to information about existing table columns
|
| CommandAcceptanceException |
Indicates a problem accepting/executing a schema management command.
|
| Comment |
Specifies a comment that will be included in generated DDL.
|
| CommonFunctionFactory |
Enumeratoes common function template definitions.
|
| CommonQueryContract |
|
| ComparisonOperator |
Defines the comparison operators.
|
| ComparisonPredicate |
|
| Compatibility |
|
| CompleteFetchBuilder |
|
| CompleteFetchBuilderBasicPart |
|
| CompleteFetchBuilderEmbeddableValuedModelPart |
CompleteFetchBuilder for embeddable-valued ModelParts
|
| CompleteFetchBuilderEntityValuedModelPart |
CompleteFetchBuilder for entity-valued ModelParts
|
| 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 |
The mapping for a component, composite element,
composite identifier, etc.
|
| Component.StandardGenerationContextLocator |
|
| Component.ValueGenerationPlan |
|
| ComponentArrayComparator |
Comparator for component arrays.
|
| ComponentArrayMutabilityPlan |
Mutability plan for component based arrays.
|
| ComponentPropertyHolder |
PropertyHolder for composites (Embeddable/Embedded).
|
| ComponentType |
Handles "component" mappings
|
| CompositeElementPropertyMapping |
|
| 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 |
Contract for value types to hold collections and have cascades, etc.
|
| CompositeTypeImplementor |
|
| CompositeTypeRegistration |
Registers a custom composite user type implementation to be used
for all references to a particular Embeddable. |
| CompositeTypeRegistrations |
|
| CompositeUserType<J> |
A UserType that may be dereferenced in a query.
|
| ConcatPipeFunction |
A concat function with a pattern for clob arguments.
|
| ConfigParameterContainer |
|
| Configurable |
Deprecated.
|
| Configurable |
Allows the service to request access to the configuration properties for configuring itself.
|
| Configuration |
|
| 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 should be acquired.
|
| ConnectionObserver |
An observer of logical connection events.
|
| ConnectionObserverAdapter |
|
| ConnectionProvider |
A contract for obtaining JDBC connections and, optionally, for pooling connections.
|
| ConnectionReleaseMode |
Defines the various policies by which Hibernate might release its underlying
JDBC connection.
|
| Constraint |
A relational constraint.
|
| ConstraintModeMarshalling |
|
| ConstraintViolationException |
Implementation of JDBCException indicating that the requested DML operation
resulted in a violation of a defined integrity constraint.
|
| ConstructorEntityArgumentMode |
Describes the allowable ways in which entity references
can be handled as dynamic-instantiation (ctor result) argument.
|
| ContainedBean<B> |
|
| ContainedBeanImplementor<B> |
|
| ContextualLobCreator |
LobCreator implementation using contextual creation against the JDBC Connection class's LOB creation
methods. |
| Contributable |
Part of the mapping model that is associated with a contributor.
|
| ContributableDatabaseObject |
Contributable specialization for Tables and Sequences
|
| 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
|
| ConvertedBasicType<J> |
Extension for BasicType impls which have an implied conversion
|
| ConverterAutoApplyHandler |
|
| ConverterDescriptor |
Boot-time descriptor of a JPA AttributeConverter
|
| ConverterRegistration |
|
| ConverterRegistrations |
|
| Converters |
Factory for converter instances
|
| ConvertibleValueMapping<O> |
Describes a part of the domain model to which a value converter can be applied
|
| CopyIdentifierComponentSecondPass |
|
| CorrelatedPluralTableGroup |
A table group for correlated plural attributes.
|
| CorrelatedTableGroup |
|
| CountFunction |
|
| CreateKeySecondPass |
|
| CreationTimestamp |
Marks a property as the creation timestamp of the containing entity.
|
| CreationTimestampGeneration |
|
| 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 |
|
| CurrencyJavaType |
|
| CurrentFunction |
A "function" with no parameters that returns the current date, time, or timestamp.
|
| CurrentSessionContext |
Defines the contract for implementations which know how to scope the notion
of a current session. |
| CurrentTenantIdentifierResolver |
|
| CurrentTimestamp |
Specifies that the database current_timestamp function is used to
generate values of the annotated attribute, based on CurrentTimestamp.timing(). |
| CurrentTimestampGeneration |
Value generation strategy for using the database `current_timestamp` function to generate
the values
|
| 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 |
|
| CustomizableColumns |
|
| CustomSql |
Models the information for custom SQL execution defined as part of
the mapping for a primary/secondary table
|
| 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 |
Implementation of 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
|
| DB2390Dialect |
Deprecated.
|
| DB2390IdentityColumnSupport |
|
| DB2390V8Dialect |
Deprecated.
|
| DB2400Dialect |
Deprecated.
|
| DB2400V7R3Dialect |
Deprecated.
|
| DB297Dialect |
Deprecated.
|
| DB2Dialect |
|
| DB2FormatEmulation |
DB2's varchar_format() can't handle quoted literal strings in
the format pattern.
|
| DB2IdentityColumnSupport |
|
| DB2iDialect |
An SQL dialect for DB2 for iSeries 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. |
| DB2SequenceSupport |
|
| DB2SqlAstTranslator<T extends JdbcOperation> |
A SQL AST translator for DB2.
|
| DB2UniqueDelegate |
DB2 does not allow unique constraints on nullable columns.
|
| DB2zDialect |
An SQL dialect for DB2 for z/OS, previously known as known as Db2 UDB for z/OS and Db2 UDB for z/OS and OS/390.
|
| DB2zSequenceSupport |
|
| DB2zSqlAstTranslator<T extends JdbcOperation> |
A SQL AST translator for DB2z.
|
| DbTimestampJavaType<T> |
Deprecated.
|
| DbTimestampType |
Deprecated.
|
| DdlTransactionIsolator |
Provides access to a Connection that is isolated from
any "current transaction" with the designed purpose of
performing DDL commands
|
| DdlType |
Descriptor for a DDL type.
|
| DdlTypeRegistry |
Basically a map from SQL type code (int) -> DdlType |
| DecimalJdbcType |
|
| DefaultComponentSafeNamingStrategy |
|
| DefaultEnhancementContext |
default implementation of EnhancementContext.
|
| DefaultNamingStrategy |
|
| DefaultUniqueDelegate |
The default UniqueDelegate implementation for most dialects.
|
| 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 |
An SQL DELETE statement
|
| DeleteContext |
|
| DeleteEvent |
Defines an event class for the deletion of an entity.
|
| DeleteEventListener |
Defines the contract for handling of deletion events generated from a session.
|
| DeleteStatement |
|
| DeleteStatement.DeleteStatementBuilder |
|
| DenormalizedTable |
|
| DependantBasicValue |
|
| DependantValue |
A value which is "typed" by reference to some other
value (for example, a foreign key is typed by the
referenced primary key).
|
| 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.
|
| DerbyTenFiveDialect |
Deprecated.
|
| DerbyTenSevenDialect |
Deprecated.
|
| DerbyTenSixDialect |
Deprecated.
|
| 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.
|
| DialectFactory |
A factory for generating Dialect instances.
|
| 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 |
Service which acts as a registry for named strategy implementations.
|
| DirectAccessRegion |
Specialized Region whose data is accessed directly (not requiring 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.
|
| DiscriminatorFormula |
Specifies an expression written in native SQL as the discriminator for an
entity inheritance hierarchy.
|
| DiscriminatorMapping |
Mapping of a discriminator value to the corresponding entity-name
|
| DiscriminatorMetadata |
Provides the information needed to properly handle type discrimination
in HQL queries, either by 'something.class' or 'type(something)' references.
|
| DiscriminatorOptions |
Optional annotation to express Hibernate specific discriminator properties.
|
| DiscriminatorSource |
Contract for sources of information about a mapped discriminator.
|
| DiscriminatorType<T> |
TODO : javadoc
|
| DiscriminatorTypeMarshalling |
|
| Distinct |
|
| DomainDataCachingConfig |
Configuration for a specific type of data to be stored in the
region
|
| DomainDataRegion |
A Region for cacheable domain data - entity, collection, natural-id.
|
| 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 |
Specialization of StorageAccess for domain data regions
|
| 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
Both DomainResult and Fetch are ResultSetMappingNode subtypes. |
| 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 |
Hibernate often deals with compound names/paths.
|
| DoubleJavaType |
Descriptor for Double handling. |
| DoubleJdbcType |
Descriptor for DOUBLE handling. |
| DoublePrimitiveArrayJavaType |
Descriptor for double[] handling.
|
| DoubleStreamDecorator |
|
| DowncastLocation |
|
| DuplicateMappingException |
Raised whenever a duplicate for a certain type occurs.
|
| 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 |
|
| 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 -> 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 |
|
| EmbeddableDomainType<J> |
|
| EmbeddableInitializer |
Special initializer contract for embeddables
|
| EmbeddableInstantiator |
Specifies a custom instantiator for a specific embedded
|
| EmbeddableInstantiator |
Contract for instantiating embeddable values
NOTE : incubating until the proposed
`instantiate(IntFunction valueAccess, SessionFactoryImplementor sessionFactory)`
form can be implemented
|
| 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.
|
| 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 |
|
| 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 |
|
| EntityBasedBasicAttribute |
|
| EntityBasedCompositionAttribute |
|
| EntityBinder |
Stateful holder and processor for binding Entity information
|
| 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 |
|
| EntityDomainType<J> |
|
| EntityEntry |
We need an entry to tell us all about the current state of an object with respect to its persistent state
Implementation Warning: Hibernate needs to instantiate a high amount of instances of this class,
therefore we need to take care of its impact on memory consumption.
|
| 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.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.
|
| EntityIdentifierNature |
Describes the possible natures of an entity-defined identifier.
|
| EntityIdentifierNavigablePath |
Specialized NavigablePath implementation 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> |
EntityJavaType uses object identity for equals/hashCode as we ensure that internally.
|
| EntityKey |
Uniquely identifies of an entity instance in a particular Session by identifier.
|
| EntityLoadingLogging |
|
| EntityManagerFactoryBuilder |
Represents a 2-phase JPA bootstrap process for building a Hibernate EntityManagerFactory.
|
| EntityMappingType |
Mapping of an entity
|
| EntityMappingType.ConstraintOrderedTableConsumer |
|
| EntityMetamodel |
Centralizes metamodel information about an entity.
|
| EntityMetamodel.GenerationStrategyPair |
|
| EntityMetamodel.ValueGenerationStrategyException |
|
| EntityNameResolver |
An object capable of determining the entity name for a given entity instance.
|
| 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.
|
| 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>> |
Value type mapper for enumerations.
|
| EnumTypeMarshalling |
|
| EnumValueConverter<O extends Enum<O>,R> |
BasicValueConverter extension for enum-specific support
|
| 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.
|
| 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 Executable & Comparable<? super E> & Serializable> |
|
| ExecutableList.Sorter<E extends Executable> |
|
| 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 Region contract 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 |
Specify the fetching strategy used for the annotated association.
|
| Fetch |
Models an individual fetch 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. |
| FetchMemento |
|
| FetchMemento.Parent |
The parent node for the fetch
|
| FetchMementoBasic |
|
| FetchMode |
How the association should be fetched.
|
| 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 |
Define the fetching strategy profile.
|
| FetchProfile |
A 'fetch profile' allows a user to dynamically modify the fetching strategy used for particular associations at
runtime, whereas that information was historically only statically defined in the metadata.
|
| FetchProfile |
A fetch profile allows a user to dynamically modify the fetching strategy used for particular associations at
runtime, whereas that information was historically only statically defined in the metadata.
|
| FetchProfile.Fetch |
Defines an individual association fetch within the given profile.
|
| FetchProfile.FetchOverride |
Descriptor for a particular association override.
|
| 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 |
Add filters to an entity or a target entity of a collection.
|
| Filter |
Allows control over an enabled filter at runtime.
|
| Filterable |
Defines mapping elements to which filters may be applied.
|
| FilterDef |
Filter definition.
|
| FilterDefinition |
Represents the definition of a filter. |
| FilterDefs |
Array of filter definitions.
|
| FilterJoinTable |
Add filters to a join table collection.
|
| FilterJoinTables |
Add multiple @FilterJoinTable to a collection.
|
| FilterKey |
Allows cached queries to be keyed by enabled filters.
|
| FilterPredicate |
Represents a filter applied to an entity/collection.
|
| FilterPredicate.FilterFragmentPredicate |
|
| FilterRestrictable |
Things that can have associated Filter declarations. |
| Filters |
Add multiple @Filters.
|
| FilterSource |
Defines the source of filter information.
|
| FkDomainPathContinuation |
|
| FkSecondPass |
|
| 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 |
foreign
|
| ForeignKey |
Deprecated, for removal: This API element is subject to removal in a future version.
|
| ForeignKey |
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 formula is a derived column value
|
| Formula |
A read-only expression (e.g.
|
| ForUpdateFragment |
|
| 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 |
Contract for contributing functions
|
| FunctionExpression |
Represents a function used in an order-by fragment
|
| FunctionExpression |
Models a function expression at the SQL AST level.
|
| FunctionKind |
The kind of a 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.
|
| GeneratedAlwaysValueGeneration |
|
| 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.
|
| GeneratedValueGeneration |
|
| GeneratedValueResolver |
Generalized contract covering an attribute's generation handling
|
| GenerationTime |
Represents the timing of value generation that occurs in the database.
|
| GenerationTiming |
Represents the timing of value generation that occurs
in the Java program, or in the database. |
| GenerationTimingMarshalling |
|
| GenerationTypeMarshalling |
|
| GenerationTypeStrategy |
Delegate for defining how to handle the various types of
GenerationType possibilities. |
| GenerationTypeStrategyRegistration |
|
| GeneratorDefinitionResolver |
Access to resolve IdentifierGeneratorDefinition instances
|
| GeneratorType |
Deprecated.
|
| GenericGenerator |
Generator annotation describing any kind of Hibernate generator in a
generic (de-typed) manner.
|
| GenericGenerators |
Array of generic generator definitions.
|
| GenericJDBCException |
Generic, non-specific JDBCException.
|
| GetGeneratedKeysDelegate |
Delegate for dealing with IDENTITY columns using JDBC3 getGeneratedKeys
|
| Getter |
The contract for getting value for a persistent property 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 |
|
| H2DurationIntervalSecondJdbcType |
|
| H2FinalTableIdentityColumnSupport |
Identity column support for H2 2+ versions
|
| H2IdentityColumnSupport |
|
| 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 |
|
| HCANNHelper |
Manage the various fun-ness of dealing with HCANN...
|
| Helper |
TODO : javadoc
|
| 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 |
Hibernate extensions to the JPA CriteriaBuilder.
|
| HibernateError |
Marks a group of exceptions that generally indicate an internal Hibernate error or bug.
|
| HibernateException |
The base exception type for Hibernate exceptions.
|
| HibernateHints |
List of Hibernate-specific (extension) hints available to query,
load and lock scenarios.
|
| HibernatePersistenceProvider |
|
| HibernateProxy |
Marker interface for entity proxies
|
| 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.CubeContext |
|
| HqlParser.CurrentDateFunctionContext |
|
| HqlParser.CurrentTimeFunctionContext |
|
| HqlParser.CurrentTimestampFunctionContext |
|
| 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.LocalDateTimeFunctionContext |
|
| 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.OffsetDateTimeFunctionContext |
|
| 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.SearchedCaseListContext |
|
| HqlParser.SearchedCaseWhenContext |
|
| 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.TupleExpressionContext |
|
| HqlParser.UnaryExpressionContext |
|
| HqlParser.UnaryNumericLiteralExpressionContext |
|
| HqlParser.UpdateStatementContext |
|
| HqlParser.ValuesContext |
|
| HqlParser.ValuesListContext |
|
| HqlParser.VariableContext |
|
| HqlParser.WeekFieldContext |
|
| HqlParser.WhereClauseContext |
|
| HqlParser.WithinGroupClauseContext |
|
| HqlParser.YearContext |
|
| 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. |
| HqlTranslator |
Main entry point into building semantic queries.
|
| HSQLDialect |
|
| HSQLIdentityColumnSupport |
|
| HSQLSequenceSupport |
|
| HSQLSqlAstTranslator<T extends JdbcOperation> |
A SQL AST translator for HSQL.
|
| HydratedCompoundValueHandler |
Where to begin...
|
| HypotheticalSetFunction |
|
| HypotheticalSetWindowEmulation |
|
| IdBagBinder |
|
| IdentifiableDomainType<J> |
|
| IdentifiableTypeSource |
Common contract between Entity and MappedSuperclass sources.
|
| Identifier |
Models an identifier (name), which may or may not be quoted.
|
| Identifier |
Models an identifier (name), which may or may not be quoted.
|
| IdentifierAttribute |
|
| IdentifierBag |
An IdentifierBag has a primary key consisting of
just the identifier column
|
| IdentifierBagType |
|
| IdentifierCaseStrategy |
An enumeration of the way DatabaseMetaData might store and return identifiers
|
| IdentifierCollection |
A collection with a synthetic "identifier" column
|
| IdentifierGeneratingInsert |
Nothing more than a distinguishing subclass of Insert used to indicate
intent.
|
| IdentifierGenerationException |
Thrown by IdentifierGenerator implementation class when
ID generation fails.
|
| IdentifierGenerator |
The general contract between a class that generates unique
identifiers and the Session.
|
| IdentifierGeneratorAggregator |
|
| IdentifierGeneratorCreator |
|
| IdentifierGeneratorDefinition |
Identifier generator definition, should be immutable.
|
| IdentifierGeneratorDefinition.Builder |
|
| IdentifierGeneratorFactory |
|
| IdentifierGeneratorHelper |
|
| IdentifierGeneratorHelper.BasicHolder |
|
| IdentifierGeneratorHelper.BigDecimalHolder |
|
| IdentifierGeneratorHelper.BigIntegerHolder |
|
| IdentifierGeneratorStrategyProvider |
Deprecated.
|
| IdentifierHelper |
|
| IdentifierHelperBuilder |
Builder for IdentifierHelper instances.
|
| IdentifierLoadAccess<T> |
Loads an entity by its primary identifier.
|
| IdentifierLoadAccessImpl<T> |
|
| IdentifierProperty |
Represents a defined entity identifier property within the Hibernate
runtime-metamodel.
|
| 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 |
A generator for use with ANSI-SQL IDENTITY columns used as the primary key.
|
| IdentityGenerator.BasicDelegate |
Delegate for dealing with IDENTITY columns where the dialect requires an
additional command execution to retrieve the generated IDENTITY value
|
| IdentityGenerator.InsertSelectDelegate |
Delegate for dealing with IDENTITY columns where the dialect supports returning
the generated IDENTITY value directly from the insert statement.
|
| IdGenerator |
Identifier generator container,
Useful to keep named generator in annotations
|
| IdGeneratorResolverSecondPass |
|
| IdGeneratorStrategyInterpreter |
Deprecated.
|
| IdGeneratorStrategyInterpreter.GeneratorNameDeterminationContext |
|
| IdGeneratorType |
Meta-annotation used to mark another annotation as providing configuration
for a custom IdentifierGenerator. |
| IdGenFactoryLogging |
Logging related to IdentifierGeneratorFactory
|
| IllegalIdentifierException |
Indicates an attempted use of a name that was deemed illegal
|
| 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 |
|
| Immutable |
Marks an entity, collection, or attribute 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 |
Pluggable strategy for applying implicit naming rules when an
explicit name is not given.
|
| ImplicitNamingStrategyComponentPathImpl |
An ImplicitNamingStrategy implementation which uses full composite paths
extracted from AttributePath, as opposed to just the terminal property part.
|
| ImplicitNamingStrategyJpaCompliantImpl |
Implementation of the ImplicitNamingStrategy contract, generally preferring to conform
to JPA standards.
|
| 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).
|
| ImplicitTenantIdColumnNameSource |
Context for determining the implicit name of an entity's tenant identifier
column.
|
| ImplicitUniqueKeyNameSource |
|
| ImprovedNamingStrategy |
An improved naming strategy that prefers embedded
underscores to mixed case names
|
| IncomparableComparator |
Comparator for things that cannot be compared (in a way we know about).
|
| IncrementGenerator |
increment
|
| Incubating |
Marks certain of packages, types, etc.
|
| InDatabaseGeneratedValueResolver |
GeneratedValueResolver impl for in-db generation.
|
| InDatabaseValueGenerationStrategy |
Strategy for describing values which are generated in the database.
|
| Index |
Deprecated.
|
| Index |
A relational table index
|
| IndexBackref |
|
| IndexColumn |
Deprecated.
|
| IndexColumn |
index column
|
| IndexedBiConsumer<T,U> |
A consumer like BiConsumer but also accepts an integer as index. |
| IndexedCollection |
Indexed collections include Lists, Maps, arrays and
primitive arrays.
|
| IndexedConsumer<T> |
A consumer like Consumer but also accepts an integer as index. |
| IndexInformation |
Provides access to information about existing index in the database
|
| IndexOrUniqueKeySecondPass |
|
| 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 |
An SQL IN expression.
|
| InheritanceState |
Some extra data to the inheritance position of a class.
|
| InheritanceState.ElementsToProcess |
|
| 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
|
| InlineView |
|
| InLineViewSource |
Describes in-line view source information.
|
| InListPredicate |
|
| InMemoryGeneratedValueResolver |
GeneratedValueResolver impl for in-memory generation
|
| InMemoryValueGenerationStrategy |
|
| InnoDBStorageEngine |
Represents the InnoDB storage engine.
|
| InputStreamAccess |
Contract for building InputStreams, especially in on-demand situations
|
| Insert |
An SQL INSERT statement
|
| InsertGeneratedIdentifierDelegate |
Responsible for handling delegation relating to variants in how
insert-generated-identifier generator strategies dictate processing:
building the sql insert statement
determination of the generated identifier value
|
| InsertSelectIdentityInsert |
Specialized IdentifierGeneratingInsert which appends the database
specific clause which signifies to return generated IDENTITY values
to the end of the insert statement.
|
| InsertStatement |
|
| InsertSubstringOverlayEmulation |
Emulates the ANSI SQL-standard overlay() function using insert()
substring(), and concat().
|
| InstantAsTimestampJdbcType |
|
| InstantAsTimestampWithTimeZoneJdbcType |
|
| InstantiationException |
Thrown if Hibernate can't instantiate a class at runtime.
|
| Instantiator |
Strategy for instantiating a managed type
|
| Instantiator |
Deprecated.
|
| InstantJavaType |
Java type descriptor for the LocalDateTime type.
|
| InstantJdbcType |
|
| InstrumentedClassLoader |
A specialized ClassLoader which performs bytecode enhancement on class definitions as they are loaded
into the ClassLoader scope.
|
| 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 stuff that integrates with Hibernate.
|
| IntegratorProvider |
|
| IntegratorService |
|
| Interceptor |
Allows user code to inspect and/or change entity property values before they are
written to the database, or after the are read from the database.
|
| Internal |
Annotation used to identify a package, class, interface or method
as "internal", meaning that applications should expect 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.
|
| IntStreamDecorator |
|
| 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 |
|
| 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> |
AbstractBasicTypeDescriptor adapter for cases where we do not know a proper JavaType
for a given Java type.
|
| 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 |
|
| JdbcAnonBlock |
An anonymous call block (sometimes called an anonymous procedure) to be executed
on the database.
|
| JdbcBindingLogging |
|
| JdbcCall |
|
| JdbcCallFunctionReturn |
Models the function return when the JdbcCall 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 |
Implementation of JDBCException indicating problems with communicating with the
database (can also include incorrect JDBC setup).
|
| JdbcCoordinator |
Coordinates JDBC-related activities.
|
| JdbcDataType |
|
| JdbcDateJavaType |
Descriptor for Date handling. |
| JdbcDateJavaType.DateMutabilityPlan |
|
| JdbcDelete |
|
| 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 |
|
| JdbcInsert |
|
| JdbcLiteral<T> |
Represents a literal in the SQL AST.
|
| JdbcLiteralFormatter<T> |
|
| JdbcLockStrategy |
The strategy to use for applying locks to a JdbcSelect. |
| JdbcMapping |
Models the type of a thing that can be used as an expression in a SQL query
|
| JdbcMappingContainer |
Container for one-or-more JdbcMappings
|
| JdbcMetadaAccessStrategy |
|
| JdbcMutation |
Classification of JdbcDelete and JdbcUpdate operations
|
| JdbcMutationExecutor |
Executor for JdbcDelete and JdbcUpdate operations
|
| JdbcObserver |
Deprecated.
|
| JdbcOperation |
Unifying contract for any SQL statement we want to execute via JDBC.
|
| JdbcParameter |
|
| JdbcParameterBinder |
Performs parameter value binding to a JDBC PreparedStatement.
|
| JdbcParameterBinding |
|
| JdbcParameterBindings |
Access to all of the externalized JDBC parameter bindings
|
| JdbcParameterBySqmParameterAccess |
Access to the mapping between an SqmParameter and all of its JDBC parameters
|
| JdbcParameters |
The collection
|
| JdbcResourceTransaction |
Models access to the resource transaction of the underlying JDBC resource.
|
| JdbcResourceTransactionAccess |
Provides access to DataStoreTransaction (JDBC transaction stand-in) for use in building resource-local
TransactionCoordinator instances.
|
| JdbcSelect |
Executable JDBC command
|
| JdbcSelectExecutor |
An executor for JdbcSelect operations.
|
| JdbcServices |
Contract for services around JDBC operations.
|
| JdbcSessionContext |
Provides the JdbcSession implementation with contextual information it needs during its lifecycle.
|
| JdbcSessionOwner |
Contract for something that controls a JdbcSessionContext.
|
| 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 |
More-or-less a parameter-object intended for use in determining 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 |
Basically a map from JDBC type code (int) -> JdbcType |
| JdbcUpdate |
|
| JdbcValues |
|
| JdbcValuesMapping |
|
| JdbcValuesMappingImpl |
Implementation of JdbcValuesMapping for native / procedure queries
|
| JdbcValuesMappingProducer |
Producer for JdbcValuesMapping references.
|
| 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 |
Anything that can be loaded by outer join - namely
persisters for classes or collections.
|
| JoinColumnOrFormula |
|
| JoinColumnsOrFormulas |
Specifies a composite join condition involving one or more formulas
and, optionally, one or more columns. |
| JoinedSubclass |
A subclass in a table-per-subclass mapping
|
| JoinedSubclassEntityPersister |
|
| JoinedSubclassEntitySource |
|
| JoinedSubclassFkSecondPass |
|
| JoinFormula |
Specifies a join condition based on an arbitrary native SQL formula
instead of a column name. |
| JoinStatus |
See the JPA notion of joining a transaction for details.
|
| JpaAttributeConverter<O,R> |
BasicValueConverter extension for AttributeConverter-specific support
|
| 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 |
Contract 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> |
|
| 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.
|
| JPAIndexHolder |
|
| 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 |
Hibernate extension to the JPA Metamodel contract |
| JpaMetamodelImplementor |
SPI extension of JpaMetamodel
|
| 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> |
|
| JpaSelectCriteria<T> |
|
| JpaSelection<T> |
|
| JpaSetJoin<O,T> |
Specialization of JpaJoin for Set typed attribute joins |
| JpaSimpleCase<C,R> |
|
| JpaSubQuery<T> |
|
| JpaTargetAndSourceDescriptor |
|
| JpaTuple |
Hibernate extension to the Jakarta Persistence Tuple
contract |
| JpaTupleElement<T> |
|
| JsonBJsonFormatMapper |
|
| 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 |
Represents an identifying key of a table: the value for primary key
of an entity, or a foreign key of a collection or join table or
joined subclass 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 |
Define the lazy status of a collection.
|
| LazyCollectionOption |
Lazy options available for a collection.
|
| LazyFetchGroupMetadata |
Information about a particular bytecode lazy attribute grouping.
|
| LazyGroup |
For use with bytecode-enhanced lazy-loading support.
|
| LazyInitializable |
Hibernate "wraps" a java collection in an instance of PersistentCollection.
|
| LazyInitializationException |
Indicates an attempt to access not-yet-fetched data outside of a session context.
|
| 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.
|
| LazyToOne |
|
| LazyToOneOption |
Lazy options available for a ToOne association.
|
| LegacyDB2LimitHandler |
|
| LegacyDB2SequenceSupport |
|
| 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 list mapping has a primary key consisting of the key columns + index column.
|
| ListaggFunction |
|
| ListaggGroupConcatEmulation |
|
| ListaggStringAggEmulation |
|
| ListBinder |
Bind a list to the underlying Hibernate configuration
|
| ListIndexBase |
Defines the start index value for a list index as stored on the database.
|
| 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 |
Contract for things that can be loaded by a Loader.
|
| Loadable |
|
| LoadAccessContext |
Context for loader-access objects.
|
| LoadContexts |
Maintains a Stack of processing state related to performing load operations.
|
| LoadedConfig |
Models the information gleaned from parsing a cfg.xml file.
|
| Loader |
Specifies that a named query should be used to load an entity,
overriding the SQL that Hibernate generates by default.
|
| 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 |
|
| LobMergeStrategy |
Strategy for how dialects need LOB values to be merged.
|
| LobStreamDataHelper |
A help for dealing with BLOB and CLOB data
|
| LobTypeMappings |
|
| LocalDateJavaType |
Java type descriptor for the LocalDateTime type.
|
| LocalDateTimeJavaType |
Java type descriptor for the LocalDateTime type.
|
| 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 |
Java type descriptor for the LocalDateTime type.
|
| 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 |
|
| LockAcquisitionException |
Implementation of JDBCException indicating a problem acquiring 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 locking details (LockMode, Timeout and Scope).
|
| LockTimeoutException |
|
| Loggable |
Marker for things which can be logged.
|
| LoggableUserType |
Marker interface for user types which want to perform custom
logging of their corresponding values
|
| LogicalConnection |
Models the logical notion of a JDBC Connection.
|
| LogicalConnectionImplementor |
SPI contract for LogicalConnection
|
| LongJavaType |
Descriptor for Long handling. |
| LongNVarcharJdbcType |
|
| LongPrimitiveArrayJavaType |
Descriptor for long[] handling.
|
| LongStreamDecorator |
|
| 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 |
Commonality in regards to the mapping type system for all managed domain
types - entity types, mapped-superclass types, composite types, etc
|
| 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 |
Declares a many-valued association targeting one of several entity types,
depending on a local discriminator column.
|
| ManyToOne |
A many-to-one association mapping
|
| ManyToOneType |
A many-to-one association to an entity.
|
| Map |
A map has a primary key consisting of
the key columns + index columns.
|
| MapBinder |
Implementation to bind a Map
|
| MapEntryJavaType |
|
| MapKeyColumnDelegator |
|
| MapKeyCompositeType |
|
| MapKeyJavaType |
Form of JavaType for describing the key of a Map |
| MapKeyJdbcType |
Form of JdbcType for describing the key of a Map |
| MapKeyJdbcTypeCode |
|
| MapKeyJoinColumnDelegator |
|
| 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 |
Represents a @MappedSuperclass.
|
| MappedSuperclassDomainType<J> |
|
| MapPersistentAttribute<D,K,V> |
|
| Mapping |
Deprecated.
|
| MappingDefaults |
Defines a (contextual) set of values to use as defaults in the absence of related mapping information.
|
| MappingException |
Indicates a problem parsing a mapping document.
|
| MappingException |
An exception that occurs while reading mapping sources (xml/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 |
|
| MappingModelCreationLogger |
Logger used during mapping-model creation
|
| MappingModelExpressible<T> |
Something that can be expressible at the mapping model level.
|
| MappingModelHelper |
|
| MappingModelVisitor |
|
| MappingModelWalker |
|
| 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 |
Parts of the ModelPart hierarchy that are type descriptors, as opposed to attributes e.g.
|
| MappingTypedModelPart |
|
| 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> |
Extension of CollectionSemantics for Maps
|
| MapsIdSource |
Describes a relationship annotated with MapsId |
| MapType |
|
| MariaDB102Dialect |
Deprecated.
|
| MariaDB103Dialect |
Deprecated.
|
| MariaDB106Dialect |
Deprecated.
|
| MariaDB10Dialect |
Deprecated.
|
| MariaDB53Dialect |
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.
|
| 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 |
|
| 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 |
Contract for contributing to the initialization of MetadataBuilder.
|
| MetadataBuildingContext |
Describes the context in which the process of building Metadata out of MetadataSources occurs.
|
| MetadataBuildingOptions |
|
| MetadataBuildingProcess |
|
| MetadataContributor |
Contract for contributing to Metadata (InFlightMetadataCollector).
|
| MetadataImplementor |
The SPI-level Metadata contract.
|
| 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 |
A bootstrap process hook for contributing sources to MetadataSources.
|
| MetadataSourceType |
Enumeration of the types of sources of mapping metadata
|
| Metamodel |
Deprecated.
|
| MetamodelImplementor |
Deprecated.
|
| MetaType |
|
| 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
|
| ModelPart |
Describes a mapping related to any part of the app's domain model - e.g.
|
| ModelPart.JdbcValueConsumer |
|
| 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
|
| MultiLoader<T> |
Commonality for multi-loading
|
| 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 Java type.
|
| MutabilityPlanExposer<T> |
Something that exposes a MutabilityPlan
|
| MutableJpaCompliance |
|
| MutableMutabilityPlan<T> |
Mutability plan for mutable objects
|
| MutableQueryOptions |
|
| MutatingTableReferenceGroupWrapper |
Acts as a TableGroup for DML query operations.
|
| MutationQuery |
Models a mutation (insert, update, or delete) query.
|
| MutationStatement |
Specialization of Statement for mutation (DML) statements
|
| MyISAMStorageEngine |
Represents the MyISAM storage engine.
|
| MySQL55Dialect |
Deprecated.
|
| MySQL57Dialect |
Deprecated.
|
| MySQL5Dialect |
Deprecated.
|
| MySQL8Dialect |
Deprecated.
|
| 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.
|
| MySQLUniqueDelegate |
|
| 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 |
|
| 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 run-time environment
|
| NamedNativeQueryMemento.Builder |
Delegate used in creating named HQL query mementos.
|
| NamedObjectRepository |
Repository for references to named things related with 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 |
A grouping of Hibernate-specific NamedQuery definitions. |
| NamedQuery |
|
| 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.
|
| 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.
|
| NativeJdbcMutation |
Executable JDBC command
|
| NativeNonSelectQueryDefinition |
Access the values defining a native non-select query
|
| NativeNonSelectQueryPlan |
|
| NativeQuery<T> |
Represents a native (SQL) query.
|
| NativeQuery.CollectionReturn |
|
| 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 |
ResultNode which can be a query result
|
| 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 |
ResultTransformer adapter for handling Tuple results from Native queries
|
| NativeSelectQueryDefinition<R> |
Access the values defining a native select query
|
| NativeSelectQueryPlan<T> |
|
| NaturalId |
This specifies that a property is part of the natural id of the entity.
|
| NaturalId |
JAXB binding interface for natural-id definitions
|
| NaturalIdCache |
Specifies that the natural id values associated with the annotated
entity 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.
|
| NaturalIdLoadAccessImpl<T> |
|
| 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 |
|
| NaturalIdPostLoadListener |
Listener for post load-by-natural-id events
|
| NaturalIdPreLoadListener |
Listener for pre load-by-natural-id events
|
| 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 |
Compound-name where each path references to a domain or mapping model-part relative to a root path.
|
| NavigablePath.FullPathCalculator |
Effectively a tri-function
|
| NavigablePath.RelativePathCollector |
|
| NavigableRole |
Poorly named.
|
| 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> |
|
| 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
EmbeddedId 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 |
|
| 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 |
|
| 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 an association maps to a foreign key column without a
foreign key constraint, and which thus potentially violates referential
integrity.
|
| NotFoundAction |
Specifies how Hibernate should handle the case of an orphaned foreign
key with no associated row in the referenced table.
|
| NotImplementedYetException |
Marker interface for exceptions that indicate that something hasn't been implemented yet for a certain version
|
| 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.
|
| NotYetImplementedException |
Mapping not yet implemented
|
| NotYetImplementedFor6Exception |
Thrown from methods added for 6.0 that are not yet implemented.
|
| Nullability |
Are the columns forced to null, not null or not forced
|
| NullJdbcType |
Descriptor for binding nulls with Types.NULL
|
| NullnessPredicate |
|
| 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 |
|
| NullTypeBindableParameterRegistration<T> |
Deprecated.
|
| 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 |
Descriptor for binding objects
|
| ObjectNameNormalizer |
Provides centralized normalization of how database object names are handled.
|
| ObjectNameSource |
Source for database object names (identifiers).
|
| ObjectNotFoundException |
Thrown when Session.load() fails to select a row with
the given primary key (identifier value).
|
| 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 |
Java type descriptor for the LocalDateTime type.
|
| OnDelete |
Strategy to use on collections, arrays and on joined subclasses delete.
|
| OnDeleteAction |
Possible actions for on-delete.
|
| OnDeleteActionMarshalling |
|
| OneToMany |
A mapping for a one-to-many association
|
| OneToManyPersister |
|
| OneToManyTableGroup |
A table group for one-to-many plural attributes.
|
| OneToOne |
A one-to-one association mapping
|
| OneToOneSecondPass |
We have to handle OneToOne in a second pass because:
-
|
| OneToOneType |
A one-to-one association to an entity
|
| OptimisticEntityLockException |
Represents an error trying to apply an optimistic LockingStrategy to an entity |
| OptimisticForceIncrementLockingStrategy |
An optimistic locking strategy that forces an increment of the version (after verifying that version hasn't changed).
|
| OptimisticLock |
Specifies whether updating the annotated attribute should trigger an increment
to the version of the entity instance. |
| OptimisticLocking |
Used to define the style of optimistic locking to be applied to an entity.
|
| OptimisticLockingStrategy |
An optimistic locking strategy that verifies that the version hasn't changed (prior to transaction commit).
|
| OptimisticLockStyle |
Describes how an entity should be optimistically locked.
|
| OptimisticLockStyleMarshalling |
|
| OptimisticLockType |
Possible optimistic locking strategies.
|
| OptimizableGenerator |
Commonality between sequence-based and table-based generators
|
| Optimizer |
Performs optimization on an optimizable identifier generator.
|
| OptimizerFactory |
|
| Oracle10gDialect |
Deprecated.
|
| Oracle12cDialect |
Deprecated.
|
| Oracle12cGetGeneratedKeysDelegate |
|
| 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. |
| Oracle8iDialect |
Deprecated.
|
| Oracle9iDialect |
Deprecated.
|
| OracleArrayJdbcType |
Descriptor for ARRAY handling. |
| OracleDialect |
|
| OracleSequenceSupport |
|
| OracleSqlAstTranslator<T extends JdbcOperation> |
A SQL AST translator for Oracle.
|
| OracleTypesHelper |
A Helper for dealing with the OracleTypes class
|
| 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 |
A EntityPersister that may be loaded by outer join using
and may be an element of a one-to-many association. |
| 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 (IMO) of how this is exposed in the JDBC API.
|
| Over<T> |
|
| Overflow |
|
| 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 defined in a FilterDef.
|
| Parameter |
Generic parameter (basically a key/value combination) used to parametrize other annotations.
|
| ParameterBind<T> |
Represents the value currently bound to a particular (bindable) parameter.
|
| 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.
|
| 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.
|
| ParameterRegistration<T> |
|
| ParameterStrategy |
The style/strategy of parameter registration used in a particular procedure call definition.
|
| ParameterStrategyException |
|
| 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. |
| 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
|
| PersistenceStandardEntityResolver |
Resolve JPA xsd files locally
Hibernate OGM uses this class, consider this some kind of exposed service at the SPI level
|
| PersistenceStandardNamingStrategy |
Naming strategy implementing the EJB3 standards
|
| 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 persistent wrapper for an array.
|
| PersistentAttribute |
Common interface for JAXB bindings that represent persistent attributes.
|
| PersistentAttribute<D,J> |
Hibernate extension to the JPA Attribute contract |
| PersistentAttributeFilter |
|
| 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, unkeyed collection that can contain the same element
multiple times.
|
| PersistentClass |
Mapping for an entity.
|
| PersistentClassVisitor |
|
| PersistentCollection<E> |
Persistent collections are treated as value objects by Hibernate.
|
| PersistentIdentifierBag<E> |
An IdentifierBag implements "bag" semantics more efficiently than
a regular Bag by adding a synthetic identifier column to the
table.
|
| PersistentIdentifierGenerator |
An IdentifierGenerator that requires creation of database objects.
|
| PersistentList<E> |
A persistent wrapper for a java.util.List.
|
| PersistentMap<K,E> |
A persistent wrapper for a java.util.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 java.util.Set.
|
| PersistentSortedMap<K,E> |
A persistent wrapper for a java.util.SortedMap.
|
| PersistentSortedSet<E> |
A persistent wrapper for a java.util.SortedSet.
|
| Persister |
Specify a custom persister.
|
| 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 that increments the version immediately (obtaining an exclusive write lock).
|
| PessimisticLockException |
Thrown when a pessimistic locking conflict occurs.
|
| PessimisticReadSelectLockingStrategy |
A pessimistic locking strategy where the locks are obtained through select statements.
|
| PessimisticReadUpdateLockingStrategy |
A pessimistic locking strategy where the locks are obtained through update statements.
|
| PessimisticWriteSelectLockingStrategy |
A pessimistic locking strategy where the locks are obtained through select statements.
|
| PessimisticWriteUpdateLockingStrategy |
A pessimistic locking strategy where the locks are obtained through update statements.
|
| PhysicalColumn |
A column physically defined in the database table or inline-view
|
| PhysicalConnectionHandlingMode |
|
| PhysicalJdbcTransaction |
Provides access to manage "transactionality" via the JDBC Connection
|
| PhysicalNamingStrategy |
Pluggable strategy contract for applying physical naming rules for database object names.
|
| PhysicalNamingStrategyStandardImpl |
Standard implementation of the PhysicalNamingStrategy contract.
|
| PhysicalTable |
A table (or view, etc) that is physically defined on the database.
|
| PkDrivenByDefaultMapsIdSecondPass |
|
| 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 |
Used to define the type of polymorphism Hibernate will apply to entity hierarchies.
|
| PolymorphismType |
Type of available polymorphism for a particular entity.
|
| 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
|
| PostgreSQL81Dialect |
Deprecated.
|
| PostgreSQL82Dialect |
Deprecated.
|
| PostgreSQL91Dialect |
Deprecated.
|
| PostgreSQL92Dialect |
Deprecated.
|
| PostgreSQL93Dialect |
Deprecated.
|
| PostgreSQL94Dialect |
Deprecated.
|
| PostgreSQL95Dialect |
Deprecated.
|
| PostgreSQL9Dialect |
Deprecated.
|
| PostgreSQLDialect |
|
| PostgreSQLDriverKind |
|
| PostgreSQLIdentityColumnSupport |
|
| PostgreSQLInetJdbcType |
|
| PostgreSQLIntervalSecondJdbcType |
|
| PostgreSQLJsonbJdbcType |
|
| PostgreSQLJsonJdbcType |
|
| PostgreSQLMinMaxFunction |
PostgreSQL doesn't support min/max for uuid yet,
but since that type is comparable we want to support this operation.
|
| PostgreSQLPGObjectJdbcType |
|
| PostgreSQLSequenceSupport |
|
| PostgreSQLSqlAstTranslator<T extends JdbcOperation> |
A SQL AST translator for PostgreSQL.
|
| 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.
|
| 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 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.
|
| PrimitiveArrayBinder |
|
| 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> |
NOTE: Consider this contract (and its sub-contracts) as incubating as we transition to 6.0 and SQM
|
| 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 |
Represents a property as part of an entity or a component.
|
| PropertyAccess |
Describes access to a particular persistent property in terms of getting and setting
values.
|
| PropertyAccessBuildingException |
Indicates a problem while building a PropertyAccess
|
| 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 persistent property access (field, JavaBean-style property, etc).
|
| PropertyAccessStrategyResolver |
Contract for resolving the PropertyAccessStrategy to use.
|
| PropertyBasedMapping |
Describes an attribute with a property access.
|
| PropertyBinder |
|
| PropertyData |
|
| PropertyFactory |
Responsible for generation of runtime metamodel Property representations. |
| PropertyFactory.NonIdentifierAttributeNature |
|
| PropertyGeneration |
Deprecated.
|
| PropertyHolder |
Property holder abstract property containers from their direct implementation
|
| PropertyHolderBuilder |
This factory is here to build a PropertyHolder and prevent .mapping interface adding
|
| PropertyInferredData |
Retrieve all inferred data from an annotated element
|
| PropertyMapping |
Contract for all things that know how to map a property to the needed bits of SQL.
|
| PropertyNotFoundException |
Indicates that an expected getter or setter method could not be
found on a class.
|
| PropertyPath |
|
| PropertyPreloadedData |
|
| 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 |
Lazy and proxy configuration of a particular class.
|
| 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 run-time, 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 |
|
| QuantifiedLeastGreatestEmulation |
|
| Query<R> |
|
| Queryable |
Defines a mapping model contract for things that can be queried in the HQL,
Criteria, etc sense.
|
| Queryable |
Deprecated.
|
| Queryable.Declarer |
|
| QueryableCollection |
A collection role that may be queried or loaded by outer join.
|
| QueryBinder |
Query binder
|
| 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, etc.
|
| QueryGroup |
|
| QueryHintDefinition |
|
| 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 Type 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 |
Defines the responsibility for managing query result data caching
in regards to a specific region.
|
| QueryResultsRegion |
Defines the contract for a cache region which will specifically be used to
store query results.
|
| QueryResultsRegionTemplate |
|
| QuerySecondPass |
Bind query
|
| QuerySpacesHelper |
|
| 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 "region".
|
| RegionFactory |
Deprecated.
|
| RegionFactory |
Contract for building second level cache regions.
|
| RegionFactoryTemplate |
|
| RegionNameQualifier |
|
| RegisteredConversion |
A registered conversion.
|
| RegistryHelper |
|
| RelationalModel |
Deprecated.
|
| RelationalValueSource |
|
| RelationalValueSource.Nature |
|
| RelationalValueSourceContainer |
|
| Remove |
Indicates that the annotated element is planned for removal as part
of a deprecation lifecycle.
|
| 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 |
|
| 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 |
Indicates an attempt was made to use a closed resource (Session, SessionFactory, etc).
|
| 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 |
| 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 |
Possible styles of checking return codes on SQL INSERT, UPDATE and DELETE 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 |
An optional contract for Type or
UserType implementations to handle generated
id values any way they see fit as opposed to being limited to the discrete set of
numeric types handled by IdentifierGeneratorHelper |
| ResultSetMapping |
|
| ResultSetMappingBindingDefinition |
|
| ResultSetMappingContainer |
|
| ResultSetMappingImpl |
|
| ResultsetMappingSecondPass |
|
| ResultSetMappingSqlSelection |
|
| ResultSetOutput |
Models a return that is a result set.
|
| ResultSetReturn |
Contract for extracting ResultSets from Statements, executing Statements,
managing Statement/ResultSet 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 following the lines of Work but returning a result. |
| ReturnMetadata |
Metadata about the query return(s).
|
| RootClass |
The root class of an inheritance hierarchy
|
| RootGraph<J> |
|
| RootGraphImplementor<J> |
Integration version of the RootGraph contract
|
| RootSequencePart |
SequencePart implementation used to translate the root of a path
|
| RootTableGroupProducer |
Contract for things that can produce the TableGroup that is the root of a
from-clause |
| RowId |
Specifies that an Oracle-style rowid should be used in SQL
update statements for an entity, instead of the primary key.
|
| RowLockStrategy |
The strategy for rendering which row to lock with the FOR UPDATE OF clause.
|
| 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 |
Access to Hibernate's runtime metamodels which includes its domain-model (JPA impl) and its
relational-mapping model
|
| RuntimeMetamodelsImplementor |
|
| RuntimeModelCreationContext |
|
| RuntimeRelationModelHelper |
|
| 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
|
| 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. |
| 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 |
|
| SecondaryTableContainer |
Common interface for mappings that may contain secondary table (join) mappings.
|
| SecondaryTableFromAnnotationSecondPass |
|
| SecondaryTableSecondPass |
|
| SecondaryTableSource |
|
| SecondLevelCacheLogger |
|
| SecondPass |
Second pass operation
|
| Selectable |
Models the commonality between a column and a formula (computed value).
|
| SelectableConsumer |
Consumer used to visit selectable (column/formula) mappings
|
| SelectableMapping |
Mapping of a selectable (column/formula)
|
| SelectableMappings |
A container for multiple selectable (column, formula) mappings.
|
| SelectBeforeUpdate |
Specifies that the current persistent state of a detached entity instance
should be fetched from the database when the entity is reattached using
Session.update(Object). |
| SelectClause |
The SELECT CLAUSE in the SQL AST.
|
| SelectGenerator |
A generator that selects the just inserted row to determine the identifier
value assigned by the database.
|
| SelectGenerator.SelectGeneratorDelegate |
The delegate for the select generation strategy.
|
| SelectInterpretationsKey |
|
| SelectionQuery<R> |
Models a selection query returning results.
|
| SelectItemReferenceStrategy |
Strategies for referring to a select item.
|
| SelectLockingStrategy |
A locking strategy where the locks are obtained through select statements.
|
| 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.
|
| 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 |
|
| 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 |
Contains locking details (LockMode, Timeout and Scope).
|
| SessionAssociableInterceptor |
|
| SessionBuilder<T extends SessionBuilder> |
Allows creation of a new Session with specific options. |
| SessionBuilderImplementor<T extends SessionBuilder> |
Defines the internal contract between the SessionBuilder and
other parts of Hibernate. |
| SessionDelegatorBaseImpl |
This class is meant to be extended.
|
| SessionEventListener |
NOTE : Consider this an incubating API, likely to change as wider usage indicates changes that need to be made
|
| 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 |
Additional contract for SessionFactoryBuilder mainly intended for implementors
of SessionFactoryBuilderFactory.
|
| SessionFactoryBuilderService |
|
| SessionFactoryDelegatingImpl |
|
| SessionFactoryImplementor |
Defines the internal contract between the SessionFactory and the internal
implementation of Hibernate. |
| SessionFactoryImplementor.DeserializationResolver<T extends SessionFactoryImplementor> |
Contract for resolving this SessionFactory on deserialization
|
| SessionFactoryObserver |
|
| SessionFactoryOptions |
Aggregator of special options used to build the SessionFactory.
|
| 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 set with no nullable element columns.
|
| SetBasicValueTypeSecondPass |
|
| SetBinder |
Bind a set.
|
| SetOperator |
The SQL set operators.
|
| SetPersistentAttribute<D,E> |
|
| Setter |
The contract for setting a persistent property value into its container/owner
|
| SetterFieldImpl |
Field-based implementation of Setter
|
| SetterMethodImpl |
|
| SetType |
|
| SharedSessionBuilder<T extends SharedSessionBuilder> |
|
| SharedSessionContract |
|
| SharedSessionContractImplementor |
|
| ShortJavaType |
Descriptor for Short handling. |
| ShortPrimitiveArrayJavaType |
Descriptor for short[] handling.
|
| SimpleAuxiliaryDatabaseObject |
A simple implementation of AbstractAuxiliaryDatabaseObject in which the CREATE and DROP strings are
provided up front.
|
| SimpleBasicValueConverter<D,R> |
|
| 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.
|
| SimpleNaturalIdLoadAccessImpl<T> |
|
| SimpleSelect |
An SQL SELECT statement with no table joins
|
| SimpleStrategyRegistrationImpl<T> |
A simple implementation of StrategyRegistration.
|
| SimpleTimestamper |
Generates increasing identifiers (in a single VM only).
|
| SimpleToOneFkSecondPass |
A simple second pass that just creates the foreign key
|
| SimpleValue |
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 |
|
| 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 |
|
| 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 |
Optional annotation in conjunction with Version and timestamp version properties
indicating the source of the timestamp value. |
| SourceColumnAdapter |
|
| SourceColumnAdapterJaxbHbmColumnType |
|
| SourceDescriptor |
Describes a source for schema create, drop and migrate actions.
|
| SourceType |
Where should Hibernate retrieve the value from? From the database, or from the current JVM?
|
| 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
|
| 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
|
| SqlAstTranslator<T extends JdbcOperation> |
|
| SqlAstTranslatorFactory |
Factory for obtaining single-use SQL AST translators
|
| SqlAstTreeHelper |
|
| SqlAstTreeLogger |
Dedicated logger for rendering a SQL AST
|
| SqlAstWalker |
|
| SQLDelete |
Custom SQL statement for delete of an entity/collection.
|
| SQLDeleteAll |
Custom SQL statement for delete of all of a collection's elements.
|
| 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.
|
| SqlFragmentAlias |
Describe aliases for filters.
|
| SqlFunction |
A function to pass through a SQL fragment.
|
| SQLGrammarException |
Implementation of JDBCException indicating that the SQL sent to the database
server was invalid (syntax error, invalid object references, etc).
|
| SQLInsert |
Custom SQL statement for insertion of an entity/collection.
|
| SQLLoadable |
An EntityPersister that supports queries expressed
in the platform native SQL dialect. |
| SQLLoadableCollection |
|
| 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. |
| 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 |
|
| SQLServer2005Dialect |
Deprecated.
|
| 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.
|
| SQLServerDialect |
A dialect for Microsoft SQL Server 2000 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 |
The class that defines the constants that are used to identify generic
SQL types.
|
| SQLUpdate |
Custom SQL statement for update of an entity/collection.
|
| 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 |
|
| SqmCteStatement<T> |
|
| SqmCteTable |
|
| 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 -> 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.
|
| 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.
|
| 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 generator impls
|
| StandardNamingStrategy |
Hibernate's standard implicit naming strategy for identifier sequences and tables.
|
| StandardOptimizerDescriptor |
Enumeration of the standard Hibernate id generation optimizers.
|
| StandardProperty |
Deprecated.
|
| 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 |
|
| 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 for performing bulk operations against a database.
|
| StatelessSessionBuilder<T extends StatelessSessionBuilder> |
Represents a consolidation of all stateless session creation options into a builder style delegate.
|
| Statement |
Base contract for any statement
|
| StatementCreatorHelper |
Helper for creating various types of
NOTE :
|
| StatementInspector |
Contract to allow inspection (and swapping) of SQL to be prepared.
|
| StatementOptions |
Options for the creation of a JDBC statement
|
| StatementPreparer |
Contracting for preparing SQL statements
|
| StaticUserTypeSupport<T> |
|
| Statistics |
Exposes statistics collected from all sessions belonging to a
particular SessionFactory. |
| StatisticsFactory |
|
| StatisticsImplementor |
Statistics SPI for the Hibernate core.
|
| 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.
|
| StoredProcedureQueryParameterRegistration<T> |
ParameterRegistration extension specifically for stored procedure parameters
exposing some functionality of Hibernate's native ParameterRegistration contract |
| StrategyCreator<T> |
|
| StrategyRegistration<T> |
Describes the registration of a named strategy implementation.
|
| StrategyRegistrationProvider |
Responsible for providing the registrations of strategy selector(s).
|
| StrategyRegistrationProviderList |
|
| StrategySelectionException |
Indicates a problem performing the selection/resolution.
|
| StrategySelector |
Service which acts as a registry for named strategy implementations.
|
| StreamDecorator<R> |
|
| 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. |
| StructuredCacheEntry |
Structured CacheEntry format for entities.
|
| StructuredCollectionCacheEntry |
|
| StructuredMapCacheEntry |
Structured CacheEntry format for persistent Maps.
|
| Subclass |
A subclass in a table-per-class-hierarchy mapping
|
| 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 |
|
| Sybase11Dialect |
Deprecated.
|
| SybaseASE157Dialect |
Deprecated.
|
| SybaseASE15Dialect |
Deprecated.
|
| SybaseASEDialect |
A SQL dialect for Sybase Adaptive Server Enterprise 11.9 and above. |
| SybaseASESqlAstTranslator<T extends JdbcOperation> |
A SQL AST translator for Sybase ASE.
|
| SybaseDialect |
Superclass for all Sybase dialects.
|
| SybaseSqlAstTranslator<T extends JdbcOperation> |
A SQL AST translator for Sybase.
|
| SybaseSqmToSqlAstConverter<T extends Statement> |
A SQM to SQL AST translator for Sybase ASE.
|
| SynchronizationRegistry |
|
| SynchronizationRegistry |
|
| SynchronizationRegistryImplementor |
SPI contract for SynchronizationRegistry implementors.
|
| Synchronize |
Ensures that auto-flush happens correctly and that queries against the derived
entity do not return stale data.
|
| SynchronizeableQuery |
A unifying interface for queries which can define tables (query spaces) to synchronize on.
|
| SyntheticProperty |
Models a property which does not actually exist in the model.
|
| SyntheticVirtualTableGroup |
|
| Table |
|
| Table |
A relational table
|
| Table |
|
| Table.ForeignKeyKey |
|
| TableAliasResolver |
|
| TableBinder |
Table related operations
|
| 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
|
| TableInformation |
Provides access to information about existing tables in the database
|
| TableInformationContainer |
Common interface for all mappings that contain relational table information
|
| TableJoin |
|
| TableOwner |
Additional, optional contract as part pf the PersistentClass
hierarchy used to differentiate entity bindings for entities that map to their own table
(root, union-subclass, joined-subclass) versus those that do not (discriminator-subclass). |
| 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 |
A grouping of tables.
|
| TableSource |
Contract describing source of table information
|
| TableSpecificationSource |
Contract describing source of "table specification" information.
|
| TableStructure |
Describes a table used to mimic sequence behavior
|
| Target |
Define an explicit target, avoiding reflection and generics resolving.
|
| 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 |
|
| TemporaryTableHelper |
|
| TemporaryTableHelper.TemporaryTableCreationWork |
|
| TemporaryTableHelper.TemporaryTableDropWork |
|
| TemporaryTableKind |
|
| 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.
|
| TenantIdBinder |
Sets up filters associated with a TenantId field |
| TenantIdentifierMismatchException |
|
| TenantIdGeneration |
Value generation implementation for TenantId. |
| TiDBDialect |
|
| TiDBSequenceSupport |
|
| TiDBSqlAstTranslator<T extends JdbcOperation> |
A SQL AST translator for TiDB.
|
| 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. |
| TimestampJdbcType |
|
| TimestampsCache |
|
| 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 |
|
| TimestampsRegionTemplate |
|
| TimestampWithTimeZoneJdbcType |
|
| TimeZoneColumn |
Specifies the mapped column for storing the time zone information.
|
| TimeZoneJavaType |
|
| TimeZoneJavaType.TimeZoneComparator |
|
| TimeZoneStorage |
Specifies how the time zone information of a persistent property or field should be persisted.
|
| TimeZoneStorageStrategy |
Describes the storage strategies understood by Hibernate.
|
| TimeZoneStorageType |
Describes the storage of timezone information for zoned datetime types.
|
| TimeZoneSupport |
Describes the support for "with time zone" types.
|
| TinyIntJdbcType |
|
| ToListResultTransformer |
Transforms each result row from a tuple into a List whose elements are each tuple value |
| 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 simple-point association (ie.
|
| ToOneAttribute |
|
| ToOneBinder |
Work in progress
The goal of this class is to aggregate all operations
related to ToOne binding operations
|
| ToOneFkSecondPass |
Enable a proper set of the FK columns in respect with the id column order
Allow the correct implementation of the default EJB3 values which needs both
sides of the association to be resolved
|
| 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 "local transactions" (as transaction drivers) to control the
underlying "physical transaction" currently associated with the TransactionCoordinator.
|
| TransactionCoordinatorBuilder |
|
| TransactionCoordinatorBuilder.Options |
Access to options to are specific to each TransactionCoordinator instance
|
| TransactionCoordinatorOwner |
Models an owner of a TransactionCoordinator.
|
| TransactionException |
Indicates that a transaction could not be begun, committed
or rolled back.
|
| TransactionImplementor |
|
| 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 |
|
| 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 |
NavigablePath implementation with special handling for treated paths
|
| TrimFunction |
|
| TrimSpec |
|
| TrimSpecification |
|
| TrueFalseConverter |
Handles conversion to/from Boolean as `T` or `F`
|
| 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 (how do we check it for 'dirtiness', how do
we copy values, etc). |
| TypeBeanInstanceProducer |
|
| TypeBootstrapContext |
Provide a way to customize the Type instantiation process. |
| TypeConfiguration |
Defines a set of available Type instances as isolated from other configurations.
|
| TypeConfigurationAware |
Optional contract for Types that would like to be part of the scoping process of the
TypeConfiguration, specifically to receive access to the TypeConfiguration it is scoped
to.
|
| TypeContainer |
|
| TypeContributions |
Defines the target contributing types, whether via dialects or TypeContributor |
| TypeContributor |
Contract for contributing types.
|
| TypeContributorList |
|
| TypeDef |
Placeholder for typedef information
|
| 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.
|
| TypeNames |
|
| TypeNullability |
Describes the intrinsic nullability of a data type as reported by the JDBC driver.
|
| TypeSearchability |
Describes the searchability of a data type as reported by the JDBC driver.
|
| UnaryArithmeticOperator |
|
| UnaryOperation |
|
| UnfetchedBasicPartResultAssembler<J> |
|
| UnfetchedResultAssembler<J> |
|
| UnionSubclass |
A subclass in a table-per-concrete-class mapping
|
| UnionSubclassEntityPersister |
|
| UnionTableGroup |
|
| UnionTableReference |
|
| UniqueConstraintHolder |
|
| UniqueConstraintSchemaUpdateStrategy |
Unique columns and unique keys both use unique constraints in most dialects.
|
| UniqueDelegate |
Dialect-level delegate in charge of applying "uniqueness" to a column.
|
| UniqueKey |
A relational unique key constraint
|
| UniqueKeyLoadable |
|
| 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> |
AbstractBasicTypeDescriptor adapter for cases where we do not know a proper JavaType
for a given Java type.
|
| 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/class.
|
| UnknownNamedQueryException |
Indicates a request for a named-query when no query is
registered under that name
|
| 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 |
|
| Update |
An SQL UPDATE statement
|
| UpdateCountOutput |
Models a return that is an update count (count of rows affected)
|
| UpdateLockingStrategy |
A locking strategy where the locks are obtained through update statements.
|
| UpdateStatement |
|
| UpdateStatement.UpdateStatementBuilder |
|
| UpdateTimestamp |
Marks a property as the update timestamp of the containing entity.
|
| UpdateTimestampGeneration |
|
| UrlJavaType |
Descriptor for URL handling. |
| UserCollectionType |
A custom type for mapping user-written classes that implement PersistentCollection
|
| UserType<J> |
This interface should be implemented by user-defined "types".
|
| 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 |
UUID-based IdentifierGenerator
|
| UUIDGenerator |
Deprecated.
|
| UuidGenerator.Style |
|
| UUIDHexGenerator |
uuid
|
| 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 value is anything that is persisted by value, instead of by
reference.
|
| 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.
|
| ValueExtractor<X> |
|
| ValueGeneration |
Describes the generation of property values.
|
| ValueGenerationType |
Marks an annotation type as a generator annotation type.
|
| ValueGenerator<T> |
Defines a generator for in-VM generation of (non-identifier) attribute values.
|
| 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 - e.g.
|
| Values |
|
| ValuesTableGroup |
A special table group for a VALUES clause.
|
| ValuesTableReference |
|
| ValueVisitor |
|
| VarbinaryJdbcType |
|
| VarcharJdbcType |
|
| VerifyFetchProfileReferenceSecondPass |
|
| 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 |
Represents a version property within the Hibernate runtime-metamodel.
|
| 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 |
|
| Where |
Specifies a restriction written in native SQL to add to the generated
SQL when querying an entity or collection.
|
| 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 |
Contract for performing a discrete piece of JDBC 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. |
| WrappedInferredData |
|
| WrappedNClob |
Contract for NClob wrappers. |
| WrapperOptions |
Gives binding (nullSafeSet) and extracting (nullSafeGet) code access to options.
|
| 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.
|
| XmlJdbcType |
Specialized type mapping for SQLXML and the XML SQL data type.
|
| XmlJdbcType.XmlValueBinder<X> |
|
| XmlMappingBinderAccess |
Poor naming.
|
| 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 |
|