org.datanucleus.query

Class QueryUtils

java.lang.Object

org.datanucleus.query.QueryUtils

public class QueryUtils
extends Object

Utilities for use in queries.

Constructor Summary

Constructors

Constructor and Description
QueryUtils()

Method Summary

Modifier and Type	Method and Description
static boolean	compareExpressionValues(Object left, Object right, Expression.Operator op) Convenience method to compare two expression values against the specified operator.
static Object	createResultObjectUsingArgumentedConstructor(Class resultClass, Object[] fieldValues, Class[] fieldTypes) Convenience method to create an instance of the result class with the provided field values, using a constructor taking the arguments.
static Object	createResultObjectUsingDefaultConstructorAndSetters(Class resultClass, String[] resultFieldNames, Field[] resultFields, Object[] fieldValues) Convenience method to create an instance of the result class with the provided field values, using the default constructor and setting the fields using either public fields, or setters, or a put method.
static Object	createResultObjectUsingDefaultConstructorAndSetters(Class resultClass, String[] resultFieldNames, Map resultClassFieldNames, Object[] fieldValues) Convenience method to create an instance of the result class with the provided field values, using the default constructor and setting the fields using either public fields, or setters, or a put method.
static boolean	expressionHasNotOperator(Expression expr) Convenience method to return if there is a NOT operator in the expression.
static boolean	expressionHasOrOperator(Expression expr) Convenience method to return if there is an OR operator in the expression.
static String[]	getExpressionsFromString(String str) Convenience method to split an expression string into its constituent parts where separated by commas.
static String	getKeyForQueryResultsCache(Query query, Map params) Convenience method to generate the "key" for storing the query results of a query with parameters.
static ParameterExpression	getParameterExpressionForPosition(Expression rootExpr, int pos) Convenience method to return the ParameterExpression for the specified position if found in the expression tree starting at
static Method	getPublicPutMethodForResultClass(Class resultClass) Convenience method to return the put(Object, Object method for the result class.
static Method	getPublicSetMethodForFieldOfResultClass(Class resultClass, String fieldName, Class fieldType) Convenience method to return the setXXX method for a field of the result class.
static String	getStringValue(Object obj) Convenience method to get the String value for an Object.
static String	getStringValueForExpression(Expression expr, Map parameters) Convenience method to get the String value for an Expression.
static Object	getValueForParameterExpression(Map parameterValues, ParameterExpression paramExpr) Convenience method to get the value for a ParameterExpression.
static List	orderCandidates(List candidates, Class type, String ordering, ExecutionContext ec, ClassLoaderResolver clr) Convenience method to in-memory order the candidates, using the ordering supplied.
static List	orderCandidates(List candidates, Class type, String ordering, ExecutionContext ec, ClassLoaderResolver clr, String queryLanguage) Convenience method to in-memory order the candidates, using the ordering supplied.
static List	orderCandidates(List candidates, Expression[] ordering, Map state, String candidateAlias, ExecutionContext ec, ClassLoaderResolver clr, Map parameterValues, Imports imports, String queryLanguage) Convenience method to order the input List of objects to the ordering defined by the compilation.
static boolean	queryParameterTypesAreCompatible(Class cls1, Class cls2)
static boolean	queryReturnsSingleRow(Query query) Convenience method to return whether the query should return a single row.
static boolean	resultClassIsSimple(String className) Utility to return if the passed result class is a simple type with a single value.
static boolean	resultClassIsUserType(String className) Utility to return if the passed result class is a user-type, and so requires fields matching up.
static boolean	resultHasOnlyAggregates(String result) Convenience method to return if the "result" clause from a java string-based query language includes only aggregates.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

QueryUtils

public QueryUtils()

Method Detail

resultClassIsUserType

public static boolean resultClassIsUserType(String className)

Utility to return if the passed result class is a user-type, and so requires fields matching up.

Parameters:

className - the class name looked for

Returns:

Whether it is a user class

resultClassIsSimple

public static boolean resultClassIsSimple(String className)

Utility to return if the passed result class is a simple type with a single value. Checks the class name against the supported "simple" query result-class types.

Parameters:

className - the class name looked for

Returns:

Whether the result class is "simple".

resultHasOnlyAggregates

public static boolean resultHasOnlyAggregates(String result)

Convenience method to return if the "result" clause from a java string-based query language includes only aggregates. This provides useful information when determining if the results will be a single row.

Parameters:

result - The result required

Returns:

Whether it has only aggregates

queryReturnsSingleRow

public static boolean queryReturnsSingleRow(Query query)

Convenience method to return whether the query should return a single row.

Parameters:

query - The query

Returns:

Whether it represents a unique row

createResultObjectUsingArgumentedConstructor

public static Object createResultObjectUsingArgumentedConstructor(Class resultClass,
                                                                  Object[] fieldValues,
                                                                  Class[] fieldTypes)

Convenience method to create an instance of the result class with the provided field values, using a constructor taking the arguments. If the returned object is null there is no constructor with the correct signature. Tries to find a constructor taking the required arguments. Uses the fieldTypes first (if specified), then (if not specified) uses the type of the fieldValues, otherwise uses Object as the argument type.

Parameters:

resultClass - The class of results that need creating

fieldValues - The field values

fieldTypes - The field types (optional). If specified needs same number as fieldValues

Returns:

The result class object

createResultObjectUsingDefaultConstructorAndSetters

public static Object createResultObjectUsingDefaultConstructorAndSetters(Class resultClass,
                                                                         String[] resultFieldNames,
                                                                         Map resultClassFieldNames,
                                                                         Object[] fieldValues)

Convenience method to create an instance of the result class with the provided field values, using the default constructor and setting the fields using either public fields, or setters, or a put method. If one of these parts is not found in the result class the returned object is null.

Parameters:

resultClass - Result class that we need to create an object of

resultFieldNames - Names of the fields in the results

resultClassFieldNames - Map of the result class fields, keyed by the field name

fieldValues - The field values

Returns:

The result class object

createResultObjectUsingDefaultConstructorAndSetters

public static Object createResultObjectUsingDefaultConstructorAndSetters(Class resultClass,
                                                                         String[] resultFieldNames,
                                                                         Field[] resultFields,
                                                                         Object[] fieldValues)

Convenience method to create an instance of the result class with the provided field values, using the default constructor and setting the fields using either public fields, or setters, or a put method. If one of these parts is not found in the result class the returned object is null.

Parameters:

resultClass - Result class that we need to create an object of

resultFieldNames - Names of the fields in the results

resultFields - (java.lang.reflect.)Field objects for the fields in the results

fieldValues - The field values

Returns:

The result class object

getPublicSetMethodForFieldOfResultClass

public static Method getPublicSetMethodForFieldOfResultClass(Class resultClass,
                                                             String fieldName,
                                                             Class fieldType)

Convenience method to return the setXXX method for a field of the result class.

Parameters:

resultClass - The result class

fieldName - Name of the field

fieldType - The type of the field being set

Returns:

The setter method

getPublicPutMethodForResultClass

public static Method getPublicPutMethodForResultClass(Class resultClass)

Convenience method to return the put(Object, Object method for the result class.

Parameters:

resultClass - The result class

Returns:

The put(Object, Object) method

getExpressionsFromString

public static String[] getExpressionsFromString(String str)

Convenience method to split an expression string into its constituent parts where separated by commas. This is used in the case of, for example, a result specification, to get the column definitions.

Parameters:

str - The expression string

Returns:

The expression parts

getValueForParameterExpression

public static Object getValueForParameterExpression(Map parameterValues,
                                                    ParameterExpression paramExpr)

Convenience method to get the value for a ParameterExpression. If the parameterValues is supplied as named then it will be like {[name1, val1], [name2, val2], ...} and paramExpr as id="name1", pos=0. If the parameterValues is supplied as positional then it will be like {[0, val1], [1, val2], ...} and paramExpr as id="name1", pos=0 (JDOQL) or id="1", pos=0 (JPQL)

Parameters:

parameterValues - Input parameter values keyed by the parameter name/position

paramExpr - Expression

Returns:

The value in the object for this expression

getStringValue

public static String getStringValue(Object obj)

Convenience method to get the String value for an Object. Currently String, Character and Number are supported.

Parameters:

obj - Object

Returns:

The String value for the Object

getStringValueForExpression

public static String getStringValueForExpression(Expression expr,
                                                 Map parameters)

Convenience method to get the String value for an Expression. Currently only ParameterExpression and Literal are supported.

Parameters:

expr - Expression

parameters - Input parameters

Returns:

The String value in the object for this expression

compareExpressionValues

public static boolean compareExpressionValues(Object left,
                                              Object right,
                                              Expression.Operator op)

Convenience method to compare two expression values against the specified operator. Returns true if "left {operator} right" is true. The operator can be <, >, ≥, ≤, ==, !=.

Parameters:

left - Left object

right - Right object

op - Operator

Returns:

Whether the comparison is true

Throws:

NucleusException - if the comparison is impossible

expressionHasOrOperator

public static boolean expressionHasOrOperator(Expression expr)

Convenience method to return if there is an OR operator in the expression. Allows for hierarchical expressions, navigating down through the expression tree.

Parameters:

expr - The expression

Returns:

Whether there is an OR

expressionHasNotOperator

public static boolean expressionHasNotOperator(Expression expr)

Convenience method to return if there is a NOT operator in the expression. Allows for hierarchical expressions, navigating down through the expression tree.

Parameters:

expr - The expression

Returns:

Whether there is a NOT

getParameterExpressionForPosition

public static ParameterExpression getParameterExpressionForPosition(Expression rootExpr,
                                                                    int pos)

Convenience method to return the ParameterExpression for the specified position if found in the expression tree starting at

rootExpr

Parameters:

rootExpr - The expression

pos - The position

Returns:

The ParameterExpression (if found)

queryParameterTypesAreCompatible

public static boolean queryParameterTypesAreCompatible(Class cls1,
                                                       Class cls2)

getKeyForQueryResultsCache

public static String getKeyForQueryResultsCache(Query query,
                                                Map params)

Convenience method to generate the "key" for storing the query results of a query with parameters. The key will be of the form

 JDOQL:SELECT FROM myClass WHERE myFilter:123456
 

where "123456" is the hashCode of the parameters for the query

Parameters:

query - The query

params - The params

Returns:

The key

orderCandidates

public static List orderCandidates(List candidates,
                                   Class type,
                                   String ordering,
                                   ExecutionContext ec,
                                   ClassLoaderResolver clr)

Convenience method to in-memory order the candidates, using the ordering supplied. Assumes that the query is JDOQL.

Parameters:

candidates - The candidates

type - Candidate type

ordering - The ordering clause

ec - Execution Context

clr - ClassLoader resolver

Returns:

The ordered list

orderCandidates

public static List orderCandidates(List candidates,
                                   Class type,
                                   String ordering,
                                   ExecutionContext ec,
                                   ClassLoaderResolver clr,
                                   String queryLanguage)

Convenience method to in-memory order the candidates, using the ordering supplied. Assumes that the query is JDOQL.

Parameters:

candidates - The candidates

type - Candidate type

ordering - The ordering clause

ec - Execution Context

clr - ClassLoader resolver

queryLanguage - The query language in use

Returns:

The ordered list. Note that this typically returns Arrays$List which may not be what you want

orderCandidates

public static List orderCandidates(List candidates,
                                   Expression[] ordering,
                                   Map state,
                                   String candidateAlias,
                                   ExecutionContext ec,
                                   ClassLoaderResolver clr,
                                   Map parameterValues,
                                   Imports imports,
                                   String queryLanguage)

Convenience method to order the input List of objects to the ordering defined by the compilation.

Parameters:

candidates - Candidates

ordering - Ordering expression(s)

state - Map of state information (see JavaQueryEvaluator)

candidateAlias - Candidate alias

ec - ExecutionContext

clr - ClassLoader resolver

parameterValues - Any parameter values (maybe used by the ordering clause)

imports - Imports for the query

queryLanguage - The language of this query (JDOQL, JPQL etc)

Returns:

The ordered List of candidates