| 
 | ||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
| Packages that use StoreQuery | |
|---|---|
| org.apache.openjpa.abstractstore | OpenJPA Abstract StoreManager Implementation | 
| org.apache.openjpa.datacache | OpenJPA Data Cache | 
| org.apache.openjpa.jdbc.kernel | OpenJPA-JDBC Runtime Kernel | 
| org.apache.openjpa.kernel | OpenJPA Runtime Kernel | 
| org.apache.openjpa.slice | Extended OpenJPA Interfaces for distributed databases. | 
| org.apache.openjpa.slice.jdbc | Implements Distributed version of JDBCStoreManager and JDBCStoreQuery. | 
| Uses of StoreQuery in org.apache.openjpa.abstractstore | 
|---|
| Methods in org.apache.openjpa.abstractstore that return StoreQuery | |
|---|---|
|  StoreQuery | AbstractStoreManager.newQuery(String language) | 
| Uses of StoreQuery in org.apache.openjpa.datacache | 
|---|
| Classes in org.apache.openjpa.datacache that implement StoreQuery | |
|---|---|
|  class | QueryCacheStoreQueryA StoreQueryimplementation that caches the OIDs involved in
 the query, and can determine whether or not the query has been dirtied. | 
| Methods in org.apache.openjpa.datacache that return StoreQuery | |
|---|---|
|  StoreQuery | QueryCacheStoreQuery.getDelegate()Delegate. | 
| Constructors in org.apache.openjpa.datacache with parameters of type StoreQuery | |
|---|---|
| QueryCacheStoreQuery(StoreQuery query,
                     QueryCache cache)Create a new instance that delegates to queryif no
 cached results are available. | |
| Uses of StoreQuery in org.apache.openjpa.jdbc.kernel | 
|---|
| Classes in org.apache.openjpa.jdbc.kernel that implement StoreQuery | |
|---|---|
|  class | JDBCStoreQueryJDBC query implementation. | 
|  class | PreparedSQLStoreQueryA executor for Prepared SQL Query. | 
|  class | SQLStoreQueryA SQL query. | 
| Methods in org.apache.openjpa.jdbc.kernel that return StoreQuery | |
|---|---|
|  StoreQuery | JDBCStoreManager.newQuery(String language) | 
| Methods in org.apache.openjpa.jdbc.kernel with parameters of type StoreQuery | |
|---|---|
|  ResultObjectProvider | SQLStoreQuery.SQLExecutor.executeQuery(StoreQuery q,
             Object[] params,
             StoreQuery.Range range) | 
|  ResultObjectProvider | PreparedSQLStoreQuery.PreparedSQLExecutor.executeQuery(StoreQuery q,
             Object[] params,
             StoreQuery.Range range) | 
|  Number | SQLStoreQuery.SQLExecutor.executeUpdate(StoreQuery q,
              Object[] params) | 
|  String[] | SQLStoreQuery.SQLExecutor.getDataStoreActions(StoreQuery q,
                    Object[] params,
                    StoreQuery.Range range) | 
|  int | SQLStoreQuery.SQLExecutor.getOperation(StoreQuery q) | 
|  Class[] | PreparedSQLStoreQuery.PreparedSQLExecutor.getProjectionTypes(StoreQuery q) | 
|  boolean | SQLStoreQuery.SQLExecutor.isPacking(StoreQuery q) | 
|  Object[] | SQLStoreQuery.SQLExecutor.toParameterArray(StoreQuery q,
                 Map userParams)The given query is parsed to find the parameter tokens of the form ?nwhich is different than?tokens in
 actual SQL parameter tokens. | 
|  Object[] | PreparedSQLStoreQuery.PreparedSQLExecutor.toParameterArray(StoreQuery q,
                 Map userParams)Convert given userParams to an array whose ordering matches as per expected during executeXXX() methods. | 
| Uses of StoreQuery in org.apache.openjpa.kernel | 
|---|
| Classes in org.apache.openjpa.kernel that implement StoreQuery | |
|---|---|
|  class | AbstractStoreQueryAbstract StoreQuerythat implements most methods as no-ops. | 
|  class | ExpressionStoreQueryImplementation of an expression-based query, which can handle String-based query expressions such as JPQL and JDOQL. | 
|  class | MethodStoreQueryA query that is executed by a user-defined method. | 
| Methods in org.apache.openjpa.kernel that return StoreQuery | |
|---|---|
|  StoreQuery | QueryImpl.getStoreQuery()Internal store query. | 
|  StoreQuery | StoreManager.newQuery(String language)Return a query implementation suitable for this store. | 
|  StoreQuery | DelegatingStoreManager.newQuery(String language) | 
| Methods in org.apache.openjpa.kernel with parameters of type StoreQuery | |
|---|---|
| protected  void | ExpressionStoreQuery.AbstractExpressionExecutor.assertNotContainer(Value val,
                   StoreQuery q)Throw proper exception if given value is a collection/map/array. | 
