Package org.hibernate.loader

Class Loader

java.lang.Object

org.hibernate.loader.Loader

Direct Known Subclasses:

BasicLoader, CustomLoader

public abstract class Loader
extends Object

Abstract superclass of object loading (and querying) strategies. This class implements useful common functionality that concrete loaders delegate to. It is not intended that this functionality would be directly accessed by client code. (Hence, all methods of this class are declared protected or private.) This class relies heavily upon the Loadable interface, which is the contract between this class and EntityPersisters that may be loaded by it.

The present implementation is able to load any number of columns of entities and at most one collection role per query.

See Also:

Loadable

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
protected static class	Loader.SqlStatementWrapper	Wrapper class for Statement and associated ResultSet.

Field Summary

Fields

Modifier and Type	Field	Description
protected static org.hibernate.internal.CoreMessageLogger	LOG
static String	SELECT
static String	SELECT_DISTINCT

Constructor Summary

Constructors

Constructor	Description
Loader(SessionFactoryImplementor factory)

Method Summary

Modifier and Type	Method	Description
protected String	applyLocks(String sql, QueryParameters parameters, Dialect dialect, List<AfterLoadAction> afterLoadActions)	Append FOR UPDATE OF clause, if necessary.
protected void	applyPostLoadLocks(Object[] row, LockMode[] lockModesArray, SharedSessionContractImplementor session)
protected boolean	areResultSetRowsTransformedImmediately()	Are rows transformed immediately after being read from the ResultSet?
protected void	autoDiscoverTypes(ResultSet rs)
protected int	bindNamedParameters(PreparedStatement statement, Map<String,TypedValue> namedParams, int startIndex, SharedSessionContractImplementor session)	Bind named parameters to the JDBC prepared statement.
protected int	bindParameterValues(PreparedStatement statement, QueryParameters queryParameters, int startIndex, SharedSessionContractImplementor session)	Bind all parameter values into the prepared statement in preparation for execution.
protected int	bindPositionalParameters(PreparedStatement statement, QueryParameters queryParameters, int startIndex, SharedSessionContractImplementor session)	Bind positional parameter values to the JDBC prepared statement.
protected PreparedStatement	bindPreparedStatement(PreparedStatement st, QueryParameters queryParameters, LimitHandler limitHandler, SharedSessionContractImplementor session)
protected void	checkScrollability()	Check whether the current loader can support returning ScrollableResults.
protected CacheableResultTransformer	createCacheableResultTransformer(QueryParameters queryParameters)
protected void	createSubselects(List keys, QueryParameters queryParameters, SharedSessionContractImplementor session)
protected LockMode	determineFollowOnLockMode(LockOptions lockOptions)
protected List	doList(SharedSessionContractImplementor session, QueryParameters queryParameters)	Actually execute a query, ignoring the query cache
List	doQueryAndInitializeNonLazyCollections(SharedSessionContractImplementor session, QueryParameters queryParameters, boolean returnProxies)	Execute an SQL query and attempt to instantiate instances of the class mapped by the given persister from each row of the ResultSet.
List	doQueryAndInitializeNonLazyCollections(SharedSessionContractImplementor session, QueryParameters queryParameters, boolean returnProxies, ResultTransformer forcedResultTransformer)
protected void	endCollectionLoad(Object resultSetId, SharedSessionContractImplementor session, CollectionPersister collectionPersister)
protected Loader.SqlStatementWrapper	executeQueryStatement(String sqlStatement, QueryParameters queryParameters, boolean scroll, List<AfterLoadAction> afterLoadActions, SharedSessionContractImplementor session)
protected Loader.SqlStatementWrapper	executeQueryStatement(QueryParameters queryParameters, boolean scroll, List<AfterLoadAction> afterLoadActions, SharedSessionContractImplementor session)	Process query string by applying filters, LIMIT clause, locks and comments if necessary.
protected void	extractKeysFromResultSet(Loadable[] persisters, QueryParameters queryParameters, ResultSet resultSet, SharedSessionContractImplementor session, EntityKey[] keys, LockMode[] lockModes, List hydratedObjects)
protected QueryKey	generateQueryKey(SharedSessionContractImplementor session, QueryParameters queryParameters)
protected String[]	getAliases()	Get the SQL table aliases of entities whose associations are subselect-loadable, returning null if this loader does not support subselect loading
protected abstract CollectionAliases[]	getCollectionAliases()
protected int[]	getCollectionOwners()	Get the index of the entity that owns the collection, or -1 if there is no owner in the query results (ie.
protected CollectionPersister[]	getCollectionPersisters()	An (optional) persister for a collection to be initialized; only collection loaders return a non-null value
protected int[][]	getCompositeKeyManyToOneTargetIndices()
protected abstract EntityAliases[]	getEntityAliases()	Get the result set descriptor
protected boolean[][]	getEntityEagerPerPropertyFetches()	An array indicating for each entity which specific properties must have eager fetching enabled.
protected boolean[]	getEntityEagerPropertyFetches()	An array indicating whether the entities have eager property fetching enabled for all of their properties.
protected EntityPersister	getEntityPersister(EntityType entityType)
protected abstract Loadable[]	getEntityPersisters()	An array of persisters of entity classes contained in each row of results; implemented by all subclasses
SessionFactoryImplementor	getFactory()
protected LimitHandler	getLimitHandler(RowSelection selection)	Build LIMIT clause handler applicable for given selection criteria.
protected abstract LockMode[]	getLockModes(LockOptions lockOptions)	What lock options does this load entities with?
int[]	getNamedParameterLocs(String name)
protected static EntityKey	getOptionalObjectKey(QueryParameters queryParameters, SharedSessionContractImplementor session)
protected EntityType[]	getOwnerAssociationTypes()	An array of the owner types corresponding to the getOwners() returns.
protected int[]	getOwners()	An array of indexes of the entity that owns a one-to-one association to the entity at the given index (-1 if there is no "owner").
protected String	getQueryIdentifier()	Identifies the query for statistics reporting, if null, no statistics will be reported
protected Object	getResultColumnOrRow(Object[] row, ResultTransformer transformer, ResultSet rs, SharedSessionContractImplementor session)	Get the actual object that is returned in the user-visible result list.
protected List	getResultFromQueryCache(SharedSessionContractImplementor session, QueryParameters queryParameters, Set<Serializable> querySpaces, Type[] resultTypes, QueryResultsCache queryCache, QueryKey key)
protected List	getResultList(List results, ResultTransformer resultTransformer)
protected Object[]	getResultRow(Object[] row, ResultSet rs, SharedSessionContractImplementor session)
protected String[]	getResultRowAliases()	Returns the aliases that corresponding to a result row.
protected ResultSet	getResultSet(CallableStatement st, RowSelection selection, LimitHandler limitHandler, boolean autodiscovertypes, SharedSessionContractImplementor session)	Execute given CallableStatement, advance to the first result and return SQL ResultSet.
protected ResultSet	getResultSet(PreparedStatement st, RowSelection selection, LimitHandler limitHandler, boolean autodiscovertypes, SharedSessionContractImplementor session)	Execute given PreparedStatement, advance to the first result and return SQL ResultSet.
protected List<Object>	getRowsFromResultSet(ResultSet rs, QueryParameters queryParameters, SharedSessionContractImplementor session, boolean returnProxies, ResultTransformer forcedResultTransformer, int maxRows, List<Object> hydratedObjects, List<EntityKey[]> subselectResultKeys)
abstract String	getSQLString()	The SQL query string to be called; implemented by all subclasses
protected void	handleEmptyCollections(Serializable[] keys, Object resultSetId, SharedSessionContractImplementor session)	If this is a collection initializer, we need to tell the session that a collection is being initialized, to account for the possibility of the collection having no elements (hence no rows in the result set).
protected boolean	hasSubselectLoadableCollections()
protected boolean[]	includeInResultRow()
protected void	instanceAlreadyLoaded(ResultSet rs, int i, Loadable persister, EntityKey key, Object object, LockMode requestedLockMode, List hydratedObjects, SharedSessionContractImplementor session)	The entity instance is already in the session cache
protected Object	instanceNotYetLoaded(ResultSet rs, int i, Loadable persister, String rowIdAlias, EntityKey key, LockMode lockMode, EntityKey optionalObjectKey, Object optionalObject, List hydratedObjects, SharedSessionContractImplementor session)	The entity instance is not in the session cache
protected boolean	isSingleRowLoader()	Return false is this loader is a batch entity loader
protected boolean	isSubselectLoadingEnabled()
protected List	list(SharedSessionContractImplementor session, QueryParameters queryParameters, Set<Serializable> querySpaces, Type[] resultTypes)	Return the query results, using the query cache, called by subclasses that implement cacheable queries
void	loadCollection(SharedSessionContractImplementor session, Serializable id, Type type)	Called by subclasses that initialize collections
void	loadCollectionBatch(SharedSessionContractImplementor session, Serializable[] ids, Type type)	Called by wrappers that batch initialize collections
protected void	loadCollectionSubselect(SharedSessionContractImplementor session, Serializable[] ids, Object[] parameterValues, Type[] parameterTypes, Map<String,TypedValue> namedParameters, Type type)	Called by subclasses that batch initialize collections
protected List	loadEntity(SharedSessionContractImplementor session, Object key, Object index, Type keyType, Type indexType, EntityPersister persister)	Called by subclasses that load entities
protected List	loadEntity(SharedSessionContractImplementor session, Object id, Type identifierType, Object optionalObject, String optionalEntityName, Serializable optionalIdentifier, EntityPersister persister, LockOptions lockOptions, Boolean readOnly)	Called by subclasses that load entities
List	loadEntityBatch(SharedSessionContractImplementor session, Serializable[] ids, Type idType, Object optionalObject, String optionalEntityName, Serializable optionalId, EntityPersister persister, LockOptions lockOptions)	Called by wrappers that batch load entities
List	loadEntityBatch(SharedSessionContractImplementor session, Serializable[] ids, Type idType, Object optionalObject, String optionalEntityName, Serializable optionalId, EntityPersister persister, LockOptions lockOptions, Boolean readOnly)	Called by wrappers that batch load entities
Object	loadSequentialRowsForward(ResultSet resultSet, SharedSessionContractImplementor session, QueryParameters queryParameters, boolean returnProxies)	Loads a single logical row from the result set moving forward.
Object	loadSequentialRowsReverse(ResultSet resultSet, SharedSessionContractImplementor session, QueryParameters queryParameters, boolean returnProxies, boolean isLogicallyAfterLast)	Loads a single logical row from the result set moving forward.
Object	loadSingleRow(ResultSet resultSet, SharedSessionContractImplementor session, QueryParameters queryParameters, boolean returnProxies)	Loads a single row from the result set.
protected boolean	needsFetchingScroll()	Does the result set to be scrolled contain collection fetches?
protected void	postInstantiate()	Calculate and cache select-clause suffixes.
protected PreparedStatement	prepareQueryStatement(String sql, QueryParameters queryParameters, LimitHandler limitHandler, boolean scroll, SharedSessionContractImplementor session)	Obtain a PreparedStatement with all parameters pre-bound.
protected ResultSet	preprocessResultSet(ResultSet rs, RowSelection selection, LimitHandler limitHandler, boolean autodiscovertypes, SharedSessionContractImplementor session)
protected String	preprocessSQL(String sql, QueryParameters parameters, SessionFactoryImplementor sessionFactory, List<AfterLoadAction> afterLoadActions)	Modify the SQL, adding lock hints and comments, if necessary
protected String	processDistinctKeyword(String sql, QueryParameters parameters)	Remove distinct keyword from SQL statement if the query should not pass it through.
protected List	processResultSet(ResultSet rs, QueryParameters queryParameters, SharedSessionContractImplementor session, boolean returnProxies, ResultTransformer forcedResultTransformer, int maxRows, List<AfterLoadAction> afterLoadActions)
protected void	putResultInQueryCache(SharedSessionContractImplementor session, QueryParameters queryParameters, Type[] resultTypes, QueryResultsCache queryCache, QueryKey key, List result)
protected void	registerNonExists(EntityKey[] keys, Loadable[] persisters, SharedSessionContractImplementor session)	For missing objects associated by one-to-one with another object in the result set, register the fact that the the object is missing with the session.
protected ResultTransformer	resolveResultTransformer(ResultTransformer resultTransformer)	Determine the actual ResultTransformer that will be used to transform query results.
protected ScrollableResultsImplementor	scroll(QueryParameters queryParameters, Type[] returnTypes, org.hibernate.hql.internal.HolderInstantiator holderInstantiator, SharedSessionContractImplementor session)	Return the query results, as an instance of ScrollableResults
protected boolean	shouldUseFollowOnLocking(QueryParameters parameters, Dialect dialect, List<AfterLoadAction> afterLoadActions)
String	toString()
protected boolean	upgradeLocks()	Does this query return objects that might be already cached by the session, whose lock mode may need upgrading

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

SELECT

public static final String SELECT

See Also:

Constant Field Values

SELECT_DISTINCT

public static final String SELECT_DISTINCT

See Also:

Constant Field Values

LOG

protected static final org.hibernate.internal.CoreMessageLogger LOG

Constructor Detail

Loader

public Loader(SessionFactoryImplementor factory)

Method Detail

getSQLString

public abstract String getSQLString()

The SQL query string to be called; implemented by all subclasses

Returns:

The sql command this loader should use to get its ResultSet.

getEntityPersisters

protected abstract Loadable[] getEntityPersisters()

An array of persisters of entity classes contained in each row of results; implemented by all subclasses

Returns:

The entity persisters.

getEntityEagerPropertyFetches

protected boolean[] getEntityEagerPropertyFetches()

An array indicating whether the entities have eager property fetching enabled for all of their properties.

Supersedes getEntityEagerPerPropertyFetches().

Returns:

Eager property fetching indicators.

getEntityEagerPerPropertyFetches

protected boolean[][] getEntityEagerPerPropertyFetches()

An array indicating for each entity which specific properties must have eager fetching enabled.

Superseded by getEntityEagerPropertyFetches().

Returns:

Eager property fetching indicators.

getOwners

protected int[] getOwners()

An array of indexes of the entity that owns a one-to-one association to the entity at the given index (-1 if there is no "owner"). The indexes contained here are relative to the result of getEntityPersisters().

Returns:

The owner indicators (see discussion above).

getOwnerAssociationTypes

protected EntityType[] getOwnerAssociationTypes()

An array of the owner types corresponding to the getOwners() returns. Indices indicating no owner would be null here.

Returns:

The types for the owners.

getCollectionPersisters

protected CollectionPersister[] getCollectionPersisters()

An (optional) persister for a collection to be initialized; only collection loaders return a non-null value

getCollectionOwners

protected int[] getCollectionOwners()

Get the index of the entity that owns the collection, or -1 if there is no owner in the query results (ie. in the case of a collection initializer) or no collection.

getCompositeKeyManyToOneTargetIndices

protected int[][] getCompositeKeyManyToOneTargetIndices()

getLockModes

protected abstract LockMode[] getLockModes(LockOptions lockOptions)

What lock options does this load entities with?

Parameters:

lockOptions - a collection of lock options specified dynamically via the Query interface

applyLocks

protected String applyLocks(String sql,
                            QueryParameters parameters,
                            Dialect dialect,
                            List<AfterLoadAction> afterLoadActions)
                     throws HibernateException

Append FOR UPDATE OF clause, if necessary. This empty superclass implementation merely returns its first argument.

Throws:

HibernateException

upgradeLocks

protected boolean upgradeLocks()

Does this query return objects that might be already cached by the session, whose lock mode may need upgrading

isSingleRowLoader

protected boolean isSingleRowLoader()

Return false is this loader is a batch entity loader

getAliases

protected String[] getAliases()

Get the SQL table aliases of entities whose associations are subselect-loadable, returning null if this loader does not support subselect loading

preprocessSQL

protected String preprocessSQL(String sql,
                               QueryParameters parameters,
                               SessionFactoryImplementor sessionFactory,
                               List<AfterLoadAction> afterLoadActions)
                        throws HibernateException

Modify the SQL, adding lock hints and comments, if necessary

Throws:

HibernateException

shouldUseFollowOnLocking

protected boolean shouldUseFollowOnLocking(QueryParameters parameters,
                                           Dialect dialect,
                                           List<AfterLoadAction> afterLoadActions)

determineFollowOnLockMode

protected LockMode determineFollowOnLockMode(LockOptions lockOptions)

doQueryAndInitializeNonLazyCollections

public List doQueryAndInitializeNonLazyCollections(SharedSessionContractImplementor session,
                                                   QueryParameters queryParameters,
                                                   boolean returnProxies)
                                            throws HibernateException,
                                                   SQLException

Execute an SQL query and attempt to instantiate instances of the class mapped by the given persister from each row of the ResultSet. If an object is supplied, will attempt to initialize that object. If a collection is supplied, attempt to initialize that collection.

Throws:

HibernateException

SQLException

doQueryAndInitializeNonLazyCollections

public List doQueryAndInitializeNonLazyCollections(SharedSessionContractImplementor session,
                                                   QueryParameters queryParameters,
                                                   boolean returnProxies,
                                                   ResultTransformer forcedResultTransformer)
                                            throws HibernateException,
                                                   SQLException

Throws:

HibernateException

SQLException

loadSingleRow

public Object loadSingleRow(ResultSet resultSet,
                            SharedSessionContractImplementor session,
                            QueryParameters queryParameters,
                            boolean returnProxies)
                     throws HibernateException

Loads a single row from the result set. This is the processing used from the ScrollableResults where no collection fetches were encountered.

Parameters:

resultSet - The result set from which to do the load.

session - The session from which the request originated.

queryParameters - The query parameters specified by the user.

returnProxies - Should proxies be generated

Returns:

The loaded "row".

Throws:

HibernateException

loadSequentialRowsForward

public Object loadSequentialRowsForward(ResultSet resultSet,
                                        SharedSessionContractImplementor session,
                                        QueryParameters queryParameters,
                                        boolean returnProxies)
                                 throws HibernateException

Loads a single logical row from the result set moving forward. This is the processing used from the ScrollableResults where there were collection fetches encountered; thus a single logical row may have multiple rows in the underlying result set.

Parameters:

resultSet - The result set from which to do the load.

session - The session from which the request originated.

queryParameters - The query parameters specified by the user.

returnProxies - Should proxies be generated

Returns:

The loaded "row".

Throws:

HibernateException

loadSequentialRowsReverse

public Object loadSequentialRowsReverse(ResultSet resultSet,
                                        SharedSessionContractImplementor session,
                                        QueryParameters queryParameters,
                                        boolean returnProxies,
                                        boolean isLogicallyAfterLast)
                                 throws HibernateException

Loads a single logical row from the result set moving forward. This is the processing used from the ScrollableResults where there were collection fetches encountered; thus a single logical row may have multiple rows in the underlying result set.

Parameters:

resultSet - The result set from which to do the load.

session - The session from which the request originated.

queryParameters - The query parameters specified by the user.

returnProxies - Should proxies be generated

Returns:

The loaded "row".

Throws:

HibernateException

getOptionalObjectKey

protected static EntityKey getOptionalObjectKey(QueryParameters queryParameters,
                                                SharedSessionContractImplementor session)

extractKeysFromResultSet

protected void extractKeysFromResultSet(Loadable[] persisters,
                                        QueryParameters queryParameters,
                                        ResultSet resultSet,
                                        SharedSessionContractImplementor session,
                                        EntityKey[] keys,
                                        LockMode[] lockModes,
                                        List hydratedObjects)
                                 throws SQLException

Throws:

SQLException

applyPostLoadLocks

protected void applyPostLoadLocks(Object[] row,
                                  LockMode[] lockModesArray,
                                  SharedSessionContractImplementor session)

processResultSet

protected List processResultSet(ResultSet rs,
                                QueryParameters queryParameters,
                                SharedSessionContractImplementor session,
                                boolean returnProxies,
                                ResultTransformer forcedResultTransformer,
                                int maxRows,
                                List<AfterLoadAction> afterLoadActions)
                         throws SQLException

Throws:

SQLException

getRowsFromResultSet

protected List<Object> getRowsFromResultSet(ResultSet rs,
                                            QueryParameters queryParameters,
                                            SharedSessionContractImplementor session,
                                            boolean returnProxies,
                                            ResultTransformer forcedResultTransformer,
                                            int maxRows,
                                            List<Object> hydratedObjects,
                                            List<EntityKey[]> subselectResultKeys)
                                     throws SQLException

Throws:

SQLException

isSubselectLoadingEnabled

protected boolean isSubselectLoadingEnabled()

hasSubselectLoadableCollections

protected boolean hasSubselectLoadableCollections()

createSubselects

protected void createSubselects(List keys,
                                QueryParameters queryParameters,
                                SharedSessionContractImplementor session)

endCollectionLoad

protected void endCollectionLoad(Object resultSetId,
                                 SharedSessionContractImplementor session,
                                 CollectionPersister collectionPersister)

resolveResultTransformer

protected ResultTransformer resolveResultTransformer(ResultTransformer resultTransformer)

Determine the actual ResultTransformer that will be used to transform query results.

Parameters:

resultTransformer - the specified result transformer

Returns:

the actual result transformer

getResultList

protected List getResultList(List results,
                             ResultTransformer resultTransformer)
                      throws QueryException

Throws:

QueryException

areResultSetRowsTransformedImmediately

protected boolean areResultSetRowsTransformedImmediately()

Are rows transformed immediately after being read from the ResultSet?

Returns:

true, if getResultColumnOrRow() transforms the results; false, otherwise

getResultRowAliases

protected String[] getResultRowAliases()

Returns the aliases that corresponding to a result row.

Returns:

Returns the aliases that corresponding to a result row.

getResultColumnOrRow

protected Object getResultColumnOrRow(Object[] row,
                                      ResultTransformer transformer,
                                      ResultSet rs,
                                      SharedSessionContractImplementor session)
                               throws SQLException,
                                      HibernateException

Get the actual object that is returned in the user-visible result list. This empty implementation merely returns its first argument. This is overridden by some subclasses.

Throws:

SQLException

HibernateException

includeInResultRow

protected boolean[] includeInResultRow()

getResultRow

protected Object[] getResultRow(Object[] row,
                                ResultSet rs,
                                SharedSessionContractImplementor session)
                         throws SQLException,
                                HibernateException

Throws:

SQLException

HibernateException

registerNonExists

protected void registerNonExists(EntityKey[] keys,
                                 Loadable[] persisters,
                                 SharedSessionContractImplementor session)

For missing objects associated by one-to-one with another object in the result set, register the fact that the the object is missing with the session.

handleEmptyCollections

protected void handleEmptyCollections(Serializable[] keys,
                                      Object resultSetId,
                                      SharedSessionContractImplementor session)

If this is a collection initializer, we need to tell the session that a collection is being initialized, to account for the possibility of the collection having no elements (hence no rows in the result set).

instanceAlreadyLoaded

protected void instanceAlreadyLoaded(ResultSet rs,
                                     int i,
                                     Loadable persister,
                                     EntityKey key,
                                     Object object,
                                     LockMode requestedLockMode,
                                     List hydratedObjects,
                                     SharedSessionContractImplementor session)
                              throws HibernateException,
                                     SQLException

The entity instance is already in the session cache

Throws:

HibernateException

SQLException

instanceNotYetLoaded

protected Object instanceNotYetLoaded(ResultSet rs,
                                      int i,
                                      Loadable persister,
                                      String rowIdAlias,
                                      EntityKey key,
                                      LockMode lockMode,
                                      EntityKey optionalObjectKey,
                                      Object optionalObject,
                                      List hydratedObjects,
                                      SharedSessionContractImplementor session)
                               throws HibernateException,
                                      SQLException

The entity instance is not in the session cache

Throws:

HibernateException

SQLException

getLimitHandler

protected LimitHandler getLimitHandler(RowSelection selection)

Build LIMIT clause handler applicable for given selection criteria. Returns NoopLimitHandler delegate if dialect does not support LIMIT expression or processed query does not use pagination.

Parameters:

selection - Selection criteria.

Returns:

LIMIT clause delegate.

executeQueryStatement

protected Loader.SqlStatementWrapper executeQueryStatement(QueryParameters queryParameters,
                                                           boolean scroll,
                                                           List<AfterLoadAction> afterLoadActions,
                                                           SharedSessionContractImplementor session)
                                                    throws SQLException

Process query string by applying filters, LIMIT clause, locks and comments if necessary. Finally execute SQL statement and advance to the first row.

Throws:

SQLException

executeQueryStatement

protected Loader.SqlStatementWrapper executeQueryStatement(String sqlStatement,
                                                           QueryParameters queryParameters,
                                                           boolean scroll,
                                                           List<AfterLoadAction> afterLoadActions,
                                                           SharedSessionContractImplementor session)
                                                    throws SQLException

Throws:

SQLException

prepareQueryStatement

protected final PreparedStatement prepareQueryStatement(String sql,
                                                        QueryParameters queryParameters,
                                                        LimitHandler limitHandler,
                                                        boolean scroll,
                                                        SharedSessionContractImplementor session)
                                                 throws SQLException,
                                                        HibernateException

Obtain a PreparedStatement with all parameters pre-bound. Bind JDBC-style ? parameters, named parameters, and limit parameters.

Throws:

SQLException

HibernateException

bindPreparedStatement

protected final PreparedStatement bindPreparedStatement(PreparedStatement st,
                                                        QueryParameters queryParameters,
                                                        LimitHandler limitHandler,
                                                        SharedSessionContractImplementor session)
                                                 throws SQLException,
                                                        HibernateException

Throws:

SQLException

HibernateException

bindParameterValues

protected int bindParameterValues(PreparedStatement statement,
                                  QueryParameters queryParameters,
                                  int startIndex,
                                  SharedSessionContractImplementor session)
                           throws SQLException

Bind all parameter values into the prepared statement in preparation for execution.

Parameters:

statement - The JDBC prepared statement

queryParameters - The encapsulation of the parameter values to be bound.

startIndex - The position from which to start binding parameter values.

session - The originating session.

Returns:

The number of JDBC bind positions actually bound during this method execution.

Throws:

SQLException - Indicates problems performing the binding.

bindPositionalParameters

protected int bindPositionalParameters(PreparedStatement statement,
                                       QueryParameters queryParameters,
                                       int startIndex,
                                       SharedSessionContractImplementor session)
                                throws SQLException,
                                       HibernateException

Bind positional parameter values to the JDBC prepared statement.

Positional parameters are those specified by JDBC-style ? parameters in the source query. It is (currently) expected that these come before any named parameters in the source query.

Parameters:

statement - The JDBC prepared statement

queryParameters - The encapsulation of the parameter values to be bound.

startIndex - The position from which to start binding parameter values.

session - The originating session.

Returns:

The number of JDBC bind positions actually bound during this method execution.

Throws:

SQLException - Indicates problems performing the binding.

HibernateException - Indicates problems delegating binding to the types.

bindNamedParameters

protected int bindNamedParameters(PreparedStatement statement,
                                  Map<String,TypedValue> namedParams,
                                  int startIndex,
                                  SharedSessionContractImplementor session)
                           throws SQLException,
                                  HibernateException

Bind named parameters to the JDBC prepared statement.

This is a generic implementation, the problem being that in the general case we do not know enough information about the named parameters to perform this in a complete manner here. Thus this is generally overridden on subclasses allowing named parameters to apply the specific behavior. The most usual limitation here is that we need to assume the type span is always one...

Parameters:

statement - The JDBC prepared statement

namedParams - A map of parameter names to values

startIndex - The position from which to start binding parameter values.

session - The originating session.

Returns:

The number of JDBC bind positions actually bound during this method execution.

Throws:

SQLException - Indicates problems performing the binding.

HibernateException - Indicates problems delegating binding to the types.

getNamedParameterLocs

public int[] getNamedParameterLocs(String name)

getResultSet

protected final ResultSet getResultSet(PreparedStatement st,
                                       RowSelection selection,
                                       LimitHandler limitHandler,
                                       boolean autodiscovertypes,
                                       SharedSessionContractImplementor session)
                                throws SQLException,
                                       HibernateException

Execute given PreparedStatement, advance to the first result and return SQL ResultSet.

Throws:

SQLException

HibernateException

getResultSet

protected final ResultSet getResultSet(CallableStatement st,
                                       RowSelection selection,
                                       LimitHandler limitHandler,
                                       boolean autodiscovertypes,
                                       SharedSessionContractImplementor session)
                                throws SQLException,
                                       HibernateException

Execute given CallableStatement, advance to the first result and return SQL ResultSet.

Throws:

SQLException

HibernateException

preprocessResultSet

protected ResultSet preprocessResultSet(ResultSet rs,
                                        RowSelection selection,
                                        LimitHandler limitHandler,
                                        boolean autodiscovertypes,
                                        SharedSessionContractImplementor session)
                                 throws SQLException,
                                        HibernateException

Throws:

SQLException

HibernateException

autoDiscoverTypes

protected void autoDiscoverTypes(ResultSet rs)

loadEntity

protected final List loadEntity(SharedSessionContractImplementor session,
                                Object id,
                                Type identifierType,
                                Object optionalObject,
                                String optionalEntityName,
                                Serializable optionalIdentifier,
                                EntityPersister persister,
                                LockOptions lockOptions,
                                Boolean readOnly)
                         throws HibernateException

Called by subclasses that load entities

Throws:

HibernateException

loadEntity

protected final List loadEntity(SharedSessionContractImplementor session,
                                Object key,
                                Object index,
                                Type keyType,
                                Type indexType,
                                EntityPersister persister)
                         throws HibernateException

Called by subclasses that load entities

Parameters:

persister - only needed for logging

Throws:

HibernateException

loadEntityBatch

public final List loadEntityBatch(SharedSessionContractImplementor session,
                                  Serializable[] ids,
                                  Type idType,
                                  Object optionalObject,
                                  String optionalEntityName,
                                  Serializable optionalId,
                                  EntityPersister persister,
                                  LockOptions lockOptions)
                           throws HibernateException

Called by wrappers that batch load entities

Throws:

HibernateException

loadEntityBatch

public final List loadEntityBatch(SharedSessionContractImplementor session,
                                  Serializable[] ids,
                                  Type idType,
                                  Object optionalObject,
                                  String optionalEntityName,
                                  Serializable optionalId,
                                  EntityPersister persister,
                                  LockOptions lockOptions,
                                  Boolean readOnly)
                           throws HibernateException

Called by wrappers that batch load entities

Throws:

HibernateException

loadCollection

public final void loadCollection(SharedSessionContractImplementor session,
                                 Serializable id,
                                 Type type)
                          throws HibernateException

Called by subclasses that initialize collections

Throws:

HibernateException

loadCollectionBatch

public final void loadCollectionBatch(SharedSessionContractImplementor session,
                                      Serializable[] ids,
                                      Type type)
                               throws HibernateException

Called by wrappers that batch initialize collections

Throws:

HibernateException

loadCollectionSubselect

protected final void loadCollectionSubselect(SharedSessionContractImplementor session,
                                             Serializable[] ids,
                                             Object[] parameterValues,
                                             Type[] parameterTypes,
                                             Map<String,TypedValue> namedParameters,
                                             Type type)
                                      throws HibernateException

Called by subclasses that batch initialize collections

Throws:

HibernateException

list

protected List list(SharedSessionContractImplementor session,
                    QueryParameters queryParameters,
                    Set<Serializable> querySpaces,
                    Type[] resultTypes)
             throws HibernateException

Return the query results, using the query cache, called by subclasses that implement cacheable queries

Throws:

HibernateException

generateQueryKey

protected QueryKey generateQueryKey(SharedSessionContractImplementor session,
                                    QueryParameters queryParameters)

createCacheableResultTransformer

protected CacheableResultTransformer createCacheableResultTransformer(QueryParameters queryParameters)

getResultFromQueryCache

protected List getResultFromQueryCache(SharedSessionContractImplementor session,
                                       QueryParameters queryParameters,
                                       Set<Serializable> querySpaces,
                                       Type[] resultTypes,
                                       QueryResultsCache queryCache,
                                       QueryKey key)

getEntityPersister

protected EntityPersister getEntityPersister(EntityType entityType)

putResultInQueryCache

protected void putResultInQueryCache(SharedSessionContractImplementor session,
                                     QueryParameters queryParameters,
                                     Type[] resultTypes,
                                     QueryResultsCache queryCache,
                                     QueryKey key,
                                     List result)

doList

protected List doList(SharedSessionContractImplementor session,
                      QueryParameters queryParameters)
               throws HibernateException

Actually execute a query, ignoring the query cache

Throws:

HibernateException

checkScrollability

protected void checkScrollability()
                           throws HibernateException

Check whether the current loader can support returning ScrollableResults.

Throws:

HibernateException

needsFetchingScroll

protected boolean needsFetchingScroll()

Does the result set to be scrolled contain collection fetches?

Returns:

True if it does, and thus needs the special fetching scroll functionality; false otherwise.

scroll

protected ScrollableResultsImplementor scroll(QueryParameters queryParameters,
                                              Type[] returnTypes,
                                              org.hibernate.hql.internal.HolderInstantiator holderInstantiator,
                                              SharedSessionContractImplementor session)
                                       throws HibernateException

Return the query results, as an instance of ScrollableResults

Parameters:

queryParameters - The parameters with which the query should be executed.

returnTypes - The expected return types of the query

holderInstantiator - If the return values are expected to be wrapped in a holder, this is the thing that knows how to wrap them.

session - The session from which the scroll request originated.

Returns:

The ScrollableResults instance.

Throws:

HibernateException - Indicates an error executing the query, or constructing the ScrollableResults.

postInstantiate

protected void postInstantiate()

Calculate and cache select-clause suffixes. Must be called by subclasses after instantiation.

getEntityAliases

protected abstract EntityAliases[] getEntityAliases()

Get the result set descriptor

getCollectionAliases

protected abstract CollectionAliases[] getCollectionAliases()

getQueryIdentifier

protected String getQueryIdentifier()

Identifies the query for statistics reporting, if null, no statistics will be reported

getFactory

public final SessionFactoryImplementor getFactory()

toString

public String toString()

Overrides:

toString in class Object

processDistinctKeyword

protected String processDistinctKeyword(String sql,
                                        QueryParameters parameters)

Remove distinct keyword from SQL statement if the query should not pass it through.

Parameters:

sql - SQL string

parameters - SQL parameters

Returns:

SQL string