ObjectBuildingQuery (EclipseLink 2.6.1, API Reference)

java.lang.Object
- org.eclipse.persistence.queries.DatabaseQuery
- - org.eclipse.persistence.queries.ReadQuery
  - - org.eclipse.persistence.queries.ObjectBuildingQuery

All Implemented Interfaces:

java.io.Serializable, java.lang.Cloneable

Direct Known Subclasses:

ObjectLevelReadQuery, ResultSetMappingQuery
```
public abstract class ObjectBuildingQuery
extends ReadQuery
```
Purpose: Abstract class for all read queries that build objects and potentially manipulate the TopLink cache.
Description: Contains common behavior for all read queries building objects.

See Also:
Serialized Form
Author:

Gordon Yorke

Since:

TopLink Essentials

Nested Class Summary
- Nested classes/interfaces inherited from class org.eclipse.persistence.queries.DatabaseQuery
  DatabaseQuery.ParameterType

Field Summary

Fields
Modifier and Type	Field and Description
`static short`	`DEFAULT_LOCK_MODE`
`protected long`	`executionTime` Used to set the read time on objects that use this query.
`protected boolean`	`isCacheCheckComplete` was a check early return completed
`static short`	`LOCK`
`static short`	`LOCK_NOWAIT`
`static java.lang.String`	`LOCK_RESULT_PROPERTY` INTERNAL: This is the key for accessing unregistered and locked result in the query's properties.
`protected org.eclipse.persistence.internal.expressions.ForUpdateClause`	`lockingClause` Used for pessimistic locking.
`static short`	`NO_LOCK`
`protected java.util.Map<java.lang.Object,org.eclipse.persistence.internal.identitymaps.CacheKey>`	`prefetchedCacheKeys`
`protected java.lang.Class`	`referenceClass` The class of the target objects to be read from the database.
`protected java.lang.String`	`referenceClassName`
`protected java.lang.Boolean`	`requiresDeferredLocks` When reading across relationships, queries may be set to acquire deferred locks This is used to ensure any Eagerly fetched object that is the target of a relationship with an object the acquires deferred locks behaves the same as its owner
`protected boolean`	`shouldBuildNullForNullPk` INTERNAL: If primary key is null ObjectBuilder.buildObject returns null in case this flag is set to true (instead of throwing exception).
`protected boolean`	`shouldRefreshIdentityMapResult` Allows for the resulting objects to be refresh with the data from the database.
`protected boolean`	`shouldRefreshRemoteIdentityMapResult`
`protected boolean`	`shouldRegisterResultsInUnitOfWork` INTERNAL: for bug 2612601 allow ability not to register results in UOW.
`protected boolean`	`shouldUseExclusiveConnection` Added for Exclusive Connection (VPD) support see accessor for information
`protected boolean`	`wasDefaultLockMode` PERF: Store if the query originally used the default lock mode.

Fields inherited from class org.eclipse.persistence.queries.ReadQuery
fetchSize, firstResult, maxResults, maxRows, queryId, queryResultCachingPolicy, temporaryCachedQueryResults

Fields inherited from class org.eclipse.persistence.queries.DatabaseQuery
accessors, allowNativeSQLQuery, argumentFields, argumentParameterTypes, arguments, argumentTypeNames, argumentTypes, argumentValues, BATCH_FETCH_PROPERTY, CascadeAggregateDelete, CascadeAllParts, CascadeByMapping, CascadeDependentParts, cascadePolicy, CascadePrivateParts, descriptor, descriptors, doNotRedirect, executionSession, flushOnExecute, hintString, isCustomQueryUsed, isExecutionClone, isNativeConnectionRequired, isPrepared, isUserDefined, isUserDefinedSQLCall, monitorName, name, NoCascading, nullableArguments, parameterDelimiter, partitioningPolicy, properties, queryMechanism, queryTimeout, redirector, session, sessionName, shouldBindAllParameters, shouldCacheStatement, shouldCloneCall, shouldMaintainCache, shouldPrepare, shouldRetrieveBypassCache, shouldStoreBypassCache, shouldUseWrapperPolicy, shouldValidateUpdateCallCacheUse, sourceMapping, translationRow

Constructor Summary

Constructors
Constructor and Description

ObjectBuildingQuery()
INTERNAL: Initialize the state of the query

Constructors
Constructor and Description
`ObjectBuildingQuery()` INTERNAL: Initialize the state of the query

Method Summary

