/** * Convert timestamp to date * * @param type * @param dateTime * @return */ public static <D extends Comparable> DateExpression<D> date(Class<D> type, DateTimeExpression<?> dateTime) { return DateOperation.create(type, Ops.DateTimeOps.DATE, dateTime); }
public static <D extends Comparable<?>> DateExpression<D> create(Class<D> type, Operator<? super D> op, Expression<?>... args) { return new DateOperation<D>(type, op, args); }
/** * Create a new Operation expression * * @param type * @param operator * @param args * @return */ public static <T extends Comparable<?>> DateExpression<T> dateOperation(Class<T> type, Operator<? super T> operator, Expression<?>... args) { return DateOperation.create(type, operator, args); }
public static <D extends Comparable<?>> DateExpression<D> create(Class<D> type, Operator<? super D> op, Expression<?> one, Expression<?> two) { return new DateOperation<D>(type, op, ImmutableList.of(one, two)); }
/** * Get an expression representing the current date as a DateExpression instance * * @return */ public static <T extends Comparable> DateExpression<T> currentDate(Class<T> cl) { return DateOperation.create(cl, Ops.DateTimeOps.CURRENT_DATE); }
public static <D extends Comparable<?>> DateExpression<D> create(Class<D> type, Operator<? super D> op, Expression<?> one) { return new DateOperation<D>(type, op, ImmutableList.<Expression<?>>of(one)); }
@Override protected DateExpression<T> createResult(Class<T> type, Expression<T> last) { return DateOperation.create(type, Ops.CASE, last); }
/** * Get the maximum value of this expression (aggregation) * * @return max(this) */ public DateExpression<T> max() { if (max == null) { max = DateOperation.create(getType(), Ops.AggOps.MAX_AGG, mixin); } return max; }
/** * Truncate the given date expression * * @param unit * @param expr */ public static <D extends Comparable> DateExpression<D> datetrunc(DatePart unit, DateExpression<D> expr) { return DateOperation.create(expr.getType(), DATE_TRUNC_OPS.get(unit), expr); }
@Override public DateExpression<T> as(Path<T> alias) { return DateOperation.create((Class<T>)getType(), Ops.ALIAS, mixin, alias); }
/** * Get the minimum value of this expression (aggregation) * * @return min(this) */ public DateExpression<T> min() { if (min == null) { min = DateOperation.create(getType(), Ops.AggOps.MIN_AGG, mixin); } return min; }
/** * Convert timestamp to date * * @param dateTime * @return */ public static <D extends Comparable> DateExpression<D> date(DateTimeExpression<D> dateTime) { return DateOperation.create((Class)dateTime.getType(), Ops.DateTimeOps.DATE, dateTime); }
/** * Get a dateadd(unit, date, amount) expression * * @param unit * @param date * @param amount * @return */ public static <D extends Comparable> DateExpression<D> dateadd(DatePart unit, DateExpression<D> date, int amount) { return DateOperation.create((Class)date.getType(), DATE_ADD_OPS.get(unit), date, ConstantImpl.create(amount)); }
/** * Add the given amount of months to the date * * @param date * @param months * @return */ public static <D extends Comparable> DateExpression<D> addMonths(DateExpression<D> date, int months) { return DateOperation.create((Class)date.getType(), Ops.DateTimeOps.ADD_MONTHS, date, ConstantImpl.create(months)); }
/** * Add the given amount of weeks to the date * * @param date * @param weeks * @return */ public static <D extends Comparable> DateExpression<D> addWeeks(DateExpression<D> date, int weeks) { return DateOperation.create((Class)date.getType(), Ops.DateTimeOps.ADD_WEEKS, date, ConstantImpl.create(weeks)); }
/** * 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)); }
/** * Add the given amount of years to the date * * @param date * @param years * @return */ public static <D extends Comparable> DateExpression<D> addYears(DateExpression<D> date, int years) { return DateOperation.create((Class)date.getType(), Ops.DateTimeOps.ADD_YEARS, date, ConstantImpl.create(years)); }
public DateExpression<T> asDate() { return (DateExpression<T>) DateOperation.create(getType(), Ops.COALESCE, getExpressionList()); }