DescriptorQueryManager (EclipseLink 2.6.7, API Reference)

java.lang.Object
- org.eclipse.persistence.descriptors.DescriptorQueryManager

All Implemented Interfaces:

java.io.Serializable, java.lang.Cloneable
```
public class DescriptorQueryManager
extends java.lang.Object
implements java.lang.Cloneable, java.io.Serializable
```
Purpose: The query manager allows for the database operations that EclipseLink performs to be customized by the application. For each descriptor a query can be given that controls how a operation will occur. A common example is if the application requires a stored procedure to be used to insert the object, it can override the SQL call in the insert query that EclipseLink will use to insert the object. Queries can be customized to extend EclipseLink behavior, access non-relational data or use stored procedures or customized SQL calls.
The queries that can be customized include:
- insertQuery - used to insert the object
- updateQuery - used to update the object
- readObjectQuery - used to read a single object by primary key
- readAllQuery - used to read all of the objects of the class
- doesExistQuery - used to determine whether an insert or update should occur
- deleteQuery - used to delete the object
See Also:
ClassDescriptor, Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`protected java.lang.String`	`additionalCriteria`
`protected Expression`	`additionalJoinExpression`
`protected org.eclipse.persistence.internal.helper.ConcurrentFixedCache`	`cachedExpressionQueries` PERF: Expression query call cache for avoiding regenerated dynamic query SQL.
`protected org.eclipse.persistence.internal.helper.ConcurrentFixedCache`	`cachedUpdateCalls` PERF: Update call cache for avoiding regenerated update SQL.
`static int`	`DefaultTimeout`
`static java.util.concurrent.TimeUnit`	`DefaultTimeoutUnit`
`protected DeleteObjectQuery`	`deleteQuery`
`protected ClassDescriptor`	`descriptor`
`protected DoesExistQuery`	`doesExistQuery`
`protected boolean`	`hasCustomMultipleTableJoinExpression`
`protected InsertObjectQuery`	`insertQuery`
`protected Expression`	`multipleTableJoinExpression`
`static int`	`NoTimeout` queryTimeout has three possible settings: DefaultTimeout, NoTimeout, and 1..N This applies to both DatabaseQuery.queryTimeout and DescriptorQueryManager.queryTimeout DatabaseQuery.queryTimeout: - DefaultTimeout: get queryTimeout from DescriptorQueryManager - NoTimeout, 1..N: overrides queryTimeout in DescriptorQueryManager DescriptorQueryManager.queryTimeout: - DefaultTimeout: get queryTimeout from parent DescriptorQueryManager.
`protected java.util.Map<java.lang.String,java.util.List<DatabaseQuery>>`	`queries`
`protected int`	`queryTimeout`
`protected java.util.concurrent.TimeUnit`	`queryTimeoutUnit`
`protected ReadAllQuery`	`readAllQuery`
`protected ReadObjectQuery`	`readObjectQuery`
`protected java.util.Map<org.eclipse.persistence.internal.helper.DatabaseTable,Expression>`	`tablesJoinExpressions`
`protected UpdateObjectQuery`	`updateQuery`

Constructor Summary

Constructors
Constructor and Description

DescriptorQueryManager()
INTERNAL: Initialize the state of the descriptor query manager

