@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();
}