| protected  void | QueryImpl.assertParameters(StoreQuery q,
                 StoreQuery.Executor ex,
                 Map params) | 
| protected  void | QueryImpl.assertParameters(StoreQuery q,
                 StoreQuery.Executor ex,
                 Object[] params)Checks that the passed parameters match the declarations. | 
|  Number | QueryImpl.deleteInMemory(StoreQuery q,
               StoreQuery.Executor executor,
               Object[] params) | 
|  Number | QueryContext.deleteInMemory(StoreQuery q,
               StoreQuery.Executor ex,
               Object[] params)Helper method to delete the objects found by executing a query on the given executor. | 
|  Number | DelegatingQuery.deleteInMemory(StoreQuery q,
               StoreQuery.Executor ex,
               Object[] params) | 
|  Number | StoreQuery.Executor.executeDelete(StoreQuery q,
              Object[] params)Deleted the objects that result from the execution of the query, retuning the number of objects that were deleted. | 
|  Number | ExpressionStoreQuery.DataStoreExecutor.executeDelete(StoreQuery q,
              Object[] params) | 
|  Number | AbstractStoreQuery.AbstractExecutor.executeDelete(StoreQuery q,
              Object[] params) | 
|  ResultObjectProvider | StoreQuery.Executor.executeQuery(StoreQuery q,
             Object[] params,
             StoreQuery.Range range)Return the result of executing this query with the given parameter values. | 
|  ResultObjectProvider | ExpressionStoreQuery.DataStoreExecutor.executeQuery(StoreQuery q,
             Object[] params,
             StoreQuery.Range range) | 
|  Number | StoreQuery.Executor.executeUpdate(StoreQuery q,
              Object[] params)Updates the objects that result from the execution of the query, retuning the number of objects that were updated. | 
|  Number | ExpressionStoreQuery.DataStoreExecutor.executeUpdate(StoreQuery q,
              Object[] params) | 
|  Number | AbstractStoreQuery.AbstractExecutor.executeUpdate(StoreQuery q,
              Object[] params) | 
|  ClassMetaData[] | StoreQuery.Executor.getAccessPathMetaDatas(StoreQuery q)Return an array of all persistent classes used in this query, or empty array if unknown. | 
|  ClassMetaData[] | ExpressionStoreQuery.AbstractExpressionExecutor.getAccessPathMetaDatas(StoreQuery q) | 
|  ClassMetaData[] | AbstractStoreQuery.AbstractExecutor.getAccessPathMetaDatas(StoreQuery q) | 
|  String | StoreQuery.Executor.getAlias(StoreQuery q)If this is not a projection but the candidate results are placed into a result class with an alias, return that alias. | 
|  String | ExpressionStoreQuery.AbstractExpressionExecutor.getAlias(StoreQuery q) | 
|  String | AbstractStoreQuery.AbstractExecutor.getAlias(StoreQuery q) | 
|  boolean[] | StoreQuery.Executor.getAscending(StoreQuery q)Return the ordering direction for all ordering clauses, or empty array if none. | 
|  boolean[] | ExpressionStoreQuery.AbstractExpressionExecutor.getAscending(StoreQuery q) | 
|  boolean[] | AbstractStoreQuery.AbstractExecutor.getAscending(StoreQuery q) | 
|  String[] | StoreQuery.Executor.getDataStoreActions(StoreQuery q,
                    Object[] params,
                    StoreQuery.Range range)Return a description of the commands that will be sent to the datastore in order to execute the query. | 
|  String[] | ExpressionStoreQuery.DataStoreExecutor.getDataStoreActions(StoreQuery q,
                    Object[] params,
                    StoreQuery.Range range) | 
|  String[] | AbstractStoreQuery.AbstractExecutor.getDataStoreActions(StoreQuery q,
                    Object[] params,
                    StoreQuery.Range range) | 
|  int | StoreQuery.Executor.getOperation(StoreQuery q)Returns the operation this executor is meant to execute. | 
|  int | ExpressionStoreQuery.AbstractExpressionExecutor.getOperation(StoreQuery q) | 
|  int | AbstractStoreQuery.AbstractExecutor.getOperation(StoreQuery q) | 
|  OrderedMap<Object,Class<?>> | StoreQuery.Executor.getOrderedParameterTypes(StoreQuery q)Return a map of parameter names to types. | 
|  OrderedMap<Object,Class<?>> | ExpressionStoreQuery.AbstractExpressionExecutor.getOrderedParameterTypes(StoreQuery q) | 
|  OrderedMap<Object,Class<?>> | AbstractStoreQuery.AbstractExecutor.getOrderedParameterTypes(StoreQuery q) | 
|  Object | StoreQuery.Executor.getOrderingValue(StoreQuery q,
                 Object[] params,
                 Object resultObject,
                 int orderIndex)Extract the value of the orderIndexth ordering
 expression inQuery#getOrderingClausesfrom the
 given result object. | 
