/** * Get a hours expression (range 0-23) * * @return */ public NumberExpression<Integer> hour() { if (hours == null) { hours = NumberOperation.create(Integer.class, Ops.DateTimeOps.HOUR, mixin); } return hours; }
/** * Get a year / month expression * * @return */ public NumberExpression<Integer> yearMonth() { if (yearMonth == null) { yearMonth = NumberOperation.create(Integer.class, Ops.DateTimeOps.YEAR_MONTH, mixin); } return yearMonth; }
/** * @param num * @return rad(num) */ public static <A extends Number & Comparable<?>> NumberExpression<Double> radians(Expression<A> num) { return NumberOperation.create(Double.class, Ops.MathOps.RAD, num); }
/** * Get a minutes expression (range 0-59) * * @return */ public NumberExpression<Integer> minute() { if (minutes == null) { minutes = NumberOperation.create(Integer.class, Ops.DateTimeOps.MINUTE, mixin); } return minutes; }
/** * Get a year expression * * @return */ public NumberExpression<Integer> year() { if (year == null) { year = NumberOperation.create(Integer.class, Ops.DateTimeOps.YEAR, mixin); } return year; }
/** * Get the square root of this numeric expressions * * @return sqrt(this) */ public NumberExpression<Double> sqrt() { if (sqrt == null) { sqrt = NumberOperation.create(Double.class, MathOps.SQRT, mixin); } return sqrt; }
/** * Get a minutes expression (range 0-59) * * @return */ public NumberExpression<Integer> minute() { if (minutes == null) { minutes = NumberOperation.create(Integer.class, Ops.DateTimeOps.MINUTE, mixin); } return minutes; }
/** * @param num * @return acos(num) */ public static <A extends Number & Comparable<?>> NumberExpression<Double> acos(Expression<A> num) { return NumberOperation.create(Double.class, Ops.MathOps.ACOS, num); }
/** * @param num * @return cos(num) */ public static <A extends Number & Comparable<?>> NumberExpression<Double> cos(Expression<A> num) { return NumberOperation.create(Double.class, Ops.MathOps.COS, num); }
/** * @param num * @return cosh(num) */ public static <A extends Number & Comparable<?>> NumberExpression<Double> cosh(Expression<A> num) { return NumberOperation.create(Double.class, Ops.MathOps.COSH, num); }
/** * @param num * @return cot(num) */ public static <A extends Number & Comparable<?>> NumberExpression<Double> cot(Expression<A> num) { return NumberOperation.create(Double.class, Ops.MathOps.COT, num); }
/** * @param num * @return exp(num) */ public static <A extends Number & Comparable<?>> NumberExpression<Double> exp(Expression<A> num) { return NumberOperation.create(Double.class, Ops.MathOps.EXP, num); }
@SuppressWarnings("unchecked") @Override protected NumberExpression<T> createResult(Class<T> type, Expression<T> last) { return NumberOperation.create(type, Ops.CASE_EQ, base, last); }
/** * @param num * @param base * @return log(num, base) */ public static <A extends Number & Comparable<?>> NumberExpression<Double> log(Expression<A> num, int base) { return NumberOperation.create(Double.class, Ops.MathOps.LOG, num, ConstantImpl.create(base)); }
/** * Get a datediff(unit, start, end) expression * * @param unit * @param start * @param end * @return */ public static <D extends Comparable> NumberExpression<Integer> datediff(DatePart unit, D start, DateTimeExpression<D> end) { return NumberOperation.create(Integer.class, DATE_DIFF_OPS.get(unit), ConstantImpl.create(start), end); }
/** * Get the sum of this and right * * @param right * @return this + right */ public <N extends Number & Comparable<?>> NumberExpression<T> add(Expression<N> right) { return NumberOperation.create(getType(), Ops.ADD, mixin, right); }
/** * Get the minimum value of this expression (aggregation) * * @return min(this) */ @SuppressWarnings("unchecked") public NumberExpression<T> min() { if (min == null) { min = NumberOperation.create(getType(), Ops.AggOps.MIN_AGG, mixin); } return min; }
/** * @param num * @return */ public NumberExpression<T> mod(Expression<T> num) { return NumberOperation.create(getType(), Ops.MOD, mixin, num); }
/** * Round to s decimal places * * @param num * @param s * @return */ public static <A extends Number & Comparable<?>> NumberExpression<A> round(Expression<A> num, int s) { return NumberOperation.create(num.getType(), MathOps.ROUND2, num, ConstantImpl.create(s)); }
/** * Get the result of the operation this / right * * @param right * @return this / right */ public <N extends Number & Comparable<?>> NumberExpression<T> divide(Expression<N> right) { Class<?> type = getDivisionType(getType(), right.getType()); return NumberOperation.create((Class<T>)type, Ops.DIV, mixin, right); }