Uses of Class
org.eclipse.persistence.queries.DatabaseQuery

Packages that use DatabaseQuery

Package	Description
org.eclipse.persistence.descriptors
org.eclipse.persistence.descriptors.partitioning
org.eclipse.persistence.eis
org.eclipse.persistence.exceptions
org.eclipse.persistence.expressions
org.eclipse.persistence.internal.databaseaccess
org.eclipse.persistence.internal.expressions
org.eclipse.persistence.internal.helper
org.eclipse.persistence.internal.jpa.jpql
org.eclipse.persistence.internal.queries
org.eclipse.persistence.internal.sessions
org.eclipse.persistence.internal.sessions.remote
org.eclipse.persistence.mappings
org.eclipse.persistence.platform.database
org.eclipse.persistence.queries
org.eclipse.persistence.sequencing
org.eclipse.persistence.sessions
org.eclipse.persistence.sessions.broker
org.eclipse.persistence.sessions.factories
org.eclipse.persistence.sessions.remote
org.eclipse.persistence.sessions.remote.rmi
org.eclipse.persistence.sessions.server
org.eclipse.persistence.tools.profiler
org.eclipse.persistence.tools.schemaframework

Uses of DatabaseQuery in org.eclipse.persistence.descriptors

Fields in org.eclipse.persistence.descriptors declared as DatabaseQuery

Modifier and Type	Field	Description
protected DatabaseQuery	DescriptorEvent.query	The query causing the event.

Fields in org.eclipse.persistence.descriptors with type parameters of type DatabaseQuery

Modifier and Type	Field	Description
protected Map<String,List<DatabaseQuery>>	DescriptorQueryManager.queries

Methods in org.eclipse.persistence.descriptors that return DatabaseQuery

