## Package org.hibernate

This package defines the central Hibernate APIs.

See:
Description

Interface Summary
Cache: Provides an API for querying/managing the second level cache regions.
Criteria: `Criteria` is a simplified API for retrieving entities by composing `Criterion` objects.
EntityNameResolver: Contract for resolving an entity-name from a given entity instance.
Filter: Type definition of Filter.
Interceptor: Allows user code to inspect and/or change property values.
LobHelper: A `session's` helper for creating LOB data
Query: An object-oriented representation of a Hibernate query.
ScrollableResults: A result iterator that allows moving around within the results by arbitrary increments.
Session: The main runtime interface between a Java application and Hibernate.
Session.LockRequest: Contains locking details (LockMode, Timeout and Scope).
SessionFactory: The main contract here is the creation of `Session` instances.
SessionFactoryObserver: Allows reaction to basic `SessionFactory` occurrences.
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 `SQLQuery.addSynchronizedQuerySpace(java.lang.String)`, `SQLQuery.addSynchronizedEntityName(java.lang.String)` and `SQLQuery.addSynchronizedEntityClass(java.lang.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
SQLQueryResultMappingBuilder: Allows programmatic access from `SQLQuery` to define how to map SQL `results` back to in-memory objects, both entities as well as scalars.
SQLQueryResultMappingBuilder.ReturnsHolder
StatelessSession: A command-oriented API for performing bulk operations against a database.
Transaction: Allows the application to define units of work, while maintaining abstraction from the underlying transaction implementation (eg.
TypeHelper: Provides access to the various `Type` instances associated with the `SessionFactory`.

Class Summary
CacheMode: Controls how the session interacts with the second-level cache and query cache.
ConnectionReleaseMode: Defines the various policies by which Hibernate might release its underlying JDBC connection.
EmptyInterceptor: An interceptor that does nothing.
EntityMode: Defines the representation modes available for entities.
FetchMode: Represents an association fetching strategy.
FlushMode: Represents a flushing strategy.
Hibernate: Provides access to the full range of Hibernate built-in types.
LockMode: Instances represent a lock mode for a row of a relational database table.
LockOptions: Contains locking details (LockMode, Timeout and Scope).
ReplicationMode: Represents a replication strategy.
ScrollMode: Specifies the type of JDBC scrollable result set to use underneath a `ScrollableResults`
SQLQueryResultMappingBuilder.ScalarReturn
Version: Information about the Hibernate version.

Exception Summary
AnnotationException: Annotation related exception.
AssertionFailure: Indicates failure of an assertion: a possible bug in Hibernate.
CallbackException: Should be thrown by persistent objects from `Lifecycle` or `Interceptor` callbacks.
DuplicateMappingException: Raised whenever a duplicate for a certain type occurs.
HibernateException: The base `Throwable` type for Hibernate.
InstantiationException: Thrown if Hibernate can't instantiate an entity or component class at runtime.
InvalidMappingException: Thrown when a mapping is found to be invalid.
JDBCException: Wraps an `SQLException`.
LazyInitializationException: Indicates access to unfetched data outside of a session context.
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.
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.
ObjectDeletedException: Thrown when the user tries to do something illegal with a deleted object.
ObjectNotFoundException: Thrown when `Session.load()` fails to select a row with the given primary key (identifier value).
OptimisticLockException: Throw when an optimistic locking conflict occurs.
PersistentObjectException: Thrown when the user passes a persistent instance to a `Session` method that expects a transient instance.
PessimisticLockException: Thrown when a pessimistic locking conflict occurs.
PropertyAccessException: A problem occurred accessing a property of an instance of a persistent class by reflection, or via CGLIB.
PropertyNotFoundException: Indicates that an expected getter or setter method could not be found on a class.
PropertyValueException: Thrown when the (illegal) value of a property can not be persisted.
QueryException: A problem occurred translating a Hibernate query to SQL due to invalid query syntax, etc.
QueryParameterException: Parameter invalid or not found in the query
QueryTimeoutException: Thrown when a database query timeout occurs.
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).
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).
TransactionException: Indicates that a transaction could not be begun, committed or rolled back.
TransientObjectException: Thrown when the user passes a transient instance to a `Session` method that expects a persistent instance.
TypeMismatchException: Used when a user provided type does not match the expected one
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.
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.

## Package org.hibernate Description

This package defines the central Hibernate APIs.

Copyright © 2001-2010 Red Hat, Inc. All Rights Reserved.