/** * Expr: {@code this like str} ignoring case * * @param str string * @param escape escape character * @return this like string */ public BooleanExpression likeIgnoreCase(String str, char escape) { return BooleanOperation.create(Ops.LIKE_ESCAPE_IC, mixin, ConstantImpl.create(str), ConstantImpl.create(escape)); }
/** * @param num * @param exponent * @return power(num, exponent) */ public static <A extends Number & Comparable<?>> NumberExpression<Double> power(Expression<A> num, int exponent) { return NumberOperation.create(Double.class, Ops.MathOps.POWER, num, ConstantImpl.create(exponent)); }
/** * Prepend the given String and return the result * * @param str * @return str + this */ public StringExpression prepend(String str) { return prepend(ConstantImpl.create(str)); }
/** * @param in * @param length * @return */ public static StringExpression rpad(Expression<String> in, int length) { return StringOperation.create(Ops.StringOps.RPAD, in, ConstantImpl.create(length)); }
/** * Create a cast expression to the given numeric type * * @param <A> * @param type * @return */ public <A extends Number & Comparable<? super A>> NumberExpression<A> castToNum(Class<A> type) { return NumberOperation.create(type, Ops.NUMCAST, mixin, ConstantImpl.create(type)); }
/** * Get a {@code this >= right} expression * * @param right rhs of the comparison * @return * @see java.lang.Comparable#compareTo(Object) */ public BooleanExpression goe(T right) { return goe(ConstantImpl.create(right)); }
/** * Get a nextval(sequence) expression of the given type * * @param type * @param sequence * @return */ public static <T extends Number> SimpleExpression<T> nextval(Class<T> type, String sequence) { return SimpleOperation.create(type, SQLOps.NEXTVAL, ConstantImpl.create(sequence)); }
/** * Get a datediff(unit, start, end) expression * * @param unit * @param start * @param end * @return */ public static <D extends Comparable> NumberExpression<Integer> datediff(DatePart unit, DateExpression<D> start, D end) { return NumberOperation.create(Integer.class, DATE_DIFF_OPS.get(unit), start, ConstantImpl.create(end)); }
/** * Get a {@code this > right} expression * * @param right rhs of the comparison * @return * @see java.lang.Comparable#compareTo(Object) */ public BooleanExpression gt(T right) { return gt(ConstantImpl.create(right)); }
/** * Get a case expression builder * * @param other * @return */ public CaseForEqBuilder<T> when(T other) { return new CaseForEqBuilder<T>(mixin, ConstantImpl.create(other)); }
@Override public Object apply(Object arg) { if (arg instanceof Constant) { return ConstantImpl.create(apply(arg.toString()).toString()); } else if (arg instanceof Expression) { return OperationImpl.create(String.class, Ops.UPPER, (Expression)arg); } else { return String.valueOf(arg).toUpperCase(Locale.ENGLISH); } } };
@Override public Object apply(Object arg) { if (arg instanceof Constant) { return ConstantImpl.create(apply(arg.toString()).toString()); } else if (arg instanceof Expression) { return OperationImpl.create(String.class, Ops.LOWER, (Expression)arg); } else { return arg.toString().toLowerCase(Locale.ENGLISH); } } };
/** * Get a dateadd(unit, date, amount) expression * * @param unit * @param date * @param amount * @return */ public static <D extends Comparable> DateTimeExpression<D> dateadd(DatePart unit, DateTimeExpression<D> date, int amount) { return DateTimeOperation.create((Class)date.getType(), DATE_ADD_OPS.get(unit), date, ConstantImpl.create(amount)); }
@Override public Object apply(Object arg) { if (arg instanceof Constant) { return ConstantImpl.create(apply(arg.toString()).toString()); } else if (arg instanceof Expression) { return OperationImpl.create(String.class, Ops.CONCAT, (Expression)arg, PERCENT); } else { return escapeForLike(arg.toString()) + "%"; } } };
@Override public Object apply(Object arg) { if (arg instanceof Constant) { return ConstantImpl.create(apply(arg.toString()).toString()); } else if (arg instanceof Expression) { return OperationImpl.create(String.class, Ops.CONCAT, (Expression)arg, PERCENT); } else { return escapeForLike(String.valueOf(arg)) + "%"; } } };
/** * Add the given amount of years to the date * * @param date * @param years * @return */ public static <D extends Comparable> DateTimeExpression<D> addYears(DateTimeExpression<D> date, int years) { return DateTimeOperation.create((Class)date.getType(), Ops.DateTimeOps.ADD_YEARS, date, ConstantImpl.create(years)); }
/** * Add the given amount of days to the date * * @param date * @param days * @return */ public static <D extends Comparable> DateExpression<D> addDays(DateExpression<D> date, int days) { return DateOperation.create((Class)date.getType(), Ops.DateTimeOps.ADD_DAYS, date, ConstantImpl.create(days)); }
/** * Get the sum of this and right * * @param right * @return this + right */ public <N extends Number & Comparable<N>> NumberExpression<T> add(N right) { return NumberOperation.create(getType(), Ops.ADD, mixin, ConstantImpl.create(right)); }
/** * Create a {@code this > right} expression * * @param <A> * @param right rhs of the comparison * @return {@code this > right} * @see java.lang.Comparable#compareTo(Object) */ public final <A extends Number & Comparable<?>> BooleanExpression gt(A right) { return gt(ConstantImpl.create(cast(right))); }
/** * Create a {@code this < right} expression * * @param <A> * @param right rhs of the comparison * @return {@code this < right} * @see java.lang.Comparable#compareTo(Object) */ public final <A extends Number & Comparable<?>> BooleanExpression lt(A right) { return lt(ConstantImpl.create(cast(right))); }