Modifier and Type	Method	Description
DatabaseQuery	DescriptorQueryManager.getCachedExpressionQuery(DatabaseQuery query)	INTERNAL: Return the cached SQL call for the expression query.
DatabaseQuery	DescriptorQueryManager.getLocalQuery(String name, Vector arguments)	INTENAL: Return the query from the set of pre-defined queries with the given name and argument types.
DatabaseQuery	DescriptorQueryManager.getLocalQueryByArgumentTypes(String name, List argumentTypes)	INTERNAL: Return the query from the set of pre-defined queries with the given name and argument types.
DatabaseQuery	DescriptorEvent.getQuery()	PUBLIC: The query causing the event.
DatabaseQuery	DescriptorQueryManager.getQuery(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	DescriptorQueryManager.getQuery(String name, Vector arguments)	PUBLIC: Return the query from the set of pre-defined queries with the given name and argument types.
protected DatabaseQuery	DescriptorQueryManager.getQueryFromParent(String name, Vector arguments)	INTERNAL: CR#3711: Check if the class for this descriptor has a parent class.

Methods in org.eclipse.persistence.descriptors that return types with arguments of type DatabaseQuery

Modifier and Type	Method	Description
Map<String,List<DatabaseQuery>>	DescriptorQueryManager.getQueries()	PUBLIC: Return the pre-defined queries for the descriptor.

Methods in org.eclipse.persistence.descriptors with parameters of type DatabaseQuery

Modifier and Type	Method	Description
void	DescriptorQueryManager.addQuery(String name, DatabaseQuery query)	PUBLIC: Add the query to the descriptor queries with the given name
void	DescriptorQueryManager.addQuery(DatabaseQuery query)	PUBLIC: Add the query to the session queries
DatasourceCall	ClassDescriptor.buildCallFromStatement(SQLStatement statement, DatabaseQuery query, AbstractSession session)	INTERNAL: Return a call built from a statement.
DatabaseQuery	DescriptorQueryManager.getCachedExpressionQuery(DatabaseQuery query)	INTERNAL: Return the cached SQL call for the expression query.
void	DescriptorQueryManager.putCachedExpressionQuery(DatabaseQuery query)	INTERNAL: Set the cached SQL call for the expression query.
void	DescriptorQueryManager.removeCachedExpressionQuery(DatabaseQuery query)	INTERNAL: Remove the cached expression query.
void	DescriptorEvent.setQuery(DatabaseQuery query)	INTERNAL: The query causing the event.

Uses of DatabaseQuery in org.eclipse.persistence.descriptors.partitioning

Methods in org.eclipse.persistence.descriptors.partitioning with parameters of type DatabaseQuery

Modifier and Type	Method	Description
Accessor	PartitioningPolicy.acquireAccessor(String poolName, ServerSession session, DatabaseQuery query, boolean returnNullIfDead)	INTERNAL: Return an accessor from the pool.
Accessor	PartitioningPolicy.getAccessor(String poolName, AbstractSession session, DatabaseQuery query, boolean returnNullIfDead)	INTERNAL: Return an accessor from the pool for the session.
List<Accessor>	CustomPartitioningPolicy.getConnectionsForQuery(AbstractSession session, DatabaseQuery query, AbstractRecord arguments)	INTERNAL: Forward to custom policy
List<Accessor>	HashPartitioningPolicy.getConnectionsForQuery(AbstractSession session, DatabaseQuery query, AbstractRecord arguments)	INTERNAL: Get a connection from one of the pools in a round robin rotation fashion.
abstract List<Accessor>	PartitioningPolicy.getConnectionsForQuery(AbstractSession session, DatabaseQuery query, AbstractRecord arguments)
List<Accessor>	PinnedPartitioningPolicy.getConnectionsForQuery(AbstractSession session, DatabaseQuery query, AbstractRecord arguments)	INTERNAL: Get a connection from each pool.
List<Accessor>	RangePartitioningPolicy.getConnectionsForQuery(AbstractSession session, DatabaseQuery query, AbstractRecord arguments)	INTERNAL: Get a connection from one of the pools in a round robin rotation fashion.
List<Accessor>	ReplicationPartitioningPolicy.getConnectionsForQuery(AbstractSession session, DatabaseQuery query, AbstractRecord arguments)	INTERNAL: Get a connection from each pool.
List<Accessor>	RoundRobinPartitioningPolicy.getConnectionsForQuery(AbstractSession session, DatabaseQuery query, AbstractRecord arguments)	INTERNAL: Get a connection from one of the pools in a round robin rotation fashion.
List<Accessor>	UnionPartitioningPolicy.getConnectionsForQuery(AbstractSession session, DatabaseQuery query, AbstractRecord arguments)	INTERNAL: Get a connection from one of the pools in a round robin rotation fashion.
List<Accessor>	ValuePartitioningPolicy.getConnectionsForQuery(AbstractSession session, DatabaseQuery query, AbstractRecord arguments)	INTERNAL: Get a connection from one of the pools in a round robin rotation fashion.
Accessor	RoundRobinPartitioningPolicy.nextAccessor(ServerSession session, DatabaseQuery query)	INTERNAL: Return the next connection accessor.

Uses of DatabaseQuery in org.eclipse.persistence.eis

Methods in org.eclipse.persistence.eis with parameters of type DatabaseQuery

Modifier and Type	Method	Description
DatasourceCall	EISDescriptor.buildCallFromStatement(SQLStatement statement, DatabaseQuery query, AbstractSession session)	INTERNAL: Override this method to throw an exception.
DatasourceCall	EISPlatform.buildCallFromStatement(SQLStatement statement, DatabaseQuery query, AbstractSession session)	INTERNAL: Override this method to throw an exception by default.

Uses of DatabaseQuery in org.eclipse.persistence.exceptions

Fields in org.eclipse.persistence.exceptions declared as DatabaseQuery

Modifier and Type	Field	Description
protected DatabaseQuery	DatabaseException.query
protected DatabaseQuery	QueryException.query

Methods in org.eclipse.persistence.exceptions that return DatabaseQuery

Modifier and Type	Method	Description
DatabaseQuery	DatabaseException.getQuery()	PUBLIC: This method returns the databaseQuery.
DatabaseQuery	QueryException.getQuery()	PUBLIC: Return the query in which the problem was detected.

Methods in org.eclipse.persistence.exceptions with parameters of type DatabaseQuery

Modifier and Type	Method	Description
static QueryException	QueryException.additionalSizeQueryNotSpecified(DatabaseQuery query)
static QueryException	QueryException.aggregateObjectCannotBeDeletedOrWritten(ClassDescriptor descriptor, DatabaseQuery query)
static QueryException	QueryException.argumentSizeMismatchInQueryAndQueryDefinition(DatabaseQuery query)
static QueryException	QueryException.batchReadingInRequiresSingletonPrimaryKey(DatabaseQuery query)
static QueryException	QueryException.batchReadingNotSupported(DatabaseMapping mapping, DatabaseQuery query)
static QueryException	QueryException.batchReadingNotSupported(DatabaseQuery query)
static QueryException	QueryException.cannotCacheCursorResultsOnQuery(DatabaseQuery query)
static QueryException	QueryException.cannotCacheIsolatedDataOnQuery(DatabaseQuery query)
static QueryException	QueryException.cannotCachePartialObjects(DatabaseQuery query)
static QueryException	QueryException.classNotFoundWhileUsingQueryHint(DatabaseQuery query, Object hintValue, Exception exc)
static QueryException	QueryException.deleteAllQuerySpecifiesObjectsButNotSelectionCriteria(ClassDescriptor descriptor, DatabaseQuery query, String objects)
static QueryException	QueryException.descriptorIsMissing(Class<?> referenceClass, DatabaseQuery query)
static QueryException	QueryException.distinctCountOnOuterJoinedCompositePK(ClassDescriptor descr, DatabaseQuery query)
static QueryException	QueryException.errorInstantiatedClassForQueryHint(Exception exception, DatabaseQuery query, Class<?> theClass, String hint)
static QueryException	QueryException.exampleAndReferenceObjectClassMismatch(Class<?> exampleObjectClass, Class<?> referenceObjectClass, DatabaseQuery query)	Oct 18, 2000 JED Added this method and exception value
static QueryException	QueryException.exceptionWhileInitializingConstructor(Exception thrownException, DatabaseQuery query, Class<?> targetClass)	An exception was thrown while initializing the constructor from the class.
static QueryException	QueryException.exceptionWhileUsingConstructorExpression(Exception thrownException, DatabaseQuery query)	An exception was throwing while using a ReportQuery with a constructor expression
static ValidationException	ValidationException.excusiveConnectionIsNoLongerAvailable(DatabaseQuery query, AbstractSession session)
static ValidationException	ValidationException.existingQueryTypeConflict(DatabaseQuery newQuery, DatabaseQuery existingQuery)
static QueryException	QueryException.inCannotBeParameterized(DatabaseQuery query)
static QueryException	QueryException.incorrectQueryObjectFound(DatabaseQuery query, Class<?> expectedQueryClass)
static QueryException	QueryException.incorrectSizeQueryForCursorStream(DatabaseQuery query)
static QueryException	QueryException.invalidBuilderInQuery(DatabaseQuery query)
static QueryException	QueryException.invalidExpressionForQueryItem(Expression expression, DatabaseQuery owner)
static QueryException	QueryException.invalidQuery(DatabaseQuery query)
static QueryException	QueryException.invalidQueryOnHistoricalSession(DatabaseQuery query)
static QueryException	QueryException.invalidQueryOnServerSession(DatabaseQuery query)
static QueryException	QueryException.joiningAcrossInheritanceClassWithMultipleTablesNotSupported(DatabaseQuery query, Class<?> joinClass)
static QueryException	QueryException.listOrderFieldWrongValue(DatabaseQuery query, DatabaseField field, List wrongOrderValuesList)
static QueryException	QueryException.missingConnectionPool(String poolName, DatabaseQuery query)
static QueryException	QueryException.missingContextPropertyForPropertyParameterExpression(DatabaseQuery query, String argumentName)
static QueryException	QueryException.nativeSQLQueriesAreDisabled(DatabaseQuery query)
static QueryException	QueryException.noAttributesForReportQuery(DatabaseQuery query)	Oct 19, 2000 JED Added this method and exception value
static QueryException	QueryException.noConcreteClassIndicated(AbstractRecord row, DatabaseQuery query)
static QueryException	QueryException.noCursorSupport(DatabaseQuery query)
static QueryException	QueryException.noDescriptorForClassFromInheritancePolicy(DatabaseQuery query, Class<?> referenceClass)
static QueryException	QueryException.nullPrimaryKeyInBuildingObject(DatabaseQuery query, AbstractRecord databaseRow)
static QueryException	QueryException.objectToModifyNotSpecified(DatabaseQuery query)
static QueryException	QueryException.originalQueryMustUseBatchIN(DatabaseMapping mapping, DatabaseQuery query)
static QueryException	QueryException.partitioningNotSupported(AbstractSession session, DatabaseQuery query)
static QueryException	QueryException.polymorphicReportItemWithMultipletableNotSupported(String itemName, Expression expression, DatabaseQuery owner)
static QueryException	QueryException.prepareFailed(Exception error, DatabaseQuery query)
static ValidationException	ValidationException.queryArgumentTypeNotFound(DatabaseQuery query, String argumentName, String typeAsString, Exception exception)
static QueryException	QueryException.queryHintDidNotContainEnoughTokens(DatabaseQuery query, String hintName, Object hintValue)
static QueryException	QueryException.queryHintNavigatedIllegalRelationship(DatabaseQuery query, String hintName, Object hintValue, String relationship)
static QueryException	QueryException.queryHintNavigatedNonExistantRelationship(DatabaseQuery query, String hintName, Object hintValue, String relationship)
static QueryException	QueryException.querySentToInactiveUnitOfWork(DatabaseQuery query)
static QueryException	QueryException.readBeyondStream(DatabaseQuery query)
static QueryException	QueryException.redirectionClassOrMethodNotSet(DatabaseQuery query)
static QueryException	QueryException.redirectionMethodError(Exception exception, DatabaseQuery query)
static QueryException	QueryException.redirectionMethodNotDefinedCorrectly(Class<?> methodClass, String methodName, Exception exception, DatabaseQuery query)
static QueryException	QueryException.referenceClassMissing(DatabaseQuery query)
static QueryException	QueryException.refreshNotPossibleWithCheckCacheOnly(DatabaseQuery query)
static QueryException	QueryException.refreshNotPossibleWithoutCache(DatabaseQuery query)
static QueryException	QueryException.resultSetAccessOptimizationIsNotPossible(DatabaseQuery query)
static QueryException	QueryException.selectionObjectCannotBeNull(DatabaseQuery query)
void	DatabaseException.setQuery(DatabaseQuery query)	PUBLIC: This method set the databaseQuery.
void	QueryException.setQuery(DatabaseQuery query)	INTERNAL: Set the query in which the problem was detected.
static QueryException	QueryException.sizeOnlySupportedOnExpressionQueries(DatabaseQuery query)
static QueryException	QueryException.sopObjectDeserializeFailed(DatabaseQuery query, DatabaseField sopField, AbstractRecord row, Exception exception)
static QueryException	QueryException.sopObjectIsNotFound(DatabaseQuery query, DatabaseField sopField, AbstractRecord row)
static QueryException	QueryException.sopObjectWrongPk(DatabaseQuery query, Object sopObjectPk, DatabaseField sopField, AbstractRecord row)
static QueryException	QueryException.sopObjectWrongVersion(DatabaseQuery query, Object sopObjectVersion, DatabaseField sopField, AbstractRecord row)
static QueryException	QueryException.specifiedPartialAttributeDoesNotExist(DatabaseQuery query, String attributeName, String targetClassName)
static QueryException	QueryException.sqlStatementNotSetProperly(DatabaseQuery query)
static QueryException	QueryException.tempTablesNotSupported(DatabaseQuery query, String platformClassName)
static QueryException	QueryException.unableToSetRedirectorOnQueryFromHint(DatabaseQuery query, String hint, String redirectorClass, Exception ex)
static QueryException	QueryException.unnamedQueryOnSessionBroker(DatabaseQuery query)
static QueryException	QueryException.updateAllQueryAddUpdateDefinesWrongField(ClassDescriptor descriptor, DatabaseQuery query, String attributeNameOrExpression, String wrongField)
static QueryException	QueryException.updateAllQueryAddUpdateDoesNotDefineField(ClassDescriptor descriptor, DatabaseQuery query, String attributeNameOrExpression)
static QueryException	QueryException.updateAllQueryAddUpdateFieldIsNull(DatabaseQuery query)

Constructors in org.eclipse.persistence.exceptions with parameters of type DatabaseQuery

Constructor	Description
QueryException(String message, DatabaseQuery query)	INTERNAL: Constructor.
QueryException(String message, DatabaseQuery query, Exception internalException)	INTERNAL: Constructor.

Uses of DatabaseQuery in org.eclipse.persistence.expressions

Methods in org.eclipse.persistence.expressions with parameters of type DatabaseQuery

Modifier and Type	Method	Description
ClassDescriptor	Expression.getLeafDescriptor(DatabaseQuery query, ClassDescriptor rootDescriptor, AbstractSession session)	INTERNAL: Lookup the descriptor for this item by traversing its expression recursively.
ClassDescriptor	ExpressionBuilder.getLeafDescriptor(DatabaseQuery query, ClassDescriptor rootDescriptor, AbstractSession session)	INTERNAL: Lookup the descriptor for this item by traversing its expression recursively.
DatabaseMapping	Expression.getLeafMapping(DatabaseQuery query, ClassDescriptor rootDescriptor, AbstractSession session)	INTERNAL: Lookup the mapping for this item by traversing its expression recursively.

Uses of DatabaseQuery in org.eclipse.persistence.internal.databaseaccess

Fields in org.eclipse.persistence.internal.databaseaccess declared as DatabaseQuery

Modifier and Type	Field	Description
protected DatabaseQuery	DatasourceCall.query

Methods in org.eclipse.persistence.internal.databaseaccess that return DatabaseQuery

Modifier and Type	Method	Description
DatabaseQuery	DatasourceCall.getQuery()	Back reference to query, unfortunately required for events.
DatabaseQuery	DatabasePlatform.getVPDClearIdentifierQuery(String vpdIdentifier)	Any platform that supports VPD should implement this method.
DatabaseQuery	DatabasePlatform.getVPDSetIdentifierQuery(String vpdIdentifier)	Any platform that supports VPD should implement this method.

Methods in org.eclipse.persistence.internal.databaseaccess with parameters of type DatabaseQuery

Modifier and Type	Method	Description
DatabaseQueryMechanism	DatabaseCall.buildNewQueryMechanism(DatabaseQuery query)	Return the appropriate mechanism, with the call added as necessary.
DatabaseQueryMechanism	DatasourceCall.buildNewQueryMechanism(DatabaseQuery query)	Return the appropriate mechanism, with the call added as necessary.
DatabaseQueryMechanism	DatabaseCall.buildQueryMechanism(DatabaseQuery query, DatabaseQueryMechanism mechanism)	Return the appropriate mechanism, with the call added as necessary.
DatabaseQueryMechanism	DatasourceCall.buildQueryMechanism(DatabaseQuery query, DatabaseQueryMechanism mechanism)	Return the appropriate mechanism, with the call added as necessary.
void	DatasourceCall.setQuery(DatabaseQuery query)	Back reference to query, unfortunately required for events.
boolean	DatasourcePlatform.shouldPrepare(DatabaseQuery query)	Allows query prepare to be disable in the platform.

Uses of DatabaseQuery in org.eclipse.persistence.internal.expressions

Methods in org.eclipse.persistence.internal.expressions with parameters of type DatabaseQuery

Modifier and Type	Method	Description
DatabaseCall	SQLSelectStatement.buildCall(AbstractSession session, DatabaseQuery query)	Build the call, setting the query first, this is required in some cases when the query info is required to print the SQL.
ClassDescriptor	QueryKeyExpression.getLeafDescriptor(DatabaseQuery query, ClassDescriptor rootDescriptor, AbstractSession session)	INTERNAL: Lookup the descriptor for this item by traversing its expression recursively.
ClassDescriptor	TreatAsExpression.getLeafDescriptor(DatabaseQuery query, ClassDescriptor rootDescriptor, AbstractSession session)
DatabaseMapping	FunctionExpression.getLeafMapping(DatabaseQuery query, ClassDescriptor rootDescriptor, AbstractSession session)	INTERNAL: Lookup the mapping for this item by traversing its expression recursively.
DatabaseMapping	QueryKeyExpression.getLeafMapping(DatabaseQuery query, ClassDescriptor rootDescriptor, AbstractSession session)	INTERNAL: Lookup the mapping for this item by traversing its expression recursively.
DatabaseMapping	TreatAsExpression.getLeafMapping(DatabaseQuery query, ClassDescriptor rootDescriptor, AbstractSession session)
protected QueryKey	FunctionExpression.getLeafQueryKeyFor(DatabaseQuery query, Expression expression, ClassDescriptor rootDescriptor, AbstractSession session)	INTERNAL: Lookup the query key for this item.
Object	ParameterExpression.getValue(AbstractRecord translationRow, DatabaseQuery query, AbstractSession session)	Extract the value from the row.

Uses of DatabaseQuery in org.eclipse.persistence.internal.helper

Fields in org.eclipse.persistence.internal.helper with type parameters of type DatabaseQuery

Modifier and Type	Field	Description
static Class<DatabaseQuery>	ClassConstants.DatabaseQuery_Class

Uses of DatabaseQuery in org.eclipse.persistence.internal.jpa.jpql

Methods in org.eclipse.persistence.internal.jpa.jpql that return DatabaseQuery

Modifier and Type	Method	Description
DatabaseQuery	HermesParser.buildQuery(CharSequence jpqlQuery, AbstractSession session)
DatabaseQuery	ConstructorQueryMappings.getQuery()	Returns the DatabaseQuery for which its JPQL query was scanned to check if it's constructor query and if so, to gather the information.

Methods in org.eclipse.persistence.internal.jpa.jpql with parameters of type DatabaseQuery

Modifier and Type	Method	Description
ConstructorQueryMappings	JPQLQueryHelper.getConstructorQueryMappings(AbstractSession session, DatabaseQuery query)	Retrieves the class names and the attribute names mapped to their types that are used in the constructor expressions defined in the SELECT clause.
void	HermesParser.populateQuery(CharSequence jpqlQuery, DatabaseQuery query, AbstractSession session)

Uses of DatabaseQuery in org.eclipse.persistence.internal.queries

Fields in org.eclipse.persistence.internal.queries declared as DatabaseQuery

Modifier and Type	Field	Description
DatabaseQuery	MappedKeyMapContainerPolicy.keyQuery
protected DatabaseQuery	DatabaseQueryMechanism.query	The database query that uses this mechanism.

Methods in org.eclipse.persistence.internal.queries that return DatabaseQuery

Modifier and Type	Method	Description
DatabaseQuery	MappedKeyMapContainerPolicy.getKeyQuery()	INTERNAL: Some map keys must be obtained from the database.
DatabaseQuery	DatabaseQueryMechanism.getQuery()	Return the query that uses the mechanism.

Methods in org.eclipse.persistence.internal.queries with parameters of type DatabaseQuery

Modifier and Type	Method	Description
DatabaseQueryMechanism	DatabaseQueryMechanism.clone(DatabaseQuery queryClone)	Clone the mechanism for the specified query clone.
DatabaseQueryMechanism	DatasourceCallQueryMechanism.clone(DatabaseQuery queryClone)	Clone the DatasourceCall and Vector<DatasourceCall>.
DatabaseQueryMechanism	ExpressionQueryMechanism.clone(DatabaseQuery queryClone)	Clone the mechanism for the specified query clone.
DatabaseQueryMechanism	StatementQueryMechanism.clone(DatabaseQuery queryClone)	Clone the mechanism for the specified query clone.
void	ContainerPolicy.prepare(DatabaseQuery query, AbstractSession session)	Prepare and validate.
void	MapContainerPolicy.prepare(DatabaseQuery query, AbstractSession session)	Prepare and validate.
void	MappedKeyMapContainerPolicy.setKeyQuery(DatabaseQuery keyQuery)	INTERNAL: Some map keys must be obtained from the database.
void	DatabaseQueryMechanism.setQuery(DatabaseQuery query)	Set the query that uses this mechanism.

Constructors in org.eclipse.persistence.internal.queries with parameters of type DatabaseQuery

Constructor	Description
CallQueryMechanism(DatabaseQuery query)	Initialize the state of the query
CallQueryMechanism(DatabaseQuery query, DatabaseCall call)	Initialize the state of the query
DatabaseQueryMechanism(DatabaseQuery query)	Initialize the state of the query
DatasourceCallQueryMechanism(DatabaseQuery query)	Initialize the state of the query
DatasourceCallQueryMechanism(DatabaseQuery query, DatasourceCall call)	Initialize the state of the query
ExpressionQueryMechanism(DatabaseQuery query)	Initialize the state of the query
ExpressionQueryMechanism(DatabaseQuery query, Expression expression)	Initialize the state of the query
JPQLCallQueryMechanism(DatabaseQuery query)	Initialize the state of the query
JPQLCallQueryMechanism(DatabaseQuery query, JPQLCall call)	INTERNAL Initialize the state of the query
QueryByExampleMechanism(DatabaseQuery query)	Initialize the state of the query
QueryByExampleMechanism(DatabaseQuery query, Expression expression)	Initialize the state of the query
StatementQueryMechanism(DatabaseQuery query)	INTERNAL: Return a new mechanism for the query
StatementQueryMechanism(DatabaseQuery query, SQLStatement statement)	Return a new mechanism for the query

Uses of DatabaseQuery in org.eclipse.persistence.internal.sessions

Fields in org.eclipse.persistence.internal.sessions with type parameters of type DatabaseQuery

Modifier and Type	Field	Description
protected Map<String,List<DatabaseQuery>>	AbstractSession.queries	Stores predefine reusable queries.
protected List<DatabaseQuery>	AbstractSession.tablePerTenantQueries	PERF: cache table per tenant queries needing to be initialized per EM

Methods in org.eclipse.persistence.internal.sessions that return DatabaseQuery

Modifier and Type	Method	Description
DatabaseQuery	AbstractSession.getQuery(String name)	PUBLIC: Return the query from the session pre-defined queries with the given name.
DatabaseQuery	AbstractSession.getQuery(String name, List arguments)	PUBLIC: Return the query from the session pre-defined queries with the given name and argument types.
DatabaseQuery	AbstractSession.getQuery(String name, Vector arguments)	PUBLIC: Return the query from the session pre-defined queries with the given name and argument types.
DatabaseQuery	AbstractSession.getQuery(String name, Vector arguments, boolean shouldSearchParent)	INTERNAL: Return the query from the session pre-defined queries with the given name and argument types.
DatabaseQuery	UnitOfWorkImpl.getQuery(String name)	PUBLIC: Return the query from the session pre-defined queries with the given name.
DatabaseQuery	UnitOfWorkImpl.getQuery(String name, Vector arguments)	PUBLIC: Return the query from the session pre-defined queries with the given name.
DatabaseQuery	AbstractSession.prepareDatabaseQuery(DatabaseQuery query)	INTERNAL: A call back to do session specific preparation of a query.

Methods in org.eclipse.persistence.internal.sessions that return types with arguments of type DatabaseQuery

Modifier and Type	Method	Description
List<DatabaseQuery>	AbstractSession.getAllQueries()	INTERNAL: Return the pre-defined queries in this session.
List<DatabaseQuery>	AbstractSession.getJPAQueries()	ADVANCED: Return all pre-defined not yet parsed JPQL queries.
List<DatabaseQuery>	AbstractSession.getJPATablePerTenantQueries()	ADVANCED: Return all pre-defined not yet parsed JPQL queries.
Map<String,List<DatabaseQuery>>	AbstractSession.getQueries()	ADVANCED: Return all pre-defined queries.
List<DatabaseQuery>	AbstractSession.getTablePerTenantQueries()	INTERNAL: Return list of table per tenant multitenant descriptors.

Methods in org.eclipse.persistence.internal.sessions with parameters of type DatabaseQuery

Modifier and Type	Method	Description
void	AbstractSession.addJPAQuery(DatabaseQuery query)	INTERNAL: Return all pre-defined not yet parsed EJBQL queries.
void	AbstractSession.addJPATablePerTenantQuery(DatabaseQuery query)	INTERNAL: Return all pre-defined not yet parsed EJBQL multitenant queries.
void	AbstractSession.addQuery(String name, DatabaseQuery query)	PUBLIC: Add the query to the session queries with the given name.
void	AbstractSession.addQuery(String name, DatabaseQuery query, boolean replace)	PUBLIC: Add the query to the session queries with the given name.
protected void	AbstractSession.addQuery(DatabaseQuery query, boolean nameMustBeUnique)	INTERNAL: Add the query to the session queries.
protected void	AbstractSession.addTablePerTenantQuery(DatabaseQuery query)	INTERNAL: Add a query that queries a table per tenant entity
Object	AbstractSession.basicExecuteCall(Call call, AbstractRecord translationRow, DatabaseQuery query)	INTERNAL: Execute the call on each accessors and merge the results.
void	AbstractSession.endOperationProfile(String operationName, DatabaseQuery query, int weight)	INTERNAL: End the operation timing.
Object	AbstractSession.executeCall(Call call, AbstractRecord translationRow, DatabaseQuery query)	INTERNAL: Overridden by subclasses that do more than just execute the call.
Object	UnitOfWorkImpl.executeCall(Call call, AbstractRecord translationRow, DatabaseQuery query)	INTERNAL: Override From session.
Object	AbstractSession.executeQuery(DatabaseQuery query)	PUBLIC: Execute the database query.
Object	AbstractSession.executeQuery(DatabaseQuery query, List argumentValues)	PUBLIC: Return the results from executing the database query.
Object	AbstractSession.executeQuery(DatabaseQuery query, AbstractRecord row)	INTERNAL: Return the results from executing the database query.
Object	AbstractSession.executeQuery(DatabaseQuery query, AbstractRecord row, int retryCount)	INTERNAL: Return the results from executing the database query.
Collection<Accessor>	AbstractSession.getAccessors(Call call, AbstractRecord translationRow, DatabaseQuery query)	INTERNAL: Return the connections to use for the query execution.
Collection<Accessor>	UnitOfWorkImpl.getAccessors(Call call, AbstractRecord translationRow, DatabaseQuery query)	INTERNAL: Return the connections to use for the query execution.
AbstractSession	AbstractSession.getExecutionSession(DatabaseQuery query)	INTERNAL: Gets the session which this query will be executed on.
AbstractSession	IsolatedClientSession.getExecutionSession(DatabaseQuery query)	INTERNAL: Gets the session which this query will be executed on.
AbstractSession	UnitOfWorkImpl.getExecutionSession(DatabaseQuery query)	INTERNAL: Gets the session which this query will be executed on.
AbstractSession	AbstractSession.getParentIdentityMapSession(DatabaseQuery query)	INTERNAL: Gets the next link in the chain of sessions followed by a query's check early return, the chain of sessions with identity maps all the way up to the root session.
AbstractSession	AbstractSession.getParentIdentityMapSession(DatabaseQuery query, boolean canReturnSelf, boolean terminalOnly)	INTERNAL: Gets the next link in the chain of sessions followed by a query's check early return, the chain of sessions with identity maps all the way up to the root session.
AbstractSession	AbstractSession.getRootSession(DatabaseQuery query)	INTERNAL: The session that this query is executed against when not in transaction.
void	AbstractSession.incrementProfile(String operationName, DatabaseQuery query)	INTERNAL: Updates the count of SessionProfiler event
Object	AbstractSession.internalExecuteQuery(DatabaseQuery query, AbstractRecord databaseRow)	INTERNAL: Return the results from exeucting the database query.
Object	UnitOfWorkImpl.internalExecuteQuery(DatabaseQuery query, AbstractRecord databaseRow)	INTERNAL: Return the results from executing the database query.
protected boolean	IsolatedClientSession.isIsolatedQuery(DatabaseQuery query)	INTERNAL: Answers if this query is an isolated query and must be executed locally.
DatabaseQuery	AbstractSession.prepareDatabaseQuery(DatabaseQuery query)	INTERNAL: A call back to do session specific preparation of a query.
protected void	AbstractSession.processJPAQuery(DatabaseQuery jpaQuery)	INTERNAL: Process the JPA named query into an EclipseLink Session query.
void	AbstractSession.releaseConnectionAfterCall(DatabaseQuery query)	INTERNAL: Release (if required) connection after call.
Object	AbstractSession.retryQuery(DatabaseQuery query, AbstractRecord row, DatabaseException databaseException, int retryCount, AbstractSession executionSession)	INTERNAL: A query execution failed due to an invalid query.
Object	DatabaseSessionImpl.retryQuery(DatabaseQuery query, AbstractRecord row, DatabaseException databaseException, int retryCount, AbstractSession executionSession)	INTERNAL: A query execution failed due to an invalid query.
Object	UnitOfWorkImpl.retryQuery(DatabaseQuery query, AbstractRecord row, DatabaseException databaseException, int retryCount, AbstractSession executionSession)	INTERNAL: A query execution failed due to an invalid query.
protected boolean	ExclusiveIsolatedClientSession.shouldExecuteLocally(DatabaseQuery query)	INTERNAL: Helper method to calculate whether to execute this query locally or send it to the server session.
protected boolean	IsolatedClientSession.shouldExecuteLocally(DatabaseQuery query)	INTERNAL: Helper method to calculate whether to execute this query locally or send it to the server session.
void	AbstractSession.startOperationProfile(String operationName, DatabaseQuery query, int weight)	INTERNAL: Start the operation timing.
void	UnitOfWorkImpl.storeDeferredModifyAllQuery(DatabaseQuery query, AbstractRecord translationRow)	INTERNAL: Store the deferred UpdateAllQuery's from the UoW in the list for execution.
void	UnitOfWorkImpl.storeModifyAllQuery(DatabaseQuery query)	INTERNAL: Store the ModifyAllQuery's from the UoW in the list.
void	AbstractSession.validateQuery(DatabaseQuery query)	INTERNAL: This method will be used to update the query with any settings required For this session.

Method parameters in org.eclipse.persistence.internal.sessions with type arguments of type DatabaseQuery

Modifier and Type	Method	Description
void	AbstractSession.setQueries(Map<String,List<DatabaseQuery>> queries)	INTERNAL: Set the named queries.

Uses of DatabaseQuery in org.eclipse.persistence.internal.sessions.remote

Fields in org.eclipse.persistence.internal.sessions.remote declared as DatabaseQuery

Modifier and Type	Field	Description
protected DatabaseQuery	Transporter.query

Methods in org.eclipse.persistence.internal.sessions.remote that return DatabaseQuery

Modifier and Type	Method	Description
DatabaseQuery	Transporter.getQuery()	Return the query associated with this transporter.

Methods in org.eclipse.persistence.internal.sessions.remote with parameters of type DatabaseQuery

Modifier and Type	Method	Description
Object	RemoteUnitOfWork.internalExecuteQuery(DatabaseQuery query, AbstractRecord Record)	INTERNAL: Return the results from exeucting the database query.
abstract Transporter	RemoteConnection.remoteExecute(DatabaseQuery query)	Execute query remotely.
void	Transporter.setQuery(DatabaseQuery query)	Set the query associated with this transporter

Uses of DatabaseQuery in org.eclipse.persistence.mappings

Methods in org.eclipse.persistence.mappings with parameters of type DatabaseQuery

Modifier and Type	Method	Description
protected void	CollectionMapping.executeBatchQuery(DatabaseQuery query, CacheKey parentCacheKey, Map referenceObjectsByKey, AbstractSession session, AbstractRecord translationRow)	INTERNAL: Prepare and execute the batch query and store the results for each source object in a map keyed by the mappings source keys of the source objects.
protected void	DirectCollectionMapping.executeBatchQuery(DatabaseQuery query, CacheKey parentCacheKey, Map referenceDataByKey, AbstractSession session, AbstractRecord translationRow)	INTERNAL: Prepare and execute the batch query and store the results for each source object in a map keyed by the mappings source keys of the source objects.
protected void	DirectMapMapping.executeBatchQuery(DatabaseQuery query, CacheKey parentCacheKey, Map referenceDataByKey, AbstractSession session, AbstractRecord translationRow)	INTERNAL: Prepare and execute the batch query and store the results for each source object in a map keyed by the mappings source keys of the source objects.
protected void	ForeignReferenceMapping.executeBatchQuery(DatabaseQuery query, CacheKey parentCacheKey, Map referenceObjectsByKey, AbstractSession session, AbstractRecord row)	INTERNAL: Prepare and execute the batch query and store the results for each source object in a map keyed by the mappings source keys of the source objects.
protected void	OneToOneMapping.executeBatchQuery(DatabaseQuery query, CacheKey parentCacheKey, Map referenceObjectsByKey, AbstractSession session, AbstractRecord translationRow)	INTERNAL: Prepare and execute the batch query and store the results for each source object in a map keyed by the mappings source keys of the source objects.

Uses of DatabaseQuery in org.eclipse.persistence.platform.database

Methods in org.eclipse.persistence.platform.database that return DatabaseQuery

Modifier and Type	Method	Description
DatabaseQuery	OraclePlatform.getVPDClearIdentifierQuery(String vpdIdentifier)	INTERNAL: Return an Oracle defined VPD clear identifier query.
DatabaseQuery	OraclePlatform.getVPDSetIdentifierQuery(String vpdIdentifier)	INTERNAL: Return an Oracle defined VPD set identifier query.

Uses of DatabaseQuery in org.eclipse.persistence.queries

Subclasses of DatabaseQuery in org.eclipse.persistence.queries

Modifier and Type	Class	Description
class	DataModifyQuery	Purpose: Concrete class used for executing non selecting SQL strings.
class	DataReadQuery	Purpose: Concrete class to perform read using raw SQL.
class	DeleteAllQuery	Purpose: Query used to delete a collection of objects.
class	DeleteObjectQuery	Purpose: Used for deleting objects.
class	DirectReadQuery	Purpose: Concrete class to perform a direct read.
class	DoesExistQuery	Purpose: This should only be used by the descriptor, this should not be executed directly.
class	InsertObjectQuery	Purpose: Used for inserting new objects into the database.
class	ModifyAllQuery	PUBLIC: Query used to perform a bulk delete using the expression framework.
class	ModifyQuery	Purpose: Abstract class for all modify queries.
class	ObjectBuildingQuery	Purpose: Abstract class for all read queries that build objects and potentially manipulate the TopLink cache.
class	ObjectLevelModifyQuery	Purpose: Abstract class for all object modify queries.
class	ObjectLevelReadQuery	Purpose: Abstract class for all read queries using objects.
class	ReadAllQuery	Purpose: Concrete class for all read queries involving a collection of objects.
class	ReadObjectQuery	Purpose: Concrete class for all read queries involving a single object.
class	ReadQuery	Purpose: Abstract class for all read queries.
class	ReportQuery	Purpose: Query for information about a set of objects instead of the objects themselves.
class	ResultSetMappingQuery	Purpose: Concrete class to perform read using raw SQL and the SQLResultSetMapping.
class	UpdateAllQuery	PUBLIC: A Query Class used to perform a bulk update using TopLink's expression framework.
class	UpdateObjectQuery	Purpose: Used for updating existing objects into the database.
class	ValueReadQuery	Purpose: Concrete class to perform a read of a single data value.
class	WriteObjectQuery	Purpose: Used for inserting or updating objects WriteObjectQuery determines whether to perform a insert or an update on the database.

Fields in org.eclipse.persistence.queries declared as DatabaseQuery

Modifier and Type	Field	Description
protected DatabaseQuery	JPQLCall.query

Fields in org.eclipse.persistence.queries with type parameters of type DatabaseQuery

Modifier and Type	Field	Description
protected Map<Class<?>,DatabaseQuery>	ObjectLevelReadQuery.concreteSubclassQueries	Allow concrete subclasses queries to be prepared and cached for inheritance queries.

Methods in org.eclipse.persistence.queries that return DatabaseQuery

Modifier and Type	Method	Description
DatabaseQuery	JPAQueryBuilder.buildQuery(CharSequence jpqlQuery, AbstractSession session)	Creates a fully initialized DatabaseQuery by parsing the given JPQL query.
protected DatabaseQuery	DatabaseQuery.checkForCustomQuery(AbstractSession session, AbstractRecord translationRow)	INTERNAL: Check to see if a custom query should be used for this query.
protected DatabaseQuery	DeleteObjectQuery.checkForCustomQuery(AbstractSession session, AbstractRecord translationRow)	INTERNAL: Check to see if a custom query should be used for this query.
protected DatabaseQuery	InsertObjectQuery.checkForCustomQuery(AbstractSession session, AbstractRecord translationRow)	INTERNAL: Check to see if a custom query should be used for this query.
protected DatabaseQuery	ObjectLevelReadQuery.checkForCustomQuery(AbstractSession session, AbstractRecord translationRow)	INTERNAL: Check to see if a custom query should be used for this query.
protected DatabaseQuery	ReportQuery.checkForCustomQuery(AbstractSession session, AbstractRecord translationRow)	INTERNAL: Check to see if a custom query should be used for this query.
protected DatabaseQuery	UpdateObjectQuery.checkForCustomQuery(AbstractSession session, AbstractRecord translationRow)	INTERNAL: Check to see if a custom query should be used for this query.
DatabaseQuery	JPQLCall.getQuery()	Back reference to query, unfortunately required for events.
DatabaseQuery	ObjectLevelReadQuery.prepareOutsideUnitOfWork(AbstractSession session)	INTERNAL: There is a very special case where a query may be a bean-level pessimistic locking query.

Methods in org.eclipse.persistence.queries that return types with arguments of type DatabaseQuery

Modifier and Type	Method	Description
Map<Class<?>,DatabaseQuery>	ObjectLevelReadQuery.getConcreteSubclassQueries()	INTERNAL: Return the cache of concrete subclass queries.

Methods in org.eclipse.persistence.queries with parameters of type DatabaseQuery

Modifier and Type	Method	Description
DatabaseQueryMechanism	Call.buildNewQueryMechanism(DatabaseQuery query)	INTERNAL: Return the appropriate mechanism, with the call set as necessary.
DatabaseQueryMechanism	JPQLCall.buildNewQueryMechanism(DatabaseQuery query)	INTERNAL: Return the appropriate mechanism, with the call added as necessary.
DatabaseQueryMechanism	Call.buildQueryMechanism(DatabaseQuery query, DatabaseQueryMechanism mechanism)	INTERNAL: Return the appropriate mechanism, with the call added as necessary.
DatabaseQueryMechanism	JPQLCall.buildQueryMechanism(DatabaseQuery query, DatabaseQueryMechanism mechanism)	INTERNAL: Return the appropriate mechanism, with the call added as necessary.
static Object	QueryRedirectorHelper.checkEclipseLinkCache(DatabaseQuery query, DataRecord dataRecord, Session session)	This method will cause EclipseLink to check the EclipseLink cache for the object.
protected void	DatabaseQuery.clonedQueryExecutionComplete(DatabaseQuery query, AbstractSession session)	INTERNAL Used to give the subclasses opportunity to copy aspects of the cloned query to the original query.
protected void	ModifyAllQuery.clonedQueryExecutionComplete(DatabaseQuery query, AbstractSession session)	INTERNAL Used to give the subclasses opportunity to copy aspects of the cloned query to the original query.
protected void	ObjectBuildingQuery.clonedQueryExecutionComplete(DatabaseQuery query, AbstractSession session)	INTERNAL Used to give the subclasses opportunity to copy aspects of the cloned query to the original query.
protected void	ReadQuery.clonedQueryExecutionComplete(DatabaseQuery query, AbstractSession session)	INTERNAL Used to give the subclasses opportunity to copy aspects of the cloned query to the original query.
void	DatabaseQuery.copyFromQuery(DatabaseQuery query)	INTERNAL: Copy all setting from the query.
void	ObjectBuildingQuery.copyFromQuery(DatabaseQuery query)	INTERNAL: Copy all setting from the query.
void	ObjectLevelReadQuery.copyFromQuery(DatabaseQuery query)	INTERNAL: Copy all setting from the query.
void	ReadObjectQuery.copyFromQuery(DatabaseQuery query)	INTERNAL: Copy all setting from the query.
void	ReadQuery.copyFromQuery(DatabaseQuery query)	INTERNAL: Copy all setting from the query.
protected void	MethodBaseQueryRedirector.initializeMethod(DatabaseQuery query)	INTERNAL: Set the method.
Object	MethodBaseQueryRedirector.invokeQuery(DatabaseQuery query, DataRecord arguments, Session session)	INTERNAL: Call the static method to execute the query.
Object	QueryRedirector.invokeQuery(DatabaseQuery query, DataRecord arguments, Session session)	REQUIRED: Perform the query.
void	JPAQueryBuilder.populateQuery(CharSequence jpqlQuery, DatabaseQuery query, AbstractSession session)	Populates the given DatabaseQuery by parsing the given JPQL query.
void	CursoredStreamPolicy.prepare(DatabaseQuery query, AbstractSession session)	INTERNAL: Prepare and validate.
void	CursorPolicy.prepare(DatabaseQuery query, AbstractSession session)	INTERNAL: Prepare and validate.
protected void	DatabaseQuery.prepareCustomQuery(DatabaseQuery customQuery)	INTERNAL: Set the properties needed to be cascaded into the custom query.
protected void	DeleteObjectQuery.prepareCustomQuery(DatabaseQuery customQuery)	INTERNAL: Set the properties needed to be cascaded into the custom query.
protected void	InsertObjectQuery.prepareCustomQuery(DatabaseQuery customQuery)	INTERNAL: Set the properties needed to be cascaded into the custom query.
protected void	ObjectBuildingQuery.prepareCustomQuery(DatabaseQuery customQuery)	INTERNAL: Set the properties needed to be cascaded into the custom query including the translation row.
protected void	ReadAllQuery.prepareCustomQuery(DatabaseQuery customQuery)	INTERNAL: Set the properties needed to be cascaded into the custom query.
protected void	ReadObjectQuery.prepareCustomQuery(DatabaseQuery customQuery)	INTERNAL: Set the properties needed to be cascaded into the custom query including the translation row.
protected void	UpdateObjectQuery.prepareCustomQuery(DatabaseQuery customQuery)	INTERNAL: Set the properties needed to be cascaded into the custom query.
void	DatabaseQuery.prepareFromQuery(DatabaseQuery query)	INTERNAL: Prepare the query from the prepared query.
void	ObjectBuildingQuery.prepareFromQuery(DatabaseQuery query)	INTERNAL: Prepare the query from the prepared query.
void	ObjectLevelReadQuery.prepareFromQuery(DatabaseQuery query)	INTERNAL: Prepare the query from the prepared query.
void	ReadAllQuery.prepareFromQuery(DatabaseQuery query)	INTERNAL: Prepare the query from the prepared query.
void	ReportQuery.prepareFromQuery(DatabaseQuery query)	INTERNAL: Prepare the query from the prepared query.
Object	DatabaseQuery.redirectQuery(QueryRedirector redirector, DatabaseQuery queryToRedirect, AbstractSession session, AbstractRecord translationRow)	INTERNAL: Use a EclipseLink redirector to redirect this query to a method.
void	JPQLCall.setQuery(DatabaseQuery query)	INTERNAL: Back reference to query, unfortunately required for events.

Uses of DatabaseQuery in org.eclipse.persistence.sequencing

Methods in org.eclipse.persistence.sequencing with parameters of type DatabaseQuery

Modifier and Type	Method	Description
protected Vector<Object>	QuerySequence.createArguments(DatabaseQuery query, String seqName, Number sizeOrNewValue)	INTERNAL:

Uses of DatabaseQuery in org.eclipse.persistence.sessions

Fields in org.eclipse.persistence.sessions declared as DatabaseQuery

Modifier and Type	Field	Description
protected DatabaseQuery	SessionEvent.query	Some events may have a query associated with them (pre/postExecuteQuery).

Fields in org.eclipse.persistence.sessions with type parameters of type DatabaseQuery

Modifier and Type	Field	Description
protected List<DatabaseQuery>	Project.jpaQueries	List of queries from JPA that need special processing before execution.
protected List<DatabaseQuery>	Project.jpaTablePerTenantQueries	List of queries from JPA that may special processing and handling before execution.
protected List<DatabaseQuery>	Project.queries	List of queries - once Project is initialized, these are copied to the Session.

Methods in org.eclipse.persistence.sessions that return DatabaseQuery

Modifier and Type	Method	Description
DatabaseQuery	Session.getQuery(String name)	PUBLIC: Return the query from the session pre-defined queries with the given name.
DatabaseQuery	Session.getQuery(String name, List arguments)	PUBLIC: Return the query from the session pre-defined queries with the given name.
DatabaseQuery	SessionEvent.getQuery()	PUBLIC: Some events may have a query associated with them (pre/postExecuteQuery).

Methods in org.eclipse.persistence.sessions that return types with arguments of type DatabaseQuery

Modifier and Type	Method	Description
List<DatabaseQuery>	Project.getJPAQueries()	INTERNAL: Return all pre-defined not yet parsed JPQL queries.
List<DatabaseQuery>	Session.getJPAQueries()	ADVANCED: Return all pre-defined not yet parsed EJBQL queries.
List<DatabaseQuery>	Project.getJPATablePerTenantQueries()	INTERNAL: Return all pre-defined not yet parsed JPQL queries to table per tenant entities.
List<DatabaseQuery>	Project.getQueries()	INTERNAL: List of queries that upon initialization are copied over to the session
Map<String,List<DatabaseQuery>>	Session.getQueries()	ADVANCED: Return all pre-defined queries.

Methods in org.eclipse.persistence.sessions with parameters of type DatabaseQuery

Modifier and Type	Method	Description
void	Project.addJPAQuery(DatabaseQuery query)	INTERNAL: Return all pre-defined not yet parsed EJBQL queries.
void	Session.addJPAQuery(DatabaseQuery query)	ADVANCED: Add a pre-defined not yet parsed JPQL String/query to the session to be parsed after descriptors are initialized.
void	Project.addJPATablePerTenantQuery(DatabaseQuery query)	INTERNAL: Return all pre-defined not yet parsed EJBQL queries to table per tenant entities.
void	Session.addQuery(String name, DatabaseQuery query)	PUBLIC: Add the query to the session queries with the given name.
void	SessionProfiler.endOperationProfile(String operationName, DatabaseQuery query, int weight)	INTERNAL: End the operation timing.
void	SessionProfilerAdapter.endOperationProfile(String operationName, DatabaseQuery query, int weight)	INTERNAL: End the operation timing.
Object	Session.executeQuery(DatabaseQuery query)	PUBLIC: Execute the database query.
Object	Session.executeQuery(DatabaseQuery query, List argumentValues)	PUBLIC: Return the results from executing the database query.
void	SessionProfiler.occurred(String operationName, DatabaseQuery query, AbstractSession session)	INTERNAL: Increase DMS Event sensor occurrence.(DMS)
void	SessionProfilerAdapter.occurred(String operationName, DatabaseQuery query, AbstractSession session)	INTERNAL: Increase DMS Event sensor occurrence.(DMS)
void	SessionEventManager.postExecuteQuery(DatabaseQuery query, Object result)	INTERNAL: Post execute query.
void	SessionEventManager.preExecuteQuery(DatabaseQuery query)	INTERNAL: Pre execute query.
Object	SessionProfiler.profileExecutionOfQuery(DatabaseQuery query, DataRecord row, AbstractSession session)	INTERNAL: Finish a profile operation if profiling.
Object	SessionProfilerAdapter.profileExecutionOfQuery(DatabaseQuery query, DataRecord row, AbstractSession session)	INTERNAL: Finish a profile operation if profiling.
void	SessionEvent.setQuery(DatabaseQuery query)	INTERNAL: Some events may have a query associated with them (pre/postExecuteQuery).
void	SessionProfiler.startOperationProfile(String operationName, DatabaseQuery query, int weight)	INTERNAL: Start the operation timing.
void	SessionProfilerAdapter.startOperationProfile(String operationName, DatabaseQuery query, int weight)	INTERNAL: Start the operation timing.

Method parameters in org.eclipse.persistence.sessions with type arguments of type DatabaseQuery

Modifier and Type	Method	Description
void	Project.setQueries(List<DatabaseQuery> queries)	INTERNAL:

Uses of DatabaseQuery in org.eclipse.persistence.sessions.broker

Methods in org.eclipse.persistence.sessions.broker that return DatabaseQuery

Modifier and Type	Method	Description
DatabaseQuery	SessionBroker.getQuery(String name, Vector arguments, boolean shouldSearchParent)	PUBLIC: Return the query from the session pre-defined queries with the given name and argument types.

Methods in org.eclipse.persistence.sessions.broker with parameters of type DatabaseQuery

Modifier and Type	Method	Description
Collection<Accessor>	SessionBroker.getAccessors(Call call, AbstractRecord translationRow, DatabaseQuery query)	INTERNAL: Return the low-level database accessors.
AbstractSession	SessionBroker.getExecutionSession(DatabaseQuery query)	INTERNAL: Gets the session which this query will be executed on.
protected AbstractSession	SessionBroker.getSessionForQuery(DatabaseQuery query)	INTERNAL: Answers the session to be used for the given query.
Object	SessionBroker.internalExecuteQuery(DatabaseQuery query, AbstractRecord row)	INTERNAL: Return the results from exeucting the database query.
Object	SessionBroker.retryQuery(DatabaseQuery query, AbstractRecord row, DatabaseException databaseException, int retryCount, AbstractSession executionSession)	INTERNAL: A query execution failed due to an invalid query.

Uses of DatabaseQuery in org.eclipse.persistence.sessions.factories

Methods in org.eclipse.persistence.sessions.factories with parameters of type DatabaseQuery

Modifier and Type	Method	Description
protected void	ProjectClassGenerator.addNamedQueryLines(NonreflectiveMethodDefinition method, DatabaseQuery query, DescriptorQueryManager queryManager, int iteration)

Uses of DatabaseQuery in org.eclipse.persistence.sessions.remote

Methods in org.eclipse.persistence.sessions.remote with parameters of type DatabaseQuery

Modifier and Type	Method	Description
abstract Object	DistributedSession.executeQuery(DatabaseQuery query)	Execute the database query.
Object	DistributedSession.executeQuery(DatabaseQuery query, AbstractRecord row)	INTERNAL: Execute the database query.
Object	RemoteSession.executeQuery(DatabaseQuery query)	PUBLIC: Execute the database query.

Uses of DatabaseQuery in org.eclipse.persistence.sessions.remote.rmi

Methods in org.eclipse.persistence.sessions.remote.rmi with parameters of type DatabaseQuery

Modifier and Type	Method	Description
Transporter	RMIConnection.remoteExecute(DatabaseQuery query)	INTERNAL: Execute the query on the server.

Uses of DatabaseQuery in org.eclipse.persistence.sessions.server

Methods in org.eclipse.persistence.sessions.server that return DatabaseQuery

Modifier and Type	Method	Description
DatabaseQuery	ClientSession.getQuery(String name)	INTERNAL: Was PUBLIC: customer will be redirected to Session.
DatabaseQuery	ClientSession.getQuery(String name, Vector args)	INTERNAL:

Methods in org.eclipse.persistence.sessions.server with parameters of type DatabaseQuery

Modifier and Type	Method	Description
Object	ClientSession.executeCall(Call call, AbstractRecord translationRow, DatabaseQuery query)	INTERNAL: Execute the call on the correct connection accessor.
Object	ServerSession.executeCall(Call call, AbstractRecord translationRow, DatabaseQuery query)	INTERNAL: Execute the call on the correct connection accessor.
Object	ServerSession.executeQuery(DatabaseQuery query, List argumentValues)	PUBLIC: Return the results from executing the database query.
List<Accessor>	ServerSession.getAccessors(Call call, AbstractRecord translationRow, DatabaseQuery query)	INTERNAL: Return the connections to use for the query execution.
AbstractSession	ClientSession.getExecutionSession(DatabaseQuery query)	INTERNAL: Gets the session which this query will be executed on.
AbstractSession	ServerSession.getExecutionSession(DatabaseQuery query)	INTERNAL: Gets the session which this query will be executed on.
void	ClientSession.releaseConnectionAfterCall(DatabaseQuery query)	INTERNAL: Release (if required) connection after call.
void	ServerSession.releaseConnectionAfterCall(DatabaseQuery query)	INTERNAL: Release (if required) connection after call.
Object	ClientSession.retryQuery(DatabaseQuery query, AbstractRecord row, DatabaseException databaseException, int retryCount, AbstractSession executionSession)	INTERNAL: A query execution failed due to an invalid query.
void	ServerSession.validateQuery(DatabaseQuery query)	INTERNAL: This method will be used to update the query with any settings required For this session.

Uses of DatabaseQuery in org.eclipse.persistence.tools.profiler

Methods in org.eclipse.persistence.tools.profiler with parameters of type DatabaseQuery

Modifier and Type	Method	Description
void	PerformanceMonitor.endOperationProfile(String operationName, DatabaseQuery query, int weight)	INTERNAL: End the operation timing.
void	PerformanceProfiler.endOperationProfile(String operationName, DatabaseQuery query, int weight)	INTERNAL: End the operation timing.
void	PerformanceMonitor.occurred(String operationName, DatabaseQuery query, AbstractSession session)
Object	PerformanceMonitor.profileExecutionOfQuery(DatabaseQuery query, DataRecord row, AbstractSession session)	INTERNAL: Monitoring is done on the endOperation only.
Object	PerformanceProfiler.profileExecutionOfQuery(DatabaseQuery query, DataRecord row, AbstractSession session)	INTERNAL: Finish a profile operation if profiling.
void	PerformanceMonitor.startOperationProfile(String operationName, DatabaseQuery query, int weight)	INTERNAL: Start the operation timing.
void	PerformanceProfiler.startOperationProfile(String operationName, DatabaseQuery query, int weight)	INTERNAL: Start the operation timing.

Uses of DatabaseQuery in org.eclipse.persistence.tools.schemaframework

Methods in org.eclipse.persistence.tools.schemaframework with parameters of type DatabaseQuery

Modifier and Type	Method	Description
protected StoredProcedureDefinition	StoredProcedureGenerator.generateObjectStoredProcedure(DatabaseQuery query, List<DatabaseField> fields, String namePrefix)	INTERNAL: Generates the object level stored procedure based on the passed in query
protected StoredProcedureDefinition	StoredProcedureGenerator.generateOneToManyMappingProcedures(OneToManyMapping mapping, DatabaseQuery query, Map<DatabaseField,DatabaseField> fields, String namePrefix)	INTERNAL: Generates all the stored procedures for this mapping
protected StoredProcedureDefinition	StoredProcedureGenerator.generateStoredProcedure(DatabaseQuery query, List<DatabaseField> fields, String name)	INTERNAL: Generates the stored procedure for this query.
protected StoredProcedureDefinition	StoredProcedureGenerator.generateStoredProcedure(DatabaseQuery query, List<DatabaseField> fields, AbstractRecord rowForPrepare, String name)	INTERNAL: Generates the stored procedure for this query using the row passed in for the check prepare.