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

Example 11 with Literal

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

the class StringSubstringMethod method evaluate.

/* (non-Javadoc)
     * @see org.datanucleus.query.evaluator.memory.InvocationEvaluator#evaluate(org.datanucleus.query.expression.InvokeExpression, org.datanucleus.query.evaluator.memory.InMemoryExpressionEvaluator)
     */
public Object evaluate(InvokeExpression expr, Object invokedValue, InMemoryExpressionEvaluator eval) {
    String method = expr.getOperation();
    if (invokedValue == null) {
        return null;
    }
    if (!(invokedValue instanceof String)) {
        throw new NucleusException(Localiser.msg("021011", method, invokedValue.getClass().getName()));
    }
    int arg0 = -1;
    Expression arg0Expr = expr.getArguments().get(0);
    Object arg0Val = null;
    if (arg0Expr instanceof PrimaryExpression) {
        arg0Val = eval.getValueForPrimaryExpression((PrimaryExpression) arg0Expr);
    } else if (arg0Expr instanceof ParameterExpression) {
        arg0Val = QueryUtils.getValueForParameterExpression(eval.getParameterValues(), (ParameterExpression) arg0Expr);
    } else if (arg0Expr instanceof Literal) {
        arg0Val = ((Literal) arg0Expr).getLiteral();
    } else if (arg0Expr instanceof DyadicExpression) {
        arg0Val = ((DyadicExpression) arg0Expr).evaluate(eval);
    }
    if (!(arg0Val instanceof Number)) {
        throw new NucleusException(method + "(param1[,param2]) : param1 must be numeric");
    }
    arg0 = ((Number) arg0Val).intValue();
    String result = null;
    if (expr.getArguments().size() == 2) {
        int arg1 = -1;
        Expression arg1Expr = expr.getArguments().get(1);
        Object arg1Val = null;
        if (arg1Expr instanceof PrimaryExpression) {
            arg1Val = eval.getValueForPrimaryExpression((PrimaryExpression) arg1Expr);
        } else if (arg1Expr instanceof ParameterExpression) {
            arg1Val = QueryUtils.getValueForParameterExpression(eval.getParameterValues(), (ParameterExpression) arg1Expr);
        } else if (arg1Expr instanceof Literal) {
            arg1Val = ((Literal) arg1Expr).getLiteral();
        } else if (arg0Expr instanceof DyadicExpression) {
            arg1Val = ((DyadicExpression) arg1Expr).evaluate(eval);
        }
        if (!(arg1Val instanceof Number)) {
            throw new NucleusException(method + "(param1,param2) : param2 must be numeric");
        }
        arg1 = ((Number) arg1Val).intValue();
        if (((String) invokedValue).length() < arg1) {
            if (((String) invokedValue).length() < arg0) {
                return null;
            }
            return ((String) invokedValue).substring(arg0);
        }
        result = ((String) invokedValue).substring(arg0, arg1);
    } else {
        if (((String) invokedValue).length() < arg0) {
            return null;
        }
        result = ((String) invokedValue).substring(arg0);
    }
    return result;
}

Example 12 with Literal

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

the class OptionalOrElseMethod method evaluate.

/* (non-Javadoc)
     * @see org.datanucleus.query.evaluator.memory.InvocationEvaluator#evaluate(org.datanucleus.query.expression.InvokeExpression, org.datanucleus.query.evaluator.memory.InMemoryExpressionEvaluator)
     */
public Object evaluate(InvokeExpression expr, Object invokedValue, InMemoryExpressionEvaluator eval) {
    String method = expr.getOperation();
    if (invokedValue == null) {
        return null;
    }
    if (!(invokedValue instanceof Optional)) {
        throw new NucleusException(Localiser.msg("021011", method, invokedValue.getClass().getName()));
    }
    List<Expression> args = expr.getArguments();
    if (args == null || args.isEmpty() || args.size() != 1) {
        throw new NucleusException("orElse requires one argument");
    }
    Expression argExpr = args.get(0);
    Object argument = null;
    if (argExpr instanceof Literal) {
        argument = ((Literal) argExpr).getLiteral();
    } else if (argExpr instanceof PrimaryExpression) {
        PrimaryExpression primExpr = (PrimaryExpression) argExpr;
        argument = eval.getValueForPrimaryExpression(primExpr);
    } else if (argExpr instanceof ParameterExpression) {
        ParameterExpression paramExpr = (ParameterExpression) argExpr;
        argument = QueryUtils.getValueForParameterExpression(eval.getParameterValues(), paramExpr);
    } else if (argExpr instanceof InvokeExpression) {
        argument = eval.getValueForInvokeExpression((InvokeExpression) argExpr);
    } else if (argExpr instanceof DyadicExpression) {
        argument = ((DyadicExpression) argExpr).evaluate(eval);
    } else {
        throw new NucleusException(method + "(param1) where param is instanceof " + argExpr.getClass().getName() + " not supported");
    }
    return ((Optional) invokedValue).orElse(argument);
}

