All Classes and Interfaces
Class
Description
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.Convenience base class for
AuxiliaryDatabaseObjects.Manages prepared statements and batching.
Deprecated.
Deprecated.
Use the
AbstractStandardBasicType approach insteadBasic implementation of the
ClassTransformer contract.Defines a base class for events involving collections.
Base implementation of the QueryableCollection interface.
Support for tuplizers relating to components.
Deprecated.
in favor of
CompositeTypeA templated resolver impl which delegates to the
AbstractDialectResolver.resolveDialectInternal(java.sql.DatabaseMetaData) method
and handles any thrown SQLExceptions.Implementation of AbstractEmptinessExpression.
Abstract walker for walkers which begin at an entity (criteria
queries and entity loaders).
Basic functionality for persisting an entity via JDBC
through either generated or custom SQL
Support for tuplizers relating to entities.
Defines a base class for Session generated events.
Convenience base class for explicitly defined query parameters.
A convenience base class for listeners whose functionality results in flushing.
Provides the basic templating of how instrumentation should occur.
Support for CacheProvider implementations which are backed by caches bound
into JNDI namespace.
Convenience base class for lazy initialization handlers.
Convenient base class for proxy-based LobCreator for handling wrapping.
Deprecated.
A convenience base class for listeners that respond to requests to perform a
pessimistic lock upgrade on an entity.
Deprecated.
Use the
AbstractStandardBasicType approach insteadDeprecated.
Use the
AbstractStandardBasicType approach insteadTODO : javadoc
Base class for nodes dealing 'is null' and 'is not null' operators.
Base class implementing
PersistentCollectionBasic implementation of the
PostInsertIdentifierGenerator
contract.Represents an operation we are about to perform against the database.
Basic implementation of the
PropertyMapping contract.Abstract implementation of the Query interface.
A convenience base class for listeners that respond to requests to reassociate an entity
to a session ( such as through lock() or update() ).
Convenience implementation of
RestrictableStatement
to centralize common functionality.Abstract InsertGeneratedIdentifierDelegate implementation where the
underlying strategy causes the generated identifier to be returned as an
effect of performing the insert statement.
A convenience bas class for listeners responding to save events.
Implementation of the ScrollableResults interface
Partial implementation of SelectExpression for all the nodes that aren't constructors.
Abstract InsertGeneratedIdentifierDelegate implementation where the
underlying strategy requires an subsequent select after the insert
to determine the generated identifier.
Base
LockingStrategy implementation to support implementations
based on issuing SQL SELECT statementsConvenience base class for SerializableProxy.
Functionality common to stateless and stateful sessions
TODO : javadoc
TODO : javadoc
Convenience implementation of Statement to centralize common functionality.
Implementation of AbstractStatementExecutor.
Abstract superclass of the built in Type hierarchy.
Abstract adapter for Java type descriptors.
The base class for identifier generators that use a UUID algorithm.
Abstract superclass of algorithms that walk
a tree of property values of an entity, and
perform specific functionality for collections,
components and associated entities.
Contract for providing callback access to a
DatabaseStructure,
typically from the Optimizer.Deprecated.
Per HHH-5451 support for cglib as a bytecode provider has been deprecated.
The
implementation for Javassist
which simply acts as an adapter to the
invalid reference
ReflectionOptimizer#AccessOptimizerBulkAccessor class.Property Access type
Prefer the standard
Access annotationThe types of access strategies available.
Enum defining deifferent access strategies for accessing entity values.
Responsible for maintaining the queue of actions related to events.
Optimize a mutable type, if the user promises not to mutable the
instances.
TODO : javadoc
Contract representing some process that needs to occur during after transaction completion.
Contract for a select expression which aggregates other select expressions together into a single return
Represents an aggregate function i.e.
Base class for standard aggregation functions.
An alias generator for SQL identifiers
Generates class/table/column aliases during semantic analysis and SQL rendering.
TODO : javadoc
Wraps the tuples in a constructor call.
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.
ResultTransformer implementation which builds a map for each "row",
made up of each aliased value where the alias is the map key.Provides alternative types for binding LOB values.
Provides alternative types for binding
BLOB values.Provides alternative types for binding
CLOB values.Type of annotation of a class will give its type
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)Deprecated.
All functionality has been moved to
ConfigurationAnnotation related exception.
An ANSI SQL CASE expression.
An ANSI-style join
A
SQLFunction implementation that emulates the ANSI SQL trim function
on dialects which do not support the full definition.Defines support for rendering according to ANSI SQL TRIM function specification.
Define a ToOne association pointing to several entity types.
A Hibernate "any" type (ie.
Defines @Any and @manyToAny metadata
Defines @Any and @ManyToAny set of metadata.
Handles "any" mappings
An array mapping has a primary key consisting of the key columns + index column.
Bind an Array
A mutability plan for arrays.
A type for persistent arrays.
Indicates failure of an assertion: a possible bug in Hibernate.
assigned
An IdentifierGenerator that returns the current identifier assigned to an instance.
An IdentifierGenerator that returns the current identifier assigned to an instance.
Encapsulates the information relating to an individual assignment within the
set clause of an HQL update statement.
Models the association of a given fetch.
A type that represents some kind of association between entities.
Appends child nodes to a parent efficiently.
Depth first iteration of an ANTLR AST.
Depth first iteration of an ANTLR AST.
Utility for generating pretty "ASCII art" representations of syntax trees.
Generates translators which uses the Antlr-based parser to perform
the translation.
Provides utility methods for AST traversal and manipulation.
Filters nodes out of a tree.
A predicate that uses inclusion, rather than exclusion semantics.
Defines an event class for the auto-flushing of a session.
Defines the contract for handling of session auto-flush events.
Auxiliary database objects (i.e., triggers, stored procedures, etc) defined
in the mappings.
An avg() projection
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.
Represents a "back-reference" to the id of a collection owner.
Internal implementation of a property setter specific to these back-ref properties.
A bag permits duplicates, so it has no primary key
Bind a bag.
Convenience base implementation of
ValueBinderBasicClassFilter provides class filtering based on a series of packages to
be included and/or a series of explicit class names to be included.
Walker for collections of values and many-to-many associations
Loads a collection of values or a many-to-many association.
Collection persister for collections of values and many-to-many associations.
Intended as support for custom resolvers.
Implementation of BasicExecutor.
Convenience base implementation of
ValueExtractorPerforms formatting of basic SQL statements (DML + query).
Super class for all Hibernate instrumentation tasks.
Lazy initializer for POJOs
Uses the default mapping from property to result set column
alias defined by the entities' persisters.
Accesses property values via a get/set pair, which may be nonpublic.
A proxy factory for "basic proxy" generation
A helper to centralize conversion of
SQLExceptions to JDBCExceptions.Provides the basic "noop" impls of the
ResultTransformer contract.Marker interface for basic types.
A registry of
BasicType instancesMuch like
TooManyRowsAffectedException, indicates that more
rows than what we were expcecting were affected.Manages PreparedStatements for a session.
Factory for Batcher instances.
Indicates a failed batch entry (-3 return).
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.
An implementation of the Batcher interface that
actually uses batching
A BatcherFactory implementation which constructs Batcher instances
capable of actually performing batch operations.
"Batch" loads collections, using multiple foreign key values in the
SQL where clause.
"Batch" loads entities, using multiple primary key values in the
SQL where clause.
Batch size for SQL loading
This class has no hard dependency on Bean Validation APIs
It must use reflection every time BV is required.
Event listener used to enable Bean Validation for insert/update/delete events.
Contract for checking whether to perform a managed flush in a
Synchronization.beforeCompletion() callbackContract representing some process that needs to occur during before transaction completion.
A TransactionManager lookup strategy for Borland ES.
Constrains a property to between two values
Contract for nodes representing logcial BETWEEN (ternary) operators.
A type that maps between a
NUMERIC and BigDecimal.Descriptor for
BigDecimal handling.A type that maps between a
NUMERIC and BigInteger.Descriptor for
BigInteger handling.Descriptor for
BIGINT handling.Nodes which represent binary arithmetic operators.
Contract for nodes representing binary operators.
Contract for nodes representing binary operators.
Wraps a binary stream to also provide the length which is needed when binding.
Implementation of
BinaryStreamA type that maps between a
VARBINARY and byte[]Descriptor for
BINARY handling.Descriptor for
BIT handling.Marker interface for non-contextually created
Blob instances..Manages aspects of proxying
Blobs for non-contextual creation, including proxy creation and
handling proxy invocations.Descriptor for
Blob handling.Descriptor for
BLOB handling.Represents a boolean literal within a query.
Descriptor for
Boolean handling.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).
TransactionManager lookup strategy for BTM
A JavaBean accessor.
An exception thrown while generating a bulk accessor.
An
ActionQueue Executable for ensuring
shared cache cleanup in relation to performed bulk HQL queries.Deprecated.
replaced by
WrappedMaterializedBlobTypeTODO : javadoc
A helper for reading byte code from various input sources.
Contract for providers of bytecode services to Hibernate.
Deprecated.
Per HHH-5451 support for cglib as a bytecode provider has been deprecated.
Bytecode provider implementation for Javassist.
Descriptor for
Byte handling.Add caching strategy to a root entity or a collection
Provides an API for querying/managing the second level cache regions.
Caché 2007.1 dialect.
Cache concurrency strategy
Describes attributes regarding the type of data to be cached.
A cached instance of a persistent class
Something went wrong in the cache
A Caché dialect join.
Allows multiple entity classes / collection roles to be
stored in the same cache region.
Controls how the session interacts with the second-level
cache and query cache.
Enumeration for the different interaction modes between the session and
the Level 2 Cache.
A SQLExceptionConverter implementation specific to Caché SQL,
accounting for its custom integrity constraint violation error codes.
A JTA transaction synch used to allow the
Session to know about transaction
events.Descriptor for
Calendar handling, but just for the date (month, day, year) portion.Descriptor for
Calendar handling.Manages callbacks from the
Synchronization registered by Hibernate.Should be thrown by persistent objects from Lifecycle
or Interceptor callbacks.
Apply a cascade strategy on an association
Delegate responsible for, in conjunction with the various
actions, implementing cascade processing.A contract for defining the aspects of cascading various persistence actions.
Cascade types (can override default EJB3 cascades
A session action that may be cascaded from parent entity to its children
Represents a case ...
Abstract SQL case fragment renderer
Represents a case ...
ANSI-SQL style cast(foo as type) where the type is
a Hibernate type
Statistics for a particular "category" (a named entity,
collection role, second level cache region or query).
Deprecated.
Per HHH-5451 support for cglib as a bytecode provider has been deprecated.
Strategy for performing build-time instrumentation of persistent classes in order to enable
field-level interception using CGLIB.
Deprecated.
Per HHH-5451 support for cglib as a bytecode provider has been deprecated.
Deprecated.
Per HHH-5451 support for cglib as a bytecode provider has been deprecated.
A type that maps between
CLOB and Character[]A type that maps between
VARCHAR and Character[]TODO : javadoc
Wraps a character stream (reader) to also provide the length (number of characters) which is needed
when binding.
Implementation of
CharacterStreamDescriptor for
Character handling.A type that maps between
VARCHAR and char[]Deprecated.
Use the
AbstractStandardBasicType approach insteadEmulation of locate() on Sybase
Descriptor for
CHAR handling.Arbitrary SQL check constraints which can be defined at the class,
property or collection level
Contract describing the information Hibernate needs in terms of instrumenting
a class, either via ant task or dynamic classloader.
Used to determine whether a class should be instrumented.
Classic AVG sqlfunction that return types as it was done in Hibernate 3.1
Classic COUNT sqlfunction that return types as it was done in Hibernate 3.1
Generates translators which uses the older hand-written parser to perform
the translation.
Classic SUM sqlfunction that return types as it was done in Hibernate 3.1
Exposes entity class metadata to the application
A persistence provider provides an instance of this interface
to the PersistenceUnitInfo.addTransformer method.
TODO : javadoc
Parses the Hibernate query into its constituent clauses.
Marker interface for non-contextually created
Clob instances..Manages aspects of proxying
Clobs for non-contextual creation, including proxy creation and
handling proxy invocations.Descriptor for
Clob handling.Descriptor for
CLOB handling.An object that is shallow-coneable
Implements a basic transaction strategy for CMT transactions.
Factory for
CMTTransaction instances.Models a collation specification (COLLATE using a specific character-set) within a
SortSpecification.Mapping for a collection.
Adapter specifically bridging
CollectionRegionAccessStrategy to CacheConcurrencyStrategy.Any action relating to insert/update/delete of a collection
Type definition of CollectionAliases.
Base class for binding different types of collections to Hibernate configuration objects.
We need an entry to tell us all about the current state
of a collection with respect to its persistent state
Spefically a fetch return that refers to a collection association.
implementation of the Query interface for collection filters
A specialized ParameterSpecification impl for dealing with a collection-key as part of a collection filter
compilation.
Represents 'elements()' or 'indices()'.
Various help for handling collections.
Describe an identifier column for a bag (ie an idbag)
EXPERIMENTAL: the structure of this annotation might slightly change (generator() mix strategy and generator
An interface for collection loaders
Superclass of walkers for collection initializers
Uniquely identifies a collection instance in a particular session.
Represents state associated with the processing of a given
ResultSet
in regards to loading collections.Superclass for loaders that initialize collections
Exposes collection metadata to the application
Deprecated.
use @ElementCollection
A strategy for persisting a collection role.
Provides a map of collection function names to the corresponding property names.
The names of all the collection properties.
Defines the contract for a cache region which will specifically be used to
store collection data.
Contract for managing transactional and concurrent access to cached collection
data.
Adapter specifically bridging
CollectionRegion to Cache.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).
Implements book-keeping for the collection persistence by reachability algorithm
Collection second pass
Collection related statistics
Collection related statistics
Provides the SQL for collection subqueries.
A type that handles Hibernate PersistentCollections (including arrays).
A column of a relational database table
Strategy for extracting the unique column alias out of a
ResultSetMetaData.CollectionAliases that uses columnnames instead of generated aliases.
EntityAliases that chooses the column names over the alias names.
Provides utility methods for dealing with arrays of SQL column names.
Contract for mapping a (an assumed) property reference to its columns.
JDBC column metadata
Cache of column-name -> column-index resolutions
Support an array of columns.
Custom SQL expression used to read the value from and write a value to a column.
Plural annotation for @ColumnTransformer.
Delegates to Comparable
The mapping for a component, composite element,
composite identifier, etc.
Models an explicit join terminating at a component value (e.g.
Centralizes metamodel information about a component.
Component implementation of property holder
Defines further responsibilities regarding tuplization based on
a mapped components.
A registry allowing users to define the default
ComponentTuplizer class to use per EntityMode.Handles "component" mappings
Adapts
CompositeUserType to the Type interfaceFor composite identifiers, defines a number of "nested" generations that
need to happen to "fill" the identifier property(s).
Contract for declaring how to locate the context for sub-value injection.
Contract for performing the actual sub-value generation, usually injecting it into the
determined
contextContract for value types to hold collections and have cascades, etc.
A UserType that may be dereferenced in a query.
Collection related statistics
Entity related statistics
Query statistics (HQL and SQL)
Second level cache statistics of a specific region
Implementation of
Statistics, as well as StatisticsImplementor, based on the
java.util.concurrent package introduced in Java 5.Essentially the same as
StandardSQLFunction,
except that here the parentheses are not included when no arguments are given.A simple class to centralize logic needed to locate config files on the system.
The Configurable interface defines the contract for SQLExceptionConverter impls that
want to be configured prior to usage given the currently defined Hibernate properties.
An IdentifierGenerator that supports "configuration".
An instance of Configuration allows the application
to specify properties and mapping documents to be used when
creating a SessionFactory.
Encapsulates JDBC Connection management logic needed by Hibernate.
A strategy for obtaining JDBC connections.
Instantiates a connection provider given either System properties or
a java.util.Properties instance.
Defines the various policies by which Hibernate might release its underlying
JDBC connection.
Interface implemented by JDBC connection wrappers in order to give
access to the underlying wrapped connection.
A relational constraint.
Implementation of JDBCException indicating that the requested DML operation
resulted in a violation of a defined integrity constraint.
Represents a constructor (new) in a SELECT.
LobCreator implementation using contextual creation against the JDBC Connection class's LOB creation
methods.A Caché defintion of a convert function.
Represents a COUNT expression in a select.
A count
Criteria is a simplified API for retrieving entities
by composing Criterion objects.
Implementation of the Criteria interface
A JoinWalker for Criteria queries.
A Loader for Criteria queries.
An instance of CriteriaQuery is passed to criterion,
order and projection instances when actually compiling and
executing the query.
An object-oriented representation of a query criterion that may be used
as a restriction in a Criteria query.
An SQL dialect for CUBRID (8.3.x and later).
TODO : javadoc
Defines the contract for implementations which know how to scope the notion
of a
current session.A custom type for mapping user-written classes that implement PersistentCollection
Extension point for loaders which use a SQL result set with "unexpected" column aliases.
Extension point allowing any SQL query with named and positional parameters
to be executed by Hibernate, returning managed entities, collections and
simple scalar values.
Applies a version 1 (time-based) generation strategy (using ip address rather than mac address) but applies them in a
different layout.
JDBC database metadata
Encapsulates definition of the underlying data structure backing a
sequence-style generator.
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.
A help for dealing with BLOB and CLOB data
A connection provider that uses a DataSource registered with JNDI.
TODO : javadoc
Descriptor for
DATE handling.An SQL dialect for DB2/390.
An SQL dialect for DB2/400.
An SQL dialect for DB2.
dbtimestamp: An extension of
TimestampType which
maps to the database's current timestamp, rather than the jvm's
current timestamp.Performs formatting of DDL SQL statements.
Descriptor for
DECIMAL handling.An Oracle-style DECODE function.
Defines the default flush event listeners used by hibernate for
flushing session state in response to generated auto-flush events.
Defines the default delete event listener used by hibernate for deleting entities
from the datastore in response to generated delete events.
Defines the default dirty-check event listener used by hibernate for
checking the session for dirtiness in response to generated dirty-check
events.
EntityAliases which handles the logic of selecting user provided aliases (via return-property),
before using the default aliases.
Defines the default evict event listener used by hibernate for evicting entities
in response to generated flush events.
An event that occurs for each entity instance at flush time
Defines the default flush event listeners used by hibernate for
flushing session state in response to generated flush events.
Basic templated support for
IdentifierGeneratorFactory implementations.Defines the default load event listeners used by hibernate for loading entities
in response to generated load events.
Defines the default lock event listeners used by hibernate to lock entities
in response to generated lock events.
Defines the default copy event listener used by hibernate for copying entities
in response to generated copy events.
The default NamingStrategy
Defines the default create event listener used by hibernate for creating
transient entities in response to generated create events.
When persist is used as the cascade action, persistOnFlush should be used
We do 2 things here:
Call
Lifecycle interface if necessary
Perform needed EntityEntry.getLockMode() related processing
Called before injecting property values into a newly
loaded entity instance.
Defines the default refresh event listener used by hibernate for refreshing entities
in response to generated refresh events.
Defines the default replicate event listener used by Hibernate to replicate
entities in response to generated replicate events.
An event handler for save() events
Defines the default listener used by Hibernate for handling save-update
events.
An event handler for update() events
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).
An SQL DELETE statement
Defines an event class for the deletion of an entity.
Defines the contract for handling of deletion events generated from a session.
Defines a top-level AST node representing an HQL delete statement.
A value which is "typed" by reference to some other
value (for example, a foreign key is typed by the
referenced primary key).
A specialized concat() function definition in which:
we translate to use the concat operator ('||')
wrap dynamic parameters in CASTs to VARCHAR
Hibernate Dialect for Cloudscape 10 - aka Derby.
Contract for listeners which require notification of SessionFactory closing,
presumably to destroy internal state.
Some applications need to create criteria queries in "detached
mode", where the Hibernate session is not available.
Thrown when a call to the underlying Hibernate engine fails, indicating
some form of semantic exception (e.g.
Represents a dialect of SQL implemented by a particular RDBMS.
A factory for generating Dialect instances.
Contract for determining the
Dialect to use based on a JDBC Connection.A
DialectResolver implementation which coordinates resolution by delegating to its
registered sub-resolvers.Accesses fields directly.
Defines an event class for the dirty-checking of a session.
Defines the contract for handling of session dirty-check events.
Do we have a dirty collection here?
1.
Discriminator formula
To be placed at the root entity.
Provides the information needed to properly handle type discrimination
in HQL queries, either by 'something.class' or 'type(something)' references.
Optional annotation to express Hibernate specific discrimintor properties.
TODO : javadoc
Additional contract for a
Type may be used for a discriminator.A disjunctive string of conditions
Implementors will return additional display text, which will be used
by the ASTPrinter to display information (besides the node type and node
text).
Distinctions the result tuples in the final result based on the defined
equality of the tuples.
Much like
RootEntityResultTransformer, but we also distinct
the entity in the final result.Responsible for accessing property values represented as a dom4j Element
or Attribute.
For nodes like "@bar"
For nodes like "@bar"
Defines the strategy for getting property values out of a dom4j Node.
For nodes like "foo/@bar"
For nodes like "foo/@bar"
For nodes like "foo"
For nodes like "foo"
For nodes like "."
For nodes like "."
A
ComponentTuplizer specific to the dom4j entity mode.An
EntityTuplizer specific to the dom4j entity mode.Performs "instantiation" based on DOM4J elements.
Lazy initializer for "dom4j" entity representations.
Proxy for "dom4j" entity representations.
Builds proxies for "dom4j" entity representations.
Represents a reference to a property or alias expression.
Descriptor for
Double handling.Descriptor for
DOUBLE handling.A connection provider that uses java.sql.DriverManager.
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.
Any systemId URL using classpath as the scheme (i.e.Raised whenever a duplicate for a certain type occurs.
A specialized ParameterSpecification impl for dealing with a dynamic filter parameters.
A
ComponentTuplizer specific to the dynamic-map entity mode.An
EntityTuplizer specific to the dynamic-map entity mode.Wrap state of an EJB3 @Column annotation
and build the Hibernate column mapping element
Discriminator column
Resolve JPA xsd files locally
Hibernate OGM uses this class, consider this some kind of exposed service at the SPI level
Wrap state of an EJB3 @JoinColumn annotation
and build the Hibernate column mapping element
Naming strategy implementing the EJB3 standards
Wraps dom4j elements, allowing them to exist in a
non-hierarchical structure.
An interceptor that does nothing.
An "enhanced" Projection for a
Criteria query.A custom type that may function as an identifier or
discriminator type, or may be marshalled to and from
an XML document
Extends
Entity with Hibernate featuresAdapter specifically bridging
EntityRegionAccessStrategy to CacheConcurrencyStrategy.Base class for actions relating to insert/update/delete of an entity
instance.
Metadata describing the SQL result set column aliases
for a particular entity.
Stateful holder and processor for binding Entity information
Handles mapping
EntityModes to EntityTuplizers.We need an entry to tell us all about the current state
of an object with respect to its persistent state
Spefically a fetch return that refers to an entity association.
Verify/Increment the entity version
A walker for loaders that fetch entities
Uniquely identifies of an entity instance in a particular session by identifier.
Loads an entity instance using outerjoin fetching to fetch associated entities.
Centralizes metamodel information about an entity.
Defines the representation modes available for entities.
Centralizes handling of
EntityMode to Tuplizer mappings.Contract for resolving an entity-name from a given entity instance.
Delegate to handle the scenario of an entity not found by a specified id.
Implementors define mapping and persistence logic for a particular
strategy of entity mapping.
Defines the contract for a cache region which will specifically be used to
store entity data.
Contract for managing transactional and concurrent access to cached entity
data.
Adapter specifically bridging
EntityRegion to Cache.Entity related statistics
Entity related statistics
Defines further responsibilities reagarding tuplization based on
a mapped entity.
A registry allowing users to define the default
EntityTuplizer class to use per EntityMode.Base for types which map associations to persistent entities.
Used to uniquely key an entity instance in relation to a particular session
by some unique property reference, as opposed to identifier.
Verify/Increment the entity version
Enum type mapper
Try and find the appropriate SQL type depending on column metadata
Provides access to configuration info passed in Properties objects.
An error handler that counts parsing errors and warnings.
Implements an
ErrorHandler that mainly just logs errors/warnings.Implementations will report or handle errors invoked by an ANTLR base parser.
A convience holder for all defined session event listeners.
Defines an event class for the evicting of an entity.
Defines the contract for handling of evict events generated from a session.
Evict any collections referenced by the object from the session cache.
Support for query by example.
A strategy for choosing property values for inclusion in the query
criteria
TODO : javadoc
An operation which may be scheduled for later execution.
For persistence operations (INSERT, UPDATE, DELETE) what style of determining
results (success/failure) is to be used.
Indicates problem performing the instrumentation execution.
Defines an expected DML operation outcome.
Holds various often used
Expectation definitions.Interface for nodes which wish to be made aware of any determined "expected
type" based on the context within they appear in the query.
An additional contract for parameters which originate from parameters explicitly encountered in the source statement
(HQL or native-SQL).
Deprecated.
Use Restrictions.
Deprecated.
All functionality has been moved up to
MappingsRepresents a mapping queued for delayed processing to await
processing of an extends entity upon which it depends.
Defines support for various externally configurable SessionFactory(s), for
example,
JMX or the JCA
adapter.Acts as a
ASTFactory for injecting our specific AST node classes into the Antlr generated trees.Define the fetching strategy used for the given association
Models an individual fetch within a profile.
The type or style of fetch.
Any mapping with an outer-join attribute
Implementation of ScrollableResults which can handle collection fetches.
Fetch options on associations
Represents an association fetching strategy.
Define the fetching strategy profile.
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.
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.
Defines an individual association fetch within the given profile.
Represents a return which names a fetched association.
Contract for deciding whether fields should be read and/or write intercepted.
Used to determine whether a field reference should be instrumented.
Interface introduced to the enhanced class in order to be able to
inject a
FieldHandler to define the interception behavior.The interface defining how interception of a field should be handled.
Helper class for dealing with enhanced entity classes.
Contract for field interception handlers.
A field-level interceptor that initializes lazily fetched properties.
A field-level interceptor that initializes lazily fetched properties.
The thing that handles actual class enhancement in regards to
intercepting field accesses.
Add filters to an entity or a target entity of a collection
Type definition of Filter.
Defines mapping elements to which filters may be applied.
Filter definition
A FilterDefinition defines the global attributes of a dynamic filter.
Array of filter definitions
Implementation of FilterHelper.
Implementation of FilterImpl.
Add filters to a join table collection
Add multiple @FilterJoinTable to a collection
Allows cached queries to be keyed by enabled filters.
Extends an HQLQueryPlan to maintain a reference to the collection-role name
being filtered.
Add multiple @Filters
Specialized interface for filters.
An SQL dialect for Firebird.
Descriptor for
Float handling.Descriptor for
FLOAT handling.Defines an event class for the flushing of a session.
Defines the contract for handling of session flush events.
Represents a flushing strategy.
Enumeration extending javax.persistence flush modes.
Process collections reachable from an entity.
Deprecated.
use
DiscriminatorOptions insteadforeign
An Identifier generator that uses the value of the id property of an associated object
One mapping parameter is required: property.
An Identifier generator that uses the value of the id property of an associated object
One mapping parameter is required: property.
A foreign key constraint
Represents directionality of the foreign key constraint
JDBC foreign key metadata
Algorithms related to foreign key constraint transparency
Represents the the understood types or styles of formatting.
Formatter contract
Formula.
A formula is a derived column value
Represents the 'FROM' part of a query or subquery, containing all mapped class references.
Represents a single mapped class mentioned in an HQL FROM clause.
Encapsulates the creation of FromElements and JoinSequences.
Parses the from clause of a hibernate query, looking for tables and
aliases for the SQL query.
Represents a reference to a FROM element, for example a class alias in a WHERE clause.
An SQL Dialect for Frontbase.
Identifies a node which models a SQL function.
Contract for general-purpose cache regions.
The annotated property is generated by the database
CollectionAliases which handles the logic of selecting user provided aliases (via return-property),
before using the default aliases.
Antlr grammar for dealing with order-by mapping fragments.
Antlr grammar for rendering ORDER_BY trees as described by the
OrderByFragmentParserLexer for the order-by fragment parser
When should the generation occurs
Generator annotation describing any kind of Hibernate
generator in a detyped manner
Array of generic generator definitions
Generic, non-specific JDBCException.
Gets values of a particular property
Parses the GROUP BY clause of an aggregate query
Generates string values using the SQL Server NEWID() function.
A dialect compatible with the H2 database.
A lightweight implementation of the Cache interface
A simple in-memory Hashtable-based cache impl.
Parses the having clause of a hibernate query and translates it to an
SQL having clause.
Walks an XML mapping document and produces the Hibernate configuration-time metamodel (the
classes in the mapping package)
TODO : javadoc
Provides access to the full range of Hibernate built-in types.
The base
Throwable type for Hibernate.An iterator that may be "closed"
Marker interface for entity proxies
Utility methods for working with proxies.
Deprecated.
as of release 3.4.0.CR2, replaced by Hibernate Search's
invalid reference
org.hibernate.search.cfg.EventListenerRegisterImplementation of HibernateServiceMBean.
Hibernate JMX Management API
The
Synchronization implementation Hibernate registers with the JTA TransactionUse Hibernate metadata to ignore cascade on entities.
User: Joshua Davis
Date: Sep 23, 2005
Time: 12:30:01 PM
Date: Sep 23, 2005
Time: 12:30:01 PM
Hibernate Query Language Lexer
This lexer provides the HQL parser with tokens.
This lexer provides the HQL parser with tokens.
Hibernate Query Language Grammar
This grammar parses the query language for Hibernate (an Open Source, Object-Relational mapping library).
This grammar parses the query language for Hibernate (an Open Source, Object-Relational mapping library).
Implements the semantic action methods defined in the HQL base parser to keep the grammar
source file a little cleaner.
Defines a query execution plan for an HQL query (or filter).
Hibernate Query Language to SQL Tree Transform.
This is a tree grammar that transforms an HQL AST into a intermediate SQL AST with bindings to Hibernate interfaces (Queryable, etc.).
This is a tree grammar that transforms an HQL AST into a intermediate SQL AST with bindings to Hibernate interfaces (Queryable, etc.).
Implements methods used by the HQL->SQL tree transform grammar (a.k.a.
A semantic analysis node, that points back to the main analyzer.
A custom token class for the HQL grammar.
The HSQL CASEWHEN function.
An SQL dialect compatible with HSQLDB (HyperSQL).
An IdentifierBag has a primary key consisting of
just the identifier column
A collection with a synthetic "identifier" column
An identifier constraint
Nothing more than a distinguishing subclass of Insert used to indicate
intent.
Thrown by IdentifierGenerator implementation class when
ID generation fails.
The general contract between a class that generates unique
identifiers and the Session.
Identifies
generators which potentially aggregate other
PersistentIdentifierGenerator generators.Contract for a factory of
IdentifierGenerator instances.Factory and helper methods for
IdentifierGenerator framework.A property value, or grouped property value
Represents a defined entity identifier property within the Hibernate
runtime-metamodel.
Additional contract for a
Type may be used for a discriminator.A strategy for determining if an identifier value is an identifier of
a new transient instance or a previously persistent transient instance.
A generator for use with ANSI-SQL IDENTITY columns used as the primary key.
Delegate for dealing with IDENTITY columns where the dialect requires an
additional command execution to retrieve the generated IDENTITY value
Delegate for dealing with IDENTITY columns using JDBC3 getGeneratedKeys
Delegate for dealing with IDENTITY columns where the dialect supports returning
the generated IDENTITY value directly from the insert statement.
A Map where keys are compared by object identity,
rather than equals().
Set implementation that use == instead of equals() as its comparison
mechanism.
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.
Identifier generator container,
Useful to keep named generator in annotations
A case-insensitive "like"
A type that maps between
LONGVARBINARY and byte[]Mark an Entity or a Collection as immutable.
Mutability plan for immutable objects
Deprecated.
Use the
AbstractStandardBasicType approach insteadRepresents a FROM element implied by a path expression or a collection reference.
An improved naming strategy that prefers embedded
underscores to mixed case names
TODO : javadoc
increment
An IdentifierGenerator that returns a long, constructed by counting from the maximum primary key value at startup.
An IdentifierGenerator that returns a long, constructed by counting from the maximum primary key value at startup.
Define a DB index
A relational table index
Describe an index column of a List
Prefer the standard
OrderColumn annotationindex column
Indexed collections include Lists, Maps, arrays and
primitive arrays.
JDBC index metadata
Represents the [] operator and provides it's semantics.
Represents a "back-reference" to the index of a collection.
The Setter implementation for index backrefs.
Constrains the property to a specified list of values
Informix dialect.
Seems to work with Informix Dynamic Server Version 7.31.UD3, Informix JDBC driver version 2.21JC3.
Seems to work with Informix Dynamic Server Version 7.31.UD3, Informix JDBC driver version 2.21JC3.
An SQL IN expression.
A SQL dialect for Ingres 10 and later versions.
A SQL dialect for Ingres 9.3 and later versions.
An SQL dialect for Ingres 9.2.
Some extra data to the inheritance position of a class.
An event listener that requires access to mappings to initialize state at
initialization time.
An interface for initializeable AST nodes.
An event that occurs when a collection wants to be
initialized
Defines the contract for handling of collection initialization events
generated by a session.
An SQL INSERT statement
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
Implementation of InsertSelect.
Specialized IdentifierGeneratingInsert which appends the database
specific clause which signifies to return generated IDENTITY values
to the end of the insert statement.
Defines a top-level AST node representing an HQL "insert select" statement.
Thrown if Hibernate can't instantiate an entity or component
class at runtime.
Deprecated.
Per HHH-5451 support for cglib as a bytecode provider has been deprecated.
The
implementation for Javassist
which simply acts as an adapter to the
invalid reference
ReflectionOptimizer#InstantiationOptimizerFastClass class.Contract for implementors responsible for instantiating entity/component instances.
A specialized classloader which performs bytecode enhancement on class
definitions as they are loaded into the classloader scope.
TODO : javadoc
Deprecated.
Per HHH-5451 support for cglib as a bytecode provider has been deprecated; use
InstrumentTask insteadAn Ant task for instrumenting persistent classes in order to enable
field-level interception using Javassist.
A type that maps between
INTEGER and @link Integer}Descriptor for
Integer handling.Descriptor for
INTEGER handling.Defines a common api for dealing with data of integral data type.
An SQL dialect for Interbase.
Allows user code to inspect and/or change property values.
Represents an entity referenced in the INTO clause of an HQL
INSERT statement.
Thrown when a mapping is found to be invalid.
Exception thrown when an invalid path is found in a query.
IsNotNullLogicOperatorNode implementation
Represents a 'is null' check.
Represents work that needs to be performed in a manner
which isolates it from any current application unit of
work transaction.
Class which provides the isolation semantics required by
an
IsolatedWork.An isolation delegate for JDBC-based transactions.
An isolation delegate for JTA-based transactions.
An implementation of java.util.Iterator that is
returned by iterate() query execution methods.
Adds Hibernate permissions to roles via JACC
Copied from JBoss org.jboss.ejb3.security.JaccHelper and org.jboss.ejb3.security.SecurityActions
Check security before any deletion
Check security before an insertion
Check security before any load
Check security before any update
Marker interface for JACC event listeners
A node representing a static Java constant.
Enhance the classes allowing them to implements InterceptFieldEnabled
This interface is then used by Hibernate for some optimizations.
Strategy for performing build-time instrumentation of persistent classes in order to enable
field-level interception using Javassist.
A Javassist-based lazy initializer proxy.
A
ProxyFactory implementation for producing Javassist-based proxies.Descriptor for the Java side of a value mapping.
A
TransactionManagerLookup lookup strategy for JBoss AS.Return a standalone JTA transaction manager for JBoss Transactions
Known to work for org.jboss.jbossts:jbossjta:4.14.0.Final
A Dialect for JDataStore.
Implementation of JDBCException indicating problems with communicating with the
database (can also include incorrect JDBC setup).
Acts as the mediary between "entity-mode related" sessions in terms of
their interaction with the JDBC data store.
TODO : javadoc
Wraps an SQLException.
Implementation of JDBCExceptionHelper.
Contract for handling
warningsBasic support for
JDBCExceptionReporter.WarningHandler implementations which logIsolates Hibernate interactions with JDBC in terms of variations between JDBC 3 (JDK 1.4 and 1.5)
and JDBC 4 (JDK 1.6).
TODO : javadoc
Builds
JdbcSupport instances based on the capabilities of the environment.TODO : javadoc
TODO : javadoc
Transaction implementation based on transaction management through a JDBC Connection.Factory for
JDBCTransaction instances.TODO : javadoc
Template implementation of
TransactionManagerLookup where the
underlying TransactionManager is available via JNDI lookup at the
specified location - JNDITransactionManagerLookup.getName().Anything that can be loaded by outer join - namely
persisters for classes or collections.
An JoinedIterator is an Iterator that wraps a number of Iterators.
A subclass in a table-per-subclass mapping
An EntityPersister implementing the normalized "table-per-subclass"
mapping strategy
JoinFormula.
An abstract SQL join fragment renderer
Performs the post-processing of the join information gathered during semantic analysis.
Walks the metamodel, searching for joins, and collecting
together information needed by OuterJoinLoader.
TransactionManagerLookup strategy for JOnASTransactionManagerLookup strategy for JOTMMetadataProvider aware of the JPA Deployment descriptor
Encapsulates the overriding of Java annotations from an EJB 3.0 descriptor.
TransactionManagerLookup strategy for JRun4 ASAn implementation of
CurrentSessionContext which scopes the notion
of a current session to a JTA transaction.JTA transaction synch used for cleanup of the internal session map.
Transaction implementation based on transaction management through
a JTA UserTransaction.Factory for
JTATransaction instances.A sequence of a logical expressions combined by some
associative logical operator
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.
Define the lazy status of a collection
Lazy options available for a collection
Indicates access to unfetched data outside of a session context.
Handles fetching of the underlying entity for a proxy
Contract for controlling how lazy properties get initialized.
Define the lazy status of a ToOne association
(ie OneToOne or ManyToOne)
Lazy options available for a ToOne association
Provides callbacks from the Session to the persistent object.
A criterion representing a "like" expression
A list mapping has a primary key consisting of the key columns + index column.
Bind a list to the underlying Hibernate configuration
Represents a literal.
A delegate that handles literals and constants for HqlSqlWalker, performing the token replacement functions and
classifying literals.
Additional contract for a
Type that may appear as an SQL literalImplemented by a EntityPersister that may be loaded
using Loader.
Maps
result-sets to specific contextual data
related to processing that result-sets.Loader Annotation for overwriting Hibernate default FIND method
Abstract superclass of object loading (and querying) strategies.
Defines an event class for the loading of an entity.
Defines the contract for handling of load events generated from a session.
Represents a collection currently being loaded.
Centralize all options which can influence the SQL query needed to load an
entity.
Provides callback access into the context in which the LOB is to be created.
The callback contract for making use of the JDBC
Connection.Contract for creating various LOB references.
A
session's helper for creating LOB dataA base type used to define a LOB type; it also provides
alternatives that can override this type via
LobType.getAlternatives() getAlternatives()}A type that maps between
VARCHAR and @link Locale}TODO : javadoc
Contract for things that can be locked via a
LockingStrategy.Implementation of JDBCException indicating a problem acquiring lock
on the database.
Defines an event class for the locking of an entity.
Defines the contract for handling of lock events generated from a session.
A strategy abstraction for how locks are obtained in the underlying database.
Instances represent a lock mode for a row of a relational
database table.
Contains locking details (LockMode, Timeout and Scope).
Marker interface for user types which want to perform custom
logging of their corresponding values
Provides an abstraction for how instrumentation does logging because it is usually run in environments (Ant/Maven)
with their own logging infrastructure.
Superclass of binary logical expressions
Descriptor for
Long handling.Descriptor for
LONGVARBINARY handling.Descriptor for
LONGVARCHAR handling.A simple LRU cache that implements the
Map interface.Represents a
CurrentSessionContext the notion of a contextual session
is managed by some external entity (generally some form of interceptor, etc).Defined a ToMany association pointing to different entity types.
A many-to-one association mapping
A many-to-one association to an entity.
A map has a primary key consisting of
the key columns + index columns.
Implementation to bind a Map
TODO : javadoc
Deprecated.
Use
MapKeyColumn
This is the default behavior for Map properties marked as @OneToMany, @ManyToMany
or @ElementCollectionDeprecated.
Use
MapKeyJoinColumn MapKeyJoinColumns
This is the default behavior for Map properties marked as @OneToMany, @ManyToMany
or @ElementCollectionTODO : javadoc
Allows defining the type of the key of a persistent map.
Lazy initializer for "dynamic-map" entity representations.
Represents a @MappedSuperclass.
Defines operations common to "compiled" mappings (ie.
An exception that usually occurs at configuration time, rather
than runtime, as a result of something screwy in the O-R mappings.
Thrown when a resource for a mapping could not be found.
Handles reading mapping documents, both
hbm and orm varieties.A collection of mappings from classes and collections to relational database tables.
Represents a property-ref mapping.
Proxy for "dynamic-map" entity representations.
TODO : javadoc
Represents an strategy for matching strings using "like".
A type that maps between
BLOB and byte[]A Mckoi IF function.
An SQL dialect compatible with McKoi SQL
An event class for merge() and saveOrUpdateCopy()
Defines the contract for handling of merge events generated from a session.
MessageHelper methods for rendering log messages relating to managed
entities and collections typically used in log statements and exception
messages.
Common interface for things that can handle meta attributes.
A meta attribute is a named value or values.
Enumeration of the known places from which a piece of metadata may come.
Enumeration of the types of sources of mapping metadata
Represent a discriminator value associated to a given entity type
Represents a method call.
An Hibernate 3 SQL dialect for Mimer SQL.
Exception used to indicate that a query is attempting to simultaneously fetch multiple
bagsA hilo IdentifierGenerator that returns a Long, constructed using
a hi/lo algorithm.
Implementation of MultiTableDeleteExecutor.
Implementation of MultiTableUpdateExecutor.
TODO : javadoc
Mutability plan for mutable objects
Deprecated.
Use the
AbstractStandardBasicType approach insteadAn SQL dialect for MySQL 5.x specific features.
An SQL dialect for MySQL (prior to 5.x).
Extends
NamedNativeQueries to hold hibernate NamedNativeQuery
objectsExtends
NamedNativeQuery with Hibernate featuresDescriptor regarding a named parameter.
Parameter bind specification for an explicit named parameter.
Extends
NamedQueries to hold hibernate NamedQuery
objectsExtends
NamedQuery with Hibernate featuresA wrapper around a named query.
Definition of a named query, defined in the mapping metadata.
Not really a Loader, just a wrapper around a
named query.
Definition of a named native SQL query, defined in the mapping metadata.
Provides utility methods for generating HQL / SQL names.
A set of rules for determining the physical column
and table names given the information in the mapping
document.
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).
Represents a return defined as part of a native sql query which
names a fetched role.
Represents the base information for a non-scalar return defined as part of
a native sql query.
Defines a query execution plan for a native-SQL query.
Describes a return in a native SQL query.
Represents a return defined as part of a native sql query which
names a "root" entity.
Describes a scalar return in a native SQL query.
Defines the specification or blue-print for a native-sql query.
This specifies that a property is part of the natural id of the entity.
Marker interface for non-contextually created java.sql.NClob instances..
Manages aspects of proxying java.sql.NClobs for non-contextual creation, including proxy creation and
handling proxy invocations.
A function which takes no arguments
Implementation of NoCacheProvider.
Implementation of NoCachingEnabledException.
Factory used if no caching enabled in config...
Base node class for use by Hibernate within its AST trees.
General contract for AST nodes.
Basic implementation of a
Node.A visitor for traversing an AST tree.
An implementation of the Batcher interface that does no batching
A BatcherFactory implementation which constructs Batcher instances
that do not perform batch operations.
LobCreator implementation using non-contextual or local creation, meaning that we generate the LOB
references ourselves as opposed to delegating to the JDBC Connection.Represents some non-scalar (entity/collection) return within the query result.
Caches data that is sometimes updated without ever locking the cache.
This exception is thrown when an operation would
break session-scoped identity.
Thrown when the application calls Query.uniqueResult() and
the query returned more than one result.
Used to declare properties not represented at the pojo level
Negates another criterion
Action to do when an element is not found on a association whiel beeing expected
Actoin to use when an element is not found in DB while beeing expected
Constrains a property to be non-null
Mapping not yet implemented
Are the columns forced to null, not null or not forced
Implements the algorithm for validating property values
for illegal null values
Deprecated.
Use the
AbstractStandardBasicType approach insteadConstrains a property to be null
TODO : javadoc
Descriptor for
NUMERIC handling.Emulation of coalesce() on Oracle, using multiple nvl() calls
Thrown when the user tries to do something illegal with a deleted
object.
Provides centralized normalization of how database object names are handled.
Helper contract for dealing with
NamingStrategy in different situations.Source for database object names (identifiers).
Thrown when Session.load() fails to select a row with
the given primary key (identifier value).
Specific adaptation of the "any" type to the old deprecated "object" type
TransactionManagerLookup for the OC4J (Oracle) AS.Strategy to use on collections, arrays and on joined subclasses delete
OnDelete of secondary tables currently not supported.
Possible actions on deletes
A mapping for a one-to-many association
Walker for one-to-many associations
Loads one-to-many associations
The collection persister must implement QueryableCOllection.
The collection persister must implement QueryableCOllection.
Collection persister for one-to-many associations.
A one-to-one association mapping
We have to handle OneToOne in a second pass because:
-
A one-to-one association to an entity
When a transient entity is passed to lock(), we must inspect all its collections and
1.
When an entity is passed to replicate(), and there is an existing row, we must
inspect all its collections and
1.
When an entity is passed to update(), we must inspect all its collections and
1.
Contract for nodes representing operators (logic or arithmetic).
A contract for transactional cache implementations which support
optimistic locking of items within the cache.
Contract for sources of optimistically lockable data sent to the second level
cache.
An optimistic locking strategy that forces an increment of the version (after verifying that version hasn't changed).
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)
Throw when an optimistic locking conflict occurs.
An optimistic locking strategy that verifies that the version hasn't changed (prior to transaction commit).
Optimistic locking strategy
VERSION is the default and recommanded one
Performs optimization on an optimizable identifier generator.
Factory for
Optimizer instances.Optimizer which applies a 'hilo' algorithm in memory to achieve
optimization.
Marker interface for optimizer which wish to know the user-specified initial value.
An optimizer that performs no optimization.
Common support for optimizer implementations.
Optimizer which uses a pool of values, storing the next low value of the
range in the database.
A dialect specifically for use with Oracle 10g.
A dialect for Oracle 8i.
Deprecated.
Use either Oracle9iDialect or Oracle10gDialect instead
A dialect for Oracle 9i databases.
Deprecated.
Use Oracle8iDialect instead.
An Oracle-style (theta) join
Represents an order imposed upon a Criteria result set
Order a collection using SQL ordering (not HQL ordering)
Implementation of OrderByClause.
Represents a parsed order-by mapping fragment.
Extension of the Antlr-generated parser for the purpose of adding our custom parsing behavior.
TODO : javadoc
A translator which coordinates translation of an order-by mapping.
Parses the ORDER BY clause of a query
A specialization of the map type, with (resultset-based) ordering.
A specialization of the set type, with (resultset-based) ordering.
Models an ordering specification (ASCENDING or DESCENDING) within a
SortSpecification.Describes the origin of an xml document
Basic implementation of
OriginTransactionManagerLookup strategy for OrionPart of the Hibernate SQL rendering internals.
A EntityPersister that may be loaded by outer join using
the OuterJoinLoader hierarchy and may be an element
of a one-to-many association.
Implements logic for walking a tree of associated classes.
A parameter definition
Parameter (basically key/value pattern)
Centralizes the commonality regarding binding of parameter values into
PreparedStatements as this logic is used in many places.
Deprecated.
Support for parameterizable types.
Encapsulates metadata about parameters encountered within a query.
Implementation of ParameterNode.
The single available method
ParameterParser.parse(java.lang.String, org.hibernate.engine.query.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.Maintains information relating to parameters which need to get bound into a
JDBC
PreparedStatement.Defines available information about the parameters encountered during
query translation.
Defines the information available for parameters encountered during
query translation through the antlr-based parser.
Implements a parameter parser recognizer specifically for the purpose
of journaling parameter locations.
Reference the property as a pointer back to the owner (generally the owning entity)
Defines the behavior of an error handler for the HQL parsers.
A parser is a state machine that accepts a string of tokens,
bounded by start() and end() and modifies a QueryTranslator.
???
Parses an expression of the form foo.bar.baz and builds up an expression
involving two less table joins than there are path components.
Provides utility methods for paths.
An AST node with a path property.
Holds the state of the persistence context, including the
first-level cache, entries, snapshots, proxies, etc.
A persistent wrapper for an array.
An unordered, unkeyed collection that can contain the same element
multiple times.
Mapping for an entity.
Persistent collections are treated as value objects by Hibernate.
A persistent wrapper for an XML element
An IdentifierBag implements "bag" semantics more efficiently than
a regular Bag by adding a synthetic identifier column to the
table.
An IdentifierGenerator that requires creation of database objects.
A persistent wrapper for an XML element
A persistent wrapper for a java.util.List.
A persistent wrapper for a java.util.Map.
Thrown when the user passes a persistent instance to a Session
method that expects a transient instance.
A persistent wrapper for a java.util.Set.
A persistent wrapper for a java.util.SortedMap.
A persistent wrapper for a java.util.SortedSet.
Specify a custom persister.
Provides persister classes based on the entity or collection role.
Factory for EntityPersister and CollectionPersister instances
An event class for persist()
Defines the contract for handling of create events generated from a session.
A pessimistic locking strategy that increments the version immediately (obtaining an exclusive write lock).
Thrown when a pessimistic locking conflict occurs.
A pessimistic locking strategy where the locks are obtained through select statements.
A pessimistic locking strategy where the locks are obtained through update statements.
A pessimistic locking strategy where the locks are obtained through select statements.
A pessimistic locking strategy where the locks are obtained through update statements.
A Dialect for Pointbase.
A
ComponentTuplizer specific to the pojo entity mode.An
EntityTuplizer specific to the pojo entity mode.Defines a POJO-based instantiator for use from the tuplizers.
Type of available polymorphism for a particular entity
Parameter bind specification for an explicit positional (or ordinal) parameter.
Emulation of locate() on PostgreSQL
An event that occurs after a collection is recreated
Called after recreating a collection
An event that occurs after a collection is removed
Called after removing a collection
An event that occurs after a collection is updated
Called after updating a collection
Occurs after deleting an item from the datastore
Called after deleting an item from the datastore
An SQL dialect for Postgres Plus
An SQL dialect for Postgres
Specialized type mapping for
UUID and the Postgres UUID data type (which is mapped as OTHER in its
JDBC driver).Occurs after inserting an item in the datastore
Called after insterting an item in the datastore
A persister that may have an identity assigned by execution of
a SQL INSERT.
Occurs after an an entity instance is fully loaded.
Occurs after an an entity instance is fully loaded.
Occurs after the datastore is updated
Called after updating the datastore
An event that occurs before a collection is recreated
Called before recreating a collection
An event that occurs before a collection is removed
Called before removing a collection
An event that occurs before a collection is updated
Called before updating a collection
Represents a pre-delete event, which occurs just prior to
performing the deletion of an entity from the database.
Called before deleting an item from the datastore
Represents a pre-insert event, which occurs just prior to
performing the insert of an entity into the database.
Called before inserting an item in the datastore
Called before injecting property values into a newly
loaded entity instance.
Called before injecting property values into a newly
loaded entity instance.
Represents a pre-update event, which occurs just prior to
performing the update of an entity in the database.
Called before updating the datastore
A primary key constraint
A primitive array has a primary key consisting of the key columns + index column.
Deprecated.
replaced by
MaterializedBlobTypeDescriptor for
byte[] handling.Map a char[] to a Clob
TODO : javadoc
Additional contract for primitive / primitive wrapper types.
Renders entities to a nicely readable string.
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.
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.
An object-oriented representation of a query result set projection in a
Criteria query.The criterion package may be used by applications as a framework for building
new kinds of Projection.
Collection of helper methods for dealing with
Properties
objects.A factory for property-specific criterion and projection instances
Represents a property as part of an entity or a component.
Defines the basic contract of a Property within the runtime metamodel.
A problem occurred accessing a property of an instance of a
persistent class by reflection, or via CGLIB.
Abstracts the notion of a "property".
A factory for building/retrieving PropertyAccessor instances.
superclass for comparisons between two properties (with SQL binary operators)
Responsible for generation of runtime metamodel
Property representations.Indicates whether given properties are generated by the database and, if
so, at what time(s) they are generated.
Property holder abstract property containers from their direct implementation
This factory is here ot build a PropertyHolder and prevent .mapping interface adding
Retrieve all inferred data from an annnoted element
Abstraction of all mappings that define properties:
entities, collection elements.
Indicates that an expected getter or setter method could not be
found on a class.
A property value, or grouped property value
A comparison between a property value in the outer query and the
result of a subquery
Thrown when the (illegal) value of a property can not be persisted.
Lazy and proxy configuration of a particular class
Contract for run-time, proxy-based lazy initialization proxies.
An interface for factories of
proxy factory instances.Deprecated.
Per HHH-5451 support for cglib as a bytecode provider has been deprecated.
A factory for Javassist-based
ProxyFactory instances.Reassociates uninitialized proxies with the session
An object-oriented representation of a Hibernate query.
Extends the generic EntityPersister contract to add
operations required by the Hibernate Query Language
A collection role that may be queried or loaded by outer join.
Query binder
Defines the contract for caches capable of storing query results.
Defines a factory for query cache instances.
A problem occurred translating a Hibernate query to SQL
due to invalid query syntax, etc.
Expecting to execute an illegal operation regarding the query type
default implementation of the Query interface,
for "ordinary" HQL queries (not collection filters)
A join that appears in a translated HQL query
A key that identifies a particular query with bound parameter values.
A delegate that implements the Loader part of QueryTranslator.
Defines metadata regarding a translated HQL or native-SQL query.
Defines a top-level AST node representing an HQL select statement.
Parameter invalid or not found in the query
Acts as a cache for compiled query plans, as well as query-parameter metadata.
Defines the contract for a cache region which will specifically be used to
store query results.
Adapter specifically briding
QueryResultsRegion to Cache.Bind query
A translated HQL query
Provides query splitting methods, which were originally in QueryTranslator.
Query statistics (HQL and SQL)
Query statistics (HQL and SQL)
Exception thrown when there is a syntax error in the HQL.
Thrown when a database query timeout occurs.
Defines the contract of an HQL->SQL translator.
Facade for generation of
QueryTranslator and FilterTranslator instances.A QueryTranslator that uses an Antlr-based parser.
An instance of QueryTranslator translates a Hibernate
query string to SQL.
This is the Hibernate dialect for the Unisys 2200 Relational Database (RDMS).
Exposes a
Reader as an InputStream.Deprecated.
Should not be used anymore.
Caches data that is never updated.
Caches data that is sometimes updated while maintaining the semantics of
"read committed" isolation level.
An item of cached data, timestamped with the time it was cached,.
A soft lock which supports concurrent locking,
timestamped with the time it was released
Descriptor for
REAL handling.Abstract superclass of visitors that reattach collections.
Should neven be exposed to the client
An exception that wrap an underlying exception whith the hope
subsequent processing will recover from it.
Utility class for various reflection operations.
Represents reflection optimization for a particular class.
Represents optimized entity property access.
Represents optimized entity instantiation.
Deprecated.
Per HHH-5451 support for cglib as a bytecode provider has been deprecated.
ReflectionOptimizer implementation for Javassist.
Defines an event class for the refreshing of an object.
Defines the contract for handling of refresh events generated from a session.
Defines a contract for accessing a particular named region within the
underlying cache implementation.
Contract for building second level cache regions.
Acts as a bridge between the
RegionFactory contract and the older
CacheProvider contract.A relational object which may be created using DDL
Defines an event class for the replication of an entity.
Defines the contract for handling of replicate events generated from a session.
Represents a replication strategy.
TransactionManagerLookup strategy for ResinThe contract for expression sub-trees that can resolve themselves.
Type definition for Statements which are restrictable via a where-clause (and
thus also having a from-clause).
The criterion package may be used by applications as a framework for building
new kinds of Criterion.
Possible checks on Sql Insert, Delete, Update
Defines how we need to reference columns in the group-by, having, and order-by
clauses.
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 IdentifierGeneratorHelperKeep a description of the resultset mapping
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).
Implementors define a strategy for transforming query results into the
actual application-visible query result list.
Represents a reference to a result_variable as defined in the JPA 2 spec.
Represents a return in a custom query.
The root class of an inheritance hierarchy
ResultTransformer implementation which limits the result tuple
to only the "root entity".Represents a return which names a "root" entity.
A row count
Represents a selection of rows in a JDBC ResultSet
An SQL dialect compatible with SAP DB.
An event class for saveOrUpdate()
Defines the contract for handling of update events generated from a session.
Represent a scalar (aka simple value) return within a query result.
Commandline tool to export table schema to the database.
An Ant task for SchemaExport.
A commandline tool to update a database schema.
An Ant task for SchemaUpdate.
A commandline tool to update a database schema.
An Ant task for SchemaUpdate.
A result iterator that allows moving around within the results
by arbitrary increments.
Implementation of the ScrollableResults interface
Specifies the type of JDBC scrollable result set to use
underneath a ScrollableResults
Second level cache statistics of a specific region
Second level cache statistics of a specific region
Second pass operation
A simple SQL SELECT statement
Represents the list of expressions in a SELECT clause.
Represents an element of a projection list, i.e.
TODO : javadoc
A select expression that was generated by a FROM element.
Common behavior - a node that contains a list of select expressions.
A fragment of an SQL SELECT clause
A generator that selects the just inserted row to determine the identifier
value assigned by the database.
The delegate for the select generation strategy.
A locking strategy where the locks are obtained through select statements.
Parsers the select clause of a Hibernate query.
sequence
Generates long values using an oracle-style sequence.
Generates long values using an oracle-style sequence.
seqhilo
An IdentifierGenerator that combines a hi/lo algorithm with an underlying oracle-style sequence that generates hi values.
An IdentifierGenerator that combines a hi/lo algorithm with an underlying oracle-style sequence that generates hi values.
A generator which combines sequence generation with immediate retrieval
through JDBC3
getGeneratedKeys.Describes a sequence.
Generates identifier values based on an sequence-style database structure.
Manages aspects of proxying
Blobs to add serializability.Manages aspects of proxying
Clobs to add serializability.Manages aspects of proxying java.sql.NClobs to add serializability.
Deprecated.
Per HHH-5451 support for cglib as a bytecode provider has been deprecated.
Serializable placeholder for Javassist proxies
A type that maps between a
VARBINARY and Serializable classes.TODO : javadoc
Thrown when a property cannot be serializaed/deserialized
Assists with the serialization process and performs additional functionality based
on serialization.
An extension of the Session API, including all
deprecated methods from Hibernate2.
The main runtime interface between a Java application and Hibernate.
Contains locking details (LockMode, Timeout and Scope).
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).The main contract here is the creation of
Session instances.Interface for nodes which require access to the SessionFactory
Helper for performing common and/or complex operations with the
SessionFactoryImplementor during translation of an HQL query.Concrete implementation of the SessionFactory interface.
Defines the internal contract between the SessionFactory and other parts of
Hibernate such as implementors of Type.
Resolves
SessionFactory instances during JNDI look-ups as well as during deserializationAllows reaction to basic
SessionFactory occurrences.A flyweight for SessionFactory.
Concrete implementation of a Session, and also the central, organizing component
of Hibernate's internal implementation.
Defines the internal contract between the Session and other parts of
Hibernate such as implementors of Type or EntityPersister.
Information about the first-level (session) cache
for a particular session instance
A set with no nullable element columns.
Bind a set.
Sets values to a particular property.
Settings that affect the behaviour of Hibernate at runtime.
Reads configuration properties and builds a
Settings instance.Descriptor for
Short handling.A simple implementation of AbstractAuxiliaryDatabaseObject in which the CREATE and DROP strings are
provided up front.
superclass for "simple" comparisons (with SQL binary operators)
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.
A single-column projection that may be aliased
An SQL SELECT statement with no table joins
A comparison between a constant value and the the result of a subquery
Any value that maps to columns.
Provide convenient methods for binding and extracting values for use with
BasicType.The default implementation of the EntityPersister interface.
Descriptor for
SMALLINT handling.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.
Moved up from inner definition on the now deprecated
CacheConcurrencyStrategy.Collection sort
(Java level sorting)
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
SortSpecificationModels each sorting exprersion.
Sort strategies
Optional annotation in conjunction with
Version and timestamp version properties.Where should Hibernate retrieve the value from? From the database, or from the current JVM?
A one-to-one association that maps to specific formula(s)
instead of the primary key column of the owning entity.
Custom AST factory the intermediate tree that causes ANTLR to create specialized
AST nodes, given the AST node type (from HqlSqlTokenTypes).
A SQL fragment.
Implements Hibernate's built-in support for native SQL queries.
SqlDelete Annotation for overwriting Hibernate default DELETE method
SqlDelete Annotation for overwriting Hibernate default DELETE ALL method
Defines a contract for implementations that know how to convert a SQLException
into Hibernate's JDBCException hierarchy.
A factory for building SQLExceptionConverter instances.
Represents an SQL fragment in the AST.
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.
Represents HQL functions that can have different representations in different SQL dialects.
Generates SQL by overriding callback methods in the base class, which does
the actual SQL AST walking.
SQL Generator Tree Parser, providing SQL rendering of SQL ASTs produced by the previous phase, HqlSqlWalker.
Implementation of JDBCException indicating that the SQL sent to the database
server was invalid (syntax error, invalid object references, etc).
SqlInsert Annotation for overwriting Hibernate default INSERT INTO method
A class persister that supports queries expressed in the
platform native SQL dialect
A base AST node for the intermediate tree.
A SQL fragment.
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).Allows access to further control how join fetch returns are mapped back from result sets
Allows access to further control how properties within a root or join fetch are mapped back from the result set.
Allows access to further control how root returns are mapped back from result sets
Implementation of the
SQLQuery contract.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.A dialect for Microsoft SQL 2005.
A dialect for Microsoft SQL Server 2008 with JDBC Driver 3.0 and above
A dialect for Microsoft SQL Server 2000
A SQLExceptionConverter implementation which performs converion based on
the underlying SQLState.
Centralize logging handling for SQL statements.
Descriptor for the SQL/JDBC side of a value mapping.
SqlUpdate Annotation for overwriting Hibernate default UPDATE method
A StaleStateException that carries information
about a particular entity instance that was the source
of the failure.
Thrown when a version number or timestamp check failed, indicating that the
Session contained stale data (when using long transactions
with versioning).
TODO : javadoc
Definition of a standard ANSI SQL compliant AVG function
Definition of a standard ANSI SQL compliant COUNT function
Centralizes access to the standard set of basic
types.The standard Hibernate resolver.
Analogous to
StandardSQLFunction
except that standard JDBC escape sequences (i.e.Represents a basic property within the Hibernate runtime-metamodel.
The standard implementation of the Hibernate QueryCache interface.
Standard Hibernate implementation of the QueryCacheFactory interface.
Implements a "random" UUID generation strategy as defined by the
UUID.randomUUID() method.Provides a standard implementation that supports the majority of the HQL
functions that are translated to SQL.
A PersistenceContext represents the state of persistent "stuff" which
Hibernate is tracking.
A command-oriented API for performing bulk operations against a database.
Common interface modeling the different HQL statements (i.e., INSERT, UPDATE, DELETE, SELECT).
Encapsulates the strategy required to execute various types of update, delete,
and insert statements issued through HQL.
Statistics for a particular SessionFactory.
Deprecated.
Use
ConcurrentStatisticsImpl insteadStatistics SPI for the Hibernate core.
JMX service for Hibernate statistics
Register this MBean in your JMX server for a specific session factory
Register this MBean in your JMX server for a specific session factory
MBean exposing Session Factory statistics
Represents the status of an entity with respect to
this session.
Stream copying utilities
Deprecated.
replaced by
MaterializedClobTypeAdditional, optional contract for types capable of rendering and consuming their values to/from strings.
Descriptor for
String handling.A sublass in a table-per-class-hierarchy mapping
Factory class for criterion instances that represent expressions
involving subqueries.
Map an immutable and read-only entity to a given SQL subselect expression:
Implements subselect fetching for a collection
Implements subselect fetching for a one to many association
TransactionManagerLookup strategy for Sun ONE Application Server 7 and aboveA SQL dialect suitable for use with Sybase 11.9.2 (specifically: avoids ANSI JOIN syntax)
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.
SQL Dialect for Sybase Anywhere
extending Sybase (Enterprise) Dialect
(Tested on ASA 8.x)
An SQL dialect targeting Sybase Adaptive Server Enterprise (ASE) 15.7 and higher.
An SQL dialect targeting Sybase Adaptive Server Enterprise (ASE) 15 and higher.
Deprecated.
Manages a registry of
Synchronizations.Ensures that auto-flush happens correctly and that queries against the derived
entity do not return stale data.
Creates synthetic and nodes based on the where fragment part of a JoinSequence.
Models a property which does not actually exist in the model.
Complementary information to a table either primary or secondary
A relational table
Table related operations
An enhanced version of table-based id generation.
An IdentifierGenerator that uses a database
table to store the last generated value.
hilo
An IdentifierGenerator that returns a Long, constructed using a hi/lo algorithm.
An IdentifierGenerator that returns a Long, constructed using a hi/lo algorithm.
JDBC table metadata
Interface allowing to differenciate SubClasses
from Classes, JoinedSubClasses and UnionSubClasses
The first one has not its own table while the others have
Plural of Table
Describes a table used to mimic sequence behavior
Define an explicit target,a voiding reflection and generics resolving
Parses SQL fragments specified in mapping documents
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.
Delegate for handling function "templates".
A dialect for the Teradata database created by MCR as part of the
dialect certification process.
A type that maps between
LONGVARCHAR and StringA
CurrentSessionContext impl which scopes the notion of current
session by the current thread of execution.JTA transaction synch used for cleanup of the internal session map.
Generates increasing identifiers (in a single VM only).
Defines the contract for a cache region which will specifically be used to
store entity "update timestamps".
Adapter specifically briding
TimestampsRegion to Cache.Descriptor for
TIMESTAMP handling.A SQL dialect for TimesTen 5.1.
Descriptor for
TIME handling.Descriptor for
TimeZone handling.Descriptor for
TINYINT handling.Indicates that more rows were affected then we were expecting to be.
A simple-point association (ie.
Work in progress
The goal of this class is to aggregate all operations
related to ToOne binding operations
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
Allows the application to define units of work, while
maintaining abstraction from the underlying transaction
implementation (eg.
Support for fully transactional cache implementations like
JBoss TreeCache.
Defines contract for regions which hold transactionally-managed data.
Marker interface for identifying cache impls which are aware of
JTA transactions
Indicates that a transaction could not be begun, committed
or rolled back.
Contract for generating Hibernate
Transaction instances.Callback mechanism; a context is always a
Session
in the Hibernate usage.Helper for creating
TransactionFactory instances.Allows work to be done outside the current transaction, by suspending it,
and performing work in a new transaction
Contract for locating the JTA
TransactionManager on given platform.Helper for generating
TransactionManagerLookup instances.Thrown when the user passes a transient instance to a Session
method that expects a persistent instance.
Contract for contextual information required to perform translation.
Defines the basic template support for TRIM functions
Define a tuplizer for an entity or a component
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).Define a set of tuplizer for an entity or a component
Functionality relating to Hibernate's two-phase loading process,
that may be reused by persisters that do not use the Loader
framework
hibernate type
Defines a mapping between a Java type and one or more JDBC types, as well
as describing the in-memory semantics of the given java type (how do we check it for 'dirtiness', how do
we copy values, etc).
Type definition
Placeholder for typedef information
Type definition array
Essentially a wrapper around a
DiscriminatorMetadata
and the proper sql alias to use.An ordered pair of a value and its Hibernate type.
Used internally to build instances of
Type, specifically it builds instances of
Used internally to obtain instances of Type.Collection of convenience methods relating to operations across arrays of types...
Provides access to the various
Type instances associated with the SessionFactory.Implementation of
TypeHelperUsed when a user provided type does not match the expected one
This class maps a type to names.
Acts as the contract for getting types and as the mediator between
BasicTypeRegistry and TypeFactory.Represents a unary operator node.
Contract for nodes representing unary operators.
A subclass in a table-per-concrete-class mapping
Implementation of the "table-per-concrete-class" or "roll-down" mapping
strategy for an entity and its inheritence hierarchy.
UniqueConstraint annotations are handled via second pass.Loads entities for a EntityPersister
A relational unique key constraint
Used to indicate a request against an unknown profile name.
Thrown when Hibernate could not resolve an object by id, especially when
loading an association.
An SQL UPDATE statement
A locking strategy where the locks are obtained through update statements.
Defines a top-level AST node representing an HQL update statement.
Tracks the timestamps of the most recent updates to particular tables.
Descriptor for
URL handling.A custom type for mapping user-written classes that implement PersistentCollection
An implementation of the ConnectionProvider interface that
simply throws an exception when a connection is requested.
This interface should be implemented by user-defined "types".
A user type that may be used for a version property
A type mapping
Types.BINARY and UUIDA strategy for generating a variant 2
UUID value.uuid
A UUIDGenerator that returns a string of length 32, This string will consist of only hex digits.
A UUIDGenerator that returns a string of length 32, This string will consist of only hex digits.
Descriptor for
UUID handling.Implemented by persistent classes with invariants that must
be checked before inserting into or updating the database.
Thrown from Validatable.validate() when an invariant
was violated.
A value is anything that is persisted by value, instead of
by reference.
Contract for binding values to a
PreparedStatement.Contract for extracting a value from a
ResultSet.An enum of the different ways a value might be "included".
Support for slightly more general templating than
StandardSQLFunction, with an unlimited number of arguments.Descriptor for
VARBINARY handling.Descriptor for
VARCHAR handling.Deprecated.
Use
Version insteadInformation about the Hibernate version.
Utilities for dealing with optimisitic locking values.
Represents a version property within the Hibernate runtime-metamodel.
Additional contract for types which may be used to version (and optimistic lock) data.
Parameter bind specification used for optimisitc lock version seeding (from insert statements).
A strategy for determining if a version value is an version of
a new transient instance or a previously persistent transient instance.
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.
TransactionManager lookup strategy for WebLogic
TransactionManagerLookup implementation intended for use with WebSphere
Application Server (WAS).
TransactionManagerLookup strategy for WebSphere (versions 4, 5.0 and 5.1)Where clause to add to the element Entity or target entity of a collection
The clause is written in SQL
Where clause to add to the colleciton join table
The clause is written in SQL
Parses the where clause of a hibernate query and translates it to an
SQL where clause.
Contract for performing a discrete piece of JDBC work.
Contract for
Blob wrappers.Contract for
Clob wrappers.A type that maps JDBC
BLOB and Byte[].TODO : javadoc
Wrap collections in a Hibernate collection
wrapper.
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.
Describes a parsed xml document.
Basic implemementation of
XmlDocumentSmall helper class that lazy loads DOM and SAX reader and keep them for fast use afterwards.
Additional, optional contract for types whose values can be represented as XML text (either as attribute or
element value).
AbstractStandardBasicTypeapproach instead