Examples with ParameterExpression org.datanucleus.query.expression.ParameterExpression used on opensource projects

Example 21 with ParameterExpression

use of org.datanucleus.query.expression.ParameterExpression in project datanucleus-core by datanucleus.

the class AbstractResultClassMapper method map.

/**
 * Method to map the input results to the required result class type.
 * @param inputResults The results to process
 * @param resultNames Expressions for the result components of the input results (columns)
 * @return Collection<resultClass>
 */
public Collection map(final Collection inputResults, final Expression[] resultNames) {
    // Do as PrivilegedAction since can use reflection
    return (Collection) AccessController.doPrivileged(new PrivilegedAction() {

        public Object run() {
            String[] fieldNames = new String[resultNames.length];
            Field[] fields = new Field[fieldNames.length];
            for (int i = 0; i < fieldNames.length; i++) {
                if (resultNames[i] instanceof PrimaryExpression) {
                    fieldNames[i] = ((PrimaryExpression) resultNames[i]).getId();
                    if (fieldNames[i].indexOf('.') > 0) {
                        // Just take last part of name (for when the user specifies something like "p.firstName")
                        int pos = fieldNames[i].lastIndexOf('.');
                        fieldNames[i] = fieldNames[i].substring(pos + 1);
                    }
                    fields[i] = getFieldForFieldNameInResultClass(resultClass, fieldNames[i]);
                } else if (resultNames[i] instanceof ParameterExpression) {
                    // TODO We need to cater for outputting the parameter value. Need SymbolTable
                    // This code below is wrong.
                    fieldNames[i] = ((ParameterExpression) resultNames[i]).getId();
                    fields[i] = getFieldForFieldNameInResultClass(resultClass, fieldNames[i]);
                } else {
                    fieldNames[i] = resultNames[i].getAlias();
                    fields[i] = null;
                }
            }
            List outputResults = new ArrayList();
            Iterator it = inputResults.iterator();
            while (it.hasNext()) {
                Object inputResult = it.next();
                Object row = getResultForResultSetRow(inputResult, fieldNames, fields);
                outputResults.add(row);
            }
            return outputResults;
        }
    });
}

Example 22 with ParameterExpression

use of org.datanucleus.query.expression.ParameterExpression in project datanucleus-core by datanucleus.

the class InMemoryExpressionEvaluator method getValueForInvokeExpression.

/**
 * Method to evaluate an InvokeExpression.
 * Will navigate along chained invocations, evaluating the first one, then the second one etc
 * until it gets the value for the passed in expression.
 * @param invokeExpr The InvokeExpression
 * @return The value
 */
