@SuppressWarnings("unchecked") protected CollectionOperation(Class<? super E> type, Operator op, ImmutableList<Expression<?>> args) { super(ExpressionUtils.operation((Class) Collection.class, op, args)); this.opMixin = (OperationImpl) super.mixin; this.elementType = (Class<E>) type; }
/** * Create a {@code count(source)} expression * * @param source source * @return count(source) */ public static Expression<Long> count(Expression<?> source) { return operation(Long.class, Ops.AggOps.COUNT_AGG, source); }
protected DateTimeOperation(Class<? extends T> type, Operator op, ImmutableList<Expression<?>> args) { super(ExpressionUtils.operation(type, op, args)); this.opMixin = (OperationImpl<T>) mixin; }
protected PolygonOperation(Class<? extends T> type, Operator op, ImmutableList<Expression<?>> args) { super(ExpressionUtils.operation(type, op, args)); this.opMixin = (OperationImpl<T>) mixin; }
protected StringOperation(Operator op, ImmutableList<Expression<?>> args) { super(ExpressionUtils.operation(String.class, op, args)); this.opMixin = (OperationImpl<String>) mixin; }
protected TimeOperation(Class<? extends T> type, Operator op, ImmutableList<Expression<?>> args) { super(ExpressionUtils.operation(type, op, args)); this.opMixin = (OperationImpl<T>) mixin; }
protected JTSLineStringOperation(Class<? extends T> type, Operator op, ImmutableList<Expression<?>> args) { super(ExpressionUtils.operation(type, op, args)); this.opMixin = (OperationImpl<T>) mixin; }
/** * Create a new Operation expression * * @param type type of expression * @param operator operator * @param args operation arguments * @return operation expression */ public static <T> Operation<T> operation(Class<? extends T> type, Operator operator, Expression<?>... args) { return operation(type, operator, ImmutableList.copyOf(args)); }
/** * Create an expression out of the given order specifiers * * @param args order * @return expression for order */ public static Expression<?> orderBy(List<OrderSpecifier<?>> args) { return operation(Object.class, Ops.ORDER, ConstantImpl.create(args)); }
/** * Create an alias expression with the given source and alias * * @param <D> type of expression * @param source source * @param alias alias * @return source as alias */ public static <D> Expression<D> as(Expression<D> source, Path<D> alias) { return operation(alias.getType(), Ops.ALIAS, source, alias); }
/** * Create an alias for the expression * * @return this as alias */ @SuppressWarnings("unchecked") public Expression<T> as(Path<T> alias) { return ExpressionUtils.operation(getType(),Ops.ALIAS, this, alias); }
/** * Create an alias for the expression * * @return alias expression */ @SuppressWarnings("unchecked") public Expression<T> as(Path<T> alias) { return ExpressionUtils.operation(getType(), Ops.ALIAS, this, alias); }
@Override public Object apply(Object arg) { if (arg instanceof Constant<?>) { return ConstantImpl.create(apply(arg.toString()).toString()); } else if (arg instanceof Expression) { Expression<String> concatenated = ExpressionUtils.operation(String.class, Ops.CONCAT, (Expression) arg, PERCENT); return ExpressionUtils.operation(String.class, Ops.LOWER, concatenated); } else { return escapeForLike(String.valueOf(arg).toLowerCase()) + "%"; } } };
@Override public Object apply(Object arg) { if (arg instanceof Constant<?>) { return ConstantImpl.create(apply(arg.toString()).toString()); } else if (arg instanceof Expression) { Expression<String> concatenated = ExpressionUtils.operation(String.class, Ops.CONCAT, PERCENT, (Expression) arg); return ExpressionUtils.operation(String.class, Ops.CONCAT, concatenated, PERCENT); } else { return "%" + escapeForLike(String.valueOf(arg)) + "%"; } } };
@Override public Object apply(Object arg) { if (arg instanceof Constant<?>) { return ConstantImpl.create(apply(arg.toString()).toString()); } else if (arg instanceof Expression) { Expression<String> concatenated = ExpressionUtils.operation(String.class, Ops.CONCAT, PERCENT, (Expression) arg); return ExpressionUtils.operation(String.class, Ops.LOWER, concatenated); } else { return "%" + escapeForLike(String.valueOf(arg).toLowerCase()); } } };
@Override public Object apply(Object arg) { if (arg instanceof Constant<?>) { return ConstantImpl.create(apply(arg.toString()).toString()); } else if (arg instanceof Expression) { return ExpressionUtils.operation(String.class, Ops.LOWER, (Expression) arg); } else { return String.valueOf(arg).toLowerCase(); } } };
@Override public Object apply(Object arg) { if (arg instanceof Constant<?>) { return ConstantImpl.create(apply(arg.toString()).toString()); } else if (arg instanceof Expression) { return ExpressionUtils.operation(String.class, Ops.UPPER, (Expression) arg); } else { return String.valueOf(arg).toUpperCase(); } } };
@Override public Object apply(Object arg) { if (arg instanceof Constant<?>) { return ConstantImpl.create(apply(arg.toString()).toString()); } else if (arg instanceof Expression) { return ExpressionUtils.operation(String.class, Ops.CONCAT, (Expression) arg, PERCENT); } else { return escapeForLike(String.valueOf(arg)) + "%"; } } };
@Override public Object apply(Object arg) { if (arg instanceof Constant) { return ConstantImpl.create(apply(arg.toString()).toString()); } else if (arg instanceof Expression) { return ExpressionUtils.operation(String.class, Ops.CONCAT, PERCENT, (Expression) arg); } else { return "%" + escapeForLike(String.valueOf(arg)); } } };
@Override public Expression<?> visit(Operation<?> expr, C context) { ImmutableList<Expression<?>> args = visit(expr.getArgs(), context); if (args.equals(expr.getArgs())) { return expr; } else if (expr instanceof Predicate) { return ExpressionUtils.predicate(expr.getOperator(), args); } else { return ExpressionUtils.operation(expr.getType(), expr.getOperator(), args); } }