@Override @SuppressWarnings({"unchecked"}) public Expression<Number> quot( Expression<? extends Number> expression1, Expression<? extends Number> expression2) { if (expression1 == null || expression2 == null) { throw new IllegalArgumentException("arguments to quot() cannot be null"); } final Class resultType = BinaryArithmeticOperation.determineResultType( expression1.getJavaType(), expression2.getJavaType(), true); return new BinaryArithmeticOperation<Number>( this, resultType, BinaryArithmeticOperation.Operation.DIVIDE, expression1, expression2); }
protected <T> Object[] parseIn(Expression<?> path, JsonNode fieldValue) throws QueryInfoException { Class<?> javaType = path.getJavaType(); TypeFactory typeFactory = objectMapper.getTypeFactory(); ArrayType arrayType = typeFactory.constructArrayType(javaType); return objectMapper.convertValue(fieldValue, arrayType); }
@Override @SuppressWarnings({"unchecked"}) public Coalesce<T> value(Expression<? extends T> value) { expressions.add(value); if (javaType == null) { javaType = (Class<T>) value.getJavaType(); } return this; }
@Override @SuppressWarnings({"unchecked"}) public <N extends Number> Expression<N> diff(N n, Expression<? extends N> expression) { if (n == null || expression == null) { throw new IllegalArgumentException("arguments to diff() cannot be null"); } final Class resultType = BinaryArithmeticOperation.determineResultType(n.getClass(), expression.getJavaType()); return new BinaryArithmeticOperation<N>( this, resultType, BinaryArithmeticOperation.Operation.SUBTRACT, n, expression); }
@Override @SuppressWarnings({"unchecked"}) public <N extends Number> Expression<N> prod(Expression<? extends N> expression, N n) { if (expression == null || n == null) { throw new IllegalArgumentException("arguments to prod() cannot be null"); } final Class resultType = BinaryArithmeticOperation.determineResultType(expression.getJavaType(), n.getClass()); return new BinaryArithmeticOperation<N>( this, resultType, BinaryArithmeticOperation.Operation.MULTIPLY, expression, n); }
/** * Creates a criteria API {@link javax.persistence.criteria.Order} from the given {@link Order}. * * @param order the order to transform into a JPA {@link javax.persistence.criteria.Order} * @param root the {@link Root} the {@link Order} expression is based on * @param cb the {@link CriteriaBuilder} to build the {@link javax.persistence.criteria.Order} * with * @return */ @SuppressWarnings("unchecked") private static javax.persistence.criteria.Order toJpaOrder( Order order, Root<?> root, CriteriaBuilder cb) { PropertyPath property = PropertyPath.from(order.getProperty(), root.getJavaType()); Expression<?> expression = toExpressionRecursively(root, property); if (order.isIgnoreCase() && String.class.equals(expression.getJavaType())) { Expression<String> lower = cb.lower((Expression<String>) expression); return order.isAscending() ? cb.asc(lower) : cb.desc(lower); } else { return order.isAscending() ? cb.asc(expression) : cb.desc(expression); } }
public Object parse(Expression<?> path, ConditionOperator conditionOperator, JsonNode fieldValue) throws QueryInfoException { Object result; Class<?> javaType = path.getJavaType(); boolean isEitherInOperator = ConditionOperator.isEitherInOperator(conditionOperator); if (isEitherInOperator) { result = parseIn(path, fieldValue); } else if (Date.class.isAssignableFrom(javaType)) { result = parseDate(fieldValue); } else { result = parseType(fieldValue, javaType); } return result; }
/** * Helper for determining the appropriate operation return type based on one of the operands as an * expression. * * @param defaultType The default return type to use if we cannot determine the java type of * 'expression' operand. * @param expression The operand. * @return The appropriate return type. */ public static Class<? extends Number> determineReturnType( Class<? extends Number> defaultType, Expression<? extends Number> expression) { return expression == null || expression.getJavaType() == null ? defaultType : expression.getJavaType(); }