Class Index

A B C D E F G H I J K L M N O P Q R S T U V W X Y

A

AbstractAnsiTrimEmulationFunction	A `SQLFunction` providing support for implementing TRIM functionality (as defined by both the ANSI SQL and JPA specs) in cases where the dialect may not support the full `trim` function itself.
AbstractAuxiliaryDatabaseObject	Convenience base class for `AuxiliaryDatabaseObject`s.
AbstractBatcher	Manages prepared statements and batching.
AbstractBynaryType	This class is deprecated. Use the `AbstractStandardBasicType` approach instead
AbstractCharArrayType	This class is deprecated. Use the `AbstractStandardBasicType` approach instead
AbstractClassTransformerImpl	Basic implementation of the `ClassTransformer` contract.
AbstractCollectionEvent	Defines a base class for events involving collections.
AbstractCollectionPersister	Base implementation of the `QueryableCollection` interface.
AbstractComponentTuplizer	Support for tuplizers relating to components.
AbstractComponentType	This interface is deprecated. in favor of `CompositeType`
AbstractDialectResolver	A templated resolver impl which delegates to the `resolveDialectInternal(DatabaseMetaData)` method and handles any thrown SQLExceptions.
AbstractEmptinessExpression	Implementation of AbstractEmptinessExpression.
AbstractEntityJoinWalker	Abstract walker for walkers which begin at an entity (criteria queries and entity loaders).
AbstractEntityLoader
AbstractEntityPersister	Basic functionality for persisting an entity via JDBC through either generated or custom SQL
AbstractEntityPersister.InclusionChecker
AbstractEntityTuplizer	Support for tuplizers relating to entities.
AbstractEvent	Defines a base class for Session generated events.
AbstractExplicitParameterSpecification	Convenience base class for explicitly defined query parameters.
AbstractFieldInterceptor
AbstractFlushingEventListener	A convenience base class for listeners whose functionality results in flushing.
AbstractInstrumenter	Provides the basic templating of how instrumentation should occur.
AbstractInstrumenter.CustomFieldFilter	Allows control over what exacctly to transform.
AbstractJndiBoundCacheProvider	Support for CacheProvider implementations which are backed by caches bound into JNDI namespace.
AbstractLazyInitializer	Convenience base class for lazy initialization handlers.
AbstractLobCreator	Convenient base class for proxy-based LobCreator for handling wrapping.
AbstractLobType	This class is deprecated. No replacement.
AbstractLockUpgradeEventListener	A convenience base class for listeners that respond to requests to perform a pessimistic lock upgrade on an entity.
AbstractLongBinaryType	This class is deprecated. Use the `AbstractStandardBasicType` approach instead
AbstractLongStringType	This class is deprecated. Use the `AbstractStandardBasicType` approach instead
AbstractMapComponentNode	TODO : javadoc
AbstractNullnessCheckNode	Base class for nodes dealing 'is null' and 'is not null' operators.
AbstractPersistentCollection	Base class implementing `PersistentCollection`
AbstractPersistentCollection.DelayedOperation
AbstractPostInsertGenerator	Basic implementation of the `PostInsertIdentifierGenerator` contract.
AbstractPreDatabaseOperationEvent	Represents an operation we are about to perform against the database.
AbstractPropertyHolder
AbstractPropertyMapping	Basic implementation of the `PropertyMapping` contract.
AbstractQueryImpl	Abstract implementation of the Query interface.
AbstractReassociateEventListener	A convenience base class for listeners that respond to requests to reassociate an entity to a session ( such as through lock() or update() ).
AbstractRestrictableStatement	Convenience implementation of `RestrictableStatement` to centralize common functionality.
AbstractReturningDelegate	Abstract InsertGeneratedIdentifierDelegate implementation where the underlying strategy causes the enerated identitifer to be returned as an effect of performing the insert statement.
AbstractSaveEventListener	A convenience bas class for listeners responding to save events.
AbstractScrollableResults	Implementation of the `ScrollableResults` interface
AbstractSelectExpression	Partial implementation of SelectExpression for all the nodes that aren't constructors.
AbstractSelectingDelegate	Abstract InsertGeneratedIdentifierDelegate implementation where the underlying strategy requires an subsequent select after the insert to determine the generated identifier.
AbstractSelectLockingStrategy	Base `LockingStrategy` implementation to support implementations based on issuing `SQL` `SELECT` statements
AbstractSerializableProxy	Convenience base class for SerializableProxy.
AbstractSessionImpl	Functionality common to stateless and stateful sessions
AbstractSingleColumnStandardBasicType<T>	TODO : javadoc
AbstractStandardBasicType<T>	TODO : javadoc
AbstractStatement	Convenience implementation of Statement to centralize common functionality.
AbstractStatementExecutor	Implementation of AbstractStatementExecutor.
AbstractType	Abstract superclass of the built in Type hierarchy.
AbstractTypeDescriptor<T>	Abstract adapter for Java type descriptors.
AbstractUUIDGenerator	The base class for identifier generators that use a UUID algorithm.
AbstractVisitor	Abstract superclass of algorithms that walk a tree of property values of an entity, and perform specific functionality for collections, components and associated entities.
AccessCallback	Contract for providing callback access to a `DatabaseStructure`, typically from the `Optimizer`.
AccessOptimizerAdapter	This class is deprecated. Per HHH-5451 support for cglib as a bytecode provider has been deprecated.
AccessOptimizerAdapter	The ReflectionOptimizer#AccessOptimizer implementation for Javassist which simply acts as an adapter to the `BulkAccessor` class.
AccessType	Property Access type Prefer the standard javax.persistence.Access annotation
AccessType	The types of access strategies available.
AccessType	Enum defining deifferent access strategies for accessing entity values.
ActionQueue	Responsible for maintaining the queue of actions related to events.
AdaptedImmutableType<T>	Optimize a mutable type, if the user promises not to mutable the instances.
AfterCompletionAction	TODO : javadoc
AfterTransactionCompletionProcess	Contract representing some process that needs to occur during after transaction completion.
AggregatedSelectExpression	Contract for a select expression which aggregates other select expressions together into a single return
AggregateNode	Represents an aggregate function i.e.
AggregateProjection	Base class for standard aggregation functions.
Alias	An alias generator for SQL identifiers
AliasedProjection
AliasGenerator	Generates class/table/column aliases during semantic analysis and SQL rendering.
AliasGenerator	TODO : javadoc
AliasToBeanConstructorResultTransformer	Wraps the tuples in a constructor call.
AliasToBeanResultTransformer	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.
AlternativeLobTypes<S, T extends LobType<S>>	Provides alternative types for binding LOB values.
AlternativeLobTypes.BlobTypes<S, T extends LobType<S>>	Provides alternative types for binding `BLOB` values.
AlternativeLobTypes.ClobTypes<S, T extends LobType<S>>	Provides alternative types for binding `CLOB` values.
AnnotatedClassType	Type of annotation of a class will give its type
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)
AnnotationConfiguration	This class is deprecated. All functionality has been moved to `Configuration`
AnnotationConfiguration.ExtendedMappingsImpl
AnnotationException	Annotation related exception.
ANSICaseFragment	An ANSI SQL CASE expression.
ANSIJoinFragment	An ANSI-style join
AnsiTrimEmulationFunction	A `SQLFunction` implementation that emulates the ANSI SQL trim function on dialects which do not support the full definition.
AnsiTrimFunction	Defines support for rendering according to ANSI SQL `TRIM` function specification.
Any	Define a ToOne association pointing to several entity types.
Any	A Hibernate "any" type (ie.
AnyMetaDef	Defines @Any and @manyToAny metadata
AnyMetaDefs	Defines @Any and @ManyToAny set of metadata.
AnyType	Handles "any" mappings
AnyType.ObjectTypeCacheEntry
Array	An array mapping has a primary key consisting of the key columns + index column.
ArrayBinder	Bind an Array
ArrayHelper
ArrayMutabilityPlan<T>	A mutability plan for arrays.
ArrayType	A type for persistent arrays.
AssertionFailure	Indicates failure of an assertion: a possible bug in Hibernate.
Assigned	assigned An `IdentifierGenerator` that returns the current identifier assigned to an instance.
AssignmentSpecification	Encapsulates the information relating to an individual assignment within the set clause of an HQL update statement.
Association	Models the association of a given fetch.
AssociationType	A type that represents some kind of association between entities.
ASTAppender	Appends child nodes to a parent efficiently.
ASTIterator	Depth first iteration of an ANTLR AST.
ASTParentsFirstIterator	Depth first iteration of an ANTLR AST.
ASTPrinter	Utility for generating pretty "ASCII art" representations of syntax trees.
ASTQueryTranslatorFactory	Generates translators which uses the Antlr-based parser to perform the translation.
ASTUtil	Provides utility methods for AST traversal and manipulation.
ASTUtil.FilterPredicate	Filters nodes out of a tree.
ASTUtil.IncludePredicate	A predicate that uses inclusion, rather than exclusion semantics.
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.
AvgProjection	An avg() projection
AvgWithArgumentCastFunction	Some databases strictly return the type of the of the aggregation value for `AVG` which is problematic in the case of averaging integers because the decimals will be dropped.

B

Backref
BackrefPropertyAccessor	Represents a "back-reference" to the id of a collection owner.
BackrefPropertyAccessor.BackrefGetter	Internal implementation of a property getter specific to these back-ref properties.
BackrefPropertyAccessor.BackrefSetter	Internal implementation of a property setter specific to these back-ref properties.
Bag	A bag permits duplicates, so it has no primary key
BagBinder	Bind a bag.
BagType
BaseGeneralDataRegionAdapter
BaseRegionAdapter	Basic adapter bridging between `Region` and `Cache`.
BaseTransactionalDataRegionAdapter
BasicBinder<J>	Convenience base implementation of `ValueBinder`
BasicClassFilter	BasicClassFilter provides class filtering based on a series of packages to be included and/or a series of explicit class names to be included.
BasicCollectionJoinWalker	Walker for collections of values and many-to-many associations
BasicCollectionLoader	Loads a collection of values or a many-to-many association.
BasicCollectionPersister	Collection persister for collections of values and many-to-many associations.
BasicDialectResolver	Intended as support for custom resolvers.
BasicEntityPropertyMapping
BasicExecutor	Implementation of BasicExecutor.
BasicExtractor<J>	Convenience base implementation of `ValueExtractor`
BasicFormatterImpl	Performs formatting of basic SQL statements (DML + query).
BasicInstrumentationTask	Super class for all Hibernate instrumentation tasks.
BasicInstrumentationTask.LoggerBridge
BasicLazyInitializer	Lazy initializer for POJOs
BasicLoader	Uses the default mapping from property to result set column alias defined by the entities' persisters.
BasicPropertyAccessor	Accesses property values via a get/set pair, which may be nonpublic.
BasicPropertyAccessor.BasicGetter
BasicPropertyAccessor.BasicSetter
BasicProxyFactory	A proxy factory for "basic proxy" generation
BasicSQLExceptionConverter	A helper to centralize conversion of java.sql.SQLExceptions to `JDBCException`s.
BasicTransformerAdapter	Provides the basic "noop" impls of the `ResultTransformer` contract.
BasicType	Marker interface for basic types.
BasicTypeRegistry	A registry of `BasicType` instances
BatchedTooManyRowsAffectedException	Much like `TooManyRowsAffectedException`, indicates that more rows than what we were expcecting were affected.
Batcher	Manages `PreparedStatement`s for a session.
BatcherFactory	Factory for `Batcher` instances.
BatchFailedException	Indicates a failed batch entry (-3 return).
BatchFetchQueue	Tracks entity and collection keys that are available for batch fetching, and the queries which were used to load entities, which can be re-used as a subquery for loading owned collections.
BatchingBatcher	An implementation of the `Batcher` interface that actually uses batching
BatchingBatcherFactory	A BatcherFactory implementation which constructs Batcher instances capable of actually performing batch operations.
BatchingCollectionInitializer	"Batch" loads collections, using multiple foreign key values in the SQL `where` clause.
BatchingEntityLoader	"Batch" loads entities, using multiple primary key values in the SQL `where` clause.
BatchSize	Batch size for SQL loading
BeanValidationActivator	This class has no hard dependency on Bean Validation APIs It must use reflection every time BV is required.
BeanValidationEventListener	Event listener used to enable Bean Validation for insert/update/delete events.
BeforeCompletionManagedFlushChecker	Contract for checking whether to perform a managed flush in a javax.transaction.Synchronization#beforeCompletion() callback
BeforeTransactionCompletionProcess	Contract representing some process that needs to occur during before transaction completion.
BESTransactionManagerLookup	A `TransactionManager` lookup strategy for Borland ES.
BetweenExpression	Constrains a property to between two values
BetweenOperatorNode	Contract for nodes representing logcial BETWEEN (ternary) operators.
BigDecimalType	A type that maps between a `NUMERIC` and BigDecimal.
BigDecimalTypeDescriptor	Descriptor for BigDecimal handling.
BigIntegerType	A type that maps between a `NUMERIC` and BigInteger.
BigIntegerTypeDescriptor	Descriptor for BigInteger handling.
BigIntTypeDescriptor	Descriptor for `BIGINT` handling.
BinaryArithmeticOperatorNode	Nodes which represent binary arithmetic operators.
BinaryLogicOperatorNode	Contract for nodes representing binary operators.
BinaryOperatorNode	Contract for nodes representing binary operators.
BinaryStream	Wraps a binary stream to also provide the length which is needed when binding.
BinaryStreamImpl	Implementation of `BinaryStream`
BinaryType	A type that maps between a `VARBINARY` and `byte[]`
BinaryTypeDescriptor	Descriptor for `BINARY` handling.
Binder
BinderHelper
BitTypeDescriptor	Descriptor for `BIT` handling.
BlobImplementer	Marker interface for non-contextually created java.sql.Blob instances..
BlobProxy	Manages aspects of proxying Blob Blobs for non-contextual creation, including proxy creation and handling proxy invocations.
BlobType	A type that maps between `BLOB` and Blob
BlobTypeDescriptor	Descriptor for Blob handling.
BlobTypeDescriptor	Descriptor for `BLOB` handling.
BlobTypeDescriptor.BlobMutabilityPlan
BooleanLiteralNode	Represents a boolean literal within a query.
BooleanType	A type that maps between `BIT` and Boolean
BooleanTypeDescriptor	Descriptor for Boolean handling.
BorrowedConnectionProxy	A proxy for borrowed connections which funnels all requests back into the ConnectionManager from which it was borrowed to be properly handled (in terms of connection release modes).
BTMTransactionManagerLookup	TransactionManager lookup strategy for BTM
BulkAccessor	A JavaBean accessor.
BulkAccessorException	An exception thrown while generating a bulk accessor.
BulkOperationCleanupAction	An `ActionQueue` `Executable` for ensuring shared cache cleanup in relation to performed bulk HQL queries.
ByteArrayBlobType	This class is deprecated. replaced by `WrappedMaterializedBlobType`
ByteArrayTypeDescriptor	TODO : javadoc
ByteCodeHelper	A helper for reading byte code from various input sources.
BytecodeProvider	Contract for providers of bytecode services to Hibernate.
BytecodeProviderImpl	This class is deprecated. Per HHH-5451 support for cglib as a bytecode provider has been deprecated.
BytecodeProviderImpl	Bytecode provider implementation for Javassist.
BytesHelper
ByteType	A type that maps between `TINYINT` and Byte
ByteTypeDescriptor	Descriptor for Byte handling.

C

Cache	Provides an API for querying/managing the second level cache regions.
Cache	Add caching strategy to a root entity or a collection
Cache	This interface is deprecated. As of 3.3; see for details.
Cache71Dialect	Caché 2007.1 dialect.
CacheConcurrencyStrategy	Cache concurrency strategy
CacheConcurrencyStrategy	This interface is deprecated. As of 3.3; see for details.
CacheDataDescription	Describes attributes regarding the type of data to be cached.
CacheDataDescriptionImpl
CacheEntry	A cached instance of a persistent class
CacheEntryStructure
CacheException	Something went wrong in the cache
CacheJoinFragment	A Caché dialect join.
CacheKey	Allows multiple entity classes / collection roles to be stored in the same cache region.
CacheMode	Controls how the session interacts with the second-level cache and query cache.
CacheModeType	Enumeration for the different interaction modes between the session and the Level 2 Cache.
CacheProvider	This interface is deprecated. As of 3.3; see for details.
CacheSQLStateConverter	A SQLExceptionConverter implementation specific to Caché SQL, accounting for its custom integrity constraint violation error codes.
CacheSynchronization	A JTA transaction synch used to allow the `Session` to know about transaction events.
CalendarComparator
CalendarDateType	A type mapping `DATE` and Calendar
CalendarDateTypeDescriptor	Descriptor for java.util.Calendar handling, but just for the date (month, day, year) portion.
CalendarType	A type that maps between `TIMESTAMP` and Calendar
CalendarTypeDescriptor	Descriptor for Calendar handling.
CalendarTypeDescriptor.CalendarMutabilityPlan
CallbackCoordinator	Manages callbacks from the javax.transaction.Synchronization registered by Hibernate.
CallbackException	Should be thrown by persistent objects from `Lifecycle` or `Interceptor` callbacks.
Cascade	Apply a cascade strategy on an association
Cascade	Delegate responsible for, in conjunction with the various `actions`, implementing cascade processing.
CascadeEntityJoinWalker
CascadeEntityLoader
CascadeStyle	A contract for defining the aspects of cascading various persistence actions.
CascadeStyle.MultipleCascadeStyle
CascadeType	Cascade types (can override default EJB3 cascades
CascadingAction	A session action that may be cascaded from parent entity to its children
Case2Node	Represents a case ...
CaseFragment	Abstract SQL case fragment renderer
CaseNode	Represents a case ...
CastFunction	ANSI-SQL style `cast(foo as type)` where the type is a Hibernate type
CategorizedStatistics	Statistics for a particular "category" (a named entity, collection role, second level cache region or query).
CglibClassTransformer	This class is deprecated. Per HHH-5451 support for cglib as a bytecode provider has been deprecated.
CGLIBHelper
CGLIBInstrumenter	Strategy for performing build-time instrumentation of persistent classes in order to enable field-level interception using CGLIB.
CGLIBLazyInitializer	This class is deprecated. Per HHH-5451 support for cglib as a bytecode provider has been deprecated.
CGLIBProxyFactory	This class is deprecated. Per HHH-5451 support for cglib as a bytecode provider has been deprecated.
ChainedPropertyAccessor
CharacterArrayClobType	A type that maps between `CLOB` and Character Character[] Essentially a `MaterializedClobType` but represented as a Character[] in Java rather than String.
CharacterArrayType	A type that maps between `VARCHAR` and Character Character[]
CharacterArrayTypeDescriptor	TODO : javadoc
CharacterStream	Wraps a character stream (reader) to also provide the length (number of characters) which is needed when binding.
CharacterStreamImpl	Implementation of `CharacterStream`
CharacterType	A type that maps between `CHAR(1)` and Character
CharacterTypeDescriptor	Descriptor for Character handling.
CharArrayType	A type that maps between `VARCHAR` and `char[]`
CharBooleanType	This class is deprecated. Use the `AbstractStandardBasicType` approach instead
CharIndexFunction	Emulation of `locate()` on Sybase
CharTypeDescriptor	Descriptor for `CHAR` handling.
Check	Arbitrary SQL check constraints which can be defined at the class, property or collection level
ClassDescriptor	Contract describing the information Hibernate needs in terms of instrumenting a class, either via ant task or dynamic classloader.
ClassFilter	Used to determine whether a class should be instrumented.
ClassicAvgFunction	Classic AVG sqlfunction that return types as it was done in Hibernate 3.1
ClassicCountFunction	Classic COUNT sqlfunction that return types as it was done in Hibernate 3.1
ClassicQueryTranslatorFactory	Generates translators which uses the older hand-written parser to perform the translation.
ClassicSumFunction	Classic SUM sqlfunction that return types as it was done in Hibernate 3.1
ClassMetadata	Exposes entity class metadata to the application
ClassPropertyHolder
ClassTransformer	A persistence provider provides an instance of this interface to the PersistenceUnitInfo.addTransformer method.
ClassType	A type that maps between `VARCHAR` and Class
ClassTypeDescriptor	TODO : javadoc
ClauseParser	Parses the Hibernate query into its constituent clauses.
ClobImplementer	Marker interface for non-contextually created java.sql.Clob instances..
ClobProxy	Manages aspects of proxying Clob Clobs for non-contextual creation, including proxy creation and handling proxy invocations.
ClobType	A type that maps between `CLOB` and Clob
ClobTypeDescriptor	Descriptor for Clob handling.
ClobTypeDescriptor	Descriptor for `CLOB` handling.
ClobTypeDescriptor.ClobMutabilityPlan
Cloneable	An object that is shallow-coneable
CMTTransaction	Implements a basic transaction strategy for CMT transactions.
CMTTransactionFactory	Factory for `CMTTransaction` instances.
CollationSpecification	Models a collation specification (`COLLATE` using a specific character-set) within a `SortSpecification`.
Collection	Mapping for a collection.
CollectionAccessStrategyAdapter	Adapter specifically bridging `CollectionRegionAccessStrategy` to `CacheConcurrencyStrategy`.
CollectionAction	Any action relating to insert/update/delete of a collection
CollectionAliases	Type definition of CollectionAliases.
CollectionBinder	Base class for binding different types of collections to Hibernate configuration objects.
CollectionCacheEntry
CollectionElementLoader
CollectionEntry	We need an entry to tell us all about the current state of a collection with respect to its persistent state
CollectionFetchReturn	Spefically a fetch return that refers to a collection association.
CollectionFilterImpl	implementation of the `Query` interface for collection filters
CollectionFilterKeyParameterSpecification	A specialized ParameterSpecification impl for dealing with a collection-key as part of a collection filter compilation.
CollectionFunction	Represents 'elements()' or 'indices()'.
CollectionHelper	Various help for handling collections.
CollectionId	Describe an identifier column for a bag (ie an idbag) EXPERIMENTAL: the structure of this annotation might slightly change (generator() mix strategy and generator
CollectionInitializer	An interface for collection loaders
CollectionJoinWalker	Superclass of walkers for collection initializers
CollectionKey	Uniquely identifies a collection instance in a particular session.
CollectionLoadContext	Represents state associated with the processing of a given ResultSet in regards to loading collections.
CollectionLoader	Superclass for loaders that initialize collections
CollectionMetadata	Exposes collection metadata to the application
CollectionOfElements	This @interface is deprecated. use @ElementCollection
CollectionPersister	A strategy for persisting a collection role.
CollectionProperties	Provides a map of collection function names to the corresponding property names.
CollectionPropertyHolder
CollectionPropertyMapping
CollectionPropertyNames	The names of all the collection properties.
CollectionRecreateAction
CollectionRegion	Defines the contract for a cache region which will specifically be used to store collection data.
CollectionRegionAccessStrategy	Contract for managing transactional and concurrent access to cached collection data.
CollectionRegionAdapter	Adapter specifically bridging `CollectionRegion` to `Cache`.
CollectionRemoveAction
CollectionReturn	Represents a return which names a collection role; it is used in defining a custom query for loading an entity's collection in non-fetching scenarios (i.e., loading the collection itself as the "root" of the result).
Collections	Implements book-keeping for the collection persistence by reachability algorithm
CollectionSecondPass	Collection second pass
CollectionStatistics	Collection related statistics
CollectionStatisticsImpl	Collection related statistics
CollectionSubqueryFactory	Provides the SQL for collection subqueries.
CollectionType	A type that handles Hibernate `PersistentCollection`s (including arrays).
CollectionUpdateAction
Column	A column of a relational database table
ColumnCollectionAliases	CollectionAliases that uses columnnames instead of generated aliases.
ColumnEntityAliases	EntityAliases that chooses the column names over the alias names.
ColumnHelper	Provides utility methods for dealing with arrays of SQL column names.
ColumnMapper	Contract for mapping a (an assumed) property reference to its columns.
ColumnMetadata	JDBC column metadata
ColumnNameCache	Cache of column-name -> column-index resolutions
Columns	Support an array of columns.
ColumnTransformer	Custom SQL expression used to read the value from and write a value to a column.
ColumnTransformers	Plural annotation for @ColumnTransformer.
ComparableComparator	Delegates to Comparable
Component	The mapping for a component, composite element, composite identifier, etc.
Component.StandardGenerationContextLocator
Component.ValueGenerationPlan
ComponentJoin	Models an explicit join terminating at a component value (e.g.
ComponentJoin.ComponentFromElementType
ComponentMetamodel	Centralizes metamodel information about a component.
ComponentPropertyHolder	Component implementation of property holder
ComponentTuplizer	Defines further responsibilities regarding tuplization based on a mapped components.
ComponentTuplizerFactory	A registry allowing users to define the default `ComponentTuplizer` class to use per `EntityMode`.
ComponentType	Handles "component" mappings
CompositeCustomType	Adapts `CompositeUserType` to the `Type` interface
CompositeElementPropertyMapping
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`
CompositeType	Contract for value types to hold collections and have cascades, etc.
CompositeUserType	A `UserType` that may be dereferenced in a query.
ConcurrentCollectionStatisticsImpl	Collection related statistics
ConcurrentEntityStatisticsImpl	Entity related statistics
ConcurrentQueryStatisticsImpl	Query statistics (HQL and SQL) Note that for a cached query, the cache miss is equals to the db count
ConcurrentSecondLevelCacheStatisticsImpl	Second level cache statistics of a specific region
ConcurrentStatisticsImpl	Implementation of `Statistics`, as well as `StatisticsImplementor`, based on the `java.util.concurrent` package introduced in Java 5.
ConditionalParenthesisFunction	Essentially the same as `StandardSQLFunction`, except that here the parentheses are not included when no arguments are given.
ConditionFragment
ConfigHelper	A simple class to centralize logic needed to locate config files on the system.
Configurable	The Configurable interface defines the contract for SQLExceptionConverter impls that want to be configured prior to usage given the currently defined Hibernate properties.
Configurable	An `IdentifierGenerator` that supports "configuration".
Configuration	An instance of `Configuration` allows the application to specify properties and mapping documents to be used when creating a `SessionFactory`.
Configuration.MappingsImpl	Internal implementation of the Mappings interface giving access to the Configuration's internal `metadata repository` state (`classes`, `tables`, etc).
Configuration.MetadataSourceQueue
Conjunction
ConnectionManager	Encapsulates JDBC Connection management logic needed by Hibernate.
ConnectionManager.Callback
ConnectionProvider	A strategy for obtaining JDBC connections.
ConnectionProviderFactory	Instantiates a connection provider given either `System` properties or a `java.util.Properties` instance.
ConnectionReleaseMode	Defines the various policies by which Hibernate might release its underlying JDBC connection.
ConnectionWrapper	Interface implemented by JDBC connection wrappers in order to give access to the underlying wrapped connection.
Constraint	A relational constraint.
ConstraintViolationException	Implementation of JDBCException indicating that the requested DML operation resulted in a violation of a defined integrity constraint.
ConstructorNode	Represents a constructor (new) in a SELECT.
ContextualLobCreator	`LobCreator` implementation using contextual creation against the JDBC java.sql.Connection class's LOB creation methods.
ConvertFunction	A Caché defintion of a convert function.
CopyIdentifierComponentSecondPass
CountNode	Represents a COUNT expression in a select.
CountProjection	A count
CreateKeySecondPass
Criteria	`Criteria` is a simplified API for retrieving entities by composing `Criterion` objects.
CriteriaImpl	Implementation of the `Criteria` interface
CriteriaImpl.CriterionEntry
CriteriaImpl.OrderEntry
CriteriaImpl.Subcriteria
CriteriaJoinWalker	A `JoinWalker` for `Criteria` queries.
CriteriaLoader	A `Loader` for `Criteria` queries.
CriteriaQuery	An instance of `CriteriaQuery` is passed to criterion, order and projection instances when actually compiling and executing the query.
CriteriaQueryTranslator
CriteriaSpecification
Criterion	An object-oriented representation of a query criterion that may be used as a restriction in a `Criteria` query.
CurrencyType	A type that maps between `VARCHAR` and Currency
CurrencyTypeDescriptor	TODO : javadoc
CurrentSessionContext	Defines the contract for implementations which know how to scope the notion of a `current session`.
CustomCollectionType	A custom type for mapping user-written classes that implement `PersistentCollection`
CustomizableColumns
CustomLoader	Extension point for loaders which use a SQL result set with "unexpected" column aliases.
CustomLoader.NonScalarResultColumnProcessor
CustomLoader.ResultRowProcessor
CustomLoader.ScalarResultColumnProcessor
CustomQuery	Extension point allowing any SQL query with named and positional parameters to be executed by Hibernate, returning managed entities, collections and simple scalar values.
CustomType	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.

D

DatabaseMetadata	JDBC database metadata
DatabaseStructure	Encapsulates definition of the underlying data structure backing a sequence-style generator.
DataDirectOracle9Dialect
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
DatasourceConnectionProvider	A connection provider that uses a `DataSource` registered with JNDI.
DateType	A type that maps between `DATE` and java.sql.Date
DateTypeDescriptor	TODO : javadoc
DateTypeDescriptor	Descriptor for `DATE` handling.
DateTypeDescriptor.DateMutabilityPlan
DB2390Dialect	An SQL dialect for DB2/390.
DB2400Dialect	An SQL dialect for DB2/400.
DB2Dialect	An SQL dialect for DB2.
DbTimestampType	`dbtimestamp`: An extension of `TimestampType` which maps to the database's current timestamp, rather than the jvm's current timestamp.
DDLFormatterImpl	Performs formatting of DDL SQL statements.
DecimalTypeDescriptor	Descriptor for `DECIMAL` handling.
DecodeCaseFragment	An Oracle-style DECODE function.
DefaultAutoFlushEventListener	Defines the default flush event listeners used by hibernate for flushing session state in response to generated auto-flush events.
DefaultComponentSafeNamingStrategy
DefaultDeleteEventListener	Defines the default delete event listener used by hibernate for deleting entities from the datastore in response to generated delete events.
DefaultDirtyCheckEventListener	Defines the default dirty-check event listener used by hibernate for checking the session for dirtiness in response to generated dirty-check events.
DefaultEntityAliases	EntityAliases which handles the logic of selecting user provided aliases (via return-property), before using the default aliases.
DefaultEvictEventListener	Defines the default evict event listener used by hibernate for evicting entities in response to generated flush events.
DefaultFlushEntityEventListener	An event that occurs for each entity instance at flush time
DefaultFlushEventListener	Defines the default flush event listeners used by hibernate for flushing session state in response to generated flush events.
DefaultIdentifierGeneratorFactory	Basic `templated` support for `IdentifierGeneratorFactory` implementations.
DefaultInitializeCollectionEventListener
DefaultLoadEventListener	Defines the default load event listeners used by hibernate for loading entities in response to generated load events.
DefaultLockEventListener	Defines the default lock event listeners used by hibernate to lock entities in response to generated lock events.
DefaultMergeEventListener	Defines the default copy event listener used by hibernate for copying entities in response to generated copy events.
DefaultNamingStrategy	The default `NamingStrategy`
DefaultPersistEventListener	Defines the default create event listener used by hibernate for creating transient entities in response to generated create events.
DefaultPersistOnFlushEventListener	When persist is used as the cascade action, persistOnFlush should be used
DefaultPostLoadEventListener	We do 2 things here: Call `Lifecycle` interface if necessary Perform needed `getLockMode()` related processing
DefaultPreLoadEventListener	Called before injecting property values into a newly loaded entity instance.
DefaultRefreshEventListener	Defines the default refresh event listener used by hibernate for refreshing entities in response to generated refresh events.
DefaultReplicateEventListener	Defines the default replicate event listener used by Hibernate to replicate entities in response to generated replicate events.
DefaultSaveEventListener	An event handler for save() events
DefaultSaveOrUpdateCopyEventListener
DefaultSaveOrUpdateEventListener	Defines the default listener used by Hibernate for handling save-update events.
DefaultUpdateEventListener	An event handler for update() events
DelayedPostInsertIdentifier	Acts as a stand-in for an entity identifier which is supposed to be generated on insert (like an IDENTITY column) where the insert needed to be delayed because we were outside a transaction when the persist occurred (save currently still performs the insert).
Delete	An SQL `DELETE` statement
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	Defines a top-level AST node representing an HQL delete statement.
DenormalizedTable
DependantValue	A value which is "typed" by reference to some other value (for example, a foreign key is typed by the referenced primary key).
DerbyCaseFragment
DerbyConcatFunction	A specialized concat() function definition in which: we translate to use the concat operator ('\|\|') wrap dynamic parameters in CASTs to VARCHAR This last spec is to deal with a limitation on DB2 and variants (e.g.
DerbyDialect	Hibernate Dialect for Cloudscape 10 - aka Derby.
Destructible	Contract for listeners which require notification of SessionFactory closing, presumably to destroy internal state.
DetachedCriteria	Some applications need to create criteria queries in "detached mode", where the Hibernate session is not available.
DetailedSemanticException	Thrown when a call to the underlying Hibernate engine fails, indicating some form of semantic exception (e.g.
Dialect	Represents a dialect of SQL implemented by a particular RDBMS.
DialectFactory	A factory for generating Dialect instances.
DialectResolver	Contract for determining the `Dialect` to use based on a JDBC Connection.
DialectResolverSet	A `DialectResolver` implementation which coordinates resolution by delegating to its registered sub-resolvers.
DirectPropertyAccessor	Accesses fields directly.
DirectPropertyAccessor.DirectGetter
DirectPropertyAccessor.DirectSetter
DirtyCheckEvent	Defines an event class for the dirty-checking of a session.
DirtyCheckEventListener	Defines the contract for handling of session dirty-check events.
DirtyCollectionSearchVisitor	Do we have a dirty collection here? 1.
DiscriminatorFormula	Discriminator formula To be placed at the root entity.
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 discrimintor properties.
DiscriminatorType	TODO : javadoc
DiscriminatorType<T>	Additional contract for a `Type` may be used for a discriminator.
Disjunction
DisjunctionFragment	A disjunctive string of conditions
DisplayableNode	Implementors will return additional display text, which will be used by the ASTPrinter to display information (besides the node type and node text).
Distinct
DistinctResultTransformer	Distinctions the result tuples in the final result based on the defined equality of the tuples.
DistinctRootEntityResultTransformer	Much like `RootEntityResultTransformer`, but we also distinct the entity in the final result.
Dom4jAccessor	Responsible for accessing property values represented as a dom4j Element or Attribute.
Dom4jAccessor.AttributeGetter	For nodes like `"@bar"`
Dom4jAccessor.AttributeSetter	For nodes like `"@bar"`
Dom4jAccessor.Dom4jGetter	Defines the strategy for getting property values out of a dom4j Node.
Dom4jAccessor.Dom4jSetter
Dom4jAccessor.ElementAttributeGetter	For nodes like `"foo/@bar"`
Dom4jAccessor.ElementAttributeSetter	For nodes like `"foo/@bar"`
Dom4jAccessor.ElementGetter	For nodes like `"foo"`
Dom4jAccessor.ElementSetter	For nodes like `"foo"`
Dom4jAccessor.TextGetter	For nodes like `"."`
Dom4jAccessor.TextSetter	For nodes like `"."`
Dom4jComponentTuplizer	A `ComponentTuplizer` specific to the dom4j entity mode.
Dom4jEntityTuplizer	An `EntityTuplizer` specific to the dom4j entity mode.
Dom4jEntityTuplizer.BasicEntityNameResolver
Dom4jInstantiator	Performs "instantiation" based on DOM4J elements.
Dom4jLazyInitializer	Lazy initializer for "dom4j" entity representations.
Dom4jProxy	Proxy for "dom4j" entity representations.
Dom4jProxyFactory	Builds proxies for "dom4j" entity representations.
DotNode	Represents a reference to a property or alias expression.
DotNode.IllegalCollectionDereferenceExceptionBuilder
DoubleType	A type that maps between `DOUBLE` and Double
DoubleTypeDescriptor	Descriptor for Double handling.
DoubleTypeDescriptor	Descriptor for `DOUBLE` handling.
DriverManagerConnectionProvider	A connection provider that uses `java.sql.DriverManager`.
DTDEntityResolver	An EntityResolver implementation which attempts to resolve various systemId URLs to local classpath lookups Any systemId URL beginning with `http://www.hibernate.org/dtd/` is searched for as a classpath resource in the classloader which loaded the Hibernate classes.
DuplicateMappingException	Raised whenever a duplicate for a certain type occurs.
DynamicFilterParameterSpecification	A specialized ParameterSpecification impl for dealing with a dynamic filter parameters.
DynamicMapComponentTuplizer	A `ComponentTuplizer` specific to the dynamic-map entity mode.
DynamicMapEntityTuplizer	An `EntityTuplizer` specific to the dynamic-map entity mode.
DynamicMapEntityTuplizer.BasicEntityNameResolver
DynamicMapInstantiator

E

Ejb3Column	Wrap state of an EJB3 @Column annotation and build the Hibernate column mapping element
Ejb3DiscriminatorColumn	Discriminator column
EJB3DTDEntityResolver	Resolve JPA xsd files locally
Ejb3JoinColumn	Wrap state of an EJB3 @JoinColumn annotation and build the Hibernate column mapping element
EJB3NamingStrategy	Naming strategy implementing the EJB3 standards
ElementPropertyMapping
ElementWrapper	Wraps dom4j elements, allowing them to exist in a non-hierarchical structure.
EmbeddedComponentType
EmbeddedPropertyAccessor
EmbeddedPropertyAccessor.EmbeddedGetter
EmbeddedPropertyAccessor.EmbeddedSetter
EmptyExpression
EmptyInterceptor	An interceptor that does nothing.
EmptyIterator
EnhancedProjection	An "enhanced" Projection for a `Criteria` query.
EnhancedUserType	A custom type that may function as an identifier or discriminator type, or may be marshalled to and from an XML document
Entity	Extends javax.persistence.Entity with Hibernate features
EntityAccessStrategyAdapter	Adapter specifically bridging `EntityRegionAccessStrategy` to `CacheConcurrencyStrategy`.
EntityAction	Base class for actions relating to insert/update/delete of an entity instance.
EntityAliases	Metadata describing the SQL result set column aliases for a particular entity.
EntityBinder	Stateful holder and processor for binding Entity information
EntityDeleteAction
EntityEntityModeToTuplizerMapping	Handles mapping `EntityMode`s to `EntityTuplizer`s.
EntityEntry	We need an entry to tell us all about the current state of an object with respect to its persistent state
EntityFetchReturn	Spefically a fetch return that refers to an entity association.
EntityIdentityInsertAction
EntityIncrementVersionProcess	Verify/Increment the entity version
EntityInsertAction
EntityJoinWalker	A walker for loaders that fetch entities
EntityKey	Uniquely identifies of an entity instance in a particular session by identifier.
EntityLoadContext
EntityLoader	Loads an entity instance using outerjoin fetching to fetch associated entities.
EntityMetamodel	Centralizes metamodel information about an entity.
EntityMode	Defines the representation modes available for entities.
EntityModeToTuplizerMapping	Centralizes handling of `EntityMode` to `Tuplizer` mappings.
EntityNameResolver	Contract for resolving an entity-name from a given entity instance.
EntityNotFoundDelegate	Delegate to handle the scenario of an entity not found by a specified id.
EntityPersister	Implementors define mapping and persistence logic for a particular strategy of entity mapping.
EntityRegion	Defines the contract for a cache region which will specifically be used to store entity data.
EntityRegionAccessStrategy	Contract for managing transactional and concurrent access to cached entity data.
EntityRegionAdapter	Adapter specifically bridging `EntityRegion` to `Cache`.
EntityStatistics	Entity related statistics
EntityStatisticsImpl	Entity related statistics
EntityTuplizer	Defines further responsibilities reagarding tuplization based on a mapped entity.
EntityTuplizerFactory	A registry allowing users to define the default `EntityTuplizer` class to use per `EntityMode`.
EntityType	Base for types which map associations to persistent entities.
EntityUniqueKey	Used to uniquely key an entity instance in relation to a particular session by some unique property reference, as opposed to identifier.
EntityUpdateAction
EntityVerifyVersionProcess	Verify/Increment the entity version
EnumType	Enum type mapper Try and find the appropriate SQL type depending on column metadata TODO implements readobject/writeobject to recalculate the enumclasses
Environment	Provides access to configuration info passed in `Properties` objects.
EqualsHelper
ErrorCounter	An error handler that counts parsing errors and warnings.
ErrorLogger	Implements an ErrorHandler that mainly just logs errors/warnings.
ErrorReporter	Implementations will report or handle errors invoked by an ANTLR base parser.
EventListeners	A convience holder for all defined session event listeners.
EventSource
EvictEvent	Defines an event class for the evicting of an entity.
EvictEventListener	Defines the contract for handling of evict events generated from a session.
EvictVisitor	Evict any collections referenced by the object from the session cache.
Example	Support for query by example.
Example.PropertySelector	A strategy for choosing property values for inclusion in the query criteria
ExceptionMapper	TODO : javadoc
Executable	An operation which may be scheduled for later execution.
ExecuteUpdateResultCheckStyle	For persistence operations (INSERT, UPDATE, DELETE) what style of determining results (success/failure) is to be used.
ExecutionException	Indicates problem performing the instrumentation execution.
ExistsSubqueryExpression
Expectation	Defines an expected DML operation outcome.
Expectations	Holds various often used `Expectations.BasicExpectation` definitions.
Expectations.BasicExpectation
Expectations.BasicParamExpectation
ExpectedTypeAwareNode	Interface for nodes which wish to be made aware of any determined "expected type" based on the context within they appear in the query.
ExplicitParameterSpecification	An additional contract for parameters which originate from parameters explicitly encountered in the source statement (HQL or native-SQL).
Expression	This class is deprecated. Use `Restrictions`.
ExtendedMappings	This interface is deprecated. All functionality has been moved up to `Mappings`
ExtendsQueueEntry	Represents a mapping queued for delayed processing to await processing of an extends entity upon which it depends.
ExternalSessionFactoryConfig	Defines support for various externally configurable SessionFactory(s), for example, `JMX` or the JCA adapter.

F

Factory	Acts as a ASTFactory for injecting our specific AST node classes into the Antlr generated trees.
FastClass
Fetch	Define the fetching strategy used for the given association
Fetch	Models an individual fetch within a profile.
Fetch.Style	The type or style of fetch.
Fetchable	Any mapping with an outer-join attribute
FetchingScrollableResultsImpl	Implementation of ScrollableResults which can handle collection fetches.
FetchMode	Represents an association fetching strategy.
FetchMode	Fetch options on associations
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
FetchProfiles
FetchReturn	Represents a return which names a fetched association.
FieldFilter	Contract for deciding whether fields should be read and/or write intercepted.
FieldFilter	Used to determine whether a field reference should be instrumented.
FieldHandled	Interface introduced to the enhanced class in order to be able to inject a `FieldHandler` to define the interception behavior.
FieldHandler	The interface defining how interception of a field should be handled.
FieldInterceptionHelper	Helper class for dealing with enhanced entity classes.
FieldInterceptor	Contract for field interception handlers.
FieldInterceptorImpl	A field-level interceptor that initializes lazily fetched properties.
FieldInterceptorImpl	A field-level interceptor that initializes lazily fetched properties.
FieldTransformer	The thing that handles actual class enhancement in regards to intercepting field accesses.
Filter	Type definition of Filter.
Filter	Add filters to an entity or a target entity of a collection
Filterable	Defines mapping elements to which filters may be applied.
FilterDef	Filter definition
FilterDefinition	A FilterDefinition defines the global attributes of a dynamic filter.
FilterDefs	Array of filter definitions
FilterHelper	Implementation of FilterHelper.
FilterImpl	Implementation of FilterImpl.
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.
FilterQueryPlan	Extends an HQLQueryPlan to maintain a reference to the collection-role name being filtered.
Filters	Add multiple @Filters
FilterTranslator	Specialized interface for filters.
FirebirdDialect	An SQL dialect for Firebird.
FkSecondPass
FloatType	A type that maps between `FLOAT` and Float
FloatTypeDescriptor	Descriptor for Float handling.
FloatTypeDescriptor	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.
FlushModeType	Enumeration extending javax.persistence flush modes.
FlushVisitor	Process collections reachable from an entity.
ForceDiscriminator	This @interface is deprecated. use `DiscriminatorOptions` instead
ForeignGenerator	foreign An `Identifier` generator that uses the value of the id property of an associated object One mapping parameter is required: property.
ForeignKey
ForeignKey	A foreign key constraint
ForeignKeyDirection	Represents directionality of the foreign key constraint
ForeignKeyMetadata	JDBC foreign key metadata
ForeignKeys	Algorithms related to foreign key constraint transparency
ForeignKeys.Nullifier
FormatStyle	Represents the the understood types or styles of formatting.
Formatter	Formatter contract
Formula	Formula.
Formula	A formula is a derived column value
ForUpdateFragment
FromClause	Represents the 'FROM' part of a query or subquery, containing all mapped class references.
FromElement	Represents a single mapped class mentioned in an HQL FROM clause.
FromElementFactory	Encapsulates the creation of FromElements and JoinSequences.
FromParser	Parses the from clause of a hibernate query, looking for tables and aliases for the SQL query.
FromPathExpressionParser
FromReferenceNode	Represents a reference to a FROM element, for example a class alias in a WHERE clause.
FrontBaseDialect	An SQL Dialect for Frontbase.
FunctionNode	Identifies a node which models a SQL function.

G

GeneralDataRegion	Contract for general-purpose cache regions.
Generated	The annotated property is generated by the database
GeneratedCollectionAliases	CollectionAliases which handles the logic of selecting user provided aliases (via return-property), before using the default aliases.
GenerationTime	When should the generation occurs
GenericGenerator	Generator annotation describing any kind of Hibernate generator in a detyped manner
GenericGenerators	Array of generic generator definitions
GenericJDBCException	Generic, non-specific JDBCException.
Getter	Gets values of a particular property
GroupByParser	Parses the GROUP BY clause of an aggregate query
GroupsPerOperation
GroupsPerOperation.Operation
GUIDGenerator	Generates `string` values using the SQL Server NEWID() function.

H

H2Dialect	A dialect compatible with the H2 database.
HashtableCache	A lightweight implementation of the `Cache` interface
HashtableCacheProvider	A simple in-memory Hashtable-based cache impl.
HavingParser	Parses the having clause of a hibernate query and translates it to an SQL having clause.
HbmBinder	Walks an XML mapping document and produces the Hibernate configuration-time metamodel (the classes in the `mapping` package)
Helper	TODO : javadoc
Hibernate	Provides access to the full range of Hibernate built-in types.
HibernateException	The base Throwable type for Hibernate.
HibernateIterator	An iterator that may be "closed"
HibernatePermission
HibernateProxy	Marker interface for entity proxies
HibernateProxyHelper	Utility methods for working with proxies.
HibernateSearchEventListenerRegister	This class is deprecated. as of release 3.4.0.CR2, replaced by Hibernate Search's org.hibernate.search.cfg.EventListenerRegister
HibernateService	Implementation of `HibernateServiceMBean`.
HibernateServiceMBean	Hibernate JMX Management API
HibernateSynchronizationImpl	The Synchronization implementation Hibernate registers with the JTA javax.transaction.Transaction
HibernateTraversableResolver	Use Hibernate metadata to ignore cascade on entities.
HolderInstantiator
HqlASTFactory	User: Joshua Davis Date: Sep 23, 2005 Time: 12:30:01 PM
HqlParser	Implements the semantic action methods defined in the HQL base parser to keep the grammar source file a little cleaner.
HQLQueryPlan	Defines a query execution plan for an HQL query (or filter).
HqlSqlWalker	Implements methods used by the HQL->SQL tree transform grammar (a.k.a.
HqlSqlWalkerNode	A semantic analysis node, that points back to the main analyzer.
HqlToken	A custom token class for the HQL grammar.
HSQLCaseFragment	The HSQL CASEWHEN function.
HSQLDialect	An SQL dialect compatible with HSQLDB (HyperSQL).
HSQLDialect.ReadUncommittedLockingStrategy

I

IdBagBinder
IdentifierBag	An `IdentifierBag` has a primary key consisting of just the identifier column
IdentifierBagType
IdentifierCollection	A collection with a synthetic "identifier" column
IdentifierEqExpression	An identifier constraint
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	Identifies `generators` which potentially aggregate other `PersistentIdentifierGenerator` generators.
IdentifierGeneratorFactory	Contract for a `factory` of `IdentifierGenerator` instances.
IdentifierGeneratorHelper	Factory and helper methods for `IdentifierGenerator` framework.
IdentifierGeneratorHelper.BasicHolder
IdentifierGeneratorHelper.BigDecimalHolder
IdentifierGeneratorHelper.BigIntegerHolder
IdentifierProjection	A property value, or grouped property value
IdentifierProperty	Represents a defined entity identifier property within the Hibernate runtime-metamodel.
IdentifierType<T>	Additional contract for a `Type` may be used for a discriminator.
IdentifierValue	A strategy for determining if an identifier value is an identifier of a new transient instance or a previously persistent transient instance.
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.GetGeneratedKeysDelegate	Delegate for dealing with IDENTITY columns using JDBC3 getGeneratedKeys
IdentityGenerator.InsertSelectDelegate	Delegate for dealing with IDENTITY columns where the dialect supports returning the generated IDENTITY value directly from the insert statement.
IdentityMap	A `Map` where keys are compared by object identity, rather than `equals()`.
IdentityMap.IdentityKey
IdentityMap.IdentityMapEntry
IdentitySet	Set implementation that use == instead of equals() as its comparison mechanism.
IdentNode	Represents an identifier all by itself, which may be a function name, a class alias, or a form of naked property-ref depending on the context.
IdGenerator	Identifier generator container, Useful to keep named generator in annotations
IlikeExpression	A case-insensitive "like"
ImageType	A type that maps between `LONGVARBINARY` and `byte[]`
Immutable	Mark an Entity or a Collection as immutable.
ImmutableMutabilityPlan<T>	Mutability plan for immutable objects
ImmutableType	This class is deprecated. Use the `AbstractStandardBasicType` approach instead
ImpliedFromElement	Represents a FROM element implied by a path expression or a collection reference.
ImprovedNamingStrategy	An improved naming strategy that prefers embedded underscores to mixed case names
IncomparableComparator	TODO : javadoc
IncrementGenerator	increment An `IdentifierGenerator` that returns a `long`, constructed by counting from the maximum primary key value at startup.
Index	Define a DB index
Index	A relational table index
IndexBackref
IndexColumn	Describe an index column of a List Prefer the standard javax.persistence.OrderColumn annotation
IndexColumn	index column
IndexedCollection	Indexed collections include Lists, Maps, arrays and primitive arrays.
IndexMetadata	JDBC index metadata
IndexNode	Represents the [] operator and provides it's semantics.
IndexOrUniqueKeySecondPass
IndexPropertyAccessor	Represents a "back-reference" to the index of a collection.
IndexPropertyAccessor.IndexGetter	The Getter implementation for index backrefs.
IndexPropertyAccessor.IndexSetter	The Setter implementation for index backrefs.
InExpression	Constrains the property to a specified list of values
InformixDialect	Informix dialect.
InFragment	An SQL IN expression.
Ingres10Dialect	A SQL dialect for Ingres 10 and later versions.
Ingres9Dialect	A SQL dialect for Ingres 9.3 and later versions.
IngresDialect	An SQL dialect for Ingres 9.2.
InheritanceState	Some extra data to the inheritance position of a class.
Initializable	An event listener that requires access to mappings to initialize state at initialization time.
InitializeableNode	An interface for initializeable AST nodes.
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.
InLogicOperatorNode
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
InsertSelect	Implementation of InsertSelect.
InsertSelectIdentityInsert	Specialized IdentifierGeneratingInsert which appends the database specific clause which signifies to return generated IDENTITY values to the end of the insert statement.
InsertStatement	Defines a top-level AST node representing an HQL "insert select" statement.
InstantiationException	Thrown if Hibernate can't instantiate an entity or component class at runtime.
InstantiationOptimizerAdapter	This class is deprecated. Per HHH-5451 support for cglib as a bytecode provider has been deprecated.
InstantiationOptimizerAdapter	The ReflectionOptimizer#InstantiationOptimizer implementation for Javassist which simply acts as an adapter to the `FastClass` class.
Instantiator	Contract for implementors responsible for instantiating entity/component instances.
InstrumentedClassLoader	A specialized classloader which performs bytecode enhancement on class definitions as they are loaded into the classloader scope.
Instrumenter	TODO : javadoc
Instrumenter.Options
InstrumentTask	This class is deprecated. Per HHH-5451 support for cglib as a bytecode provider has been deprecated; use `InstrumentTask` instead
InstrumentTask	An Ant task for instrumenting persistent classes in order to enable field-level interception using Javassist.
IntegerType	A type that maps between `INTEGER` and @link Integer}
IntegerTypeDescriptor	Descriptor for Integer handling.
IntegerTypeDescriptor	Descriptor for `INTEGER` handling.
IntegralDataTypeHolder	Defines a common api for dealing with data of integral data type.
InterbaseDialect	An SQL dialect for Interbase.
Interceptor	Allows user code to inspect and/or change property values.
IntoClause	Represents an entity referenced in the INTO clause of an HQL INSERT statement.
InvalidMappingException	Thrown when a mapping is found to be invalid.
InvalidPathException	Exception thrown when an invalid path is found in a query.
InvalidWithClauseException
IsNotNullLogicOperatorNode	IsNotNullLogicOperatorNode implementation
IsNullLogicOperatorNode	Represents a 'is null' check.
IsolatedWork	Represents work that needs to be performed in a manner which isolates it from any current application unit of work transaction.
Isolater	Class which provides the isolation semantics required by an `IsolatedWork`.
Isolater.JdbcDelegate	An isolation delegate for JDBC-based transactions.
Isolater.JtaDelegate	An isolation delegate for JTA-based transactions.
IteratorImpl	An implementation of `java.util.Iterator` that is returned by `iterate()` query execution methods.

J

JACCConfiguration	Adds Hibernate permissions to roles via JACC
JACCPermissions	Copied from JBoss org.jboss.ejb3.security.JaccHelper and org.jboss.ejb3.security.SecurityActions
JACCPreDeleteEventListener	Check security before any deletion
JACCPreInsertEventListener	Check security before an insertion
JACCPreLoadEventListener	Check security before any load
JACCPreUpdateEventListener	Check security before any update
JACCSecurityListener	Marker interface for JACC event listeners
JavaConstantNode	A node representing a static Java constant.
JavassistClassTransformer	Enhance the classes allowing them to implements InterceptFieldEnabled This interface is then used by Hibernate for some optimizations.
JavassistHelper
JavassistInstrumenter	Strategy for performing build-time instrumentation of persistent classes in order to enable field-level interception using Javassist.
JavassistLazyInitializer	A Javassist-based lazy initializer proxy.
JavassistProxyFactory	A `ProxyFactory` implementation for producing Javassist-based proxies.
JavaTypeDescriptor<T>	Descriptor for the Java side of a value mapping.
JBossTransactionManagerLookup	A `TransactionManagerLookup` lookup strategy for JBoss AS.
JBossTSStandaloneTransactionManagerLookup	Return a standalone JTA transaction manager for JBoss Transactions Known to work for org.jboss.jbossts:jbossjta:4.11.0.Final
JDataStoreDialect	A `Dialect` for JDataStore.
JDBCConnectionException	Implementation of JDBCException indicating problems with communicating with the database (can also include incorrect JDBC setup).
JDBCContext	Acts as the mediary between "entity-mode related" sessions in terms of their interaction with the JDBC data store.
JDBCContext.Context
JdbcDateTypeDescriptor	TODO : javadoc
JdbcDateTypeDescriptor.DateMutabilityPlan
JDBCException	Wraps an `SQLException`.
JDBCExceptionHelper	Implementation of JDBCExceptionHelper.
JDBCExceptionReporter
JDBCExceptionReporter.StandardWarningHandler
JDBCExceptionReporter.WarningHandler	Contract for handling SQLWarning warnings
JDBCExceptionReporter.WarningHandlerLoggingSupport	Basic support for `JDBCExceptionReporter.WarningHandler` implementations which log
JdbcSupport	Isolates Hibernate interactions with JDBC in terms of variations between JDBC 3 (JDK 1.4 and 1.5) and JDBC 4 (JDK 1.6).
JdbcSupportImpl	TODO : javadoc
JdbcSupportLoader	Builds `JdbcSupport` instances based on the capabilities of the environment.
JdbcTimestampTypeDescriptor	TODO : javadoc
JdbcTimestampTypeDescriptor.TimestampMutabilityPlan
JdbcTimeTypeDescriptor	TODO : javadoc
JdbcTimeTypeDescriptor.TimeMutabilityPlan
JDBCTransaction	`Transaction` implementation based on transaction management through a JDBC java.sql.Connection.
JDBCTransactionFactory	Factory for `JDBCTransaction` instances.
JdbcTypeNameMapper	TODO : javadoc
JNDITransactionManagerLookup	Template implementation of `TransactionManagerLookup` where the underlying TransactionManager is available via JNDI lookup at the specified location - `getName()`.
Join
Joinable	Anything that can be loaded by outer join - namely persisters for classes or collections.
JoinColumnOrFormula
JoinColumnsOrFormulas
JoinedIterator	An JoinedIterator is an Iterator that wraps a number of Iterators.
JoinedSubclass	A subclass in a table-per-subclass mapping
JoinedSubclassEntityPersister	An `EntityPersister` implementing the normalized "table-per-subclass" mapping strategy
JoinedSubclassFkSecondPass
JoinFormula	JoinFormula.
JoinFragment	An abstract SQL join fragment renderer
JoinHelper
JoinProcessor	Performs the post-processing of the join information gathered during semantic analysis.
JoinSequence
JoinSequence.Join
JoinSequence.Selector
JoinWalker	Walks the metamodel, searching for joins, and collecting together information needed by `OuterJoinLoader`.
JoinWalker.AssociationInitCallback
JOnASTransactionManagerLookup	`TransactionManagerLookup` strategy for JOnAS
JOTMTransactionManagerLookup	`TransactionManagerLookup` strategy for JOTM
JPAMetadataProvider	MetadataProvider aware of the JPA Deployment descriptor
JPAOverridenAnnotationReader	Encapsulates the overriding of Java annotations from an EJB 3.0 descriptor.
JRun4TransactionManagerLookup	`TransactionManagerLookup` strategy for JRun4 AS
JTAHelper
JTASessionContext	An implementation of `CurrentSessionContext` which scopes the notion of a current session to a JTA transaction.
JTASessionContext.CleanupSynch	JTA transaction synch used for cleanup of the internal session map.
JTATransaction	`Transaction` implementation based on transaction management through a JTA UserTransaction.
JTATransactionFactory	Factory for `JTATransaction` instances.
Junction	A sequence of a logical expressions combined by some associative logical operator

K

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.

L

LazyCollection	Define the lazy status of a collection
LazyCollectionOption	Lazy options available for a collection
LazyInitializationException	Indicates access to unfetched data outside of a session context.
LazyInitializer	Handles fetching of the underlying entity for a proxy
LazyIterator
LazyPropertyInitializer	Contract for controlling how lazy properties get initialized.
LazyToOne	Define the lazy status of a ToOne association (ie OneToOne or ManyToOne)
LazyToOneOption	Lazy options available for a ToOne association
Lifecycle	Provides callbacks from the `Session` to the persistent object.
LikeExpression	A criterion representing a "like" expression
List	A list mapping has a primary key consisting of the key columns + index column.
ListBinder	Bind a list to the underlying Hibernate configuration
ListType
LiteralNode	Represents a literal.
LiteralProcessor	A delegate that handles literals and constants for HqlSqlWalker, performing the token replacement functions and classifying literals.
LiteralType<T>	Additional contract for a `Type` that may appear as an SQL literal
Loadable	Implemented by a `EntityPersister` that may be loaded using `Loader`.
LoadContexts	Maps ResultSet result-sets to specific contextual data related to processing that ResultSet result-sets.
Loader	Loader Annotation for overwriting Hibernate default FIND method
Loader	Abstract superclass of object loading (and querying) strategies.
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.
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	The callback contract for making use of the JDBC Connection.
LobCreator	Contract for creating various LOB references.
LobHelper	A `session's` helper for creating LOB data
LobType<T>	A base type used to define a LOB type; it also provides alternatives that can override this type via `getAlternatives()` getAlternatives()}
LocaleType	A type that maps between `VARCHAR` and @link Locale}
LocaleTypeDescriptor	TODO : javadoc
LocaleTypeDescriptor.LocaleComparator
Lockable	Contract for things that can be locked via a `LockingStrategy`.
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.
LockMode	Instances represent a lock mode for a row of a relational database table.
LockOptions	Contains locking details (LockMode, Timeout and Scope).
LoggableUserType	Marker interface for user types which want to perform custom logging of their corresponding values
Logger	Provides an abstraction for how instrumentation does logging because it is usually run in environments (Ant/Maven) with their own logging infrastructure.
LogicalExpression	Superclass of binary logical expressions
LongType	A type that maps between `BIGINT` and Long
LongTypeDescriptor	Descriptor for Long handling.
LongVarbinaryTypeDescriptor	Descriptor for `LONGVARBINARY` handling.
LongVarcharTypeDescriptor	Descriptor for `LONGVARCHAR` handling.
LRUMap	A simple LRU cache that implements the `Map` interface.

M

ManagedSessionContext	Represents a `CurrentSessionContext` the notion of a contextual session is managed by some external entity (generally some form of interceptor, etc).
ManyToAny	Defined a ToMany association pointing to different entity types.
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.
MapAccessor
MapAccessor.MapGetter
MapAccessor.MapSetter
MapBinder	Implementation to bind a Map
MapEntryNode	TODO : javadoc
MapKey	This @interface is deprecated. Use javax.persistence.MapKeyColumn This is the default behavior for Map properties marked as @OneToMany, @ManyToMany or @ElementCollection
MapKeyColumnDelegator
MapKeyJoinColumnDelegator
MapKeyManyToMany	This @interface is deprecated. Use javax.persistence.MapKeyJoinColumn javax.persistence.MapKeyJoinColumns This is the default behavior for Map properties marked as @OneToMany, @ManyToMany or @ElementCollection
MapKeyNode	TODO : javadoc
MapKeyType	Allows defining the type of the key of a persistent map.
MapLazyInitializer	Lazy initializer for "dynamic-map" entity representations.
MappedSuperclass	Represents a @MappedSuperclass.
Mapping	Defines operations common to "compiled" mappings (ie.
MappingException	An exception that usually occurs at configuration time, rather than runtime, as a result of something screwy in the O-R mappings.
MappingNotFoundException	Thrown when a resource for a mapping could not be found.
MappingReader	Handles reading mapping documents, both `hbm` and `orm` varieties.
Mappings	A collection of mappings from classes and collections to relational database tables.
Mappings.PropertyReference	Represents a property-ref mapping.
MapProxy	Proxy for "dynamic-map" entity representations.
MapProxyFactory
MapType
MapValueNode	TODO : javadoc
MarkerObject
MatchMode	Represents an strategy for matching strings using "like".
MaterializedBlobType	A type that maps between `BLOB` and `byte[]`
MaterializedClobType	A type that maps between `CLOB` and String
MckoiCaseFragment	A Mckoi IF function.
MckoiDialect	An SQL dialect compatible with McKoi SQL
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.
MetadataSource	Enumeration of the known places from which a piece of metadata may come.
MetadataSourceType	Enumeration of the types of sources of mapping metadata
MetaType
MetaValue	Represent a discriminator value associated to a given entity type
MethodNode	Represents a method call.
MimerSQLDialect	An Hibernate 3 SQL dialect for Mimer SQL.
MultipleBagFetchException	Exception used to indicate that a query is attempting to simultaneously fetch multiple `bags`
MultipleHiLoPerTableGenerator	A hilo `IdentifierGenerator` that returns a `Long`, constructed using a hi/lo algorithm.
MultiTableDeleteExecutor	Implementation of MultiTableDeleteExecutor.
MultiTableUpdateExecutor	Implementation of MultiTableUpdateExecutor.
MutabilityPlan<T>	TODO : javadoc
MutableMutabilityPlan<T>	Mutability plan for mutable objects
MutableType	This class is deprecated. Use the `AbstractStandardBasicType` approach instead
MySQL5Dialect	An SQL dialect for MySQL 5.x specific features.
MySQL5InnoDBDialect
MySQLDialect	An SQL dialect for MySQL (prior to 5.x).
MySQLInnoDBDialect
MySQLMyISAMDialect

N

NamedNativeQueries	Extends javax.persistence.NamedNativeQueries to hold hibernate NamedNativeQuery objects
NamedNativeQuery	Extends javax.persistence.NamedNativeQuery with Hibernate features
NamedParameterDescriptor	Descriptor regarding a named parameter.
NamedParameterSpecification	Parameter bind specification for an explicit named parameter.
NamedQueries	Extends javax.persistence.NamedQueries to hold hibernate NamedQuery objects
NamedQuery	Extends javax.persistence.NamedQuery with Hibernate features
NamedQueryCollectionInitializer	A wrapper around a named query.
NamedQueryDefinition	Definition of a named query, defined in the mapping metadata.
NamedQueryLoader	Not really a `Loader`, just a wrapper around a named query.
NamedSQLQueryDefinition	Definition of a named native SQL query, defined in the mapping metadata.
NamedSQLQuerySecondPass
NameGenerator	Provides utility methods for generating HQL / SQL names.
NamingHelper
NamingStrategy	A set of rules for determining the physical column and table names given the information in the mapping document.
NativeSQLQueryCollectionReturn	Represents a return defined as part of a native sql query which names a collection role in the form {classname}.{collectionrole}; it is used in defining a custom sql query for loading an entity's collection in non-fetching scenarios (i.e., loading the collection itself as the "root" of the result).
NativeSQLQueryJoinReturn	Represents a return defined as part of a native sql query which names a fetched role.
NativeSQLQueryNonScalarReturn	Represents the base information for a non-scalar return defined as part of a native sql query.
NativeSQLQueryPlan	Defines a query execution plan for a native-SQL query.
NativeSQLQueryReturn	Describes a return in a native SQL query.
NativeSQLQueryRootReturn	Represents a return defined as part of a native sql query which names a "root" entity.
NativeSQLQueryScalarReturn	Describes a scalar return in a native SQL query.
NativeSQLQuerySpecification	Defines the specification or blue-print for a native-sql query.
NaturalId	This specifies that a property is part of the natural id of the entity.
NaturalIdentifier
NClobImplementer	Marker interface for non-contextually created java.sql.NClob instances..
NClobProxy	Manages aspects of proxying java.sql.NClobs for non-contextual creation, including proxy creation and handling proxy invocations.
NoArgSQLFunction	A function which takes no arguments
NoCacheProvider	Implementation of NoCacheProvider.
NoCachingEnabledException	Implementation of NoCachingEnabledException.
NoCachingRegionFactory	Factory used if no caching enabled in config...
Node	Base node class for use by Hibernate within its AST trees.
Node	General contract for AST nodes.
NodeSupport	Basic implementation of a `Node`.
NodeTraverser	A visitor for traversing an AST tree.
NodeTraverser.VisitationStrategy
NonBatchingBatcher	An implementation of the `Batcher` interface that does no batching
NonBatchingBatcherFactory	A BatcherFactory implementation which constructs Batcher instances that do not perform batch operations.
NonContextualLobCreator	`LobCreator` implementation using non-contextual or local creation, meaning that we generate the LOB references ourselves as opposed to delegating to the JDBC java.sql.Connection.
NonFlushedChanges
NonFlushedChangesImpl
NonScalarReturn	Represents some non-scalar (entity/collection) return within the query result.
NonstrictReadWriteCache	Caches data that is sometimes updated without ever locking the cache.
NonUniqueObjectException	This exception is thrown when an operation would break session-scoped identity.
NonUniqueResultException	Thrown when the application calls `Query.uniqueResult()` and the query returned more than one result.
NoopAccessor	Used to declare properties not represented at the pojo level
NotEmptyExpression
NotExpression	Negates another criterion
NotFound	Action to do when an element is not found on a association whiel beeing expected
NotFoundAction	Actoin to use when an element is not found in DB while beeing expected
NotNullExpression	Constrains a property to be non-null
NotYetImplementedException	Mapping not yet implemented
Nullability	Are the columns forced to null, not null or not forced
Nullability	Implements the algorithm for validating property values for illegal null values
NullableType	This class is deprecated. Use the `AbstractStandardBasicType` approach instead
NullExpression	Constrains a property to be null
NullSynchronizationException	TODO : javadoc
NumericBooleanType	A type that maps between `INTEGER` and Boolean (using 1 and 0)
NumericTypeDescriptor	Descriptor for `NUMERIC` handling.
NvlFunction	Emulation of `coalesce()` on Oracle, using multiple `nvl()` calls

O

ObjectDeletedException	Thrown when the user tries to do something illegal with a deleted object.
ObjectNameNormalizer	Provides centralized normalization of how database object names are handled.
ObjectNameNormalizer.NamingStrategyHelper	Helper contract for dealing with `NamingStrategy` in different situations.
ObjectNameSource	Source for database object names (identifiers).
ObjectNotFoundException	Thrown when `Session.load()` fails to select a row with the given primary key (identifier value).
ObjectType	Specific adaptation of the "any" type to the old deprecated "object" type
OC4JTransactionManagerLookup	`TransactionManagerLookup` for the OC4J (Oracle) AS.
OnDelete	Strategy to use on collections, arrays and on joined subclasses delete OnDelete of secondary tables currently not supported.
OnDeleteAction	Possible actions on deletes
OneToMany	A mapping for a one-to-many association
OneToManyJoinWalker	Walker for one-to-many associations
OneToManyLoader	Loads one-to-many associations The collection persister must implement `QueryableCOllection.`
OneToManyPersister	Collection persister for one-to-many associations.
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
OnLockVisitor	When a transient entity is passed to lock(), we must inspect all its collections and 1.
OnReplicateVisitor	When an entity is passed to replicate(), and there is an existing row, we must inspect all its collections and 1.
OnUpdateVisitor	When an entity is passed to update(), we must inspect all its collections and 1.
OperatorNode	Contract for nodes representing operators (logic or arithmetic).
OptimisticCache	A contract for transactional cache implementations which support optimistic locking of items within the cache.
OptimisticCacheSource	Contract for sources of optimistically lockable data sent to the second level cache.
OptimisticCacheSourceAdapter
OptimisticForceIncrementLockingStrategy	An optimistic locking strategy that forces an increment of the version (after verifying that version hasn't changed).
OptimisticLock	Whether or not update entity's version on property's change If the annotation is not present, the property is involved in the optimistic lock srategy (default)
OptimisticLockException	Throw when an optimistic locking conflict occurs.
OptimisticLockingStrategy	An optimistic locking strategy that verifies that the version hasn't changed (prior to transaction commit).
OptimisticLockType	Optimistic locking strategy VERSION is the default and recommanded one
Optimizer	Performs optimization on an optimizable identifier generator.
OptimizerFactory	Factory for `OptimizerFactory.InitialValueAwareOptimizer` instances.
OptimizerFactory.HiLoOptimizer	Optimizer which applies a 'hilo' algorithm in memory to achieve optimization.
OptimizerFactory.InitialValueAwareOptimizer	Marker interface for optimizer which wish to know the user-specified initial value.
OptimizerFactory.LegacyHiLoAlgorithmOptimizer
OptimizerFactory.NoopOptimizer	An optimizer that performs no optimization.
OptimizerFactory.OptimizerSupport	Common support for optimizer implementations.
OptimizerFactory.PooledLoOptimizer
OptimizerFactory.PooledOptimizer	Optimizer which uses a pool of values, storing the next low value of the range in the database.
Oracle10gDialect	A dialect specifically for use with Oracle 10g.
Oracle8iDialect	A dialect for Oracle 8i.
Oracle9Dialect	This class is deprecated. Use either Oracle9iDialect or Oracle10gDialect instead
Oracle9iDialect	A dialect for Oracle 9i databases.
OracleDialect	This class is deprecated. Use Oracle8iDialect instead.
OracleJoinFragment	An Oracle-style (theta) join
Order	Represents an order imposed upon a `Criteria` result set
OrderBy	Order a collection using SQL ordering (not HQL ordering)
OrderByClause	Implementation of OrderByClause.
OrderByFragment	Represents a parsed `order-by` mapping fragment.
OrderByFragmentParser	Extension of the Antlr-generated parser for the purpose of adding our custom parsing behavior.
OrderByFragmentRenderer	TODO : javadoc
OrderByFragmentTranslator	A translator which coordinates translation of an `order-by` mapping.
OrderByParser	Parses the ORDER BY clause of a query
OrderedMapType	A specialization of the map type, with (resultset-based) ordering.
OrderedSetType	A specialization of the set type, with (resultset-based) ordering.
OrderingSpecification	Models an ordering specification (`ASCENDING` or `DESCENDING`) within a `SortSpecification`.
OrderingSpecification.Ordering
OrdinalParameterDescriptor
Origin	Describes the origin of an xml document
OriginImpl	Basic implementation of `Origin`
OrionTransactionManagerLookup	`TransactionManagerLookup` strategy for Orion
OuterJoinableAssociation	Part of the Hibernate SQL rendering internals.
OuterJoinLoadable	A `EntityPersister` that may be loaded by outer join using the `OuterJoinLoader` hierarchy and may be an element of a one-to-many association.
OuterJoinLoader	Implements logic for walking a tree of associated classes.

P

ParamDef	A parameter definition
Parameter	Parameter (basically key/value pattern)
ParameterBinder	Centralizes the commonality regarding binding of parameter values into PreparedStatements as this logic is used in many places.
ParameterBinder.NamedParameterSource
ParameterContainer	Currently this is needed in order to deal with `FromElements` which contain "hidden" JDBC parameters from applying filters.
ParameterizedType	Support for parameterizable types.
ParameterMetadata	Encapsulates metadata about parameters encountered within a query.
ParameterNode	Implementation of ParameterNode.
ParameterParser	The single available method `parse(String, ParameterParser.Recognizer)` is responsible for parsing a query string and recognizing tokens in relation to parameters (either named, JPA-style, or ordinal) and providing callbacks about such recognitions.
ParameterParser.Recognizer
ParameterSpecification	Maintains information relating to parameters which need to get bound into a JDBC PreparedStatement.
ParameterTranslations	Defines available information about the parameters encountered during query translation.
ParameterTranslationsImpl	Defines the information available for parameters encountered during query translation through the antlr-based parser.
ParameterTranslationsImpl.ParameterInfo
ParamLocationRecognizer	Implements a parameter parser recognizer specifically for the purpose of journaling parameter locations.
ParamLocationRecognizer.NamedParameterDescription
Parent	Reference the property as a pointer back to the owner (generally the owning entity)
ParseErrorHandler	Defines the behavior of an error handler for the HQL parsers.
Parser	A parser is a state machine that accepts a string of tokens, bounded by start() and end() and modifies a QueryTranslator.
ParserHelper
PassThroughResultTransformer	???
PathExpressionParser	Parses an expression of the form foo.bar.baz and builds up an expression involving two less table joins than there are path components.
PathHelper	Provides utility methods for paths.
PathNode	An AST node with a path property.
PersistenceContext	Holds the state of the persistence context, including the first-level cache, entries, snapshots, proxies, etc.
PersistentArrayHolder	A persistent wrapper for an array.
PersistentBag	An unordered, unkeyed collection that can contain the same element multiple times.
PersistentClass	Mapping for an entity.
PersistentClassVisitor
PersistentCollection	Persistent collections are treated as value objects by Hibernate.
PersistentElementHolder	A persistent wrapper for an XML element
PersistentIdentifierBag	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.
PersistentIndexedElementHolder	A persistent wrapper for an XML element
PersistentIndexedElementHolder.IndexedValue
PersistentList	A persistent wrapper for a `java.util.List`.
PersistentListElementHolder
PersistentMap	A persistent wrapper for a `java.util.Map`.
PersistentMapElementHolder
PersistentObjectException	Thrown when the user passes a persistent instance to a `Session` method that expects a transient instance.
PersistentSet	A persistent wrapper for a `java.util.Set`.
PersistentSortedMap	A persistent wrapper for a `java.util.SortedMap`.
PersistentSortedSet	A persistent wrapper for a `java.util.SortedSet`.
Persister	Specify a custom persister.
PersisterClassProvider	Provides persister classes based on the entity or collection role.
PersisterFactory	Factory for `EntityPersister` and `CollectionPersister` instances
PersistEvent	An event class for persist()
PersistEventListener	Defines the contract for handling of create events generated from a session.
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.
PkDrivenByDefaultMapsIdSecondPass
PointbaseDialect	A `Dialect` for Pointbase.
PojoComponentTuplizer	A `ComponentTuplizer` specific to the pojo entity mode.
PojoEntityTuplizer	An `EntityTuplizer` specific to the pojo entity mode.
PojoInstantiator	Defines a POJO-based instantiator for use from the tuplizers.
PolymorphismType	Type of available polymorphism for a particular entity
PositionalParameterSpecification	Parameter bind specification for an explicit positional (or ordinal) parameter.
PositionSubstringFunction	Emulation of `locate()` on PostgreSQL
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
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
PostgreSQLDialect	An SQL dialect for Postgres For discussion of BLOB support in Postgres, as of 8.4, have a peek at http://jdbc.postgresql.org/documentation/84/binary-data.html.
PostgresUUIDType	Specialized type mapping for UUID and the Postgres UUID data type (which is mapped as OTHER in its JDBC driver).
PostgresUUIDType.PostgresUUIDSqlTypeDescriptor
PostInsertEvent	Occurs after inserting an item in the datastore
PostInsertEventListener	Called after insterting 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 an entity instance is fully loaded.
PostLoadEventListener	Occurs after an 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
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.
PreprocessingParser
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
PrimitiveArray	A primitive array has a primary key consisting of the key columns + index column.
PrimitiveArrayBinder
PrimitiveByteArrayBlobType	This class is deprecated. replaced by `MaterializedBlobType`
PrimitiveByteArrayTypeDescriptor	Descriptor for `byte[]` handling.
PrimitiveCharacterArrayClobType	Map a char[] to a Clob
PrimitiveCharacterArrayTypeDescriptor	TODO : javadoc
PrimitiveType<T>	Additional contract for primitive / primitive wrapper types.
Printer	Renders entities to a nicely readable string.
ProgressDialect	An SQL dialect compatible with Progress 9.1C Connection Parameters required: hibernate.dialect org.hibernate.sql.ProgressDialect hibernate.driver com.progress.sql.jdbc.JdbcProgressDriver hibernate.url jdbc:JdbcProgress:T:host:port:dbname;WorkArounds=536870912 hibernate.username username hibernate.password password The WorkArounds parameter in the URL is required to avoid an error in the Progress 9.1C JDBC driver related to PreparedStatements.
Projection	An object-oriented representation of a query result set projection in a `Criteria` query.
ProjectionList
Projections	The `criterion` package may be used by applications as a framework for building new kinds of `Projection`.
PropertiesHelper	Collection of helper methods for dealing with java.util.Properties objects.
Property	A factory for property-specific criterion and projection instances
Property	Represents a property as part of an entity or a component.
Property	Defines the basic contract of a Property within the runtime metamodel.
PropertyAccessException	A problem occurred accessing a property of an instance of a persistent class by reflection, or via CGLIB.
PropertyAccessor	Abstracts the notion of a "property".
PropertyAccessorFactory	A factory for building/retrieving PropertyAccessor instances.
PropertyBinder
PropertyData
PropertyExpression	superclass for comparisons between two properties (with SQL binary operators)
PropertyFactory	Responsible for generation of runtime metamodel `Property` representations.
PropertyGeneration	Indicates whether given properties are generated by the database and, if so, at what time(s) they are generated.
PropertyHolder	Property holder abstract property containers from their direct implementation
PropertyHolderBuilder	This factory is here ot build a PropertyHolder and prevent .mapping interface adding
PropertyInferredData	Retrieve all inferred data from an annnoted element
PropertyMapping	Abstraction of all mappings that define properties: entities, collection elements.
PropertyNotFoundException	Indicates that an expected getter or setter method could not be found on a class.
PropertyPath	TODO : javadoc
PropertyPreloadedData
PropertyProjection	A property value, or grouped property value
PropertySubqueryExpression	A comparison between a property value in the outer query and the result of a subquery
PropertyValueException	Thrown when the (illegal) value of a property can not be persisted.
Proxy	Lazy and proxy configuration of a particular class
ProxyFactory	Contract for run-time, proxy-based lazy initialization proxies.
ProxyFactoryFactory	An interface for factories of `proxy factory` instances.
ProxyFactoryFactoryImpl	This class is deprecated. Per HHH-5451 support for cglib as a bytecode provider has been deprecated.
ProxyFactoryFactoryImpl	A factory for Javassist-based `ProxyFactory` instances.
ProxyFactoryFactoryImpl.BasicProxyFactoryImpl
ProxyVisitor	Reassociates uninitialized proxies with the session

Q

Query	An object-oriented representation of a Hibernate query.
Queryable	Extends the generic `EntityPersister` contract to add operations required by the Hibernate Query Language
Queryable.Declarer
QueryableCollection	A collection role that may be queried or loaded by outer join.
QueryBinder	Query binder
QueryCache	Defines the contract for caches capable of storing query results.
QueryCacheFactory	Defines a factory for query cache instances.
QueryException	A problem occurred translating a Hibernate query to SQL due to invalid query syntax, etc.
QueryExecutionRequestException	Expecting to execute an illegal operation regarding the query type
QueryImpl	default implementation of the `Query` interface, for "ordinary" HQL queries (not collection filters)
QueryJoinFragment	A join that appears in a translated HQL query
QueryKey	A key that identifies a particular query with bound parameter values.
QueryLoader	A delegate that implements the Loader part of QueryTranslator.
QueryMetadata	Defines metadata regarding a translated HQL or native-SQL query.
QueryNode	Defines a top-level AST node representing an HQL select statement.
QueryParameterException	Parameter invalid or not found in the query
QueryParameters
QueryPlanCache	Acts as a cache for compiled query plans, as well as query-parameter metadata.
QueryResultsRegion	Defines the contract for a cache region which will specifically be used to store query results.
QueryResultsRegionAdapter	Adapter specifically briding `QueryResultsRegion` to `Cache`.
QuerySecondPass	Bind query
QuerySelect	A translated HQL query
QuerySplitter	Provides query splitting methods, which were originally in QueryTranslator.
QueryStatistics	Query statistics (HQL and SQL) Note that for a cached query, the cache miss is equals to the db count
QueryStatisticsImpl	Query statistics (HQL and SQL) Note that for a cached query, the cache miss is equals to the db count
QuerySyntaxException	Exception thrown when there is a syntax error in the HQL.
QueryTimeoutException	Thrown when a database query timeout occurs.
QueryTranslator	Defines the contract of an HQL->SQL translator.
QueryTranslatorFactory	Facade for generation of `QueryTranslator` and `FilterTranslator` instances.
QueryTranslatorImpl	A QueryTranslator that uses an Antlr-based parser.
QueryTranslatorImpl	An instance of `QueryTranslator` translates a Hibernate query string to SQL.
QueryTranslatorImpl.JavaConstantConverter

R

RDMSOS2200Dialect	This is the Hibernate dialect for the Unisys 2200 Relational Database (RDMS).
ReaderInputStream	Exposes a Reader as an InputStream.
ReaderInputStream	This class is deprecated. Should not be used anymore.
ReadOnlyCache	Caches data that is never updated.
ReadWriteCache	Caches data that is sometimes updated while maintaining the semantics of "read committed" isolation level.
ReadWriteCache.Item	An item of cached data, timestamped with the time it was cached,.
ReadWriteCache.Lock	A soft lock which supports concurrent locking, timestamped with the time it was released
ReadWriteCache.Lockable
RealTypeDescriptor	Descriptor for `REAL` handling.
ReattachVisitor	Abstract superclass of visitors that reattach collections.
RecoverableException	Should neven be exposed to the client An exception that wrap an underlying exception whith the hope subsequent processing will recover from it.
ReflectHelper	Utility class for various reflection operations.
ReflectionOptimizer	Represents reflection optimization for a particular class.
ReflectionOptimizer.AccessOptimizer	Represents optimized entity property access.
ReflectionOptimizer.InstantiationOptimizer	Represents optimized entity instantiation.
ReflectionOptimizerImpl	This class is deprecated. Per HHH-5451 support for cglib as a bytecode provider has been deprecated.
ReflectionOptimizerImpl	ReflectionOptimizer implementation for Javassist.
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	Defines a contract for accessing a particular named region within the underlying cache implementation.
RegionFactory	Contract for building second level cache regions.
RegionFactoryCacheProviderBridge	Acts as a bridge between the `RegionFactory` contract and the older `CacheProvider` contract.
RelationalModel	A relational object which may be created using DDL
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	Represents a replication strategy.
ResinTransactionManagerLookup	`TransactionManagerLookup` strategy for Resin
ResolvableNode	The contract for expression sub-trees that can resolve themselves.
RestrictableStatement	Type definition for Statements which are restrictable via a where-clause (and thus also having a from-clause).
Restrictions	The `criterion` package may be used by applications as a framework for building new kinds of `Criterion`.
ResultCheckStyle	Possible checks on Sql Insert, Delete, Update
ResultColumnReferenceStrategy	Defines how we need to reference columns in the group-by, having, and order-by clauses.
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`
ResultSetMappingBinder
ResultSetMappingDefinition	Keep a description of the resultset mapping
ResultsetMappingSecondPass
ResultSetMappingSecondPass
ResultSetWrapperProxy	A proxy for a ResultSet delegate, responsible for locally caching the columnName-to-columnIndex resolution that has been found to be inefficient in a few vendor's drivers (i.e., Oracle and Postgres).
ResultTransformer	Implementors define a strategy for transforming query results into the actual application-visible query result list.
ResultVariableRefNode	Represents a reference to a result_variable as defined in the JPA 2 spec.
Return	Represents a return in a custom query.
ReturnMetadata
RootClass	The root class of an inheritance hierarchy
RootEntityResultTransformer	`ResultTransformer` implementation which limits the result tuple to only the "root entity".
RootReturn	Represents a return which names a "root" entity.
RowCountProjection	A row count
RowSelection	Represents a selection of rows in a JDBC `ResultSet`

S

SAPDBDialect	An SQL dialect compatible with SAP DB.
SaveOrUpdateEvent	An event class for saveOrUpdate()
SaveOrUpdateEventListener	Defines the contract for handling of update events generated from a session.
ScalarReturn	Represent a scalar (aka simple value) return within a query result.
SchemaExport	Commandline tool to export table schema to the database.
SchemaExportTask	An Ant task for `SchemaExport`.
SchemaUpdate	A commandline tool to update a database schema.
SchemaUpdateTask	An Ant task for `SchemaUpdate`.
SchemaValidator	A commandline tool to update a database schema.
SchemaValidatorTask	An Ant task for `SchemaUpdate`.
ScrollableResults	A result iterator that allows moving around within the results by arbitrary increments.
ScrollableResultsImpl	Implementation of the `ScrollableResults` interface
ScrollMode	Specifies the type of JDBC scrollable result set to use underneath a `ScrollableResults`
SecondaryTableSecondPass
SecondLevelCacheStatistics	Second level cache statistics of a specific region
SecondLevelCacheStatisticsImpl	Second level cache statistics of a specific region
SecondPass	Second pass operation
Select	A simple SQL `SELECT` statement
Selectable
SelectClause	Represents the list of expressions in a SELECT clause.
SelectExpression	Represents an element of a projection list, i.e.
SelectExpression	TODO : javadoc
SelectExpressionImpl	A select expression that was generated by a FROM element.
SelectExpressionList	Common behavior - a node that contains a list of select expressions.
SelectFragment	A fragment of an SQL `SELECT` clause
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.
SelectLockingStrategy	A locking strategy where the locks are obtained through select statements.
SelectParser	Parsers the select clause of a Hibernate query.
SelectPathExpressionParser
SequenceGenerator	sequence Generates `long` values using an oracle-style sequence.
SequenceHiLoGenerator	seqhilo An `IdentifierGenerator` that combines a hi/lo algorithm with an underlying oracle-style sequence that generates hi values.
SequenceIdentityGenerator	A generator which combines sequence generation with immediate retrieval through JDBC3 `getGeneratedKeys`.
SequenceIdentityGenerator.Delegate
SequenceIdentityGenerator.NoCommentsInsert
SequenceStructure	Describes a sequence.
SequenceStyleGenerator	Generates identifier values based on an sequence-style database structure.
SerializableBlobProxy	Manages aspects of proxying Blob Blobs to add serializability.
SerializableClobProxy	Manages aspects of proxying Clob Clobs to add serializability.
SerializableNClobProxy	Manages aspects of proxying java.sql.NClobs to add serializability.
SerializableProxy	This class is deprecated. Per HHH-5451 support for cglib as a bytecode provider has been deprecated.
SerializableProxy	Serializable placeholder for Javassist proxies
SerializableToBlobType
SerializableType<T extends Serializable>	A type that maps between a `VARBINARY` and `Serializable` classes.
SerializableTypeDescriptor<T extends Serializable>	TODO : javadoc
SerializableTypeDescriptor.SerializableMutabilityPlan<S extends Serializable>
SerializationException	Thrown when a property cannot be serializaed/deserialized
SerializationHelper	Assists with the serialization process and performs additional functionality based on serialization.
Session	The main runtime interface between a Java application and Hibernate.
Session	An extension of the `Session` API, including all deprecated methods from Hibernate2.
Session.LockRequest	Contains locking details (LockMode, Timeout and Scope).
SessionException	Thrown when the user calls a method of a `Session` that is in an inappropropriate state for the given call (for example, the the session is closed or disconnected).
SessionFactory	The main contract here is the creation of `Session` instances.
SessionFactoryAwareNode	Interface for nodes which require access to the SessionFactory
SessionFactoryHelper	Helper for performing common and/or complex operations with the `SessionFactoryImplementor` during translation of an HQL query.
SessionFactoryImpl	Concrete implementation of the `SessionFactory` interface.
SessionFactoryImplementor	Defines the internal contract between the `SessionFactory` and other parts of Hibernate such as implementors of `Type`.
SessionFactoryObjectFactory	Resolves `SessionFactory` instances during `JNDI look-ups as well as during deserialization`
SessionFactoryObserver	Allows reaction to basic `SessionFactory` occurrences.
SessionFactoryStub	A flyweight for `SessionFactory`.
SessionImpl	Concrete implementation of a Session, and also the central, organizing component of Hibernate's internal implementation.
SessionImplementor	Defines the internal contract between the `Session` and other parts of Hibernate such as implementors of `Type` or `EntityPersister`.
SessionStatistics	Information about the first-level (session) cache for a particular session instance
SessionStatisticsImpl
Set	A set with no nullable element columns.
SetBinder	Bind a set.
SetSimpleValueTypeSecondPass
Setter	Sets values to a particular property.
Settings	Settings that affect the behaviour of Hibernate at runtime.
SettingsFactory	Reads configuration properties and builds a `Settings` instance.
SetType
ShortType	A type that maps between `SMALLINT` and Short
ShortTypeDescriptor	Descriptor for Short handling.
SimpleAuxiliaryDatabaseObject	A simple implementation of AbstractAuxiliaryDatabaseObject in which the CREATE and DROP strings are provided up front.
SimpleExpression	superclass for "simple" comparisons (with SQL binary operators)
SimpleMRUCache	Cache following a "Most Recently Used" (MRU) algorithm for maintaining a bounded in-memory size; the "Least Recently Used" (LRU) entry is the first available for removal from the cache.
SimpleProjection	A single-column projection that may be aliased
SimpleSelect	An SQL `SELECT` statement with no table joins
SimpleSubqueryExpression	A comparison between a constant value and the the result of a subquery
SimpleValue	Any value that maps to columns.
SimpleValueBinder
SingleColumnType<T>	Provide convenient methods for binding and extracting values for use with `BasicType`.
SingleTableEntityPersister	The default implementation of the `EntityPersister` interface.
SingleTableSubclass
SingletonIterator
SizeExpression
SmallIntTypeDescriptor	Descriptor for `SMALLINT` handling.
SoftLimitMRUCache	Cache following a "Most Recently Used" (MRU) algorithm for maintaining a bounded in-memory size; the "Least Recently Used" (LRU) entry is the first available for removal from the cache.
SoftLock	Moved up from inner definition on the now deprecated `CacheConcurrencyStrategy`.
Sort	Collection sort (Java level sorting)
SortedMapType
SortedSetType
SortKey	Models the container node for the `sort key`, which is the term given by the ANSI SQL specification to the expression upon which to sort for each `SortSpecification`
SortSpecification	Models each sorting exprersion.
SortType	Sort strategies
Source	Optional annotation in conjunction with javax.persistence.Version and timestamp version properties.
SourceType	Where should Hibernate retrieve the value from? From the database, or from the current JVM?
SpecialOneToOneType	A one-to-one association that maps to specific formula(s) instead of the primary key column of the owning entity.
SqlASTFactory	Custom AST factory the intermediate tree that causes ANTLR to create specialized AST nodes, given the AST node type (from HqlSqlTokenTypes).
SQLCriterion	A SQL fragment.
SQLCustomQuery	Implements Hibernate's built-in support for native SQL queries.
SQLDelete	SqlDelete Annotation for overwriting Hibernate default DELETE method
SQLDeleteAll	SqlDelete Annotation for overwriting Hibernate default DELETE ALL method
SQLExceptionConverter	Defines a contract for implementations that know how to convert a SQLException into Hibernate's JDBCException hierarchy.
SQLExceptionConverterFactory	A factory for building SQLExceptionConverter instances.
SqlFragment	Represents an SQL fragment in the AST.
SQLFunction	Provides support routines for the HQL functions as used in the various SQL Dialects Provides an interface for supporting various HQL functions that are translated to SQL.
SQLFunctionRegistry
SQLFunctionTemplate	Represents HQL functions that can have different representations in different SQL dialects.
SqlGenerator	Generates SQL by overriding callback methods in the base class, which does the actual SQL AST walking.
SQLGrammarException	Implementation of JDBCException indicating that the SQL sent to the database server was invalid (syntax error, invalid object references, etc).
SQLInsert	SqlInsert Annotation for overwriting Hibernate default INSERT INTO method
SQLLoadable	A class persister that supports queries expressed in the platform native SQL dialect
SQLLoadableCollection
SqlNode	A base AST node for the intermediate tree.
SQLProjection	A SQL fragment.
SQLQuery	Represents a "native sql" query and allows the user to define certain aspects about its execution, such as: result-set value mapping (see below) Tables used via `addSynchronizedQuerySpace(String)`, `addSynchronizedEntityName(String)` and `addSynchronizedEntityClass(Class)`.
SQLQuery.FetchReturn	Allows access to further control how join fetch returns are mapped back from result sets
SQLQuery.ReturnProperty	Allows access to further control how properties within a root or join fetch are mapped back from the result set.
SQLQuery.RootReturn	Allows access to further control how root returns are mapped back from result sets
SQLQueryImpl	Implementation of the `SQLQuery` contract.
SQLQueryParser
SQLQueryParser.ParameterSubstitutionRecognizer
SQLQueryResultMappingBuilder	Allows programmatic access from `SQLQuery` to define how to map SQL java.sql.ResultSet results back to in-memory objects, both entities as well as scalars.
SQLQueryResultMappingBuilder.ReturnsHolder
SQLQueryResultMappingBuilder.ScalarReturn
SQLQueryReturnProcessor	Responsible for processing the series of `returns` defined by a `NativeSQLQuerySpecification` and breaking them down into a series of `returns` for use within the `CustomLoader`.
SQLServer2005Dialect	A dialect for Microsoft SQL 2005.
SQLServer2008Dialect	A dialect for Microsoft SQL Server 2008 with JDBC Driver 3.0 and above
SQLServerDialect	A dialect for Microsoft SQL Server 2000
SQLStateConverter	A SQLExceptionConverter implementation which performs converion based on the underlying SQLState.
SQLStatementLogger	Centralize logging handling for SQL statements.
SqlTypeDescriptor	Descriptor for the `SQL`/`JDBC` side of a value mapping.
SQLUpdate	SqlUpdate Annotation for overwriting Hibernate default UPDATE method
StaleObjectStateException	A `StaleStateException` that carries information about a 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).
StandardAnsiSqlAggregationFunctions	TODO : javadoc
StandardAnsiSqlAggregationFunctions.AvgFunction	Definition of a standard ANSI SQL compliant `AVG` function
StandardAnsiSqlAggregationFunctions.CountFunction	Definition of a standard ANSI SQL compliant `COUNT` function
StandardAnsiSqlAggregationFunctions.MaxFunction
StandardAnsiSqlAggregationFunctions.MinFunction
StandardAnsiSqlAggregationFunctions.SumFunction
StandardBasicTypes	Centralizes access to the standard set of basic `types`.
StandardDialectResolver	The standard Hibernate resolver.
StandardJDBCEscapeFunction	Analogous to `StandardSQLFunction` except that standard JDBC escape sequences (i.e.
StandardProperty	Represents a basic property within the Hibernate runtime-metamodel.
StandardQueryCache	The standard implementation of the Hibernate QueryCache interface.
StandardQueryCacheFactory	Standard Hibernate implementation of the QueryCacheFactory interface.
StandardRandomStrategy	Implements a "random" UUID generation strategy as defined by the `randomUUID()` method.
StandardSQLFunction	Provides a standard implementation that supports the majority of the HQL functions that are translated to SQL.
StatefulPersistenceContext	A `PersistenceContext` represents the state of persistent "stuff" which Hibernate is tracking.
StatelessSession	A command-oriented API for performing bulk operations against a database.
StatelessSessionImpl
Statement	Common interface modeling the different HQL statements (i.e., INSERT, UPDATE, DELETE, SELECT).
StatementExecutor	Encapsulates the strategy required to execute various types of update, delete, and insert statements issued through HQL.
Statistics	Statistics for a particular `SessionFactory`.
StatisticsImpl	This class is deprecated. Use `ConcurrentStatisticsImpl` instead
StatisticsImplementor	Statistics SPI for the Hibernate core.
StatisticsService	JMX service for Hibernate statistics Register this MBean in your JMX server for a specific session factory //build the ObjectName you want Hashtable tb = new Hashtable(); tb.put("type", "statistics"); tb.put("sessionFactory", "myFinancialApp"); ObjectName on = new ObjectName("hibernate", tb); StatisticsService stats = new StatisticsService(); stats.setSessionFactory(sessionFactory); server.registerMBean(stats, on); And call the MBean the way you want Register this MBean in your JMX server with no specific session factory //build the ObjectName you want Hashtable tb = new Hashtable(); tb.put("type", "statistics"); tb.put("sessionFactory", "myFinancialApp"); ObjectName on = new ObjectName("hibernate", tb); StatisticsService stats = new StatisticsService(); server.registerMBean(stats, on); And call the MBean by providing the `SessionFactoryJNDIName` first.
StatisticsServiceMBean	MBean exposing Session Factory statistics
Status	Represents the status of an entity with respect to this session.
StreamUtils	Stream copying utilities
StringClobType	This class is deprecated. replaced by `MaterializedClobType`
StringHelper
StringRepresentableType<T>	Additional, optional contract for types capable of rendering and consuming their values to/from strings.
StringType	A type that maps between `VARCHAR` and String
StringTypeDescriptor	Descriptor for String handling.
StructuredCacheEntry
StructuredCollectionCacheEntry
StructuredMapCacheEntry
Subclass	A sublass in a table-per-class-hierarchy mapping
Subqueries	Factory class for criterion instances that represent expressions involving subqueries.
SubqueryExpression
Subselect	Map an immutable and read-only entity to a given SQL subselect expression:
SubselectCollectionLoader	Implements subselect fetching for a collection
SubselectFetch
SubselectOneToManyLoader	Implements subselect fetching for a one to many association
SunONETransactionManagerLookup	`TransactionManagerLookup` strategy for Sun ONE Application Server 7 and above
Sybase11Dialect	A SQL dialect suitable for use with Sybase 11.9.2 (specifically: avoids ANSI JOIN syntax)
Sybase11JoinFragment	An old Sybase-style join (before Sybase supported the ANSI style "inner join" etc syntax) This is needed for Sybase 11.9.2 and earlier, using the HQL 2.* syntax with Collections.
SybaseAnywhereDialect	SQL Dialect for Sybase Anywhere extending Sybase (Enterprise) Dialect (Tested on ASA 8.x)
SybaseASE15Dialect	An SQL dialect targeting Sybase Adaptive Server Enterprise (ASE) 15 and higher.
SybaseDialect	This class is deprecated. use AbstractTransactSQLDialect, `SybaseASE15Dialect` or `SQLServerDialect` instead depending on need.
SynchronizationRegistry	Manages a registry of Synchronization Synchronizations.
Synchronize	Ensures that auto-flush happens correctly and that queries against the derived entity do not return stale data.
SyntheticAndFactory	Creates synthetic and nodes based on the where fragment part of a JoinSequence.
SyntheticProperty	Models a property which does not actually exist in the model.

T

Table	Complementary information to a table either primary or secondary
Table	A relational table
TableBinder	Table related operations
TableGenerator	An `IdentifierGenerator` that uses a database table to store the last generated value.
TableGenerator	An enhanced version of table-based id generation.
TableHiLoGenerator	hilo An `IdentifierGenerator` that returns a `Long`, constructed using a hi/lo algorithm.
TableMetadata	JDBC table metadata
TableOwner	Interface allowing to differenciate SubClasses from Classes, JoinedSubClasses and UnionSubClasses The first one has not its own table while the others have
Tables	Plural of Table
TableStructure	Describes a table used to mimic sequence behavior
Target	Define an explicit target,a voiding reflection and generics resolving
Template	Parses SQL fragments specified in mapping documents
Template.NoOpColumnMapper
TemplatedViolatedConstraintNameExtracter	Knows how to extract a violated constraint name from an error message based on the fact that the constraint name is templated within the message.
TemplateRenderer	Delegate for handling function "templates".
TeradataDialect	A dialect for the Teradata database created by MCR as part of the dialect certification process.
TextType	A type that maps between `LONGVARCHAR` and String
ThreadLocalSessionContext	A `CurrentSessionContext` impl which scopes the notion of current session by the current thread of execution.
ThreadLocalSessionContext.CleanupSynch	JTA transaction synch used for cleanup of the internal session map.
Timestamper	Generates increasing identifiers (in a single VM only).
TimestampsRegion	Defines the contract for a cache region which will specifically be used to store entity "update timestamps".
TimestampsRegionAdapter	Adapter specifically briding `TimestampsRegion` to `Cache`.
TimestampType	A type that maps between `TIMESTAMP` and java.sql.Timestamp
TimestampTypeDescriptor	Descriptor for `TIMESTAMP` handling.
TimesTenDialect	A SQL dialect for TimesTen 5.1.
TimeType	A type that maps between `TIME` and Time
TimeTypeDescriptor	Descriptor for `TIME` handling.
TimeZoneType	A type mapping `VARCHAR` and TimeZone
TimeZoneTypeDescriptor	Descriptor for TimeZone handling.
TimeZoneTypeDescriptor.TimeZoneComparator
TinyIntTypeDescriptor	Descriptor for `TINYINT` handling.
ToListResultTransformer	Tranforms each result row from a tuple into a List, such that what you end up with is a List of List Lists.
TooManyRowsAffectedException	Indicates that more rows were affected then we were expecting to be.
ToOne	A simple-point association (ie.
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
Transaction	Allows the application to define units of work, while maintaining abstraction from the underlying transaction implementation (eg.
TransactionalCache	Support for fully transactional cache implementations like JBoss TreeCache.
TransactionalDataRegion	Defines contract for regions which hold transactionally-managed data.
TransactionAwareCache	Marker interface for identifying cache impls which are aware of JTA transactions
TransactionException	Indicates that a transaction could not be begun, committed or rolled back.
TransactionFactory	Contract for generating Hibernate `Transaction` instances.
TransactionFactory.Context	Callback mechanism; a context is always a `Session` in the Hibernate usage.
TransactionFactoryFactory	Helper for creating `TransactionFactory` instances.
TransactionHelper	Allows work to be done outside the current transaction, by suspending it, and performing work in a new transaction
TransactionManagerLookup	Contract for locating the JTA TransactionManager on given platform.
TransactionManagerLookupFactory	Helper for generating `TransactionManagerLookup` instances.
Transformers
TransformingClassLoader
TransientObjectException	Thrown when the user passes a transient instance to a `Session` method that expects a persistent instance.
TranslationContext	Contract for contextual information required to perform translation.
TrimFunctionTemplate	Defines the basic template support for `TRIM` functions
TrimFunctionTemplate.Options
TrimFunctionTemplate.Specification
TrueFalseType	A type that maps between `CHAR(1)` and Boolean (using 'T' and 'F')
Tuplizer	Define a tuplizer for an entity or a component
Tuplizer	A tuplizer defines the contract for things which know how to manage a particular representation of a piece of data, given that representation's `EntityMode` (the entity-mode essentially defining which representation).
Tuplizers	Define a set of tuplizer for an entity or a component
TwoPhaseLoad	Functionality relating to Hibernate's two-phase loading process, that may be reused by persisters that do not use the Loader framework
Type	hibernate type
Type	Defines a mapping between a Java type and one or more JDBC java.sql.Types 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).
TypeDef	Type definition
TypeDef	Placeholder for typedef information
TypeDefs	Type definition array
TypeDiscriminatorMetadata	Essentially a wrapper around a `DiscriminatorMetadata` and the proper sql alias to use.
TypedValue	An ordered pair of a value and its Hibernate type.
TypeFactory	Used internally to build instances of `Type`, specifically it builds instances of Used internally to obtain instances of `Type`.
TypeFactory.TypeScope
TypeHelper	Provides access to the various `Type` instances associated with the `SessionFactory`.
TypeHelper	Collection of convenience methods relating to operations across arrays of types...
TypeLocatorImpl	Implementation of `TypeHelper`
TypeMismatchException	Used when a user provided type does not match the expected one
TypeNames	This class maps a type to names.
TypeResolver	Acts as the contract for getting types and as the mediator between `BasicTypeRegistry` and `TypeFactory`.

U

UnaryArithmeticNode
UnaryLogicOperatorNode	Represents a unary operator node.
UnaryOperatorNode	Contract for nodes representing unary operators.
UnionSubclass	A subclass in a table-per-concrete-class mapping
UnionSubclassEntityPersister	Implementation of the "table-per-concrete-class" or "roll-down" mapping strategy for an entity and its inheritence hierarchy.
UniqueConstraintHolder	javax.persistence.UniqueConstraint annotations are handled via second pass.
UniqueEntityLoader	Loads entities for a `EntityPersister`
UniqueKey	A relational unique key constraint
UniqueKeyLoadable
UnknownProfileException	Used to indicate a request against an unknown profile name.
UnresolvableObjectException	Thrown when Hibernate could not resolve an object by id, especially when loading an association.
UnsavedValueFactory
UnstructuredCacheEntry
Update	An SQL `UPDATE` statement
UpdateLockingStrategy	A locking strategy where the locks are obtained through update statements.
UpdateStatement	Defines a top-level AST node representing an HQL update statement.
UpdateTimestampsCache	Tracks the timestamps of the most recent updates to particular tables.
UrlType	A type that maps between `VARCHAR` and URL
UrlTypeDescriptor	Descriptor for URL handling.
UserCollectionType	A custom type for mapping user-written classes that implement `PersistentCollection`
UserSuppliedConnectionProvider	An implementation of the ConnectionProvider interface that simply throws an exception when a connection is requested.
UserType	This interface should be implemented by user-defined "types".
UserVersionType	A user type that may be used for a version property
UUIDBinaryType	A type mapping `BINARY` and UUID
UUIDCharType	A type mapping `CHAR` (or `VARCHAR`) and java.util.UUID
UUIDGenerationStrategy	A strategy for generating a variant 2 UUID value.
UUIDGenerator	An `IdentifierGenerator` which generates UUID values using a pluggable `generation strategy`.
UUIDHexGenerator	uuid A `UUIDGenerator` that returns a string of length 32, This string will consist of only hex digits.
UUIDTypeDescriptor	Descriptor for UUID handling.
UUIDTypeDescriptor.PassThroughTransformer
UUIDTypeDescriptor.ToBytesTransformer
UUIDTypeDescriptor.ToStringTransformer
UUIDTypeDescriptor.ValueTransformer

V

Validatable	Implemented by persistent classes with invariants that must be checked before inserting into or updating the database.
ValidationFailure	Thrown from `Validatable.validate()` when an invariant was violated.
Value	A value is anything that is persisted by value, instead of by reference.
ValueBinder<X>	Contract for binding values to a PreparedStatement.
ValueExtractor<X>	Contract for extracting a value from a ResultSet.
ValueInclusion	An enum of the different ways a value might be "included".
ValueVisitor
VarArgsSQLFunction	Support for slightly more general templating than `StandardSQLFunction`, with an unlimited number of arguments.
VarbinaryTypeDescriptor	Descriptor for `VARBINARY` handling.
VarcharTypeDescriptor	Descriptor for `VARCHAR` handling.
VerifyFetchProfileReferenceSecondPass
Version	Information about the Hibernate version.
Version	This class is deprecated. Use `Version` instead
Versioning	Utilities for dealing with optimisitic locking values.
VersionProperty	Represents a version property within the Hibernate runtime-metamodel.
VersionType<T>	Additional contract for types which may be used to version (and optimistic lock) data.
VersionTypeSeedParameterSpecification	Parameter bind specification used for optimisitc lock version seeding (from insert statements).
VersionValue	A strategy for determining if a version value is an version of a new transient instance or a previously persistent transient instance.
ViolatedConstraintNameExtracter	Defines a contract for implementations that can extract the name of a violated constraint from a SQLException that is the result of that constraint violation.

W

WeblogicTransactionManagerLookup	TransactionManager lookup strategy for WebLogic
WebSphereExtendedJTATransactionLookup	TransactionManagerLookup implementation intended for use with WebSphere Application Server (WAS).
WebSphereExtendedJTATransactionLookup.TransactionManagerAdapter
WebSphereExtendedJTATransactionLookup.TransactionManagerAdapter.TransactionAdapter
WebSphereTransactionManagerLookup	`TransactionManagerLookup` strategy for WebSphere (versions 4, 5.0 and 5.1)
Where	Where clause to add to the element Entity or target entity of a collection The clause is written in SQL
WhereJoinTable	Where clause to add to the colleciton join table The clause is written in SQL
WhereParser	Parses the where clause of a hibernate query and translates it to an SQL where clause.
Work	Contract for performing a discrete piece of JDBC work.
WrappedBlob	Contract for Blob wrappers.
WrappedClob	Contract for Clob wrappers.
WrappedInferredData
WrappedMaterializedBlobType	A type that maps JDBC `BLOB` and `Byte[]`.
WrapperBinaryType	A type mapping `VARBINARY` and Byte Byte[]
WrapperOptions	TODO : javadoc
WrapVisitor	Wrap collections in a Hibernate collection wrapper.
WrongClassException	Thrown when `Session.load()` selects a row with the given primary key (identifier value) but the row's discriminator value specifies a subclass that is not assignable to the class requested by the user.

X

XMLContext
XMLContext.Default
XmlDocument	Describes a parsed xml document.
XmlDocumentImpl	Basic implemementation of `XmlDocument`
XMLHelper	Small helper class that lazy loads DOM and SAX reader and keep them for fast use afterwards.
XMLHelper.ErrorLogger
XmlRepresentableType<T>	Additional, optional contract for types whose values can be represented as XML text (either as attribute or element value).

Y

YesNoType A type that maps between CHAR(1) and Boolean (using 'Y' and 'N')