Methods
Modifier and Type	Method and Description
`java.lang.Object`	`clone()` INTERNAL: Clone the query
`protected void`	`clonedQueryExecutionComplete(DatabaseQuery query, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL Used to give the subclasses opportunity to copy aspects of the cloned query to the original query.
`void`	`convertClassNamesToClasses(java.lang.ClassLoader classLoader)` INTERNAL: Convert all the class-name-based settings in this query to actual class-based settings.
`void`	`copyFromQuery(DatabaseQuery query)` INTERNAL: Copy all setting from the query.
`java.lang.Object`	`deepClone()` INTERNAL: Clone the query, including its selection criteria.
`void`	`dontRefreshIdentityMapResult()` PUBLIC: When unset means perform read normally and dont do refresh.
`void`	`dontRefreshRemoteIdentityMapResult()` PUBLIC: When unset means perform read normally and dont do refresh.
`java.util.List`	`getDataResults()` INTERNAL: Return all of the rows fetched by the query, used for 1-m joining.
`FetchGroup`	`getExecutionFetchGroup()` INTERNAL: Returns FetchGroup that will be applied to the query.
`FetchGroup`	`getExecutionFetchGroup(ClassDescriptor descriptor)` INTERNAL: Returns FetchGroup that will be applied to the query.
`long`	`getExecutionTime()` INTERNAL: Return the time this query actually went to the database
`LoadGroup`	`getLoadGroup()` Return the load group set in the query.
`short`	`getLockMode()` PUBLIC: Return the current locking mode.
`java.util.Map<java.lang.Object,org.eclipse.persistence.internal.identitymaps.CacheKey>`	`getPrefetchedCacheKeys()`
`protected java.lang.Object`	`getQueryPrimaryKey()` INTERNAL: Return the primary key stored in this query if there is one This is overridden by subclasses that actually hold a primary key
`java.lang.Class`	`getReferenceClass()` PUBLIC: Return the reference class of the query.
`java.lang.String`	`getReferenceClassName()` INTERNAL: Return the reference class of the query.
`boolean`	`hasExecutionFetchGroup()` INTERNAL: Indicates whether a FetchGroup will be applied to the query.
`boolean`	`hasPartialAttributeExpressions()` INTERNAL: Return if partial attributes.
`boolean`	`isAttributeJoined(ClassDescriptor mappingDescriptor, java.lang.String attributeName)` INTERNAL: Return if the attribute is specified for joining.
`boolean`	`isCacheCheckComplete()` INTERNAL: Returns true if an early return cache check was completed
`boolean`	`isClonePessimisticLocked(java.lang.Object clone, org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow)` INTERNAL: Helper method that checks if clone has been locked with uow.
`boolean`	`isDefaultLock()` INTERNAL: Helper method to determine the default mode.
`boolean`	`isLockQuery()` PUBLIC: Answers if the query lock mode is known to be LOCK or LOCK_NOWAIT.
`boolean`	`isObjectBuildingQuery()` PUBLIC: Return if this is an object building query.
`boolean`	`isRegisteringResults()` INTERNAL: Answers if we are executing through a UnitOfWork and registering results.
`void`	`postRegisterIndividualResult(java.lang.Object clone, java.lang.Object original, java.lang.Object primaryKey, org.eclipse.persistence.internal.sessions.UnitOfWorkImpl unitOfWork, org.eclipse.persistence.internal.queries.JoinedAttributeManager joinManager, ClassDescriptor concreteDescriptor)` Post process the object once it is registered in the unit of work.
`protected void`	`prepareCustomQuery(DatabaseQuery customQuery)` INTERNAL: Set the properties needed to be cascaded into the custom query including the translation row.
`void`	`prepareFromQuery(DatabaseQuery query)` INTERNAL: Prepare the query from the prepared query.
`void`	`recordCloneForPessimisticLocking(java.lang.Object clone, org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow)` INTERNAL: Helper method that records clone with uow if query is pessimistic locking.
`void`	`refreshIdentityMapResult()` PUBLIC: Refresh the attributes of the object(s) resulting from the query.
`void`	`refreshRemoteIdentityMapResult()` PUBLIC: Refresh the attributes of the object(s) resulting from the query.
`java.lang.Object`	`registerIndividualResult(java.lang.Object result, java.lang.Object primaryKey, org.eclipse.persistence.internal.sessions.UnitOfWorkImpl unitOfWork, org.eclipse.persistence.internal.queries.JoinedAttributeManager joinManager, ClassDescriptor concreteDescriptor)` INTERNAL: Constructs the final (registered) object for every individual object queried via a UnitOfWork.
`boolean`	`requiresDeferredLocks()` INTERNAL: When reading across relationships, queries may be set to acquire deferred locks This is used to ensure any Eagerly fetched object that is the target of a relationship with an object the acquires deferred locks behaves the same as its owner
`void`	`setExecutionTime(long executionTime)` INTERNAL: Set the the time this query went to the database.
`void`	`setLockMode(short lockMode)` PUBLIC: Sets whether this is a pessimistically locking query.
`void`	`setPrefetchedCacheKeys(java.util.Map<java.lang.Object,org.eclipse.persistence.internal.identitymaps.CacheKey> prefetchedCacheKeys)`
`void`	`setReferenceClass(java.lang.Class aClass)` REQUIRED: Set the reference class for the query.
`void`	`setReferenceClassName(java.lang.String aClass)` INTERNAL: Set the reference class for the query.
`void`	`setRequiresDeferredLocks(boolean cascadeDeferredLocks)` INTERNAL: When reading across relationships, queries may be set to acquire deferred locks This is used to ensure any Eagerly fetched object that is the target of a relationship with an object the acquires deferred locks behaves the same as its owner
`void`	`setShouldBuildNullForNullPk(boolean shouldBuildNullForNullPk)` INTERNAL: If primary key is null ObjectBuilder.buildObject returns null in case this flag is set to true (instead of throwing exception).
`void`	`setShouldRefreshIdentityMapResult(boolean shouldRefreshIdentityMapResult)` PUBLIC: Set if the attributes of the object(s) resulting from the query should be refreshed.
`void`	`setShouldRefreshRemoteIdentityMapResult(boolean shouldRefreshIdentityMapResult)` PUBLIC: Set if the attributes of the object(s) resulting from the query should be refreshed.
`void`	`setShouldRegisterResultsInUnitOfWork(boolean shouldRegisterResultsInUnitOfWork)` INTERNAL: Set to false to have queries conform to a UnitOfWork without registering any additional objects not already in that UnitOfWork.
`void`	`setShouldUseExclusiveConnection(boolean shouldUseExclusiveConnection)` ADVANCED: If the user has isolated data and specified that the client session should use an exclusive connection then by setting this condition to true EclipseLink will ensure that the query is executed through the exclusive connection.
`protected void`	`setWasDefaultLockMode(boolean wasDefaultLockMode)` INTERNAL: Set if this query originally used the default lock mode.
`boolean`	`shouldBuildNullForNullPk()` INTERNAL: If primary key is null ObjectBuilder.buildObject returns null in case this flag is set to true (instead of throwing exception).
`boolean`	`shouldReadAllMappings()` INTERNAL: Return if this is a full object query, not partial nor fetch group.
`boolean`	`shouldReadMapping(DatabaseMapping mapping, FetchGroup fetchGroup)` INTERNAL: Check if the mapping is part of the partial attributes.
`boolean`	`shouldRefreshIdentityMapResult()` PUBLIC: Set to a boolean.
`boolean`	`shouldRefreshRemoteIdentityMapResult()` PUBLIC: Set to a boolean.
`boolean`	`shouldRegisterResultsInUnitOfWork()` INTERNAL: Allows one to do conforming in a UnitOfWork without registering.
`boolean`	`shouldUseExclusiveConnection()` ADVANCED: If the user has isolated data and specified that the client session should use an exclusive connection then by setting this condition to true EclipseLink will ensure that the query is executed through the exclusive connection.
`boolean`	`shouldUseSerializedObjectPolicy()` INTERNAL: Indicates whether the query should use SerializedObjectPolicy if descriptor has it.
`boolean`	`usesResultSetAccessOptimization()` INTERNAL: Return if the query uses ResultSet optimization.
`protected boolean`	`wasDefaultLockMode()` INTERNAL: Return if this query originally used the default lock mode.

Methods inherited from class org.eclipse.persistence.queries.DatabaseQuery
addArgument, addArgument, addArgument, addArgument, addArgument, addArgument, addArgumentByTypeName, addArgumentValue, addArgumentValues, addCall, addStatement, bindAllParameters, buildArgumentFields, buildSelectionCriteria, cacheStatement, cascadeAllParts, cascadeByMapping, cascadeOnlyDependentParts, cascadePrivateParts, checkDescriptor, checkEarlyReturn, checkForCustomQuery, checkPrepare, checkPrepare, dontBindAllParameters, dontCacheStatement, dontCascadeParts, dontMaintainCache, execute, executeDatabaseQuery, executeInUnitOfWork, extractRemoteResult, getAccessor, getAccessors, getArgumentParameterTypes, getArguments, getArgumentTypeNames, getArgumentTypes, getArgumentValues, getBatchObjects, getCall, getCascadePolicy, getDatasourceCall, getDatasourceCalls, getDefaultRedirector, getDescriptor, getDescriptors, getDomainClassNounName, getDoNotRedirect, getEJBQLString, getExecutionSession, getFlushOnExecute, getHintString, getJPQLString, getMonitorName, getName, getNullableArguments, getParameterDelimiter, getParameterDelimiterChar, getPartitioningPolicy, getProperties, getProperty, getQueryMechanism, getQueryNounName, getQueryTimeout, getRedirector, getRedirectorForQuery, getSelectionCriteria, getSensorName, getSession, getSessionName, getShouldBindAllParameters, getSourceMapping, getSQLStatement, getSQLString, getSQLStrings, getTranslatedSQLString, getTranslatedSQLStrings, getTranslationRow, hasAccessor, hasArguments, hasNullableArguments, hasProperties, hasQueryMechanism, hasSessionName, ignoreBindAllParameters, ignoreCacheStatement, isCallQuery, isCascadeOfAggregateDelete, isCustomQueryUsed, isCustomSelectionQuery, isDataModifyQuery, isDataReadQuery, isDeleteAllQuery, isDeleteObjectQuery, isDirectReadQuery, isExecutionClone, isExpressionQuery, isInsertObjectQuery, isJPQLCallQuery, isModifyAllQuery, isModifyQuery, isNativeConnectionRequired, isObjectLevelModifyQuery, isObjectLevelReadQuery, isPrepared, isReadAllQuery, isReadObjectQuery, isReportQuery, isResultSetMappingQuery, isSQLCallQuery, isUpdateAllQuery, isUpdateObjectQuery, isUserDefined, isUserDefinedSQLCall, isValueReadQuery, isWriteObjectQuery, maintainCache, prepareCall, prepareForRemoteExecution, prepareInternal, redirectQuery, remoteExecute, removeProperty, replaceValueHoldersIn, resetMonitorName, retrieveBypassCache, rowFromArguments, setAccessor, setAccessors, setAllowNativeSQLQuery, setArguments, setArgumentTypeNames, setArgumentTypes, setArgumentValues, setBatchObjects, setCall, setCascadePolicy, setDatasourceCall, setDescriptor, setDoNotRedirect, setEJBQLString, setExecutionSession, setFlushOnExecute, setHintString, setIsCustomQueryUsed, setIsExecutionClone, setIsNativeConnectionRequired, setIsPrepared, setIsUserDefined, setIsUserDefinedSQLCall, setJPQLString, setName, setNullableArguments, setParameterDelimiter, setPartitioningPolicy, setProperties, setProperty, setQueryMechanism, setQueryTimeout, setRedirector, setSelectionCriteria, setSession, setSessionName, setShouldBindAllParameters, setShouldBindAllParameters, setShouldCacheStatement, setShouldMaintainCache, setShouldPrepare, setShouldRetrieveBypassCache, setShouldStoreBypassCache, setShouldUseWrapperPolicy, setShouldValidateUpdateCallCacheUse, setSourceMapping, setSQLStatement, setSQLString, setTranslationRow, shouldAllowNativeSQLQuery, shouldBindAllParameters, shouldCacheStatement, shouldCascadeAllParts, shouldCascadeByMapping, shouldCascadeOnlyDependentParts, shouldCascadeParts, shouldCascadePrivateParts, shouldCloneCall, shouldIgnoreBindAllParameters, shouldIgnoreCacheStatement, shouldMaintainCache, shouldPrepare, shouldPrepare, shouldRetrieveBypassCache, shouldStoreBypassCache, shouldUseWrapperPolicy, shouldValidateUpdateCallCacheUse, storeBypassCache, toString

Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - referenceClass
```
protected java.lang.Class referenceClass
```
    The class of the target objects to be read from the database.
  - referenceClassName
```
protected java.lang.String referenceClassName
```
  - shouldRefreshIdentityMapResult
```
protected boolean shouldRefreshIdentityMapResult
```
    Allows for the resulting objects to be refresh with the data from the database.
  - shouldRefreshRemoteIdentityMapResult
```
protected boolean shouldRefreshRemoteIdentityMapResult
```
  - shouldRegisterResultsInUnitOfWork
```
protected boolean shouldRegisterResultsInUnitOfWork
```
    INTERNAL: for bug 2612601 allow ability not to register results in UOW.
  - lockingClause
```
protected org.eclipse.persistence.internal.expressions.ForUpdateClause lockingClause
```
    Used for pessimistic locking.
  - NO_LOCK
```
public static final short NO_LOCK
```
    See Also:
    Constant Field Values
  - LOCK
```
public static final short LOCK
```
    See Also:
    Constant Field Values
  - LOCK_NOWAIT
```
public static final short LOCK_NOWAIT
```
    See Also:
    Constant Field Values
  - DEFAULT_LOCK_MODE
```
public static final short DEFAULT_LOCK_MODE
```
    See Also:
    Constant Field Values
  - executionTime
```
protected long executionTime
```
    Used to set the read time on objects that use this query. Should be set to the time the query returned from the database.
  - shouldUseExclusiveConnection
```
protected boolean shouldUseExclusiveConnection
```
    Added for Exclusive Connection (VPD) support see accessor for information
  - LOCK_RESULT_PROPERTY
```
public static final java.lang.String LOCK_RESULT_PROPERTY
```
    INTERNAL: This is the key for accessing unregistered and locked result in the query's properties. The uow and QueryBaseValueHolder use this property to record and to retrieve the result respectively.
    
    See Also:
    Constant Field Values
  - wasDefaultLockMode
```
protected boolean wasDefaultLockMode
```
    PERF: Store if the query originally used the default lock mode.
  - shouldBuildNullForNullPk
```
protected boolean shouldBuildNullForNullPk
```
    INTERNAL: If primary key is null ObjectBuilder.buildObject returns null in case this flag is set to true (instead of throwing exception).
  - requiresDeferredLocks
```
protected java.lang.Boolean requiresDeferredLocks
```
    When reading across relationships, queries may be set to acquire deferred locks This is used to ensure any Eagerly fetched object that is the target of a relationship with an object the acquires deferred locks behaves the same as its owner
  - isCacheCheckComplete
```
protected boolean isCacheCheckComplete
```
    was a check early return completed
  - prefetchedCacheKeys
```
protected java.util.Map<java.lang.Object,org.eclipse.persistence.internal.identitymaps.CacheKey> prefetchedCacheKeys
```
- Constructor Detail
  - ObjectBuildingQuery
```
public ObjectBuildingQuery()
```
    INTERNAL: Initialize the state of the query
- Method Detail
  - clone
```
public java.lang.Object clone()
```
    INTERNAL: Clone the query
    
    Overrides:
    
    clone in class DatabaseQuery
  - clonedQueryExecutionComplete
```
protected void clonedQueryExecutionComplete(DatabaseQuery query,
                                org.eclipse.persistence.internal.sessions.AbstractSession session)
