QueryUtils (DataNucleus Core 4.1.17-SNAPSHOT API)

java.lang.Object
- org.datanucleus.query.QueryUtils

```
public class QueryUtils
extends Object
```
Utilities for use in queries.

Constructor Summary

Constructors
Constructor and Description

QueryUtils()

Constructors
Constructor and Description
`QueryUtils()`

Method Summary

All Methods Static Methods Concrete Methods
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" JDOQL 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
  - 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

Class QueryUtils

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

QueryUtils

Method Detail

resultClassIsUserType

resultClassIsSimple

resultHasOnlyAggregates

queryReturnsSingleRow

createResultObjectUsingArgumentedConstructor

createResultObjectUsingDefaultConstructorAndSetters

createResultObjectUsingDefaultConstructorAndSetters

getPublicSetMethodForFieldOfResultClass

getPublicPutMethodForResultClass

getExpressionsFromString

getValueForParameterExpression

getStringValue

getStringValueForExpression

compareExpressionValues

expressionHasOrOperator

expressionHasNotOperator

getParameterExpressionForPosition

queryParameterTypesAreCompatible

getKeyForQueryResultsCache

orderCandidates

orderCandidates

orderCandidates