|  Object | ExpressionStoreQuery.DataStoreExecutor.getOrderingValue(StoreQuery q,
                 Object[] params,
                 Object resultObject,
                 int orderIndex) | 
|  Object | AbstractStoreQuery.AbstractExecutor.getOrderingValue(StoreQuery q,
                 Object[] params,
                 Object resultObject,
                 int orderIndex) | 
|  LinkedMap | StoreQuery.Executor.getParameterTypes(StoreQuery q)Deprecated. | 
|  LinkedMap | AbstractStoreQuery.AbstractExecutor.getParameterTypes(StoreQuery q) | 
|  String[] | StoreQuery.Executor.getProjectionAliases(StoreQuery q)Return the alias for each projection element, or empty array if not a projection. | 
|  String[] | ExpressionStoreQuery.AbstractExpressionExecutor.getProjectionAliases(StoreQuery q) | 
|  String[] | AbstractStoreQuery.AbstractExecutor.getProjectionAliases(StoreQuery q) | 
|  Class<?>[] | StoreQuery.Executor.getProjectionTypes(StoreQuery q)Return the expected types of the projections used by this query, or an empty array if not a projection. | 
|  Class<?>[] | ExpressionStoreQuery.AbstractExpressionExecutor.getProjectionTypes(StoreQuery q) | 
|  Class[] | ExpressionStoreQuery.DataStoreExecutor.getProjectionTypes(StoreQuery q) | 
|  Class<?>[] | AbstractStoreQuery.AbstractExecutor.getProjectionTypes(StoreQuery q) | 
|  void | StoreQuery.Executor.getRange(StoreQuery q,
         Object[] params,
         StoreQuery.Range range)Mutate the given range to set any range information stored in the query string and/or parameters. | 
|  void | ExpressionStoreQuery.AbstractExpressionExecutor.getRange(StoreQuery q,
         Object[] params,
         StoreQuery.Range range) | 
|  void | AbstractStoreQuery.AbstractExecutor.getRange(StoreQuery q,
         Object[] params,
         StoreQuery.Range range) | 
|  Class<?> | StoreQuery.Executor.getResultClass(StoreQuery q)Returns the result class, if any. | 
|  Class<?> | ExpressionStoreQuery.AbstractExpressionExecutor.getResultClass(StoreQuery q) | 
|  Class<?> | AbstractStoreQuery.AbstractExecutor.getResultClass(StoreQuery q) | 
|  ResultShape<?> | StoreQuery.Executor.getResultShape(StoreQuery q) | 
|  ResultShape<?> | ExpressionStoreQuery.AbstractExpressionExecutor.getResultShape(StoreQuery q) | 
|  ResultShape<?> | AbstractStoreQuery.AbstractExecutor.getResultShape(StoreQuery q) | 
|  Map<FieldMetaData,Value> | StoreQuery.Executor.getUpdates(StoreQuery q)Return a map of FieldMetaDatato updateConstants, in cases where this query is for a bulk update. | 
|  Map | ExpressionStoreQuery.AbstractExpressionExecutor.getUpdates(StoreQuery q) | 
|  Map<FieldMetaData,Value> | AbstractStoreQuery.AbstractExecutor.getUpdates(StoreQuery q) | 
|  boolean | StoreQuery.Executor.hasGrouping(StoreQuery q)Whether the compiled query has grouping. | 
|  boolean | ExpressionStoreQuery.AbstractExpressionExecutor.hasGrouping(StoreQuery q) | 
|  boolean | AbstractStoreQuery.AbstractExecutor.hasGrouping(StoreQuery q) | 
|  boolean | StoreQuery.Executor.isAggregate(StoreQuery q)Return true if the compiled query is an aggregate. | 
|  boolean | ExpressionStoreQuery.AbstractExpressionExecutor.isAggregate(StoreQuery q) | 
|  boolean | AbstractStoreQuery.AbstractExecutor.isAggregate(StoreQuery q) | 
|  boolean | StoreQuery.Executor.isDistinct(StoreQuery q) | 
|  boolean | ExpressionStoreQuery.AbstractExpressionExecutor.isDistinct(StoreQuery q) | 
|  boolean | AbstractStoreQuery.AbstractExecutor.isDistinct(StoreQuery q) | 
|  boolean | StoreQuery.Executor.isPacking(StoreQuery q)Return true if this executor packs projections into the result class itself. | 
|  boolean | ExpressionStoreQuery.AbstractExpressionExecutor.isPacking(StoreQuery q) | 
|  boolean | AbstractStoreQuery.AbstractExecutor.isPacking(StoreQuery q) | 
| protected  QueryImpl | BrokerImpl.newQueryImpl(String lang,
             StoreQuery sq)Create a new query. | 