public Object getValueForInvokeExpression(InvokeExpression invokeExpr) {
    String method = invokeExpr.getOperation();
    if (invokeExpr.getLeft() == null) {
        // Static function
        if (method.toLowerCase().equals("count")) {
            Collection coll = (Collection) state.get(JavaQueryInMemoryEvaluator.RESULTS_SET);
            SetExpression setexpr = new SetExpression(coll, candidateAlias);
            Expression paramExpr = invokeExpr.getArguments().get(0);
            if (paramExpr.getOperator() == Expression.OP_DISTINCT) {
                // No dups in HashSet
                coll = new HashSet(coll);
            }
            int stackSizeOrig = stack.size();
            Object returnVal = setexpr.count(paramExpr, this);
            while (stack.size() > stackSizeOrig) {
                // Remove any expressions put on the stack while evaluating the aggregate
                stack.pop();
            }
            return returnVal;
        } else if (method.toLowerCase().equals("sum")) {
            Collection coll = (Collection) state.get(JavaQueryInMemoryEvaluator.RESULTS_SET);
            SetExpression setexpr = new SetExpression(coll, candidateAlias);
            Expression paramExpr = invokeExpr.getArguments().get(0);
            if (paramExpr.getOperator() == Expression.OP_DISTINCT) {
                // No dups in HashSet
                coll = new HashSet(coll);
            }
            int stackSizeOrig = stack.size();
            Object returnVal = setexpr.sum(paramExpr, this, state);
            while (stack.size() > stackSizeOrig) {
                // Remove any expressions put on the stack while evaluating the aggregate
                stack.pop();
            }
            return returnVal;
        } else if (method.toLowerCase().equals("avg")) {
            Collection coll = (Collection) state.get(JavaQueryInMemoryEvaluator.RESULTS_SET);
            SetExpression setexpr = new SetExpression(coll, candidateAlias);
            Expression paramExpr = invokeExpr.getArguments().get(0);
            if (paramExpr.getOperator() == Expression.OP_DISTINCT) {
                // No dups in HashSet
                coll = new HashSet(coll);
            }
            int stackSizeOrig = stack.size();
            Object returnVal = setexpr.avg(paramExpr, this, state);
            while (stack.size() > stackSizeOrig) {
                // Remove any expressions put on the stack while evaluating the aggregate
                stack.pop();
            }
            return returnVal;
        } else if (method.toLowerCase().equals("min")) {
            Collection coll = (Collection) state.get(JavaQueryInMemoryEvaluator.RESULTS_SET);
            SetExpression setexpr = new SetExpression(coll, candidateAlias);
            Expression paramExpr = invokeExpr.getArguments().get(0);
            if (paramExpr.getOperator() == Expression.OP_DISTINCT) {
                // No dups in HashSet
                coll = new HashSet(coll);
            }
            int stackSizeOrig = stack.size();
            Object returnVal = setexpr.min(paramExpr, this, state);
            while (stack.size() > stackSizeOrig) {
                // Remove any expressions put on the stack while evaluating the aggregate
                stack.pop();
            }
            return returnVal;
        } else if (method.toLowerCase().equals("max")) {
            Collection coll = (Collection) state.get(JavaQueryInMemoryEvaluator.RESULTS_SET);
            SetExpression setexpr = new SetExpression(coll, candidateAlias);
            Expression paramExpr = invokeExpr.getArguments().get(0);
            if (paramExpr.getOperator() == Expression.OP_DISTINCT) {
                // No dups in HashSet
                coll = new HashSet(coll);
            }
            int stackSizeOrig = stack.size();
            Object returnVal = setexpr.max(paramExpr, this, state);
            while (stack.size() > stackSizeOrig) {
                // Remove any expressions put on the stack while evaluating the aggregate
                stack.pop();
            }
            return returnVal;
        } else {
            // Try to find a supported static method with this name
            InvocationEvaluator methodEval = queryMgr.getInMemoryEvaluatorForMethod(null, method);
            if (methodEval != null) {
                return methodEval.evaluate(invokeExpr, null, this);
            }
            NucleusLogger.QUERY.warn("Query contains call to static method " + method + " yet no support is available for in-memory evaluation of this");
            return new InMemoryFailure();
        }
    } else if (invokeExpr.getLeft() instanceof ParameterExpression) {
        // {paramExpr}.method(...)
        Object invokedValue = QueryUtils.getValueForParameterExpression(parameterValues, (ParameterExpression) invokeExpr.getLeft());
        // Invoke method on this object
        Class invokedType = invokedValue != null ? invokedValue.getClass() : invokeExpr.getLeft().getSymbol().getValueType();
        InvocationEvaluator methodEval = queryMgr.getInMemoryEvaluatorForMethod(invokedType, method);
        if (methodEval != null) {
            return methodEval.evaluate(invokeExpr, invokedValue, this);
        }
        if (invokedValue != null) {
            NucleusLogger.QUERY.warn("Query contains call to method " + invokedValue.getClass().getName() + "." + method + " yet no support is available for this");
        } else {
            NucleusLogger.QUERY.warn("Query contains call to static method " + method + " yet no support is available for this");
        }
        return new InMemoryFailure();
    } else if (invokeExpr.getLeft() instanceof PrimaryExpression) {
        // {primaryExpr}.method(...)
        Object invokedValue = getValueForPrimaryExpression((PrimaryExpression) invokeExpr.getLeft());
        if (invokedValue instanceof InMemoryFailure) {
            return invokedValue;
        }
        // Invoke method on this object
        Class invokedType = invokedValue != null ? invokedValue.getClass() : invokeExpr.getLeft().getSymbol().getValueType();
        InvocationEvaluator methodEval = queryMgr.getInMemoryEvaluatorForMethod(invokedType, method);
        if (methodEval != null) {
            return methodEval.evaluate(invokeExpr, invokedValue, this);
        }
        NucleusLogger.QUERY.warn("Query contains call to method " + invokedType.getName() + "." + method + " yet no support is available for this");
        return new InMemoryFailure();
    } else if (invokeExpr.getLeft() instanceof InvokeExpression) {
        // {invokeExpr}.method(...)
        Object invokedValue = getValueForInvokeExpression((InvokeExpression) invokeExpr.getLeft());
        // Invoke method on this object
        Class invokedType = invokedValue != null ? invokedValue.getClass() : (invokeExpr.getLeft().getSymbol() != null ? invokeExpr.getLeft().getSymbol().getValueType() : null);
        if (invokedType == null) {
            return new InMemoryFailure();
        }
        InvocationEvaluator methodEval = queryMgr.getInMemoryEvaluatorForMethod(invokedType, method);
        if (methodEval != null) {
            return methodEval.evaluate(invokeExpr, invokedValue, this);
        }
        NucleusLogger.QUERY.warn("Query contains call to method " + invokedType.getName() + "." + method + " yet no support is available for this");
        return new InMemoryFailure();
    } else if (invokeExpr.getLeft() instanceof VariableExpression) {
        // {invokeExpr}.method(...)
        Object invokedValue = getValueForVariableExpression((VariableExpression) invokeExpr.getLeft());
        // Invoke method on this object
        Class invokedType = invokedValue != null ? invokedValue.getClass() : invokeExpr.getLeft().getSymbol().getValueType();
        InvocationEvaluator methodEval = queryMgr.getInMemoryEvaluatorForMethod(invokedType, method);
        if (methodEval != null) {
            return methodEval.evaluate(invokeExpr, invokedValue, this);
        }
        NucleusLogger.QUERY.warn("Query contains call to method " + invokedType.getName() + "." + method + " yet no support is available for this");
        return new InMemoryFailure();
    } else if (invokeExpr.getLeft() instanceof Literal) {
        // {invokeExpr}.method(...)
        Object invokedValue = ((Literal) invokeExpr.getLeft()).getLiteral();
        // Invoke method on this object
        Class invokedType = invokedValue != null ? invokedValue.getClass() : invokeExpr.getLeft().getSymbol().getValueType();
        InvocationEvaluator methodEval = queryMgr.getInMemoryEvaluatorForMethod(invokedType, method);
        if (methodEval != null) {
            return methodEval.evaluate(invokeExpr, invokedValue, this);
        }
        NucleusLogger.QUERY.warn("Query contains call to method " + invokedType.getName() + "." + method + " yet no support is available for this");
        return new InMemoryFailure();
    } else if (invokeExpr.getLeft() instanceof ArrayExpression) {
        // {invokeExpr}.method(...)
        Object invokedValue = getValueForArrayExpression((ArrayExpression) invokeExpr.getLeft());
        // Invoke method on this object
        Class invokedType = invokedValue.getClass();
        InvocationEvaluator methodEval = queryMgr.getInMemoryEvaluatorForMethod(invokedType, method);
        if (methodEval != null) {
            return methodEval.evaluate(invokeExpr, invokedValue, this);
        }
        NucleusLogger.QUERY.warn("Query contains call to method " + invokedType.getName() + "." + method + " yet no support is available for this");
        return new InMemoryFailure();
    } else {
        NucleusLogger.QUERY.warn("No support is available for in-memory evaluation of methods invoked" + " on expressions of type " + invokeExpr.getLeft().getClass().getName());
        return new InMemoryFailure();
    }
}

