| Methods Summary |
|---|
| public void | addArgument(java.lang.String argumentName)PUBLIC:
Add the argument named argumentName.
This will cause the translation of references of argumentName in the receiver's expression,
with the value of the argument as supplied to the query in order from executeQuery()
// CR#3545 - Changed the default argument type to make argument types work more consistently
// with the SDK
addArgument(argumentName, java.lang.Object.class);
|
| public void | addArgument(java.lang.String argumentName, java.lang.Class type)PUBLIC:
Add the argument named argumentName and its class type.
This will cause the translation of references of argumentName in the receiver's expression,
with the value of the argument as supplied to the query in order from executeQuery().
Specifying the class type is important if identically named queries are used but with
different argument lists.
getArguments().addElement(argumentName);
getArgumentTypes().addElement(type);
getArgumentTypeNames().addElement(type.getName());
|
| public void | addArgument(java.lang.String argumentName, java.lang.String typeAsString)PUBLIC:
Add the argument named argumentName and its class type.
This will cause the translation of references of argumentName in the receiver's expression,
with the value of the argument as supplied to the query in order from executeQuery().
Specifying the class type is important if identically named queries are used but with
different argument lists.
getArguments().addElement(argumentName);
//bug 3197587
getArgumentTypes().addElement(Helper.getObjectClass(ConversionManager.loadClass(typeAsString)));
getArgumentTypeNames().addElement(typeAsString);
|
| public void | addArgumentByTypeName(java.lang.String argumentName, java.lang.String typeAsString)INTERNAL:
Add an argument to the query, but do not resovle the class yet.
This is useful for building a query without putting the domain classes
on the classpath for the Mapping Workbench.
getArguments().addElement(argumentName);
getArgumentTypeNames().addElement(typeAsString);
|
| public void | addArgumentValue(java.lang.Object argumentValue)PUBLIC:
Add the argumentValue.
Argument values must be added in the same order the arguments are defined.
getArgumentValues().addElement(argumentValue);
|
| public void | addArgumentValues(java.util.Vector theArgumentValues)PUBLIC:
Add the argumentValues to the query.
Argument values must be added in the same order the arguments are defined.
setArgumentValues(theArgumentValues);
|
| public void | addCall(oracle.toplink.essentials.queryframework.Call call)PUBLIC:
Used to define a store procedure or SQL query.
This may be used for multiple SQL executions to be mapped to a single query.
This cannot be used for cursored selects, delete alls or does exists.
setQueryMechanism(call.buildQueryMechanism(this, getQueryMechanism()));
// Must un-prepare is prepare as the SQL may change.
setIsPrepared(false);
|
| public void | addStatement(oracle.toplink.essentials.internal.expressions.SQLStatement statement)PUBLIC:
Used to define a statement level query.
This may be used for multiple SQL executions to be mapped to a single query.
This cannot be used for cursored selects, delete alls or does exists.
// bug 3524620: lazy-init query mechanism
if (!hasQueryMechanism()) {
setQueryMechanism(new StatementQueryMechanism(this));
} else if (!getQueryMechanism().isStatementQueryMechanism()) {
setQueryMechanism(new StatementQueryMechanism(this));
}
((StatementQueryMechanism)getQueryMechanism()).getSQLStatements().addElement(statement);
// Must un-prepare is prepare as the SQL may change.
setIsPrepared(false);
|
| public void | bindAllParameters()PUBLIC:
Bind all arguments to any SQL statement.
setShouldBindAllParameters(true);
|
| protected void | buildSelectionCriteria(oracle.toplink.essentials.internal.sessions.AbstractSession session)INTERNAL:
In the case of EJBQL, an expression needs to be generated. Build the required expression.
this.getQueryMechanism().buildSelectionCriteria(session);
|
| public void | cacheStatement()PUBLIC:
Cache the prepared statements, this requires full parameter binding as well.
setShouldCacheStatement(true);
|
| public void | cascadeAllParts()PUBLIC:
Cascade the query and its properties on the queries object(s) and all objects related to the queries object(s).
This includes private and independent relationships, but not read-only relationships.
This will still stop on uninstantiated indirection objects except for deletion.
Great caution should be used in using the property as the query may effect a large number of objects.
This policy is used by the unit of work to ensure persistence by reachability.
setCascadePolicy(CascadeAllParts);
|
| public void | cascadeByMapping()PUBLIC:
Cascade the query and its properties on the queries object(s) and all related objects where the mapping has
been set to cascade the merge.
setCascadePolicy(CascadeByMapping);
|
| public void | cascadeOnlyDependentParts()INTERNAL:
Used by unit of work, only cascades constraint dependecies.
setCascadePolicy(CascadeDependentParts);
|
| public void | cascadePrivateParts()PUBLIC:
Cascade the query and its properties on the queries object(s)
and all privately owned objects related to the queries object(s).
This is the default for write and delete queries.
This policy should normally be used for refreshing, otherwise you could refresh half of any object.
setCascadePolicy(CascadePrivateParts);
|
| public void | checkDescriptor(oracle.toplink.essentials.internal.sessions.AbstractSession session)INTERNAL:
Ensure that the descriptor has been set.
|
| public java.lang.Object | checkEarlyReturn(oracle.toplink.essentials.internal.sessions.AbstractSession session, oracle.toplink.essentials.internal.sessions.AbstractRecord translationRow)INTERNAL:
Check to see if this query already knows the return vale without preforming any further work.
return null;
|
| protected oracle.toplink.essentials.queryframework.DatabaseQuery | checkForCustomQuery(oracle.toplink.essentials.internal.sessions.AbstractSession session, oracle.toplink.essentials.internal.sessions.AbstractRecord translationRow)INTERNAL:
Check to see if a custom query should be used for this query.
This is done before the query is copied and prepared/executed.
null means there is none.
return null;
|
| public void | checkPrepare(oracle.toplink.essentials.internal.sessions.AbstractSession session, oracle.toplink.essentials.internal.sessions.AbstractRecord translationRow)INTERNAL:
Check to see if this query needs to be prepare and prepare it.
The prepare is done on the original query to ensure that the work is not repeated.
// This query is first prepared for global common state, this must be synced.
if (!isPrepared()) {// Avoid the monitor is already prepare, must check again for concurrency.
// Prepared queries cannot be custom as then they would never have been prepared.
synchronized (this) {
if (!isPrepared()) {
// When custom SQL is used there is a possibility that the SQL contains the # token.
// Avoid this by telling the call if this is custom SQL with parameters.
// This must not be called for SDK calls.
if ((isReadQuery() || isDataModifyQuery()) && isCallQuery() && (getQueryMechanism() instanceof CallQueryMechanism) && ((translationRow == null) || translationRow.isEmpty())) {
// Must check for read object queries as the row will be empty until the prepare.
if (isReadObjectQuery() || isUserDefined()) {
((CallQueryMechanism)getQueryMechanism()).setCallHasCustomSQLArguments();
}
} else if (isCallQuery() && (getQueryMechanism() instanceof CallQueryMechanism)) {
((CallQueryMechanism)getQueryMechanism()).setCallHasCustomSQLArguments();
}
setSession(session);// Session is required for some init stuff.
prepare();
setSession(null);
setIsPrepared(true);// MUST not set prepare until done as other thread may hit before finihsing the prepare.
}
}
}
|
| public java.lang.Object | clone()INTERNAL:
Clone the query
try {
DatabaseQuery cloneQuery = (DatabaseQuery)super.clone();
// partial fix for 3054240
// need to pay attention to other components of the query, too MWN
if (cloneQuery.properties != null) {
if (cloneQuery.properties.isEmpty()) {
cloneQuery.setProperties(null);
} else {
cloneQuery.setProperties((Hashtable)getProperties().clone());
}
}
// bug 3524620: now that the query mechanism is lazy-init'd,
// only clone the query mechanism if we have one.
if (hasQueryMechanism()) {
cloneQuery.setQueryMechanism(getQueryMechanism().clone(cloneQuery));
}
cloneQuery.setIsPrepared(isPrepared());// Setting some things will trigger unprepare.
return cloneQuery;
} catch (CloneNotSupportedException e) {
return null;
}
|
| protected void | clonedQueryExecutionComplete(oracle.toplink.essentials.queryframework.DatabaseQuery query, oracle.toplink.essentials.internal.sessions.AbstractSession session)INTERNAL
Used to give the subclasses oportunity to copy aspects of the cloned query
to the original query.
//no-op for this class
|
| public void | convertClassNamesToClasses(java.lang.ClassLoader classLoader)INTERNAL:
Convert all the class-name-based settings in this query to actual class-based
settings
This method is implemented by subclasses as necessary.
// note: normally we would fix the argument types here, but they are already
// lazily instantiated
|
| public void | deploymentSetShouldMaintainCache(int maintainCache)INTERNAL:
Added for backwards compatibility. shouldMaintainCache used to be tri-state and was converted to boolean.
This method is used by deployment XML to properly convert the tri-state variable to a boolean
Added for Bug 4034159
// FalseUndefinedTrue.Undefined is intentionally left ignored so it will map to the default.
if (maintainCache == FalseUndefinedTrue.True) {
setShouldMaintainCache(true);
} else if (maintainCache == FalseUndefinedTrue.False) {
setShouldMaintainCache(false);
}
|
| public int | deploymentShouldMaintainCache()INTERNAL:
Added for backwards compatibility. shouldMaintainCache used to be tri-state and was converted to boolean.
This method is used by deployment XML to properly convert the tri-state variable to a boolean
Added for Bug 4034159
if (shouldMaintainCache()) {
return FalseUndefinedTrue.True;
} else {
return FalseUndefinedTrue.False;
}
|
| public void | dontBindAllParameters()PUBLIC:
Do not Bind all arguments to any SQL statement.
setShouldBindAllParameters(false);
|
| public void | dontCacheStatement()PUBLIC:
Dont cache the prepared statements, this requires full parameter binding as well.
setShouldCacheStatement(false);
|
| public void | dontCascadeParts()PUBLIC:
Do not cascade the query and its properties on the queries object(s) relationships.
This does not effect the queries private parts but only the object(s) direct row-level attributes.
This is the default for read queries and can be used in writting if it is known that only
row-level attributes changed, or to resolve circular foreign key dependencies.
setCascadePolicy(NoCascading);
|
| public void | dontMaintainCache()PUBLIC:
Set for the identity map (cache) to be ignored completely.
The cache check will be skipped and the result will not be put into the identity map.
This can be used to retreive the exact state of an object on the database.
By default the identity map is always maintained.
setShouldMaintainCache(false);
|
| public java.lang.Object | execute(oracle.toplink.essentials.internal.sessions.AbstractSession session, oracle.toplink.essentials.internal.sessions.AbstractRecord translationRow)INTERNAL:
Execute the query. If there are objects in the cache return the results
of the cache lookup.
DatabaseQuery queryToExecute = this;
// Profile the query preparation time.
session.startOperationProfile(SessionProfiler.QUERY_PREPARE);
// This allows the query to check the cache or return early without doing any work.
Object earlyReturn = queryToExecute.checkEarlyReturn(session, translationRow);
if ((earlyReturn != null) || (isReadObjectQuery() && ((ReadObjectQuery)this).shouldCheckCacheOnly())) {
// Profile the query preparation time.
session.endOperationProfile(SessionProfiler.QUERY_PREPARE);
return earlyReturn;
}
boolean hasCustomQuery = false;
if (!isPrepared() && shouldPrepare()) {
// Prepared queries cannot be custom as then they would never have been prepared.
DatabaseQuery customQuery = checkForCustomQuery(session, translationRow);
if (customQuery != null) {
hasCustomQuery = true;
// The custom query will be used not the original.
queryToExecute = customQuery;
}
}
// Sometimes a session will clone the query and mutate the clone. If so
// don't need to clone again.
// All queries on a HistoricalSession become historical queries.
// On a ServerSession bean-level pessimistic locking queries need to
// be replaced with non-locking versions.
boolean alreadyClonedQuery = false;
DatabaseQuery sessionPreparedQuery = session.prepareDatabaseQuery(queryToExecute);
if (sessionPreparedQuery != queryToExecute) {
queryToExecute = sessionPreparedQuery;
alreadyClonedQuery = true;
}
if (queryToExecute.shouldPrepare()) {
queryToExecute.checkPrepare(session, translationRow);
}
// Then cloned for concurrency and repeatable execution.
if (!alreadyClonedQuery) {
queryToExecute = (DatabaseQuery)queryToExecute.clone();
}
queryToExecute.setTranslationRow(translationRow);
// If the prepare has been disbale the clone is prepare dynamically to not parameterize the SQL.
if (!queryToExecute.shouldPrepare()) {
queryToExecute.checkPrepare(session, translationRow);
}
queryToExecute.setSession(session);
if (hasCustomQuery) {
prepareCustomQuery(queryToExecute);
}
queryToExecute.prepareForExecution();
// Profile the query preparation time.
session.endOperationProfile(SessionProfiler.QUERY_PREPARE);
// Then executed.
Object result = queryToExecute.executeDatabaseQuery();
//give the subclasses the oportunity to retreive aspects of the cloned query
clonedQueryExecutionComplete(queryToExecute, session);
return result;
|
| public abstract java.lang.Object | executeDatabaseQuery()INTERNAL:
Execute the query
|
| public java.lang.Object | executeInUnitOfWork(oracle.toplink.essentials.internal.sessions.UnitOfWorkImpl unitOfWork, oracle.toplink.essentials.internal.sessions.AbstractRecord translationRow)INTERNAL:
Override query execution where Session is a UnitOfWork.
If there are objects in the cache return the results of the cache lookup.
return execute(unitOfWork, translationRow);
|
| public oracle.toplink.essentials.internal.databaseaccess.Accessor | getAccessor()INTERNAL:
Return the accessor.
return accessor;
|
| public java.util.Vector | getArgumentTypeNames()INTERNAL:
Return the argumentTypeNames for use with the pre-defined query option
These are used pre-initialization to construct the argumentTypes list.
if (argumentTypeNames == null) {
argumentTypeNames = oracle.toplink.essentials.internal.helper.NonSynchronizedVector.newInstance();
}
return argumentTypeNames;
|
| public java.util.Vector | getArgumentTypes()INTERNAL:
Return the argumentTypes for use with the pre-defined query option
if ((argumentTypes == null) || argumentTypes.isEmpty()) {
argumentTypes = new Vector();
// Bug 3256198 - lazily initialize the argument types from their class names
if (argumentTypeNames != null) {
Iterator args = argumentTypeNames.iterator();
while (args.hasNext()) {
String argumentTypeName = (String)args.next();
argumentTypes.addElement(Helper.getObjectClass(ConversionManager.loadClass(argumentTypeName)));
}
}
}
return argumentTypes;
|
| public java.util.Vector | getArgumentValues()INTERNAL:
Return the argumentValues for use with the
pre-defined query option
if (argumentValues == null) {
argumentValues = oracle.toplink.essentials.internal.helper.NonSynchronizedVector.newInstance();
}
return argumentValues;
|
| public java.util.Vector | getArguments()INTERNAL:
Return the arguments for use with the pre-defined query option
if (arguments == null) {
arguments = oracle.toplink.essentials.internal.helper.NonSynchronizedVector.newInstance();
}
return arguments;
|
| public oracle.toplink.essentials.internal.databaseaccess.DatabaseCall | getCall()INTERNAL:
Return the call for this query.
This call contains the SQL and argument list.
Call call = getDatasourceCall();
if (call instanceof DatabaseCall) {
return (DatabaseCall)call;
} else {
return null;
}
|
| public int | getCascadePolicy()INTERNAL:
Return the cascade policy.
return cascadePolicy;
|
| public oracle.toplink.essentials.queryframework.Call | getDatasourceCall()ADVANCED:
Return the call for this query.
This call contains the SQL and argument list.
Call call = null;
if (getQueryMechanism() instanceof DatasourceCallQueryMechanism) {
DatasourceCallQueryMechanism mechanism = (DatasourceCallQueryMechanism)getQueryMechanism();
call = mechanism.getCall();
// If has multiple calls return the first one.
if (mechanism.hasMultipleCalls()) {
call = (Call)mechanism.getCalls().get(0);
}
}
if ((call == null) && getQueryMechanism().isEJBQLCallQueryMechanism()) {
call = ((EJBQLCallQueryMechanism)getQueryMechanism()).getEJBQLCall();
}
return call;
|
| public java.util.List | getDatasourceCalls()ADVANCED:
Return the calls for this query. This method can be called for queries with multiple calls
This call contains the SQL and argument list.
List calls = new Vector();
if (getQueryMechanism() instanceof DatasourceCallQueryMechanism) {
DatasourceCallQueryMechanism mechanism = (DatasourceCallQueryMechanism)getQueryMechanism();
// If has multiple calls return the first one.
if (mechanism.hasMultipleCalls()) {
calls = mechanism.getCalls();
} else {
calls.add(mechanism.getCall());
}
}
if ((calls.isEmpty()) && getQueryMechanism().isEJBQLCallQueryMechanism()) {
calls.add(((EJBQLCallQueryMechanism)getQueryMechanism()).getEJBQLCall());
}
return calls;
|
| public oracle.toplink.essentials.descriptors.ClassDescriptor | getDescriptor()INTERNAL:
Return the descriptor assigned with the reference class
return descriptor;
|
| public java.lang.String | getEJBQLString()PUBLIC:
Return the SQL string of the query.
This can be used for SQL queries.
ADVANCED:
This can also be used for normal queries if they have been prepared, (i.e. query.prepareCall()).
if (!(getQueryMechanism().isEJBQLCallQueryMechanism())) {
return null;
}
EJBQLCall call = (EJBQLCall)((EJBQLCallQueryMechanism)getQueryMechanism()).getEJBQLCall();
return call.getEjbqlString();
|
| public java.lang.Boolean | getFlushOnExecute()PUBLIC:
If executed against a RepeatableWriteUnitOfWork if this attribute is true
TopLink will write changes to the database before executing the query.
return this.flushOnExecute;
|
| public java.lang.String | getName()PUBLIC:
Return the name of the query
return name;
|
| public java.util.Hashtable | getProperties()INTERNAL:
Property support for use by mappings.
if (properties == null) {//Lazy initialize to conserve space and allocation time.
properties = new Hashtable(5);
}
return properties;
|
| public synchronized java.lang.Object | getProperty(java.lang.Object property)INTERNAL:
Property support used by mappings to stach temporary stuff in the query.
if (properties == null) {
return null;
}
return getProperties().get(property);
|
| public oracle.toplink.essentials.internal.queryframework.DatabaseQueryMechanism | getQueryMechanism()INTERNAL:
Return the mechanism assigned to the query
// Bug 3524620 - lazy init
if (queryMechanism == null) {
queryMechanism = new ExpressionQueryMechanism(this);
}
return queryMechanism;
|
| public java.lang.Class | getReferenceClass()PUBLIC:
Return the domain class associated with this query.
By default this is null, but should be overridden in subclasses.
return null;
|
| public java.lang.String | getReferenceClassName()INTERNAL:
return the name of the reference class. Added for Mapping Workbench removal
of classpath dependancy. Overriden by subclasses.
return null;
|
| public oracle.toplink.essentials.internal.expressions.SQLStatement | getSQLStatement()PUBLIC:
Return the SQL statement of the query.
This can only be used with statement queries.
return ((StatementQueryMechanism)getQueryMechanism()).getSQLStatement();
|
| public java.lang.String | getSQLString()PUBLIC:
Return the SQL string of the query.
This can be used for SQL queries.
ADVANCED:
This can also be used for normal queries if they have been prepared, (i.e. query.prepareCall()).
Call call = getDatasourceCall();
if (call == null) {
return null;
}
if (!(call instanceof SQLCall)) {
return null;
}
return ((SQLCall)call).getSQLString();
|
| public java.util.List | getSQLStrings()PUBLIC:
Return the SQL strings of the query. Used for queries with multiple calls
This can be used for SQL queries.
ADVANCED:
This can also be used for normal queries if they have been prepared, (i.e. query.prepareCall()).
List calls = getDatasourceCalls();
if ((calls == null) || calls.isEmpty()) {
return null;
}
Vector returnSQL = new Vector(calls.size());
Iterator iterator = calls.iterator();
while (iterator.hasNext()) {
Call call = (Call)iterator.next();
if (!(call instanceof SQLCall)) {
return null;
}
returnSQL.addElement(((SQLCall)call).getSQLString());
}
return returnSQL;
|
| public oracle.toplink.essentials.expressions.Expression | getSelectionCriteria()PUBLIC:
Return the selection criteria of the query.
This should only be used with expression queries, null will be returned for others.
return getQueryMechanism().getSelectionCriteria();
|
| public oracle.toplink.essentials.internal.sessions.AbstractSession | getSession()INTERNAL:
Return the current session.
return session;
|
| public java.lang.String | getSessionName()PUBLIC:
Return the name of the session that the query should be executed under.
This can be with the session broker to override the default session.
return sessionName;
|
| public int | getShouldBindAllParameters()INTERNAL:
Returns the internal tri-state calue of shouldBindParameters
used far cascading these settings
return this.shouldBindAllParameters;
|
| public java.lang.String | getTranslatedSQLString(oracle.toplink.essentials.sessions.Session session, oracle.toplink.essentials.sessions.Record translationRow)ADVANCED:
This can be used to access a queries translated SQL if they have been prepared, (i.e. query.prepareCall()).
The Record argument is one of (DatabaseRow, XMLRecord) that contains the query arguments.
//CR#2859559 fix to use Session and Record interfaces not impl classes.
CallQueryMechanism queryMechanism = (CallQueryMechanism)getQueryMechanism();
if (queryMechanism.getCall() == null) {
return null;
}
SQLCall call = (SQLCall)queryMechanism.getCall().clone();
call.translate((AbstractRecord)translationRow, queryMechanism.getModifyRow(), (AbstractSession)session);
return call.getSQLString();
|
| public java.util.List | getTranslatedSQLStrings(oracle.toplink.essentials.sessions.Session session, oracle.toplink.essentials.sessions.Record translationRow)ADVANCED:
This can be used to access a queries translated SQL if they have been prepared, (i.e. query.prepareCall()).
This method can be used for queries with multiple calls.
CallQueryMechanism queryMechanism = (CallQueryMechanism)getQueryMechanism();
if ((queryMechanism.getCalls() == null) || queryMechanism.getCalls().isEmpty()) {
return null;
}
Vector calls = new Vector(queryMechanism.getCalls().size());
Iterator iterator = queryMechanism.getCalls().iterator();
while (iterator.hasNext()) {
SQLCall call = (SQLCall)iterator.next();
call = (SQLCall)call.clone();
call.translate((AbstractRecord)translationRow, queryMechanism.getModifyRow(), (AbstractSession)session);
calls.addElement(call.getSQLString());
}
return calls;
|
| public oracle.toplink.essentials.internal.sessions.AbstractRecord | getTranslationRow()INTERNAL:
Return the row for translation
return translationRow;
|
| public boolean | hasAccessor()INTERNAL:
returns true if the accessor has already been set. The getAccessor() will attempt to
lazily initialzie it.
return accessor != null;
|
| public boolean | hasProperties()INTERNAL:
Return if any properties exist in the query.
return (properties != null) && (!properties.isEmpty());
|
| public boolean | hasQueryMechanism()INTERNAL:
Check if the mechanism has been set yet, used for lazy init.
return (queryMechanism != null);
|
| public boolean | hasSessionName()PUBLIC:
Return if a name of the session that the query should be executed under has been specified.
This can be with the session broker to override the default session.
return sessionName != null;
|
| public void | ignoreBindAllParameters()PUBLIC:
Session's shouldBindAllParameters() defines whether to bind or not
(default setting)
this.shouldBindAllParameters = Undefined;
|
| public void | ignoreCacheStatement()PUBLIC:
Session's shouldCacheAllStatements() defines whether to cache or not
(default setting)
this.shouldCacheStatement = Undefined;
|
| public boolean | isCallQuery()PUBLIC:
Return true if this query uses an SQL or stored procedure, or SDK call.
return getQueryMechanism().isCallQueryMechanism();
|
| public boolean | isCascadeOfAggregateDelete()INTERNAL:
Returns true if this query has been created as the result of cascading a delete of an aggregate collection
in a UnitOfWork
CR 2811
return getCascadePolicy() == CascadeAggregateDelete;
|
| public boolean | isDataModifyQuery()PUBLIC:
Return if this is a data modify query.
return false;
|
| public boolean | isDataReadQuery()PUBLIC:
Return if this is a data read query.
return false;
|
| public boolean | isDeleteAllQuery()PUBLIC:
Return if this is a delete all query.
return false;
|
| public boolean | isDeleteObjectQuery()PUBLIC:
Return if this is a delete object query.
return false;
|
| public boolean | isExpressionQuery()PUBLIC:
Return true if this query uses an expression query mechanism
return getQueryMechanism().isExpressionQueryMechanism();
|
| public boolean | isInsertObjectQuery()PUBLIC:
Return true if this is an insert object query.
return false;
|
| public boolean | isModifyAllQuery()PUBLIC:
Return true if this is a modify all query.
return false;
|
| public boolean | isModifyQuery()PUBLIC:
Return true if this is a modify query.
return false;
|
| public boolean | isObjectBuildingQuery()PUBLIC:
Return if this is an object building query.
return true;
|
| public boolean | isObjectLevelModifyQuery()PUBLIC:
Return true if this is an object level modify query.
return false;
|
| public boolean | isObjectLevelReadQuery()PUBLIC:
Return true if this is an object level read query.
return false;
|
| public boolean | isPrepared()INTERNAL:
Queries are prepared when they are executed and then do not need to be
prepared on subsequent executions. This method returns true if this
query has been prepared. Updating the settings on a query will 'un-prepare'
the query.
return isPrepared;
|
| public boolean | isReadAllQuery()PUBLIC:
Return true if this is a read all query.
return false;
|
| public boolean | isReadObjectQuery()PUBLIC:
Return ture if this is a read object query.
return false;
|
| public boolean | isReadQuery()PUBLIC:
Return true if this is a read query.
return false;
|
| public boolean | isReportQuery()PUBLIC:
Return true if this is a report query.
return false;
|
| public boolean | isSQLCallQuery()PUBLIC:
Return true if this query uses an SQL query mechanism .
// BUG#2669342 CallQueryMechanism and isCallQueryMechanism have different meaning as SDK return true but isn't.
Call call = getDatasourceCall();
return (call != null) && (call instanceof SQLCall);
|
| public boolean | isUpdateAllQuery()PUBLIC:
Return true if this is an update all query.
return false;
|
| public boolean | isUpdateObjectQuery()PUBLIC:
Return true if this is an update object query.
return false;
|
| public boolean | isUserDefined()INTERNAL:
Return true if the query is a custom user defined query.
return isUserDefined;
|
| public boolean | isWriteObjectQuery()PUBLIC:
Return true if this is a write object query.
return false;
|
| public void | maintainCache()PUBLIC:
Set for the identity map (cache) to be maintained.
This is the default.
setShouldMaintainCache(true);
|
| protected void | prepare()INTERNAL:
This is different from 'prepareForExecution' in that this is called on the original query,
and the other is called on the copy of the query.
This query is copied for concurrency so this prepare can only setup things that
will apply to any future execution of this query.
Resolve the queryTimeout using the DescriptorQueryManager if required.
getQueryMechanism().prepare();
|
| public void | prepareCall(oracle.toplink.essentials.sessions.Session session, oracle.toplink.essentials.sessions.Record translationRow)ADVANCED:
Pre-generate the call/SQL for the query.
This method takes a Session and an implementor of Record (DatebaseRow or XMLRecord).
This can be used to access the SQL for a query without executing it.
To access the call use, query.getCall(), or query.getSQLString() for the SQL.
Note the SQL will have argument markers in it (i.e. "?").
To translate these use query.getTranslatedSQLString(session, translationRow).
//CR#2859559 fix to use Session and Record interfaces not impl classes.
checkPrepare((AbstractSession)session, (AbstractRecord)translationRow);
|
| protected void | prepareCustomQuery(oracle.toplink.essentials.queryframework.DatabaseQuery customQuery)INTERNAL:
Set the properties needed to be cascaded into the custom query.
// Nothing by default.
|
| public void | prepareForExecution()INTERNAL:
Prepare the receiver for execution in a session. In particular,
set the descriptor of the receiver to the Descriptor for the
appropriate class for the receiver's object.
getQueryMechanism().prepareForExecution();
|
| protected void | prepareForRemoteExecution()
;
|
| public void | removeProperty(java.lang.Object property)INTERNAL:
Property support used by mappings.
getProperties().remove(property);
|
| public oracle.toplink.essentials.internal.sessions.AbstractRecord | rowFromArguments(java.util.Vector argumentValues)INTERNAL:
Translate argumentValues into a database row.
Vector argumentNames = getArguments();
if (argumentNames.size() != argumentValues.size()) {
throw QueryException.argumentSizeMismatchInQueryAndQueryDefinition(this);
}
AbstractRecord row = new DatabaseRecord();
for (int index = 0; index < argumentNames.size(); index++) {
String argumentName = (String)argumentNames.elementAt(index);
Object argumentValue = argumentValues.elementAt(index);
row.put(new DatabaseField(argumentName), argumentValue);
}
return row;
|
| public void | setAccessor(oracle.toplink.essentials.internal.databaseaccess.Accessor accessor)INTERNAL:
Set the accessor, the query must always use the same accessor for database access.
This is required to support connection pooling.
this.accessor = accessor;
|
| public void | setArgumentTypeNames(java.util.Vector argumentTypeNames)INTERNAL:
Set the argumentTypes for use with the pre-defined query option
this.argumentTypeNames = argumentTypeNames;
|
| public void | setArgumentTypes(java.util.Vector argumentTypes)INTERNAL:
Set the argumentTypes for use with the pre-defined query option
this.argumentTypes = argumentTypes;
// bug 3256198 - ensure the list of type names matches the argument types.
getArgumentTypeNames().clear();
Iterator types = argumentTypes.iterator();
while (types.hasNext()) {
argumentTypeNames.addElement(((Class)types.next()).getName());
}
|
| public void | setArgumentValues(java.util.Vector theArgumentValues)INTERNAL:
Return the argumentValues for use with the
pre-defined query option
argumentValues = theArgumentValues;
|
| public void | setArguments(java.util.Vector arguments)INTERNAL:
Set the arguments for use with the pre-defined query option.
Maintain the argumentTypes as well.
for (Enumeration enumtr = arguments.elements(); enumtr.hasMoreElements();) {
// Maintain the argumentTypes as well
addArgument((String)enumtr.nextElement());
}
|
| public void | setCall(oracle.toplink.essentials.queryframework.Call call)PUBLIC:
Used to define a store procedure or SQL query.
setDatasourceCall(call);
|
| public void | setCascadePolicy(int policyConstant)INTERNAL:
Set the cascade policy.
cascadePolicy = policyConstant;
|
| public void | setDatasourceCall(oracle.toplink.essentials.queryframework.Call call)PUBLIC:
Used to define a store procedure or SQL query.
if (call == null) {
return;
}
setQueryMechanism(call.buildNewQueryMechanism(this));
|
| public void | setDescriptor(oracle.toplink.essentials.descriptors.ClassDescriptor descriptor)INTERNAL:
Set the descriptor for the query.
// If the descriptor changed must unprepare as the SQL may change.
if (this.descriptor != descriptor) {
setIsPrepared(false);
}
this.descriptor = descriptor;
|
| public void | setEJBQLString(java.lang.String ejbqlString)PUBLIC:
To any user of this object. Set the EJBQL string of the query.
If arguments are required in the string they will be preceeded by "?" then the argument number.
//Added the check for when we are building the query from the deployment XML
if ((ejbqlString != null) && (!ejbqlString.equals(""))) {
EJBQLCallQueryMechanism mechanism = new EJBQLCallQueryMechanism(this, new EJBQLCall(ejbqlString));
setQueryMechanism(mechanism);
}
|
| public void | setFlushOnExecute(java.lang.Boolean flushMode)PUBLIC:
If executed against a RepeatableWriteUnitOfWork if this attribute is true
TopLink will write changes to the database before executing the query.
this.flushOnExecute = flushMode;
|
| public void | setIsPrepared(boolean isPrepared)INTERNAL:
If changes are made to the query that affect the derived SQL or Call
parameters the query needs to be prepared again.
Automatically called internally.
this.isPrepared = isPrepared;
|
| public void | setIsUserDefined(boolean isUserDefined)INTERNAL:
Set if the query is a custom user defined query.
this.isUserDefined = isUserDefined;
|
| public void | setName(java.lang.String queryName)PUBLIC:
Set the query's name.
Queries can be named and added to a descriptor or the session and then referenced by name.
name = queryName;
|
| public void | setProperties(java.util.Hashtable properties)INTERNAL:
Property support used by mappings.
this.properties = properties;
|
| public synchronized void | setProperty(java.lang.Object property, java.lang.Object value)INTERNAL:
Property support used by mappings to stache temporary stuff.
getProperties().put(property, value);
|
| protected void | setQueryMechanism(oracle.toplink.essentials.internal.queryframework.DatabaseQueryMechanism queryMechanism)Set the query mechanism for the query.
this.queryMechanism = queryMechanism;
// Must un-prepare is prepare as the SQL may change.
setIsPrepared(false);
|
| public void | setSQLStatement(oracle.toplink.essentials.internal.expressions.SQLStatement sqlStatement)PUBLIC:
To any user of this object. Set the SQL statement of the query.
This method should only be used when dealing with statement objects.
setQueryMechanism(new StatementQueryMechanism(this, sqlStatement));
|
| public void | setSQLString(java.lang.String sqlString)PUBLIC:
To any user of this object. Set the SQL string of the query.
This method should only be used when dealing with user defined SQL strings.
If arguments are required in the string they will be preceeded by "#" then the argument name.
//Added the check for when we are building the query from the deployment XML
if ((sqlString != null) && (!sqlString.equals(""))) {
setCall(new SQLCall(sqlString));
}
|
| public void | setSelectionCriteria(oracle.toplink.essentials.expressions.Expression expression)PUBLIC:
To any user of this object. Set the selection criteria of the query.
This method be used when dealing with expressions.
// Do not overwrite the call if the expression is null.
if ((expression == null) && (!getQueryMechanism().isExpressionQueryMechanism())) {
return;
}
if (!getQueryMechanism().isExpressionQueryMechanism()) {
setQueryMechanism(new ExpressionQueryMechanism(this, expression));
} else {
((ExpressionQueryMechanism)getQueryMechanism()).setSelectionCriteria(expression);
}
// Must un-prepare is prepare as the SQL may change.
setIsPrepared(false);
|
| public void | setSession(oracle.toplink.essentials.internal.sessions.AbstractSession session)INTERNAL:
Set the session for the query
this.session = session;
|
| public void | setSessionName(java.lang.String sessionName)PUBLIC:
Set the name of the session that the query should be executed under.
This can be with the session broker to override the default session.
this.sessionName = sessionName;
|
| public void | setShouldBindAllParameters(boolean shouldBindAllParameters)PUBLIC:
Bind all arguments to any SQL statement.
if (shouldBindAllParameters) {
this.shouldBindAllParameters = True;
} else {
this.shouldBindAllParameters = False;
}
setIsPrepared(false);
|
| public void | setShouldBindAllParameters(int bindAllParams)INTERNAL:
Sets the internal tri-state value of shouldBindAllParams
Used to cascade this value to alther queries
this.shouldBindAllParameters = bindAllParams;
|
| public void | setShouldCacheStatement(boolean shouldCacheStatement)PUBLIC:
Cache the prepared statements, this requires full parameter binding as well.
if (shouldCacheStatement) {
this.shouldCacheStatement = True;
} else {
this.shouldCacheStatement = False;
}
setIsPrepared(false);
|
| public void | setShouldMaintainCache(boolean shouldMaintainCache)PUBLIC:
Set if the identity map (cache) should be used or not.
If not the cache check will be skipped and the result will not be put into the identity map.
By default the identity map is always maintained.
this.shouldMaintainCache = shouldMaintainCache;
|
| public void | setShouldPrepare(boolean shouldPrepare)PUBLIC:
Set if the query should be prepared.
TopLink automatically prepares queries to generate their SQL only once,
one each execution of the query the SQL does not need to be generated again only the arguments need to be translated.
This option is provide to disable this optimization as in can cause problems with certain types of queries that require dynamic SQL basd on their arguments.
These queries include:
- Expressions that make use of 'equal' where the argument value has the potential to be null, this can cause problems on databases that require IS NULL, instead of = NULL.
- Expressions that make use of 'in' and that use parameter binding, this will cause problems as the in values must be bound individually.
this.shouldPrepare = shouldPrepare;
setIsPrepared(false);
|
| public void | setShouldUseWrapperPolicy(boolean shouldUseWrapperPolicy)ADVANCED:
The wrapper policy can be enable on a query.
this.shouldUseWrapperPolicy = shouldUseWrapperPolicy;
|
| public void | setTranslationRow(oracle.toplink.essentials.internal.sessions.AbstractRecord translationRow)INTERNAL:
Set the row for translation
this.translationRow = translationRow;
|
| public boolean | shouldBindAllParameters()PUBLIC:
Bind all arguments to any SQL statement.
return shouldBindAllParameters == True;
|
| public boolean | shouldCacheStatement()PUBLIC:
Cache the prepared statements, this requires full parameter binding as well.
return shouldCacheStatement == True;
|
| public boolean | shouldCascadeAllParts()PUBLIC:
Flag used to determine if all parts should be cascaded
return getCascadePolicy() == CascadeAllParts;
|
| public boolean | shouldCascadeByMapping()PUBLIC:
Mappings should be checked to determined if the current operation should be
cascaded to the objects referenced.
return getCascadePolicy() == CascadeByMapping;
|
| public boolean | shouldCascadeOnlyDependentParts()INTERNAL:
Flag used for unit of works cascade policy.
return getCascadePolicy() == CascadeDependentParts;
|
| public boolean | shouldCascadeParts()PUBLIC:
Flag used to determine if any parts should be cascaded
return getCascadePolicy() != NoCascading;
|
| public boolean | shouldCascadePrivateParts()PUBLIC:
Flag used to determine if any private parts should be cascaded
return (getCascadePolicy() == CascadePrivateParts) || (getCascadePolicy() == CascadeAllParts);
|
| public boolean | shouldCloneCall()INTERNAL:
Flag used to determine if the call needs to be cloned.
return shouldCloneCall;
|
| public boolean | shouldIgnoreBindAllParameters()PUBLIC:
Local shouldBindAllParameters() should be ignored,
Session's shouldBindAllParameters() should be used.
return shouldBindAllParameters == Undefined;
|
| public boolean | shouldIgnoreCacheStatement()PUBLIC:
Local shouldCacheStatement() should be ignored,
Session's shouldCacheAllStatements() should be used.
return shouldCacheStatement == Undefined;
|
| public boolean | shouldMaintainCache()PUBLIC:
Return if the identity map (cache) should be used or not.
If not the cache check will be skipped and the result will not be put into the identity map.
By default the identity map is always maintained.
return shouldMaintainCache;
|
| public boolean | shouldPrepare()PUBLIC:
Return if the query should be prepared.
TopLink automatically prepares queries to generate their SQL only once,
one each execution of the query the SQL does not need to be generated again only the arguments need to be translated.
This option is provide to disable this optimization as in can cause problems with certain types of queries that require dynamic SQL basd on their arguments.
These queries include:
- Expressions that make use of 'equal' where the argument value has the potential to be null, this can cause problems on databases that require IS NULL, instead of = NULL.
- Expressions that make use of 'in' and that use parameter binding, this will cause problems as the in values must be bound individually.
return shouldPrepare;
|
| public boolean | shouldUseWrapperPolicy()ADVANCED:
The wrapper policy can be enabled on a query.
return shouldUseWrapperPolicy;
|
| public java.lang.String | toString()
return Helper.getShortClassName(getClass()) + "()";
|