|  Object[] | StoreQuery.Executor.toParameterArray(StoreQuery q,
                 Map<?,?> userParams)Return an array from the given user parameter values. | 
|  Object[] | ExpressionStoreQuery.AbstractExpressionExecutor.toParameterArray(StoreQuery q,
                 Map<?,?> userParams)Creates a Object[] from the values of the given user parameters. | 
| protected  Object | QueryImpl.toResult(StoreQuery q,
         StoreQuery.Executor ex,
         ResultObjectProvider rop,
         StoreQuery.Range range)Return the query result for the given result object provider. | 
|  Number | QueryImpl.updateInMemory(StoreQuery q,
               StoreQuery.Executor executor,
               Object[] params) | 
|  Number | QueryContext.updateInMemory(StoreQuery q,
               StoreQuery.Executor ex,
               Object[] params)Helper method to update the objects found by executing a query on the given executor. | 
|  Number | DelegatingQuery.updateInMemory(StoreQuery q,
               StoreQuery.Executor ex,
               Object[] params) | 
|  void | StoreQuery.Executor.validate(StoreQuery q)Validate components of query. | 
|  void | ExpressionStoreQuery.AbstractExpressionExecutor.validate(StoreQuery q) | 
|  void | AbstractStoreQuery.AbstractExecutor.validate(StoreQuery q) | 
| Constructors in org.apache.openjpa.kernel with parameters of type StoreQuery | |
|---|---|
| OrderingMergedResultObjectProvider(ResultObjectProvider[] rops,
                                   boolean[] asc,
                                   StoreQuery.Executor[] execs,
                                   StoreQuery q,
                                   Object[] params) | |
| OrderingMergedResultObjectProvider(ResultObjectProvider[] rops,
                                   boolean[] asc,
                                   StoreQuery.Executor exec,
                                   StoreQuery q,
                                   Object[] params) | |
| QueryImpl(Broker broker,
          String language,
          StoreQuery storeQuery)Construct a query managed by the given broker. | |
| Uses of StoreQuery in org.apache.openjpa.slice | 
|---|
| Methods in org.apache.openjpa.slice with parameters of type StoreQuery | |
|---|---|
| protected  QueryImpl | DistributedBrokerImpl.newQueryImpl(String lang,
             StoreQuery sq)Create a new query. | 
| Constructors in org.apache.openjpa.slice with parameters of type StoreQuery | |
|---|---|
| DistributedQueryImpl(Broker broker,
                     String language,
                     StoreQuery storeQuery) | |
| Uses of StoreQuery in org.apache.openjpa.slice.jdbc | 
|---|
| Classes in org.apache.openjpa.slice.jdbc that implement StoreQuery | |
|---|---|
| (package private)  class | DistributedStoreQueryA query for distributed databases. | 
| Fields in org.apache.openjpa.slice.jdbc declared as StoreQuery | |
|---|---|
| (package private)  StoreQuery | DistributedStoreQuery.QueryExecutor.query | 
| (package private)  StoreQuery | DistributedStoreQuery.DeleteExecutor.query | 
| (package private)  StoreQuery | DistributedStoreQuery.UpdateExecutor.query | 
| Methods in org.apache.openjpa.slice.jdbc that return StoreQuery | |
|---|---|
|  StoreQuery | DistributedJDBCStoreManager.newQuery(String language)Construct a distributed query to be executed against all the slices. | 
| Methods in org.apache.openjpa.slice.jdbc with parameters of type StoreQuery | |
|---|---|
| (package private)  void | DistributedStoreQuery.add(StoreQuery q) | 
|  Number | DistributedStoreQuery.ParallelExecutor.executeDelete(StoreQuery q,
              Object[] params) | 
|  ResultObjectProvider | DistributedStoreQuery.ParallelExecutor.executeQuery(StoreQuery q,
             Object[] params,
             StoreQuery.Range range)Each child query must be executed with slice context and not the given query context. | 
|  Number | DistributedStoreQuery.ParallelExecutor.executeUpdate(StoreQuery q,
              Object[] params) | 
| Constructors in org.apache.openjpa.slice.jdbc with parameters of type StoreQuery | |
|---|---|
| UniqueResultObjectProvider(ResultObjectProvider[] rops,
                           StoreQuery q,
                           QueryExpressions[] exps) | |
| 
 | ||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||