Class QueryUtils

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

public class QueryUtils extends Object
Utilities for use in queries.
  • Field Details

    • MAP_PUT_METHOD_ARG_TYPES

      static final Class[] MAP_PUT_METHOD_ARG_TYPES
      Convenience Class[] for parameter types in getMethod call.
  • Constructor Details

    • QueryUtils

      public QueryUtils()
  • Method Details

    • 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
    • setFieldForResultObject

      private static boolean setFieldForResultObject(Object obj, String fieldName, Field field, Object value)
      Method to set a field of an object, using set/put methods, or via a public field. See JDO spec [14.6.12] describing the 3 ways of setting the field values after creating the result object using the default constructor.
      Parameters:
      obj - The object to update the field for
      fieldName - Name of the field
      field - The field
      value - The value to apply
      Returns:
      Whether it was updated
    • 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