|
| |
|
| java.lang.Object
 org.objectweb.speedo.query.jdo.JDOQueryDefinitionImpl
org.objectweb.speedo.query.jdo.JDOQuery
| JDOQuery | | public class JDOQuery extends JDOQueryDefinitionImpl implements Query(Code) | | SpeedoQuery is the basic implementation of the javax.jdo.Query interface.
This class is just a wrapper to a SpeedoCompiledQuery object which is a
reused object.
author:
S. Chassande-Barrioz |
| modifiable | | boolean modifiable(Code) | | |
| JDOQuery | | public JDOQuery()(Code) | | |
| close | | public void close(Object queryResult)(Code) | | Close a query result and release any resources
associated with it. The parameter is the return from execute(...) and
might have iterators open on it. Iterators associated with the query
result are invalidated: they return false to hasNext() and throw
NoSuchElementException to next().
This method makes nothing, all is done by the SpeedoCompiledQuery
object. This object is never closed, and could be reused in the
future.
Parameters:
queryResult - the result of execute(...) on this Query instance. |
| closeAll | | public void closeAll()(Code) | | Close all query results associated with this Query
instance, and release all resources associated with them. The query
results might have iterators open on them. Iterators associated with the
query results are invalidated: they return false to hasNext() and throw
NoSuchElementException to next().
|
| compile | | public void compile()(Code) | | Verify the elements of the query and provide a hint to
the query to prepare and optimize an execution plan.
|
| declareImports | | public void declareImports(String imports)(Code) | | Set the import statements to be used to identify the fully qualified name of
variables or parameters. Parameters and unbound variables might
come from a different class from the candidate class, and the names
need to be declared in an import statement to eliminate ambiguity.
Import statements are specified as a String with semicolon-separated
statements.
The String parameter to this method follows the syntax of the
import statement of the Java language.
Parameters:
imports - import statements separated by semicolons. |
| declareParameters | | public void declareParameters(String parameters)(Code) | | Declare the list of parameters query execution.
The parameter declaration is a String containing one or more query
parameter declarations separated with commas. Each parameter named
in the parameter declaration must be bound to a value when
the query is executed.
The String parameter to this method follows the syntax for formal
parameters in the Java language.
Parameters:
parameters - the list of parameters separated by commas. |
| declareVariables | | public void declareVariables(String variables)(Code) | | Declare the unbound variables to be used in the query. Variables
might be used in the filter, and these variables must be declared
with their type. The unbound variable declaration is a String
containing one or more unbound variable declarations separated
with semicolons. It follows the syntax for local variables in
the Java language.
Parameters:
variables - the variables separated by semicolons. |
| deletePersistentAll | | public long deletePersistentAll()(Code) | | |
| deletePersistentAll | | public long deletePersistentAll(Map params)(Code) | | |
| deletePersistentAll | | public long deletePersistentAll(Object[] params)(Code) | | |
| executeWithArray | | public Object executeWithArray(Object[] anarray)(Code) | | Execute the query and return the filtered Set.
The execution of the query obtains the values of the parameters and
matches them against the declared parameters in order. The names
of the declared parameters are ignored. The type of
the declared parameters must match the type of the passed parameters,
except that the passed parameters might need to be unwrapped to get
their primitive values.
The filter, import, declared parameters, declared variables, and
ordering statements are verified for consistency.
Each element in the candidate Set is examined to see that it
is assignment compatible to the Class of the query. It is then evaluated
by the boolean expression of the filter. The element passes the filter
if there exist unique values for all variables for which the filter
expression evaluates to true.
the filtered Set.
Parameters:
anarray - the Object array with all of the parameters. |
| executeWithMap | | public Object executeWithMap(Map amap)(Code) | | Execute the query and return the filtered Set.
The query is executed with the parameters set by the Map values. Each
Map entry consists of a key which is the name of the parameter in the
declareParameters method, and a value which is the value used in
the execute method. The keys in the Map and the declared parameters
must exactly match or a JDOUserException is thrown.
the filtered Set.
See Also: JDOQuery.executeWithArray(java.lang.Object[] parameters)
Parameters:
amap - the Map containing all of the parameters. |
| getFetchPlan | | public FetchPlan getFetchPlan()(Code) | | |
| getIgnoreCache | | public boolean getIgnoreCache()(Code) | | Get the ignoreCache option setting.
the ignoreCache option setting.
See Also: JDOQuery.setIgnoreCache |
| getPersistenceManager | | public PersistenceManager getPersistenceManager()(Code) | | Get the PersistenceManager associated with this Query.
If this Query was restored from a serialized form, it has no
PersistenceManager, and this method returns null.
the PersistenceManager associated with this Query. |
| isUnmodifiable | | public boolean isUnmodifiable()(Code) | | |
| setCandidates | | public void setCandidates(Extent pcs)(Code) | | Set the candidate Extent to query.
Parameters:
pcs - the Candidate Extent. |
| setCandidates | | public void setCandidates(Collection pcs)(Code) | | Set the candidate Set to query.
Parameters:
pcs - the Candidate collection. |
| setClass | | public void setClass(Class cls)(Code) | | Set the class of the candidate instances of the query.
The class specifies the class
of the candidates of the query. Elements of the candidate collection
that are of the specified class are filtered before being
put into the result Set.
Parameters:
cls - the Class of the candidate instances. |
| setExtensions | | public void setExtensions(Map exts)(Code) | | |
| setFetchPlan | | public void setFetchPlan(FetchPlan fp)(Code) | | |
| setFilter | | public void setFilter(String f)(Code) | | Set the filter for the query.
The filter specification is a String containing a boolean
expression that is to be evaluated for each of the instances
in the candidate collection. If the filter is not specified,
then it defaults to "true", which has the effect of filtering
the input Set only for class type.
An element of the candidate collection is returned in the result if:
- it is assignment compatible to the candidate Class of the Query; and
- for all variables there exists a value for which the filter
expression evaluates to true.
The user may denote uniqueness in the filter expression by
explicitly declaring an expression (for example, e1 != e2).
Rules for constructing valid expressions follow the Java
language, except for these differences:
- Equality and ordering comparisons between primitives and instances
of wrapper classes are valid.
- Equality and ordering comparisons of Date fields and Date
parameters are valid.
- White space (non-printing characters space, tab, carriage
return, and line feed) is a separator and is otherwise ignored.
- The assignment operators =, +=, etc. and pre- and post-increment
and -decrement are not supported. Therefore, there are no side
effects from evaluation of any expressions.
- Methods, including object construction, are not supported, except
for Set.contains(Object o), Set.isEmpty(),
String.startsWith (String s), and String.endsWith (String e).
Implementations might choose to support non-mutating method
calls as non-standard extensions.
- Navigation through a null-valued field, which would throw
NullPointerException, is treated as if the filter expression
returned false for the evaluation of the current set of variable
values. Other values for variables might still qualify the candidate
instance for inclusion in the result set.
- Navigation through multi-valued fields (Set types) is
specified using a variable declaration and the
Set.contains(Object o) method.
Identifiers in the expression are considered to be in the name
space of the specified class, with the addition of declared imports,
parameters and variables. As in the Java language, this is a reserved
word which means the element of the collection being evaluated.
Navigation through single-valued fields is specified by the Java
language syntax of field_name.field_name....field_name.
A JDO implementation is allowed to reorder the filter expression
for optimization purposes.
Parameters:
f - the query filter. |
| setIgnoreCache | | public void setIgnoreCache(boolean ignoreCache)(Code) | | Set the ignoreCache option. The default value for this option was
set by the PersistenceManagerFactory or the PersistenceManager used
to create this Query.
The ignoreCache option setting specifies whether the query should execute
entirely in the back end, instead of in the cache. If this flag is set
to true, an implementation might be able to optimize the query
execution by ignoring changed values in the cache. For optimistic
transactions, this can dramatically improve query response times.
Parameters:
ignoreCache - the setting of the ignoreCache option. |
| setIncludeSubClasses | | public void setIncludeSubClasses(boolean val)(Code) | | |
| setLogger | | public void setLogger(Logger logger)(Code) | | |
| setOrdering | | public void setOrdering(String ordering)(Code) | | Set the ordering specification for the result Set. The
ordering specification is a String containing one or more ordering
declarations separated by commas.
Each ordering declaration is the name of the field on which
to order the results followed by one of the following words:
"ascending" or "descending".
The field must be declared in the candidate class or must be
a navigation expression starting with a field in the candidate class.
Valid field types are primitive types except boolean; wrapper types
except Boolean; BigDecimal; BigInteger; String; and Date.
Parameters:
ordering - the ordering specification. |
| setRange | | public void setRange(long first, long last)(Code) | | |
| setResultClass | | public void setResultClass(Class _resultClass)(Code) | | |
| setUnique | | public void setUnique(boolean _unique)(Code) | | |
| setUnmodifiable | | public void setUnmodifiable()(Code) | | |
|
|
|