Example 13 with Literal

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

the class LocateFunction method evaluate.

/* (non-Javadoc)
     * @see org.datanucleus.query.evaluator.memory.InvocationEvaluator#evaluate(org.datanucleus.query.expression.InvokeExpression, org.datanucleus.query.evaluator.memory.InMemoryExpressionEvaluator)
     */
public Object evaluate(InvokeExpression expr, Object invokedValue, InMemoryExpressionEvaluator eval) {
    String method = expr.getOperation();
    Object param = expr.getArguments().get(0);
    Object paramValue = null;
    if (param instanceof PrimaryExpression) {
        PrimaryExpression primExpr = (PrimaryExpression) param;
        paramValue = eval.getValueForPrimaryExpression(primExpr);
    } else if (param instanceof ParameterExpression) {
        ParameterExpression paramExpr = (ParameterExpression) param;
        paramValue = QueryUtils.getValueForParameterExpression(eval.getParameterValues(), paramExpr);
    } else if (param instanceof Literal) {
        paramValue = ((Literal) param).getLiteral();
    } else {
        throw new NucleusException(method + "(str1, str2, pos) where str1 is instanceof " + param.getClass().getName() + " not supported");
    }
    if (paramValue == null) {
        return Integer.valueOf(-1);
    }
    Object locStr = expr.getArguments().get(1);
    String locStrValue = null;
    if (locStr instanceof Literal) {
        locStrValue = (String) ((Literal) locStr).getLiteral();
    } else {
        throw new NucleusException(method + "(str, str2, pos) where str2 is instanceof " + locStr.getClass().getName() + " not supported");
    }
    if (expr.getArguments().size() == 3) {
        Object pos = expr.getArguments().get(2);
        int num2Value = -1;
        if (pos instanceof Literal) {
            num2Value = eval.getIntegerForLiteral((Literal) pos);
        } else {
            throw new NucleusException(method + "(str, str2, pos) where pos is instanceof " + pos.getClass().getName() + " not supported");
        }
        return Integer.valueOf(((String) paramValue).indexOf(locStrValue, num2Value));
    }
    return Integer.valueOf(((String) paramValue).indexOf(locStrValue));
}

Example 14 with Literal

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

the class LowerFunction method evaluate.

/* (non-Javadoc)
     * @see org.datanucleus.query.evaluator.memory.InvocationEvaluator#evaluate(org.datanucleus.query.expression.InvokeExpression, org.datanucleus.query.evaluator.memory.InMemoryExpressionEvaluator)
     */
public Object evaluate(InvokeExpression expr, Object invokedValue, InMemoryExpressionEvaluator eval) {
    String method = expr.getOperation();
    Object param = expr.getArguments().get(0);
    Object paramValue = null;
    if (param instanceof PrimaryExpression) {
        PrimaryExpression primExpr = (PrimaryExpression) param;
        paramValue = eval.getValueForPrimaryExpression(primExpr);
    } else if (param instanceof ParameterExpression) {
        ParameterExpression paramExpr = (ParameterExpression) param;
        paramValue = QueryUtils.getValueForParameterExpression(eval.getParameterValues(), paramExpr);
    } else if (param instanceof Literal) {
        paramValue = ((Literal) param).getLiteral();
    } else {
        throw new NucleusException(method + "(param) where param is instanceof " + param.getClass().getName() + " not supported");
    }
    if (paramValue == null) {
        return null;
    }
    if (!(paramValue instanceof String)) {
        throw new NucleusException(Localiser.msg("021011", method, paramValue.getClass().getName()));
    }
    return ((String) paramValue).toLowerCase();
}

Example 15 with Literal

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

the class CoalesceFunction method getValueForArgExpression.

protected Object getValueForArgExpression(Expression argExpr, InMemoryExpressionEvaluator eval) {
    Object argValue = null;
    if (argExpr instanceof PrimaryExpression) {
        PrimaryExpression primExpr = (PrimaryExpression) argExpr;
        argValue = eval.getValueForPrimaryExpression(primExpr);
    } else if (argExpr instanceof ParameterExpression) {
        ParameterExpression paramExpr = (ParameterExpression) argExpr;
        argValue = QueryUtils.getValueForParameterExpression(eval.getParameterValues(), paramExpr);
    } else if (argExpr instanceof Literal) {
        argValue = ((Literal) argExpr).getLiteral();
    } else {
        throw new NucleusException("Don't support COALESCE with argument of type " + argExpr.getClass().getName());
    }
    return argValue;
}