```
    INTERNAL Used to give the subclasses opportunity to copy aspects of the cloned query to the original query.
    
    Overrides:
    
    clonedQueryExecutionComplete in class ReadQuery
  - convertClassNamesToClasses
```
public void convertClassNamesToClasses(java.lang.ClassLoader classLoader)
```
    INTERNAL: Convert all the class-name-based settings in this query to actual class-based settings. This method is used when converting a project that has been built with class names to a project with classes.
    
    Overrides:
    
    convertClassNamesToClasses in class DatabaseQuery
    
    Parameters:
    classLoader -
  - wasDefaultLockMode
```
protected boolean wasDefaultLockMode()
```
    INTERNAL: Return if this query originally used the default lock mode.
  - setWasDefaultLockMode
```
protected void setWasDefaultLockMode(boolean wasDefaultLockMode)
```
    INTERNAL: Set if this query originally used the default lock mode.
  - deepClone
```
public java.lang.Object deepClone()
```
    INTERNAL: Clone the query, including its selection criteria.
    Normally selection criteria are not cloned here as they are cloned later on during prepare.
  - copyFromQuery
```
public void copyFromQuery(DatabaseQuery query)
```
    INTERNAL: Copy all setting from the query. This is used to morph queries from one type to the other. By default this calls prepareFromQuery, but additional properties may be required to be copied as prepareFromQuery only copies properties that affect the SQL.
    
    Overrides:
    
    copyFromQuery in class ReadQuery
  - prepareCustomQuery
```
protected void prepareCustomQuery(DatabaseQuery customQuery)
```
    INTERNAL: Set the properties needed to be cascaded into the custom query including the translation row. This is used only for primary key queries, as the descriptor query manager stores a predefined query for this query to avoid having to re-prepare and allow for customization.
    
    Overrides:
    
    prepareCustomQuery in class DatabaseQuery
  - prepareFromQuery
```
public void prepareFromQuery(DatabaseQuery query)
```
    INTERNAL: Prepare the query from the prepared query. This allows a dynamic query to prepare itself directly from a prepared query instance. This is used in the EJBQL parse cache to allow preparsed queries to be used to prepare dynamic queries. This only copies over properties that are configured through EJBQL.
    
    Overrides:
    
    prepareFromQuery in class DatabaseQuery
  - dontRefreshIdentityMapResult
```
public void dontRefreshIdentityMapResult()
```
    PUBLIC: When unset means perform read normally and dont do refresh.
  - dontRefreshRemoteIdentityMapResult
```
public void dontRefreshRemoteIdentityMapResult()
```
    PUBLIC: When unset means perform read normally and dont do refresh.
  - hasExecutionFetchGroup
```
public boolean hasExecutionFetchGroup()
```
    INTERNAL: Indicates whether a FetchGroup will be applied to the query.
  - getExecutionFetchGroup
```
public FetchGroup getExecutionFetchGroup()
```
    INTERNAL: Returns FetchGroup that will be applied to the query. Note that the returned fetchGroup may be updated during preProcess.
  - getExecutionFetchGroup
```
public FetchGroup getExecutionFetchGroup(ClassDescriptor descriptor)
```
    INTERNAL: Returns FetchGroup that will be applied to the query. Note that the returned fetchGroup may be updated during preProcess.
  - getLoadGroup
```
public LoadGroup getLoadGroup()
```
    Return the load group set in the query.
  - getLockMode
```
public short getLockMode()
```
    PUBLIC: Return the current locking mode.
  - getDataResults
```
public java.util.List getDataResults()
```
    INTERNAL: Return all of the rows fetched by the query, used for 1-m joining.
  - getExecutionTime
```
public long getExecutionTime()
```
    INTERNAL: Return the time this query actually went to the database
  - getPrefetchedCacheKeys
```
public java.util.Map<java.lang.Object,org.eclipse.persistence.internal.identitymaps.CacheKey> getPrefetchedCacheKeys()
```
  - getQueryPrimaryKey
```
protected java.lang.Object getQueryPrimaryKey()
```
    INTERNAL: Return the primary key stored in this query if there is one This is overridden by subclasses that actually hold a primary key
    
    Returns:
    See Also:
    ReadObjectQuery
  - getReferenceClass
```
public java.lang.Class getReferenceClass()
```
    PUBLIC: Return the reference class of the query.
    
    Overrides:
    
    getReferenceClass in class DatabaseQuery
  - getReferenceClassName
```
public java.lang.String getReferenceClassName()
```
    INTERNAL: Return the reference class of the query.
    
    Overrides:
    
    getReferenceClassName in class DatabaseQuery
  - hasPartialAttributeExpressions
```
public boolean hasPartialAttributeExpressions()
```
    INTERNAL: Return if partial attributes.
  - isLockQuery
```
public boolean isLockQuery()
```
    PUBLIC: Answers if the query lock mode is known to be LOCK or LOCK_NOWAIT. In the case of DEFAULT_LOCK_MODE and the query reference class being a CMP entity bean, at execution time LOCK, LOCK_NOWAIT, or NO_LOCK will be decided.
    If a single joined attribute was configured for pessimistic locking then this will return true (after first execution) as the SQL contained a FOR UPDATE OF clause.
  - isObjectBuildingQuery
```
public boolean isObjectBuildingQuery()
```
    PUBLIC: Return if this is an object building query.
    
    Overrides:
    
    isObjectBuildingQuery in class DatabaseQuery
  - isRegisteringResults
```
public boolean isRegisteringResults()
```
    INTERNAL: Answers if we are executing through a UnitOfWork and registering results. This is only ever false if using the conforming without registering feature.
  - refreshIdentityMapResult
```
public void refreshIdentityMapResult()
```
    PUBLIC: Refresh the attributes of the object(s) resulting from the query. If cascading is used the private parts of the objects will also be refreshed.
  - refreshRemoteIdentityMapResult
```
public void refreshRemoteIdentityMapResult()
```
    PUBLIC: Refresh the attributes of the object(s) resulting from the query. If cascading is used the private parts of the objects will also be refreshed.
  - registerIndividualResult
```
public java.lang.Object registerIndividualResult(java.lang.Object result,
                                        java.lang.Object primaryKey,
                                        org.eclipse.persistence.internal.sessions.UnitOfWorkImpl unitOfWork,
                                        org.eclipse.persistence.internal.queries.JoinedAttributeManager joinManager,
                                        ClassDescriptor concreteDescriptor)