Example 23 with ParameterExpression

use of org.datanucleus.query.expression.ParameterExpression in project datanucleus-core by datanucleus.

the class JDOQLQueryHelper method getJDOQLForExpression.

public static String getJDOQLForExpression(Expression expr) {
    if (expr instanceof DyadicExpression) {
        DyadicExpression dyExpr = (DyadicExpression) expr;
        Expression left = dyExpr.getLeft();
        Expression right = dyExpr.getRight();
        StringBuilder str = new StringBuilder("(");
        if (dyExpr.getOperator() == Expression.OP_DISTINCT) {
            // Distinct goes in front of the left expression
            str.append("DISTINCT ");
        }
        if (left != null) {
            str.append(JDOQLQueryHelper.getJDOQLForExpression(left));
        }
        // Special cases
        if (dyExpr.getOperator() == Expression.OP_AND) {
            str.append(" && ");
        } else if (dyExpr.getOperator() == Expression.OP_OR) {
            str.append(" || ");
        } else if (dyExpr.getOperator() == Expression.OP_BIT_AND) {
            str.append(" & ");
        } else if (dyExpr.getOperator() == Expression.OP_BIT_OR) {
            str.append(" | ");
        } else if (dyExpr.getOperator() == Expression.OP_BIT_XOR) {
            str.append(" ^ ");
        } else if (dyExpr.getOperator() == Expression.OP_ADD) {
            str.append(" + ");
        } else if (dyExpr.getOperator() == Expression.OP_SUB) {
            str.append(" - ");
        } else if (dyExpr.getOperator() == Expression.OP_MUL) {
            str.append(" * ");
        } else if (dyExpr.getOperator() == Expression.OP_DIV) {
            str.append(" / ");
        } else if (dyExpr.getOperator() == Expression.OP_EQ) {
            str.append(" == ");
        } else if (dyExpr.getOperator() == Expression.OP_GT) {
            str.append(" > ");
        } else if (dyExpr.getOperator() == Expression.OP_LT) {
            str.append(" < ");
        } else if (dyExpr.getOperator() == Expression.OP_GTEQ) {
            str.append(" >= ");
        } else if (dyExpr.getOperator() == Expression.OP_LTEQ) {
            str.append(" <= ");
        } else if (dyExpr.getOperator() == Expression.OP_NOTEQ) {
            str.append(" != ");
        } else if (dyExpr.getOperator() == Expression.OP_DISTINCT) {
        // Processed above
        } else {
            // TODO Support other operators
            throw new UnsupportedOperationException("Dont currently support operator " + dyExpr.getOperator() + " in JDOQL conversion");
        }
        if (right != null) {
            str.append(JDOQLQueryHelper.getJDOQLForExpression(right));
        }
        str.append(")");
        return str.toString();
    } else if (expr instanceof PrimaryExpression) {
        PrimaryExpression primExpr = (PrimaryExpression) expr;
        if (primExpr.getLeft() != null) {
            return JDOQLQueryHelper.getJDOQLForExpression(primExpr.getLeft()) + "." + primExpr.getId();
        }
        return primExpr.getId();
    } else if (expr instanceof ParameterExpression) {
        ParameterExpression paramExpr = (ParameterExpression) expr;
        if (paramExpr.getId() != null) {
            return ":" + paramExpr.getId();
        }
        return "?" + paramExpr.getPosition();
    } else if (expr instanceof VariableExpression) {
        VariableExpression varExpr = (VariableExpression) expr;
        return varExpr.getId();
    } else if (expr instanceof InvokeExpression) {
        InvokeExpression invExpr = (InvokeExpression) expr;
        StringBuilder str = new StringBuilder();
        if (invExpr.getLeft() != null) {
            str.append(JDOQLQueryHelper.getJDOQLForExpression(invExpr.getLeft())).append(".");
        }
        str.append(invExpr.getOperation());
        str.append("(");
        List<Expression> args = invExpr.getArguments();
        if (args != null) {
            Iterator<Expression> iter = args.iterator();
            while (iter.hasNext()) {
                str.append(JDOQLQueryHelper.getJDOQLForExpression(iter.next()));
                if (iter.hasNext()) {
                    str.append(",");
                }
            }
        }
        str.append(")");
        return str.toString();
    } else if (expr instanceof Literal) {
        Literal litExpr = (Literal) expr;
        Object value = litExpr.getLiteral();
        if (value instanceof String || value instanceof Character) {
            return "'" + value.toString() + "'";
        } else if (value instanceof Boolean) {
            return (Boolean) value ? "TRUE" : "FALSE";
        } else {
            if (litExpr.getLiteral() == null) {
                return "null";
            }
            return litExpr.getLiteral().toString();
        }
    } else {
        throw new UnsupportedOperationException("Dont currently support " + expr.getClass().getName() + " in JDOQLHelper");
    }
}

