Class QueryUtils


  • public class QueryUtils
    extends Object
    Utilities for use in queries.
    • 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
      • getResultClassConstructorForArguments

        public static Constructor getResultClassConstructorForArguments​(Class resultClass,
                                                                        Class[] fieldTypes,
                                                                        Object[] fieldValues)
        Convenience method to obtain the constructor for the result class taking in the specified argument types.
        Parameters:
        resultClass - Result class
        fieldTypes - Argument types (if known)
        fieldValues - Argument values (if types not provided)
        Returns:
        The constructor (or null if none found)
      • createResultObjectUsingArgumentedConstructor

        public static Object createResultObjectUsingArgumentedConstructor​(Constructor ctr,
                                                                          Object[] fieldValues)
        Convenience method to create an instance of the result class with the specified arg constructor and with the provided field values.
        Parameters:
        ctr - Argumented constructor
        fieldValues - The field values
        Returns:
        The result class object
      • 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,
                                                                                 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