```
    INTERNAL: Constructs the final (registered) object for every individual object queried via a UnitOfWork.
    Called for every object in a read all, the object in a read object, and every time the next or previous row is retrieved from a cursor.
    The (conform) without registering feature is implemented here, and may return an original non UnitOfWork registered result.
    Pessimistically locked objects are tracked here.
    
    Returns:
    a refreshed UnitOfWork queried object, unwrapped.
  - postRegisterIndividualResult
```
public void postRegisterIndividualResult(java.lang.Object clone,
                                java.lang.Object original,
                                java.lang.Object primaryKey,
                                org.eclipse.persistence.internal.sessions.UnitOfWorkImpl unitOfWork,
                                org.eclipse.persistence.internal.queries.JoinedAttributeManager joinManager,
                                ClassDescriptor concreteDescriptor)
```
    Post process the object once it is registered in the unit of work.
  - requiresDeferredLocks
```
public boolean requiresDeferredLocks()
```
    INTERNAL: When reading across relationships, queries may be set to acquire deferred locks This is used to ensure any Eagerly fetched object that is the target of a relationship with an object the acquires deferred locks behaves the same as its owner
  - setExecutionTime
```
public void setExecutionTime(long executionTime)
```
    INTERNAL: Set the the time this query went to the database.
  - setLockMode
```
public void setLockMode(short lockMode)
```
    PUBLIC: Sets whether this is a pessimistically locking query.
    - ObjectBuildingQuery.LOCK: SELECT .... FOR UPDATE issued.
    - ObjectBuildingQuery.LOCK_NOWAIT: SELECT .... FOR UPDATE NO WAIT issued.
    - ObjectBuildingQuery.NO_LOCK: no pessimistic locking.
    - ObjectBuildingQuery.DEFAULT_LOCK_MODE (default) and you have a CMP descriptor: fine grained locking will occur.
    Fine Grained Locking: On execution the reference class and those of all joined attributes will be checked. If any of these have a PessimisticLockingPolicy set on their descriptor, they will be locked in a SELECT ... FOR UPDATE OF ... {NO WAIT}. Issues fewer locks and avoids setting the lock mode on each query.
    Example:readAllQuery.setSelectionCriteria(employee.get("address").equal("Ottawa"));
    - LOCK: all employees in Ottawa and all referenced Ottawa addresses will be locked.
    - DEFAULT_LOCK_MODE: if address is a joined attribute, and only address has a pessimistic locking policy, only referenced Ottawa addresses will be locked.
    See Also:
    PessimisticLockingPolicy
  - setPrefetchedCacheKeys
```
public void setPrefetchedCacheKeys(java.util.Map<java.lang.Object,org.eclipse.persistence.internal.identitymaps.CacheKey> prefetchedCacheKeys)
```
  - setReferenceClass
```
public void setReferenceClass(java.lang.Class aClass)
```
    REQUIRED: Set the reference class for the query.
  - setReferenceClassName
```
public void setReferenceClassName(java.lang.String aClass)
```
    INTERNAL: Set the reference class for the query.
  - setRequiresDeferredLocks
```
public void setRequiresDeferredLocks(boolean cascadeDeferredLocks)
```
    INTERNAL: When reading across relationships, queries may be set to acquire deferred locks This is used to ensure any Eagerly fetched object that is the target of a relationship with an object the acquires deferred locks behaves the same as its owner
  - setShouldRefreshIdentityMapResult
```
public void setShouldRefreshIdentityMapResult(boolean shouldRefreshIdentityMapResult)
```
    PUBLIC: Set if the attributes of the object(s) resulting from the query should be refreshed. If cascading is used the private parts of the objects will also be refreshed.
  - setShouldRefreshRemoteIdentityMapResult
```
public void setShouldRefreshRemoteIdentityMapResult(boolean shouldRefreshIdentityMapResult)
```
    PUBLIC: Set if the attributes of the object(s) resulting from the query should be refreshed. If cascading is used the private parts of the objects will also be refreshed.
  - setShouldRegisterResultsInUnitOfWork
```
public void setShouldRegisterResultsInUnitOfWork(boolean shouldRegisterResultsInUnitOfWork)
```
    INTERNAL: Set to false to have queries conform to a UnitOfWork without registering any additional objects not already in that UnitOfWork.
    
    See Also:
    shouldRegisterResultsInUnitOfWork
    Related Bugs:
    
    2612601
  - setShouldUseExclusiveConnection
```
public void setShouldUseExclusiveConnection(boolean shouldUseExclusiveConnection)
```
    ADVANCED: If the user has isolated data and specified that the client session should use an exclusive connection then by setting this condition to true EclipseLink will ensure that the query is executed through the exclusive connection. This may be required in certain cases. An example being where database security will prevent a query joining to a secure table from returning the correct results when executed through the shared connection.
  - shouldRegisterResultsInUnitOfWork
```
public boolean shouldRegisterResultsInUnitOfWork()
```
    INTERNAL: Allows one to do conforming in a UnitOfWork without registering. Queries executed on a UnitOfWork will only return working copies for objects that have already been registered.
    Extreme care should be taken in using this feature, for a user will get back a mix of registered and original (unregistered) objects.
    Best used with a WrapperPolicy where invoking on an object will trigger its registration (CMP). Without a WrapperPolicy registerExistingObject should be called on any object that you intend to change.
    
    Returns:
    true by default.
    See Also:
    setShouldRegisterResultsInUnitOfWork(boolean)
    Related Bugs:
    
    2612601
  - shouldUseExclusiveConnection
```
public boolean shouldUseExclusiveConnection()
```
    ADVANCED: If the user has isolated data and specified that the client session should use an exclusive connection then by setting this condition to true EclipseLink will ensure that the query is executed through the exclusive connection. This may be required in certain cases. An example being where database security will prevent a query joining to a secure table from returning the correct results when executed through the shared connection.
  - shouldReadAllMappings
```
public boolean shouldReadAllMappings()
```
    INTERNAL: Return if this is a full object query, not partial nor fetch group.
  - shouldReadMapping
```
public boolean shouldReadMapping(DatabaseMapping mapping,
                        FetchGroup fetchGroup)