Constructors
Constructor and Description
`DescriptorQueryManager()` INTERNAL: Initialize the state of the descriptor query manager

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addQuery(DatabaseQuery query)` PUBLIC: Add the query to the session queries
`void`	`addQuery(java.lang.String name, DatabaseQuery query)` PUBLIC: Add the query to the descriptor queries with the given name
`void`	`assumeExistenceForDoesExist()` PUBLIC: Assume that if the objects primary key does not include null then it must exist.
`void`	`assumeNonExistenceForDoesExist()` PUBLIC: Assume that the object does not exist.
`void`	`checkCacheForDoesExist()` PUBLIC: Default behavior.
`void`	`checkDatabaseForDoesExist()` PUBLIC: Perform does exist check on the database
`java.lang.Object`	`clone()` INTERNAL: Clone the query manager
`boolean`	`containsQuery(java.lang.String queryName)` PUBLIC: Return true if the query is defined on the session
`void`	`convertClassNamesToClasses(java.lang.ClassLoader classLoader)` INTERNAL: Convert all the class-name-based settings in this Query Manager to actual class-based settings This method is implemented by subclasses as necessary.
`Expression`	`getAdditionalJoinExpression()` ADVANCED: Returns the join expression that should be appended to all of the descriptors expressions Contains any multiple table or inheritance dependencies
`java.util.Vector`	`getAllQueries()` PUBLIC: Return the pre-defined queries for the descriptor.
`DatabaseQuery`	`getCachedExpressionQuery(DatabaseQuery query)` INTERNAL: Return the cached SQL call for the expression query.
`java.util.Vector`	`getCachedUpdateCalls(java.util.Vector updateFields)` INTERNAL: Return the cached update SQL call based on the updated fields.
`Call`	`getDeleteCall()` ADVANCED: Return the receiver's delete call.
`DeleteObjectQuery`	`getDeleteQuery()` ADVANCED: Return the receiver's delete query.
`java.lang.String`	`getDeleteSQLString()` ADVANCED: Return the receiver's delete SQL string.
`ClassDescriptor`	`getDescriptor()` INTERNAL: Return the descriptor associated with this descriptor query manager
`Call`	`getDoesExistCall()` ADVANCED: Return the receiver's does-exist call.
`DoesExistQuery`	`getDoesExistQuery()` ADVANCED: Return the receiver's does exist query.
`java.lang.String`	`getDoesExistSQLString()` ADVANCED: Return the receiver's does exist SQL string.
`java.lang.String`	`getExistenceCheck()` INTERNAL: This method is explicitly used by the Builder only.
`int`	`getExpressionQueryCacheMaxSize()` ADVANCED: Return the max size of the expression query cache for avoiding regenerated dynamic query SQL.
`Call`	`getInsertCall()` ADVANCED: Return the receiver's insert call.
`InsertObjectQuery`	`getInsertQuery()` ADVANCED: Return the receiver's insert query.
`java.lang.String`	`getInsertSQLString()` ADVANCED: Return the receiver's insert SQL string.
`DatabaseQuery`	`getLocalQuery(java.lang.String name, java.util.Vector arguments)` INTENAL: Return the query from the set of pre-defined queries with the given name and argument types.
`DatabaseQuery`	`getLocalQueryByArgumentTypes(java.lang.String name, java.util.List argumentTypes)` INTERNAL: Return the query from the set of pre-defined queries with the given name and argument types.
`Expression`	`getMultipleTableJoinExpression()` ADVANCED: This is normally generated for descriptors that have multiple tables.
`DescriptorQueryManager`	`getParentDescriptorQueryManager()` INTERNAL: Get the parent DescriptorQueryManager.
`java.util.Map<java.lang.String,java.util.List<DatabaseQuery>>`	`getQueries()` PUBLIC: Return the pre-defined queries for the descriptor.
`DatabaseQuery`	`getQuery(java.lang.String queryName)` PUBLIC: Return the query name from the set of pre-defined queries If only one query exists with this name, it will be returned.
`DatabaseQuery`	`getQuery(java.lang.String name, java.util.Vector arguments)` PUBLIC: Return the query from the set of pre-defined queries with the given name and argument types.
`protected DatabaseQuery`	`getQueryFromParent(java.lang.String name, java.util.Vector arguments)` INTERNAL: CR#3711: Check if the class for this descriptor has a parent class.
`int`	`getQueryTimeout()` PUBLIC: Return the number of seconds queries will wait for their Statement to execute
`java.util.concurrent.TimeUnit`	`getQueryTimeoutUnit()`
`Call`	`getReadAllCall()` ADVANCED: Return the receiver's read-all call.
`ReadAllQuery`	`getReadAllQuery()` ADVANCED: Return the receiver's read query.
`java.lang.String`	`getReadAllSQLString()` ADVANCED: Return the receiver's read SQL string.
`Call`	`getReadObjectCall()` ADVANCED: Return the receiver's read-object call.
`ReadObjectQuery`	`getReadObjectQuery()` ADVANCED: Return the receiver's read query.
`java.lang.String`	`getReadObjectSQLString()` ADVANCED: Return the receiver's read SQL string.
`java.util.Map<org.eclipse.persistence.internal.helper.DatabaseTable,Expression>`	`getTablesJoinExpressions()` INTERNAL: Used in case descriptor has additional tables: each additional table mapped to an expression joining it.
`Call`	`getUpdateCall()` ADVANCED: Return the receiver's update call.
`int`	`getUpdateCallCacheSize()` ADVANCED: Return the size of the update call cache.
`UpdateObjectQuery`	`getUpdateQuery()` ADVANCED: Return the receiver's update query.
`java.lang.String`	`getUpdateSQLString()` ADVANCED: Return the receiver's update SQL string.
`boolean`	`hasAdditionalCriteria()` ADVANCED: Return true if an additional criteria has been set on this query manager.
`boolean`	`hasCustomMultipleTableJoinExpression()` INTERNAL: Return if a custom join expression is used.
`boolean`	`hasDeleteQuery()` INTERNAL: Flag that specifies if a delete query is available
`boolean`	`hasDoesExistQuery()` INTERNAL: Flag that specifies if a does exist query is available
`boolean`	`hasInsertQuery()` INTERNAL: Flag that specifies if a insert query is available
`boolean`	`hasReadAllQuery()` INTERNAL: Flag that specifies if a read all query is available
`boolean`	`hasReadObjectQuery()` INTERNAL: Flag that specifies if a read object query is available
`boolean`	`hasUpdateQuery()` INTERNAL: Flag that specifies if a update query is available
`void`	`initialize(org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Post initialize the mappings
`void`	`initializeQueryTimeout(org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Initialize the queryTimeout to: NoTimeout: If queryTimeout is DefaultTimeout, either directly or via inheritance.
`void`	`postDelete(DeleteObjectQuery query)` INTERNAL: Execute the post delete operation for the query
`void`	`postInitialize(org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Post initializations after mappings are initialized.
`void`	`postInsert(WriteObjectQuery query)` INTERNAL: Execute the post insert operation for the query
`void`	`postUpdate(WriteObjectQuery query)` INTERNAL: Execute the post update operation for the query
`void`	`preDelete(DeleteObjectQuery query)` INTERNAL: Execute the pre delete operation for the query
`void`	`preInitialize(org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Initialize the query manager.
`void`	`preInsert(WriteObjectQuery query)` INTERNAL: Execute the pre insert operation for the query.
`void`	`preUpdate(WriteObjectQuery query)` INTERNAL: Execute the pre update operation for the query
`void`	`putCachedExpressionQuery(DatabaseQuery query)` INTERNAL: Set the cached SQL call for the expression query.
`void`	`putCachedUpdateCalls(java.util.Vector updateFields, java.util.Vector updateCalls)` INTERNAL: Cache a clone of the update SQL calls based on the updated fields.
`void`	`removeCachedExpressionQuery(DatabaseQuery query)` INTERNAL: Remove the cached expression query.
`void`	`removeQuery(java.lang.String queryName)` PUBLIC: Remove all queries with the given query name from the set of pre-defined queries
`void`	`removeQuery(java.lang.String queryName, java.util.Vector argumentTypes)` PUBLIC: Remove the specific query with the given queryName and argumentTypes.
`void`	`setAdditionalCriteria(java.lang.String additionalCriteria)` ADVANCED: Set the additional join criteria that will be used to form the additional join expression.
`void`	`setAdditionalJoinExpression(Expression additionalJoinExpression)` ADVANCED: Set the additional join expression.
`void`	`setAllQueries(java.util.Vector vector)` INTERNAL: Set pre-defined queries for the descriptor.
`void`	`setDeleteCall(Call call)` ADVANCED: Set the receiver's delete call.
`void`	`setDeleteQuery(DeleteObjectQuery query)` ADVANCED: Set the receiver's delete query.
`void`	`setDeleteSQLString(java.lang.String sqlString)` ADVANCED: Set the receiver's delete SQL string.
`void`	`setDescriptor(ClassDescriptor descriptor)` INTERNAL: Set the descriptor.
`void`	`setDoesExistCall(Call call)` ADVANCED: Set the receiver's does exist call.
`void`	`setDoesExistQuery(DoesExistQuery query)` ADVANCED: Set the receiver's does exist query.
`void`	`setDoesExistSQLString(java.lang.String sqlString)` ADVANCED: Set the receiver's does exist SQL string.
`void`	`setExistenceCheck(java.lang.String token)` INTERNAL: This method is explicitly used by the Builder only.
`void`	`setExpressionQueryCacheMaxSize(int maxSize)` ADVANCED: Set the max size of the expression query cache for avoiding regenerated dynamic query SQL.
`protected void`	`setHasCustomMultipleTableJoinExpression(boolean hasCustomMultipleTableJoinExpression)` INTENAL: Set if a custom join expression is used.
`void`	`setInsertCall(Call call)` ADVANCED: Set the receiver's insert call.
`void`	`setInsertQuery(InsertObjectQuery insertQuery)` ADVANCED: Set the receiver's insert query.
`void`	`setInsertSQLString(java.lang.String sqlString)` ADVANCED: Set the receiver's insert SQL string.
`void`	`setInternalMultipleTableJoinExpression(Expression multipleTableJoinExpression)` INTERNAL: Used to set the multiple table join expression that was generated by EclipseLink as opposed to a custom one supplied by the user.
`void`	`setMultipleTableJoinExpression(Expression multipleTableJoinExpression)` ADVANCED: This is normally generated for descriptors that have multiple tables.
`void`	`setQueries(java.util.Map map)` PUBLIC: set the pre-defined queries for the descriptor.
`void`	`setQueryTimeout(int queryTimeout)` PUBLIC: Set the number of seconds that queries will wait for their Statement to execute.
`void`	`setQueryTimeoutUnit(java.util.concurrent.TimeUnit queryTimeoutUnit)`
`void`	`setReadAllCall(Call call)` ADVANCED: Set the receiver's read all call.
`void`	`setReadAllQuery(ReadAllQuery query)` ADVANCED: Set the receiver's read all query.
`void`	`setReadAllSQLString(java.lang.String sqlString)` ADVANCED: Set the receiver's read SQL string.
`void`	`setReadObjectCall(Call call)` ADVANCED: Set the receiver's read object call.
`void`	`setReadObjectQuery(ReadObjectQuery query)` ADVANCED: Set the receiver's read query.
`void`	`setReadObjectSQLString(java.lang.String sqlString)` ADVANCED: Set the receiver's read SQL string.
`void`	`setUpdateCall(Call call)` ADVANCED: Set the receiver's update call.
`void`	`setUpdateCallCacheSize(int updateCallCacheSize)` ADVANCED: Set the size of the update call cache.
`void`	`setUpdateQuery(UpdateObjectQuery updateQuery)` ADVANCED: Set the receiver's update query.
`void`	`setUpdateSQLString(java.lang.String sqlString)` ADVANCED: Set the receiver's update SQL string.
`protected void`	`updatePropertyParameterExpression(Expression exp)` INTERNAL: This method will walk the given expression and mark any parameter expressions as property expressions.

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

- Field Detail
  - insertQuery
```
protected InsertObjectQuery insertQuery
```
  - updateQuery
```
protected UpdateObjectQuery updateQuery
```
  - readObjectQuery
```
protected ReadObjectQuery readObjectQuery
```
  - readAllQuery
```
protected ReadAllQuery readAllQuery
```
  - deleteQuery
```
protected DeleteObjectQuery deleteQuery
```
  - doesExistQuery
```
protected DoesExistQuery doesExistQuery
```
  - descriptor
```
protected ClassDescriptor descriptor
```
  - hasCustomMultipleTableJoinExpression
```
protected boolean hasCustomMultipleTableJoinExpression
```
  - additionalCriteria
```
protected java.lang.String additionalCriteria
```
  - additionalJoinExpression
```
protected transient Expression additionalJoinExpression
```
  - multipleTableJoinExpression
```
protected transient Expression multipleTableJoinExpression
```
  - queries
```
protected java.util.Map<java.lang.String,java.util.List<DatabaseQuery>> queries
```
  - tablesJoinExpressions
```
protected transient java.util.Map<org.eclipse.persistence.internal.helper.DatabaseTable,Expression> tablesJoinExpressions
```
  - cachedUpdateCalls
```
protected transient org.eclipse.persistence.internal.helper.ConcurrentFixedCache cachedUpdateCalls
```
    PERF: Update call cache for avoiding regenerated update SQL.
  - cachedExpressionQueries
```
protected transient org.eclipse.persistence.internal.helper.ConcurrentFixedCache cachedExpressionQueries
```
    PERF: Expression query call cache for avoiding regenerated dynamic query SQL.
  - NoTimeout
```
public static final int NoTimeout
```
    queryTimeout has three possible settings: DefaultTimeout, NoTimeout, and 1..N This applies to both DatabaseQuery.queryTimeout and DescriptorQueryManager.queryTimeout DatabaseQuery.queryTimeout: - DefaultTimeout: get queryTimeout from DescriptorQueryManager - NoTimeout, 1..N: overrides queryTimeout in DescriptorQueryManager DescriptorQueryManager.queryTimeout: - DefaultTimeout: get queryTimeout from parent DescriptorQueryManager. If there is no parent, default to NoTimeout - NoTimeout, 1..N: overrides parent queryTimeout
    
    See Also:
    Constant Field Values
  - DefaultTimeout
```
public static final int DefaultTimeout
```
    See Also:
    Constant Field Values
  - queryTimeout
```
protected int queryTimeout
```
  - DefaultTimeoutUnit
```
public static final java.util.concurrent.TimeUnit DefaultTimeoutUnit
```
  - queryTimeoutUnit
```
protected java.util.concurrent.TimeUnit queryTimeoutUnit
```
- Constructor Detail
  - DescriptorQueryManager
```
public DescriptorQueryManager()
```
    INTERNAL: Initialize the state of the descriptor query manager
- Method Detail
  - setExpressionQueryCacheMaxSize
```
public void setExpressionQueryCacheMaxSize(int maxSize)
```
    ADVANCED: Set the max size of the expression query cache for avoiding regenerated dynamic query SQL.
  - getExpressionQueryCacheMaxSize
```
public int getExpressionQueryCacheMaxSize()
```
    ADVANCED: Return the max size of the expression query cache for avoiding regenerated dynamic query SQL.
  - addQuery
```
public void addQuery(java.lang.String name,
            DatabaseQuery query)
```
    PUBLIC: Add the query to the descriptor queries with the given name
    
    Parameters:
    name - This is the name of the query. It will be set on the query and used to look it up.
    query - This is the query that will be added. If the query being added has parameters, the existing list of queries will be checked for matching queries. If a matching query exists, it will be replaced.
  - addQuery
```
public void addQuery(DatabaseQuery query)
```
    PUBLIC: Add the query to the session queries
    
    Parameters:
    query - DatabaseQuery This is the query that will be added. If the query being added has parameters, the existing list of queries will be checked for matching queries. If a matching query exists, it will be replaced.
  - assumeExistenceForDoesExist
```
public void assumeExistenceForDoesExist()
```
    PUBLIC: Assume that if the objects primary key does not include null then it must exist. This may be used if the application guarantees or does not care about the existence check.
  - assumeNonExistenceForDoesExist
```
public void assumeNonExistenceForDoesExist()
```
    PUBLIC: Assume that the object does not exist. This may be used if the application guarantees or does not care about the existence check. This will always force an insert to be called.
  - checkCacheForDoesExist
```
public void checkCacheForDoesExist()
```
    PUBLIC: Default behavior. Assume that if the objects primary key does not include null and it is in the cache, then is must exist.
  - checkDatabaseForDoesExist
```
public void checkDatabaseForDoesExist()
```
    PUBLIC: Perform does exist check on the database
  - clone
```
public java.lang.Object clone()
```
    INTERNAL: Clone the query manager
    
    Overrides:
    
    clone in class java.lang.Object
  - containsQuery
```
public boolean containsQuery(java.lang.String queryName)
```
    PUBLIC: Return true if the query is defined on the session
  - convertClassNamesToClasses
```
public void convertClassNamesToClasses(java.lang.ClassLoader classLoader)
```
    INTERNAL: Convert all the class-name-based settings in this Query Manager to actual class-based settings This method is implemented by subclasses as necessary.
    
    Parameters:
    classLoader -
  - getAdditionalJoinExpression
```
public Expression getAdditionalJoinExpression()
```
    ADVANCED: Returns the join expression that should be appended to all of the descriptors expressions Contains any multiple table or inheritance dependencies
  - getDeleteQuery
```
public DeleteObjectQuery getDeleteQuery()
```
    ADVANCED: Return the receiver's delete query. This should be an instance of a valid subclass of DeleteObjectQuery. If specified this is used by the descriptor to delete itself and its private parts from the database. This gives the user the ability to define exactly how to delete the data from the database, or access data external from the database or from some other framework.
  - getDeleteSQLString
```
public java.lang.String getDeleteSQLString()
```
    ADVANCED: Return the receiver's delete SQL string. This allows the user to override the SQL generated by EclipseLink, with their own SQL or procedure call. The arguments are translated from the fields of the source row, through replacing the field names marked by '#' with the values for those fields.
    Example, "delete from EMPLOYEE where EMPLOYEE_ID = #EMPLOYEE_ID".
  - getDescriptor
```
public ClassDescriptor getDescriptor()
```
    INTERNAL: Return the descriptor associated with this descriptor query manager
  - getDoesExistQuery
```
public DoesExistQuery getDoesExistQuery()
```
    ADVANCED: Return the receiver's does exist query. This should be an instance of a valid subclass of DoesExistQuery. If specified this is used by the descriptor to query existence of an object in the database. This gives the user the ability to define exactly how to query existence from the database, or access data external from the database or from some other framework.
  - getDoesExistSQLString
```
public java.lang.String getDoesExistSQLString()
```
    ADVANCED: Return the receiver's does exist SQL string. This allows the user to override the SQL generated by EclipseLink, with there own SQL or procedure call. The arguments are translated from the fields of the source row, through replacing the field names marked by '#' with the values for those fields. This must return null if the object does not exist, otherwise return a database row.
    Example, "select EMPLOYEE_ID from EMPLOYEE where EMPLOYEE_ID = #EMPLOYEE_ID".
  - getExistenceCheck
```
public java.lang.String getExistenceCheck()
```
    INTERNAL: This method is explicitly used by the Builder only.
  - getInsertQuery
```
public InsertObjectQuery getInsertQuery()
```
    ADVANCED: Return the receiver's insert query. This should be an instance of a valid subclass of InsertObjectQuery. If specified this is used by the descriptor to insert itself into the database. If the receiver uses sequence numbers, this query must return the updated sequence value. This gives the user the ability to define exactly how to insert the data into the database, or access data external from the database or from some other framework.
  - getInsertSQLString
```
public java.lang.String getInsertSQLString()
```
    ADVANCED: Return the receiver's insert SQL string. This allows the user to override the SQL generated by EclipseLink, with their own SQL or procedure call. The arguments are translated from the fields of the source row, through replacing the field names marked by '#' with the values for those fields.
    Example, "insert into EMPLOYEE (F_NAME, L_NAME) values (#F_NAME, #L_NAME)".
  - getMultipleTableJoinExpression
```
public Expression getMultipleTableJoinExpression()
```
    ADVANCED: This is normally generated for descriptors that have multiple tables. However, if the additional table does not reference the primary tables primary key, this expression may be set directly.
  - getQueries
```
public java.util.Map<java.lang.String,java.util.List<DatabaseQuery>> getQueries()
```
    PUBLIC: Return the pre-defined queries for the descriptor. The Map returned contains Lists of queries.
    
    See Also:
    getAllQueries()
  - getAllQueries
```
public java.util.Vector getAllQueries()
```
    PUBLIC: Return the pre-defined queries for the descriptor. The Vector returned contains all queries for this descriptor.
    
    See Also:
    getQueries()
  - setAllQueries
```
public void setAllQueries(java.util.Vector vector)
```
    INTERNAL: Set pre-defined queries for the descriptor. Converts the Vector to a hashtable
  - setQueries
```
public void setQueries(java.util.Map map)
```
    PUBLIC: set the pre-defined queries for the descriptor. Used to write out deployment XML
  - getQuery
```
public DatabaseQuery getQuery(java.lang.String queryName)
```
    PUBLIC: Return the query name from the set of pre-defined queries If only one query exists with this name, it will be returned. If there are multiple queries of this name, this method will search for a query with no arguments and return the first one it finds.
    
    See Also:
    getQuery(String, Vector)
  - getQuery
```
public DatabaseQuery getQuery(java.lang.String name,
                     java.util.Vector arguments)
```
    PUBLIC: Return the query from the set of pre-defined queries with the given name and argument types. This allows for common queries to be pre-defined, reused and executed by name. This method should be used if the Session has multiple queries with the same name but different arguments. If only one query exists, it will be returned regardless of the arguments. If multiple queries exist, the first query that has corresponding argument types will be returned
    
    See Also:
    getQuery(String)
  - getLocalQuery
```
public DatabaseQuery getLocalQuery(java.lang.String name,
                          java.util.Vector arguments)
```
    INTENAL: Return the query from the set of pre-defined queries with the given name and argument types. This allows for common queries to be pre-defined, reused and executed by name. Only returns those queries locally defined, not superclass's queries If only one query exists, it will be returned regardless of the arguments. If multiple queries exist, the first query that has corresponding argument types will be returned
    
    See Also:
    getQuery(String)
  - getLocalQueryByArgumentTypes
```
public DatabaseQuery getLocalQueryByArgumentTypes(java.lang.String name,
                                         java.util.List argumentTypes)
```
    INTERNAL: Return the query from the set of pre-defined queries with the given name and argument types. This allows for common queries to be pre-defined, reused and executed by name. Only returns those queries locally defined, not superclass's queries If only one query exists, it will be returned regardless of the arguments. If multiple queries exist, the first query that has corresponding argument types will be returned
    
    See Also:
    getQuery(String)
  - getQueryFromParent
```
protected DatabaseQuery getQueryFromParent(java.lang.String name,
                               java.util.Vector arguments)
```
    INTERNAL: CR#3711: Check if the class for this descriptor has a parent class. Then search this parent's descriptor for a query with the same name and arguments. If nothing found, return null. This method should only be used recursively by getQuery().
  - getReadAllQuery
```
public ReadAllQuery getReadAllQuery()
```
    ADVANCED: Return the receiver's read query. This should be an instance of a valid subclass of ReadAllQuery.
  - getReadAllSQLString
```
public java.lang.String getReadAllSQLString()
```
    ADVANCED: Return the receiver's read SQL string. This allows the user to override the SQL generated by EclipseLink, with their own SQL or procedure call. The arguments are translated from the fields of the read arguments row, through replacing the field names marked by '#' with the values for those fields. Note that this is only used on readAllObjects(Class), and not when an expression is provided.
    Example, "select * from EMPLOYEE"
  - getReadObjectQuery
```
public ReadObjectQuery getReadObjectQuery()
```
    ADVANCED: Return the receiver's read query. This should be an instance of a valid subclass of ReadObjectQuery. If specified this is used by the descriptor to read itself from the database. The read arguments must be the primary key of the object only. This gives the user the ability to define exactly how to read the object from the database, or access data external from the database or from some other framework.
  - getReadObjectSQLString
```
public java.lang.String getReadObjectSQLString()
```
    ADVANCED: Return the receiver's read SQL string. This allows the user to override the SQL generated by EclipseLink, with their own SQL or procedure call. The arguments are translated from the fields of the read arguments row, through replacing the field names marked by '#' with the values for those fields. This must accept only the primary key of the object as arguments.
    Example, "select * from EMPLOYEE where EMPLOYEE_ID = #EMPLOYEE_ID"
  - getUpdateQuery
```
public UpdateObjectQuery getUpdateQuery()
```
    ADVANCED: Return the receiver's update query. This should be an instance of a valid subclass of UpdateObjectQuery. If specified this is used by the descriptor to insert itself into the database. If the receiver uses optimistic locking this must raise an error on optimistic lock failure. This gives the user the ability to define exactly how to update the data into the database, or access data external from the database or from some other framework.
  - getUpdateSQLString
```
public java.lang.String getUpdateSQLString()
```
    ADVANCED: Return the receiver's update SQL string. This allows the user to override the SQL generated by EclipseLink, with there own SQL or procedure call. The arguments are translated from the fields of the source row, through replacing the field names marked by '#' with the values for those fields. This must check the optimistic lock field and raise an error on optimistic lock failure.
    Example, "update EMPLOYEE set F_NAME to #F_NAME, L_NAME to #L_NAME where EMPLOYEE_ID = #EMPLOYEE_ID".
  - hasAdditionalCriteria
```
public boolean hasAdditionalCriteria()
```
    ADVANCED: Return true if an additional criteria has been set on this query manager.
  - hasCustomMultipleTableJoinExpression
```
public boolean hasCustomMultipleTableJoinExpression()
```
    INTERNAL: Return if a custom join expression is used.
  - hasDeleteQuery
```
public boolean hasDeleteQuery()
```
    INTERNAL: Flag that specifies if a delete query is available
  - hasDoesExistQuery
```
public boolean hasDoesExistQuery()
```
    INTERNAL: Flag that specifies if a does exist query is available
  - hasInsertQuery
```
public boolean hasInsertQuery()
```
    INTERNAL: Flag that specifies if a insert query is available
  - hasReadAllQuery
```
public boolean hasReadAllQuery()
```
    INTERNAL: Flag that specifies if a read all query is available
  - hasReadObjectQuery
```
public boolean hasReadObjectQuery()
```
    INTERNAL: Flag that specifies if a read object query is available
  - hasUpdateQuery
```
public boolean hasUpdateQuery()
```
    INTERNAL: Flag that specifies if a update query is available
  - initialize
```
public void initialize(org.eclipse.persistence.internal.sessions.AbstractSession session)
```
    INTERNAL: Post initialize the mappings
  - initializeQueryTimeout
```
public void initializeQueryTimeout(org.eclipse.persistence.internal.sessions.AbstractSession session)
```
    INTERNAL: Initialize the queryTimeout to: NoTimeout: If queryTimeout is DefaultTimeout, either directly or via inheritance. Parent's Timeout: If queryTimeout is something other than DefaultTimeout via my parent.
  - getParentDescriptorQueryManager
```
public DescriptorQueryManager getParentDescriptorQueryManager()
```
    INTERNAL: Get the parent DescriptorQueryManager. Caution must be used in using this method as it expects the descriptor to have inheritance. Calling this when the descriptor that does not use inheritance will cause problems, #hasInheritance() must always first be called.
  - postDelete
```
public void postDelete(DeleteObjectQuery query)
```
    INTERNAL: Execute the post delete operation for the query
  - postInitialize
```
public void postInitialize(org.eclipse.persistence.internal.sessions.AbstractSession session)
                    throws DescriptorException
```
    INTERNAL: Post initializations after mappings are initialized.
    
    Throws:
    
    DescriptorException
  - updatePropertyParameterExpression
```
protected void updatePropertyParameterExpression(Expression exp)
```
    INTERNAL: This method will walk the given expression and mark any parameter expressions as property expressions. This is done when additional criteria has been specified and parameter values must be resolved through session properties.
    
    See Also:
    postInitialize(org.eclipse.persistence.internal.sessions.AbstractSession)
  - postInsert
```
public void postInsert(WriteObjectQuery query)
```
    INTERNAL: Execute the post insert operation for the query
  - postUpdate
```
public void postUpdate(WriteObjectQuery query)
```
    INTERNAL: Execute the post update operation for the query
  - preDelete
```
public void preDelete(DeleteObjectQuery query)
```
    INTERNAL: Execute the pre delete operation for the query
  - preInitialize
```
public void preInitialize(org.eclipse.persistence.internal.sessions.AbstractSession session)
```
    INTERNAL: Initialize the query manager. Any custom queries must be inherited from the parent before any initialization.
  - preInsert
```
public void preInsert(WriteObjectQuery query)
```
    INTERNAL: Execute the pre insert operation for the query.
  - preUpdate
```
public void preUpdate(WriteObjectQuery query)
```
    INTERNAL: Execute the pre update operation for the query
  - removeQuery
```
public void removeQuery(java.lang.String queryName)
```
    PUBLIC: Remove all queries with the given query name from the set of pre-defined queries
    
    See Also:
    removeQuery(String, Vector)
  - removeQuery
```
public void removeQuery(java.lang.String queryName,
               java.util.Vector argumentTypes)
```
    PUBLIC: Remove the specific query with the given queryName and argumentTypes.
    
    See Also:
    removeQuery(String)
  - setAdditionalCriteria
```
public void setAdditionalCriteria(java.lang.String additionalCriteria)
```
    ADVANCED: Set the additional join criteria that will be used to form the additional join expression. The additionalCriteria is a jpql fragment at this point.
    
    See Also:
    setAdditionalJoinExpression(org.eclipse.persistence.expressions.Expression)
  - setAdditionalJoinExpression
```
public void setAdditionalJoinExpression(Expression additionalJoinExpression)
```
    ADVANCED: Set the additional join expression. Used in conjunction with multiple tables and inheritance relationships. This can also be used if a sub-expression is always required to be appended to all queries. Such as tables that are shared based on a type field without inheritance.
  - setDeleteQuery
```
public void setDeleteQuery(DeleteObjectQuery query)
```
    ADVANCED: Set the receiver's delete query. This should be an instance of a valid subclass of DeleteObjectQuery. If specified this is used by the descriptor to delete itself and its private parts from the database. This gives the user the ability to define exactly how to delete the data from the database, or access data external from the database or from some other framework.
  - setDeleteSQLString
```
public void setDeleteSQLString(java.lang.String sqlString)
```
    ADVANCED: Set the receiver's delete SQL string. This allows the user to override the SQL generated by EclipseLink, with their own SQL or procedure call. The arguments are translated from the fields of the source row, through replacing the field names marked by '#' with the values for those fields. Warning: Allowing an unverified SQL string to be passed into this method makes your application vulnerable to SQL injection attacks.
    Example, "delete from EMPLOYEE where EMPLOYEE_ID = #EMPLOYEE_ID".
  - setDeleteCall
```
public void setDeleteCall(Call call)
```
    ADVANCED: Set the receiver's delete call. This allows the user to override the delete operation.
  - setDescriptor
```
public void setDescriptor(ClassDescriptor descriptor)
```
    INTERNAL: Set the descriptor.
  - setDoesExistQuery
```
public void setDoesExistQuery(DoesExistQuery query)
```
    ADVANCED: Set the receiver's does exist query. This should be an instance of a valid subclass of DoesExistQuery. If specified this is used by the descriptor to query existence of an object in the database. This gives the user the ability to define exactly how to query existence from the database, or access data external from the database or from some other framework.
  - setDoesExistSQLString
```
public void setDoesExistSQLString(java.lang.String sqlString)
```
    ADVANCED: Set the receiver's does exist SQL string. This allows the user to override the SQL generated by EclipseLink, with there own SQL or procedure call. The arguments are translated from the fields of the source row, through replacing the field names marked by '#' with the values for those fields. This must return null if the object does not exist, otherwise return a database row. Warning: Allowing an unverified SQL string to be passed into this method makes your application vulnerable to SQL injection attacks.
    Example, "select EMPLOYEE_ID from EMPLOYEE where EMPLOYEE_ID = #EMPLOYEE_ID".
  - setDoesExistCall
```
public void setDoesExistCall(Call call)
```
    ADVANCED: Set the receiver's does exist call. This allows the user to override the does exist operation.
  - setExistenceCheck
```
public void setExistenceCheck(java.lang.String token)
                       throws DescriptorException
```
    INTERNAL: This method is explicitly used by the Builder only.
    
    Throws:
    
    DescriptorException
  - setHasCustomMultipleTableJoinExpression
```
protected void setHasCustomMultipleTableJoinExpression(boolean hasCustomMultipleTableJoinExpression)
```
    INTENAL: Set if a custom join expression is used.
  - setInsertQuery
```
public void setInsertQuery(InsertObjectQuery insertQuery)
```
    ADVANCED: Set the receiver's insert query. This should be an instance of a valid subclass of InsertObjectQuery. If specified this is used by the descriptor to insert itself into the database. This gives the user the ability to define exactly how to insert the data into the database, or access data external from the database or from some other framework.
  - setInsertCall
```
public void setInsertCall(Call call)
```
    ADVANCED: Set the receiver's insert call. This allows the user to override the insert operation.
  - setInsertSQLString
```
public void setInsertSQLString(java.lang.String sqlString)
```
    ADVANCED: Set the receiver's insert SQL string. This allows the user to override the SQL generated by EclipseLink, with their own SQL or procedure call. The arguments are translated from the fields of the source row, through replacing the field names marked by '#' with the values for those fields. Warning: Allowing an unverified SQL string to be passed into this method makes your application vulnerable to SQL injection attacks.
    Example, "insert into EMPLOYEE (F_NAME, L_NAME) values (#F_NAME, #L_NAME)".
  - getInsertCall
```
public Call getInsertCall()
```
    ADVANCED: Return the receiver's insert call. This allows the user to override the insert operation.
  - getUpdateCall
```
public Call getUpdateCall()
```
    ADVANCED: Return the receiver's update call. This allows the user to override the update operation.
  - getDeleteCall
```
public Call getDeleteCall()
```
    ADVANCED: Return the receiver's delete call. This allows the user to override the delete operation.
  - getReadObjectCall
```
public Call getReadObjectCall()
```
    ADVANCED: Return the receiver's read-object call. This allows the user to override the read-object operation.
  - getReadAllCall
```
public Call getReadAllCall()
```
    ADVANCED: Return the receiver's read-all call. This allows the user to override the read-all operation.
  - getDoesExistCall
```
public Call getDoesExistCall()
```
    ADVANCED: Return the receiver's does-exist call. This allows the user to override the does-exist operation.
  - getTablesJoinExpressions
```
public java.util.Map<org.eclipse.persistence.internal.helper.DatabaseTable,Expression> getTablesJoinExpressions()
```
    INTERNAL: Used in case descriptor has additional tables: each additional table mapped to an expression joining it.
  - setInternalMultipleTableJoinExpression
```
public void setInternalMultipleTableJoinExpression(Expression multipleTableJoinExpression)
```
    INTERNAL: Used to set the multiple table join expression that was generated by EclipseLink as opposed to a custom one supplied by the user.
    
    See Also:
    setMultipleTableJoinExpression(Expression)
  - setMultipleTableJoinExpression
```
public void setMultipleTableJoinExpression(Expression multipleTableJoinExpression)
```
    ADVANCED: This is normally generated for descriptors that have multiple tables. However, if the additional table does not reference the primary table's primary key, this expression may be set directly.
  - setReadAllQuery
```
public void setReadAllQuery(ReadAllQuery query)
```
    ADVANCED: Set the receiver's read all query. This should be an instance of a valid subclass of ReadAllQuery. If specified this is used by the descriptor to read all instances of its class from the database. This gives the user the ability to define exactly how to read all objects from the database, or access data external from the database or from some other framework. Note that this is only used on readAllObjects(Class), and not when an expression is provided.
  - setReadAllSQLString
```
public void setReadAllSQLString(java.lang.String sqlString)
```
    ADVANCED: Set the receiver's read SQL string. This allows the user to override the SQL generated by EclipseLink, with their own SQL or procedure call. The arguments are translated from the fields of the read arguments row, through replacing the field names marked by '#' with the values for those fields. Note that this is only used on readAllObjects(Class), and not when an expression is provided. Warning: Allowing an unverified SQL string to be passed into this method makes your application vulnerable to SQL injection attacks.
    Example, "select * from EMPLOYEE"
  - setReadAllCall
```
public void setReadAllCall(Call call)
```
    ADVANCED: Set the receiver's read all call. This allows the user to override the read all operation. Note that this is only used on readAllObjects(Class), and not when an expression is provided.
  - setReadObjectQuery
```
public void setReadObjectQuery(ReadObjectQuery query)
```
    ADVANCED: Set the receiver's read query. This should be an instance of a valid subclass of ReadObjectQuery If specified this is used by the descriptor to read itself from the database. The read arguments must be the primary key of the object only. This gives the user the ability to define exactly how to read the object from the database, or access data external from the database or from some other framework.
  - setReadObjectSQLString
```
public void setReadObjectSQLString(java.lang.String sqlString)
```
    ADVANCED: Set the receiver's read SQL string. This allows the user to override the SQL generated by EclipseLink, with their own SQL or procedure call. The arguments are translated from the fields of the read arguments row, through replacing the field names marked by '#' with the values for those fields. This must accept only the primary key of the object as arguments. Warning: Allowing an unverified SQL string to be passed into this method makes your application vulnerable to SQL injection attacks.
    Example, "select * from EMPLOYEE where EMPLOYEE_ID = #EMPLOYEE_ID"
  - setReadObjectCall
```
public void setReadObjectCall(Call call)
```
    ADVANCED: Set the receiver's read object call. This allows the user to override the read object operation. This must accept only the primary key of the object as arguments.
  - setUpdateQuery
```
public void setUpdateQuery(UpdateObjectQuery updateQuery)
```
    ADVANCED: Set the receiver's update query. This should be an instance of a valid subclass of UpdateObjectQuery. If specified this is used by the descriptor to update itself in the database. If the receiver uses optimistic locking this must raise an error on optimistic lock failure. This gives the user the ability to define exactly how to update the data into the database, or access data external from the database or from some other framework.
  - setUpdateSQLString
```
public void setUpdateSQLString(java.lang.String sqlString)
```
    ADVANCED: Set the receiver's update SQL string. This allows the user to override the SQL generated by EclipseLink, with there own SQL or procedure call. The arguments are translated from the fields of the source row, through replacing the field names marked by '#' with the values for those fields. This must check the optimistic lock field and raise an error on optimistic lock failure. Warning: Allowing an unverified SQL string to be passed into this method makes your application vulnerable to SQL injection attacks.
    Example, "update EMPLOYEE set F_NAME to #F_NAME, L_NAME to #L_NAME where EMPLOYEE_ID = #EMPLOYEE_ID".
  - setUpdateCall
```
public void setUpdateCall(Call call)
```
    ADVANCED: Set the receiver's update call. This allows the user to override the update operation.
  - getQueryTimeout
```
public int getQueryTimeout()
```
    PUBLIC: Return the number of seconds queries will wait for their Statement to execute. - DefaultTimeout: get queryTimeout from parent DescriptorQueryManager. If there is no parent, default to NoTimeout - NoTimeout, 1..N: overrides parent queryTimeout
  - getQueryTimeoutUnit
```
public java.util.concurrent.TimeUnit getQueryTimeoutUnit()
```
  - setQueryTimeout
```
public void setQueryTimeout(int queryTimeout)
```
    PUBLIC: Set the number of seconds that queries will wait for their Statement to execute. If the limit is exceeded, a DatabaseException is thrown. - DefaultTimeout: get queryTimeout from parent DescriptorQueryManager. If there is no parent, default to NoTimeout - NoTimeout, 1..N: overrides parent queryTimeout
  - setQueryTimeoutUnit
```
public void setQueryTimeoutUnit(java.util.concurrent.TimeUnit queryTimeoutUnit)
```
  - getUpdateCallCacheSize
```
public int getUpdateCallCacheSize()
```
    ADVANCED: Return the size of the update call cache. The update call cache is used to cache the update SQL to avoid regeneration. Since every update with different fields produces different SQL, this cache allows caching of the update SQL based on the fields being updated. The default cache size is 10, the update call cache can be disabled through setting the size to 0.
  - setUpdateCallCacheSize
```
public void setUpdateCallCacheSize(int updateCallCacheSize)
```
    ADVANCED: Set the size of the update call cache. The update call cache is used to cache the update SQL to avoid regeneration. Since every update with different fields produces different SQL, this cache allows caching of the update SQL based on the fields being updated. The default cache size is 10, the update call cache can be disabled through setting the size to 0.
  - getCachedUpdateCalls
```
public java.util.Vector getCachedUpdateCalls(java.util.Vector updateFields)
```
    INTERNAL: Return the cached update SQL call based on the updated fields. PERF: Allow caching of the update SQL call to avoid regeneration.
  - putCachedUpdateCalls
```
public void putCachedUpdateCalls(java.util.Vector updateFields,
                        java.util.Vector updateCalls)
```
    INTERNAL: Cache a clone of the update SQL calls based on the updated fields. If the max size is reached, do not cache the call. The call's query must be dereferenced in order to allow the GC of a related session. PERF: Allow caching of the update SQL call to avoid regeneration.
  - getCachedExpressionQuery
```
public DatabaseQuery getCachedExpressionQuery(DatabaseQuery query)
```
    INTERNAL: Return the cached SQL call for the expression query. PERF: Allow caching of expression query SQL call to avoid regeneration.
  - putCachedExpressionQuery
```
public void putCachedExpressionQuery(DatabaseQuery query)
```
    INTERNAL: Set the cached SQL call for the expression query. PERF: Allow caching of expression query SQL call to avoid regeneration.
  - removeCachedExpressionQuery
```
public void removeCachedExpressionQuery(DatabaseQuery query)
```
    INTERNAL: Remove the cached expression query. PERF: Allow caching of expression query SQL call to avoid regeneration.

Class DescriptorQueryManager

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

insertQuery

updateQuery

readObjectQuery

readAllQuery

deleteQuery

doesExistQuery

descriptor

hasCustomMultipleTableJoinExpression

additionalCriteria

additionalJoinExpression

multipleTableJoinExpression

queries

tablesJoinExpressions

cachedUpdateCalls

cachedExpressionQueries

NoTimeout

DefaultTimeout

queryTimeout

DefaultTimeoutUnit

queryTimeoutUnit

Constructor Detail

DescriptorQueryManager

Method Detail

setExpressionQueryCacheMaxSize

getExpressionQueryCacheMaxSize

addQuery

addQuery

assumeExistenceForDoesExist

assumeNonExistenceForDoesExist

checkCacheForDoesExist

checkDatabaseForDoesExist

clone

containsQuery

convertClassNamesToClasses

getAdditionalJoinExpression

getDeleteQuery

getDeleteSQLString

getDescriptor

getDoesExistQuery

getDoesExistSQLString

getExistenceCheck

getInsertQuery

getInsertSQLString

getMultipleTableJoinExpression

getQueries

getAllQueries

setAllQueries

setQueries

getQuery

getQuery

getLocalQuery

getLocalQueryByArgumentTypes

getQueryFromParent

getReadAllQuery

getReadAllSQLString

getReadObjectQuery

getReadObjectSQLString

getUpdateQuery

getUpdateSQLString

hasAdditionalCriteria

hasCustomMultipleTableJoinExpression

hasDeleteQuery

hasDoesExistQuery

hasInsertQuery

hasReadAllQuery

hasReadObjectQuery

hasUpdateQuery

initialize

initializeQueryTimeout

getParentDescriptorQueryManager

postDelete

postInitialize

updatePropertyParameterExpression

postInsert