Example 24 with ParameterExpression

use of org.datanucleus.query.expression.ParameterExpression in project datanucleus-core by datanucleus.

the class JPQLQueryHelper method getJPQLForExpression.

/**
 * Convenience method to return the JPQL single-string query text for the provided expression.
 * @param expr The expression
 * @return The JPQL single-string text that equates to this expression
 */
public static String getJPQLForExpression(Expression expr) {
    if (expr instanceof DyadicExpression) {
        DyadicExpression dyExpr = (DyadicExpression) expr;
        Expression left = dyExpr.getLeft();
        Expression right = dyExpr.getRight();
        StringBuilder str = new StringBuilder("(");
        if (left != null) {
            str.append(JPQLQueryHelper.getJPQLForExpression(left));
        }
        // Special cases
        if (right != null && right instanceof Literal && ((Literal) right).getLiteral() == null && (dyExpr.getOperator() == Expression.OP_EQ || dyExpr.getOperator() == Expression.OP_NOTEQ)) {
            str.append(dyExpr.getOperator() == Expression.OP_EQ ? " IS NULL" : " IS NOT NULL");
        } else {
            if (dyExpr.getOperator() == Expression.OP_AND) {
                str.append(" AND ");
            } else if (dyExpr.getOperator() == Expression.OP_OR) {
                str.append(" OR ");
            } else if (dyExpr.getOperator() == Expression.OP_ADD) {
                str.append(" + ");
            } else if (dyExpr.getOperator() == Expression.OP_SUB) {
                str.append(" - ");
            } else if (dyExpr.getOperator() == Expression.OP_MUL) {
                str.append(" * ");
            } else if (dyExpr.getOperator() == Expression.OP_DIV) {
                str.append(" / ");
            } else if (dyExpr.getOperator() == Expression.OP_EQ) {
                str.append(" = ");
            } else if (dyExpr.getOperator() == Expression.OP_GT) {
                str.append(" > ");
            } else if (dyExpr.getOperator() == Expression.OP_LT) {
                str.append(" < ");
            } else if (dyExpr.getOperator() == Expression.OP_GTEQ) {
                str.append(" >= ");
            } else if (dyExpr.getOperator() == Expression.OP_LTEQ) {
                str.append(" <= ");
            } else if (dyExpr.getOperator() == Expression.OP_NOTEQ) {
                str.append(" <> ");
            } else {
                // TODO Support other operators
                throw new UnsupportedOperationException("Dont currently support operator " + dyExpr.getOperator() + " in JPQL conversion");
            }
            if (right != null) {
                str.append(JPQLQueryHelper.getJPQLForExpression(right));
            }
        }
        str.append(")");
        return str.toString();
    } else if (expr instanceof PrimaryExpression) {
        PrimaryExpression primExpr = (PrimaryExpression) expr;
        return primExpr.getId();
    } else if (expr instanceof ParameterExpression) {
        ParameterExpression paramExpr = (ParameterExpression) expr;
        if (paramExpr.getId() != null) {
            return ":" + paramExpr.getId();
        }
        return "?" + paramExpr.getPosition();
    } else if (expr instanceof InvokeExpression) {
        InvokeExpression invExpr = (InvokeExpression) expr;
        Expression invoked = invExpr.getLeft();
        List<Expression> args = invExpr.getArguments();
        String method = invExpr.getOperation();
        if (method.equalsIgnoreCase("CURRENT_DATE")) {
            return "CURRENT_DATE";
        } else if (method.equalsIgnoreCase("CURRENT_TIME")) {
            return "CURRENT_TIME";
        } else if (method.equalsIgnoreCase("CURRENT_TIMESTAMP")) {
            return "CURRENT_TIMESTAMP";
        } else if (method.equalsIgnoreCase("length")) {
            StringBuilder str = new StringBuilder("LENGTH(");
            str.append(JPQLQueryHelper.getJPQLForExpression(invoked));
            if (args != null && !args.isEmpty()) {
                Expression firstExpr = args.get(0);
                str.append(",").append(JPQLQueryHelper.getJPQLForExpression(firstExpr));
                if (args.size() == 2) {
                    Expression secondExpr = args.get(1);
                    str.append(",").append(JPQLQueryHelper.getJPQLForExpression(secondExpr));
                }
            }
            str.append(")");
            return str.toString();
        } else if (method.equals("toLowerCase")) {
            return "LOWER(" + JPQLQueryHelper.getJPQLForExpression(invoked) + ")";
        } else if (method.equals("toUpperCase")) {
            return "UPPER(" + JPQLQueryHelper.getJPQLForExpression(invoked) + ")";
        } else if (method.equalsIgnoreCase("isEmpty")) {
            StringBuilder str = new StringBuilder();
            str.append(JPQLQueryHelper.getJPQLForExpression(invoked));
            str.append(" IS EMPTY");
            return str.toString();
        } else if (method.equalsIgnoreCase("indexOf")) {
            StringBuilder str = new StringBuilder("LOCATE(");
            str.append(JPQLQueryHelper.getJPQLForExpression(invoked));
            if (args != null && !args.isEmpty()) {
                Expression firstExpr = args.get(0);
                str.append(",").append(JPQLQueryHelper.getJPQLForExpression(firstExpr));
                if (args.size() > 1) {
                    Expression secondExpr = args.get(1);
                    str.append(",").append(JPQLQueryHelper.getJPQLForExpression(secondExpr));
                }
            }
            str.append(")");
            return str.toString();
        } else if (method.equalsIgnoreCase("substring")) {
            StringBuilder str = new StringBuilder("SUBSTRING(");
            str.append(JPQLQueryHelper.getJPQLForExpression(invoked));
            if (args != null && !args.isEmpty()) {
                Expression firstExpr = args.get(0);
                str.append(",").append(JPQLQueryHelper.getJPQLForExpression(firstExpr));
                if (args.size() > 1) {
                    Expression secondExpr = args.get(1);
                    str.append(",").append(JPQLQueryHelper.getJPQLForExpression(secondExpr));
                }
            }
            str.append(")");
            return str.toString();
        } else if (method.equalsIgnoreCase("trim")) {
            StringBuilder str = new StringBuilder("TRIM(BOTH ");
            str.append(JPQLQueryHelper.getJPQLForExpression(invoked));
            if (args != null && !args.isEmpty()) {
                Expression trimChrExpr = args.get(0);
                str.append(JPQLQueryHelper.getJPQLForExpression(trimChrExpr));
            }
            str.append(" FROM ");
            str.append(JPQLQueryHelper.getJPQLForExpression(invoked));
            str.append(")");
            return str.toString();
        } else if (method.equalsIgnoreCase("trimLeft")) {
            StringBuilder str = new StringBuilder("TRIM(LEADING ");
            str.append(JPQLQueryHelper.getJPQLForExpression(invoked));
            if (args != null && !args.isEmpty()) {
                Expression trimChrExpr = args.get(0);
                str.append(JPQLQueryHelper.getJPQLForExpression(trimChrExpr));
            }
            str.append(" FROM ");
            str.append(JPQLQueryHelper.getJPQLForExpression(invoked));
            str.append(")");
            return str.toString();
        } else if (method.equalsIgnoreCase("trimRight")) {
            StringBuilder str = new StringBuilder("TRIM(TRAILING ");
            str.append(JPQLQueryHelper.getJPQLForExpression(invoked));
            if (args != null && !args.isEmpty()) {
                Expression trimChrExpr = args.get(0);
                str.append(JPQLQueryHelper.getJPQLForExpression(trimChrExpr));
            }
            str.append(" FROM ");
            str.append(JPQLQueryHelper.getJPQLForExpression(invoked));
            str.append(")");
            return str.toString();
        } else if (method.equalsIgnoreCase("matches")) {
            if (args == null || args.isEmpty()) {
                throw new NucleusUserException("Cannot use 'matches' without an argument");
            }
            StringBuilder str = new StringBuilder();
            str.append(JPQLQueryHelper.getJPQLForExpression(invoked));
            str.append(" LIKE ");
            Expression firstExpr = args.get(0);
            str.append(JPQLQueryHelper.getJPQLForExpression(firstExpr));
            if (args != null && args.size() > 1) {
                Expression secondExpr = args.get(1);
                str.append(" ESCAPE ").append(JPQLQueryHelper.getJPQLForExpression(secondExpr));
            }
            return str.toString();
        } else if (method.equalsIgnoreCase("contains")) {
            StringBuilder str = new StringBuilder();
            if (args == null || args.isEmpty()) {
                throw new NucleusUserException("Cannot use 'contains' without an argument");
            }
            Expression firstExpr = args.get(0);
            str.append(JPQLQueryHelper.getJPQLForExpression(firstExpr));
            str.append(" MEMBER OF ");
            str.append(JPQLQueryHelper.getJPQLForExpression(invoked));
            return str.toString();
        } else if (method.equalsIgnoreCase("COUNT")) {
            if (args == null || args.isEmpty()) {
                throw new NucleusUserException("Cannot use 'COUNT' without an argument");
            }
            Expression argExpr = args.get(0);
            if (argExpr instanceof DyadicExpression && ((DyadicExpression) argExpr).getOperator() == Expression.OP_DISTINCT) {
                DyadicExpression dyExpr = (DyadicExpression) argExpr;
                return "COUNT(DISTINCT " + JPQLQueryHelper.getJPQLForExpression(dyExpr.getLeft()) + ")";
            }
            return "COUNT(" + JPQLQueryHelper.getJPQLForExpression(argExpr) + ")";
        } else if (method.equalsIgnoreCase("COALESCE")) {
            StringBuilder str = new StringBuilder("COALESCE(");
            if (args != null && !args.isEmpty()) {
                for (int i = 0; i < args.size(); i++) {
                    Expression argExpr = args.get(i);
                    str.append(JPQLQueryHelper.getJPQLForExpression(argExpr));
                    if (i < args.size() - 1) {
                        str.append(",");
                    }
                }
            }
            str.append(")");
            return str.toString();
        } else if (method.equalsIgnoreCase("NULLIF")) {
            StringBuilder str = new StringBuilder("NULLIF(");
            if (args != null && !args.isEmpty()) {
                for (int i = 0; i < args.size(); i++) {
                    Expression argExpr = args.get(i);
                    str.append(JPQLQueryHelper.getJPQLForExpression(argExpr));
                    if (i < args.size() - 1) {
                        str.append(",");
                    }
                }
            }
            str.append(")");
            return str.toString();
        } else if (method.equalsIgnoreCase("ABS")) {
            String argExprStr = (args != null && !args.isEmpty()) ? JPQLQueryHelper.getJPQLForExpression(args.get(0)) : "";
            return "ABS(" + argExprStr + ")";
        } else if (method.equalsIgnoreCase("AVG")) {
            String argExprStr = (args != null && !args.isEmpty()) ? JPQLQueryHelper.getJPQLForExpression(args.get(0)) : "";
            return "AVG(" + argExprStr + ")";
        } else if (method.equalsIgnoreCase("MAX")) {
            String argExprStr = (args != null && !args.isEmpty()) ? JPQLQueryHelper.getJPQLForExpression(args.get(0)) : "";
            return "MAX(" + argExprStr + ")";
        } else if (method.equalsIgnoreCase("MIN")) {
            String argExprStr = (args != null && !args.isEmpty()) ? JPQLQueryHelper.getJPQLForExpression(args.get(0)) : "";
            return "MIN(" + argExprStr + ")";
        } else if (method.equalsIgnoreCase("SQRT")) {
            String argExprStr = (args != null && !args.isEmpty()) ? JPQLQueryHelper.getJPQLForExpression(args.get(0)) : "";
            return "SQRT(" + argExprStr + ")";
        } else if (method.equalsIgnoreCase("SUM")) {
            String argExprStr = (args != null && !args.isEmpty()) ? JPQLQueryHelper.getJPQLForExpression(args.get(0)) : "";
            return "SUM(" + argExprStr + ")";
        }
        // TODO Support this
        throw new UnsupportedOperationException("Dont currently support InvokeExpression (" + invExpr + ") conversion into JPQL");
    } else if (expr instanceof Literal) {
        Literal litExpr = (Literal) expr;
        Object value = litExpr.getLiteral();
        if (value instanceof String || value instanceof Character) {
            return "'" + value.toString() + "'";
        } else if (value instanceof Boolean) {
            return (Boolean) value ? "TRUE" : "FALSE";
        } else {
            return litExpr.getLiteral().toString();
        }
    } else if (expr instanceof VariableExpression) {
        VariableExpression varExpr = (VariableExpression) expr;
        return varExpr.getId();
    } else {
        throw new UnsupportedOperationException("Dont currently support " + expr.getClass().getName() + " in JPQLQueryHelper");
    }
}

Example 25 with ParameterExpression

use of org.datanucleus.query.expression.ParameterExpression in project datanucleus-api-jdo by datanucleus.

the class JDOQLTypedQueryImpl method setParameter.

/* (non-Javadoc)
     * @see javax.jdo.JDOQLTypedQuery#setParameter(org.datanucleus.query.typesafe.Expression, java.lang.Object)
     */
public JDOQLTypedQuery<T> setParameter(Expression paramExpr, Object value) {
    assertIsOpen();
    discardCompiled();
    ParameterExpression internalParamExpr = (ParameterExpression) ((ExpressionImpl) paramExpr).getQueryExpression();
    if (parameterExprByName == null || (parameterExprByName != null && !parameterExprByName.containsKey(internalParamExpr.getAlias()))) {
        throw new JDOUserException("Parameter with name " + internalParamExpr.getAlias() + " doesnt exist for this query");
    }
    if (parameterValuesByName == null) {
        parameterValuesByName = new ConcurrentHashMap<>();
    }
    parameterValuesByName.put(internalParamExpr.getAlias(), value);
    return this;
}