```
    INTERNAL: Check if the mapping is part of the partial attributes.
  - shouldRefreshIdentityMapResult
```
public boolean shouldRefreshIdentityMapResult()
```
    PUBLIC: Set to a boolean. When set means refresh the instance variables of referenceObject from the database.
  - shouldRefreshRemoteIdentityMapResult
```
public boolean shouldRefreshRemoteIdentityMapResult()
```
    PUBLIC: Set to a boolean. When set means refresh the instance variables of referenceObject from the database.
  - isAttributeJoined
```
public boolean isAttributeJoined(ClassDescriptor mappingDescriptor,
                        java.lang.String attributeName)
```
    INTERNAL: Return if the attribute is specified for joining.
  - isCacheCheckComplete
```
public boolean isCacheCheckComplete()
```
    INTERNAL: Returns true if an early return cache check was completed
  - isClonePessimisticLocked
```
public boolean isClonePessimisticLocked(java.lang.Object clone,
                               org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow)
```
    INTERNAL: Helper method that checks if clone has been locked with uow.
  - recordCloneForPessimisticLocking
```
public void recordCloneForPessimisticLocking(java.lang.Object clone,
                                    org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow)
```
    INTERNAL: Helper method that records clone with uow if query is pessimistic locking.
  - isDefaultLock
```
public boolean isDefaultLock()
```
    INTERNAL: Helper method to determine the default mode. If true and quey has a pessimistic locking policy, locking will be configured according to the pessimistic locking policy.
  - shouldBuildNullForNullPk
```
public boolean shouldBuildNullForNullPk()
```
    INTERNAL: If primary key is null ObjectBuilder.buildObject returns null in case this flag is set to true (instead of throwing exception).
  - setShouldBuildNullForNullPk
```
public void setShouldBuildNullForNullPk(boolean shouldBuildNullForNullPk)
```
    INTERNAL: If primary key is null ObjectBuilder.buildObject returns null in case this flag is set to true (instead of throwing exception).
  - usesResultSetAccessOptimization
```
public boolean usesResultSetAccessOptimization()
```
    INTERNAL: Return if the query uses ResultSet optimization.
  - shouldUseSerializedObjectPolicy
```
public boolean shouldUseSerializedObjectPolicy()
```
    INTERNAL: Indicates whether the query should use SerializedObjectPolicy if descriptor has it.

Class ObjectBuildingQuery

Nested Class Summary

Nested classes/interfaces inherited from class org.eclipse.persistence.queries.DatabaseQuery

Field Summary

Fields inherited from class org.eclipse.persistence.queries.ReadQuery

Fields inherited from class org.eclipse.persistence.queries.DatabaseQuery

Constructor Summary

Method Summary

Methods inherited from class org.eclipse.persistence.queries.ReadQuery

Methods inherited from class org.eclipse.persistence.queries.DatabaseQuery

Methods inherited from class java.lang.Object

Field Detail

referenceClass

referenceClassName

shouldRefreshIdentityMapResult

shouldRefreshRemoteIdentityMapResult

shouldRegisterResultsInUnitOfWork

lockingClause

NO_LOCK

LOCK

LOCK_NOWAIT

DEFAULT_LOCK_MODE

executionTime

shouldUseExclusiveConnection

LOCK_RESULT_PROPERTY

wasDefaultLockMode

shouldBuildNullForNullPk

requiresDeferredLocks

isCacheCheckComplete

prefetchedCacheKeys

Constructor Detail

ObjectBuildingQuery

Method Detail

clone

clonedQueryExecutionComplete

convertClassNamesToClasses

wasDefaultLockMode

setWasDefaultLockMode

deepClone

copyFromQuery

prepareCustomQuery

prepareFromQuery

dontRefreshIdentityMapResult

dontRefreshRemoteIdentityMapResult

hasExecutionFetchGroup

getExecutionFetchGroup

getExecutionFetchGroup

getLoadGroup

getLockMode

getDataResults

getExecutionTime

getPrefetchedCacheKeys

getQueryPrimaryKey

getReferenceClass

getReferenceClassName

hasPartialAttributeExpressions

isLockQuery

isObjectBuildingQuery

isRegisteringResults

refreshIdentityMapResult

refreshRemoteIdentityMapResult

registerIndividualResult

postRegisterIndividualResult

requiresDeferredLocks

setExecutionTime

setLockMode

setPrefetchedCacheKeys

setReferenceClass

setReferenceClassName

setRequiresDeferredLocks

setShouldRefreshIdentityMapResult

setShouldRefreshRemoteIdentityMapResult

setShouldRegisterResultsInUnitOfWork

setShouldUseExclusiveConnection

shouldRegisterResultsInUnitOfWork

shouldUseExclusiveConnection

shouldReadAllMappings

shouldReadMapping

shouldRefreshIdentityMapResult

shouldRefreshRemoteIdentityMapResult