/** * Get an expression representing the current time instant as a DateTimeExpression instance * * @return */ public static DateTimeExpression<Date> currentTimestamp() { return DateTimeExpression.currentTimestamp(); }
/** * Get the maximum value of this expression (aggregation) * * @return max(this) */ public DateTimeExpression<T> max() { if (max == null) { max = DateTimeOperation.create((Class<T>)getType(), Ops.AggOps.MAX_AGG, mixin); } return max; }
@Test public void CurrentDate2() { assertToString("current_date", DateTimeExpression.currentDate()); }
private List<Tuple> getRemovedWorklogs(final Long sinceInMilliseconds, final int maxResults, final QChangeItem ci, final QChangeGroup cg, final QWorklog w, final NumberExpression<Long> oldValueExpression) { return dbConnectionManager.executeQuery(dbConnection -> dbConnection.newSqlQuery() .from(ci) .leftJoin(cg) .on(ci.group.eq(cg.id)) .where(ci.field.eq(IssueFieldConstants.WORKLOG_ID) .and(cg.created.goe(new Timestamp(sinceInMilliseconds)) .and(cg.created.loe(new Timestamp(minuteAgo())))) .and(oldValueExpression.notIn(new SQLSubQuery() .from(w) .list(w.id)) ) ) .groupBy(oldValueExpression) .orderBy(cg.created.max().asc()) .limit(maxResults) .list(oldValueExpression, cg.created.max())); }
/** * Get the minimum value of this expression (aggregation) * * @return min(this) */ public DateTimeExpression<T> min() { if (min == null) { min = DateTimeOperation.create((Class<T>)getType(), Ops.AggOps.MIN_AGG, mixin); } return min; }
@Test public void CurrentTimestamp() { assertToString("current_timestamp", DateTimeExpression.currentTimestamp()); }
/** * 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); }
/** * Truncate the given datetime expression * * @param unit * @param expr */ public static <D extends Comparable> DateTimeExpression<D> datetrunc(DatePart unit, DateTimeExpression<D> expr) { return DateTimeOperation.create(expr.getType(), DATE_TRUNC_OPS.get(unit), expr); }
@Override public DateTimeExpression<T> as(Path<T> alias) { return DateTimeOperation.create((Class<T>)getType(), Ops.ALIAS, mixin, alias); }
/** * 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)); }
/** * Add the given amount of minutes to the date * * @param date * @param minutes * @return */ public static <D extends Comparable> DateTimeExpression<D> addMinutes(DateTimeExpression<D> date, int minutes) { return DateTimeOperation.create((Class)date.getType(), Ops.DateTimeOps.ADD_MINUTES, date, ConstantImpl.create(minutes)); }
/** * Add the given amount of seconds to the date * * @param date * @param seconds * @return */ public static <D extends Comparable> DateTimeExpression<D> addSeconds(DateTimeExpression<D> date, int seconds) { return DateTimeOperation.create((Class)date.getType(), Ops.DateTimeOps.ADD_SECONDS, date, ConstantImpl.create(seconds)); }
/** * Add the given amount of days to the date * * @param date * @param days * @return */ public static <D extends Comparable> DateTimeExpression<D> addDays(DateTimeExpression<D> date, int days) { return DateTimeOperation.create((Class)date.getType(), Ops.DateTimeOps.ADD_DAYS, date, ConstantImpl.create(days)); }
@SuppressWarnings("unchecked") @Override public <RT extends Comparable<?>> DateTimeSubQuery<RT> unique(DateTimeExpression<RT> projection) { return new DateTimeSubQuery<RT>((Class)projection.getType(), uniqueProjection(projection)); }
/** * Add the given amount of months to the date * * @param date * @param months * @return */ public static <D extends Comparable> DateTimeExpression<D> addMonths(DateTimeExpression<D> date, int months) { return DateTimeOperation.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> DateTimeExpression<D> addWeeks(DateTimeExpression<D> date, int weeks) { return DateTimeOperation.create((Class)date.getType(), Ops.DateTimeOps.ADD_WEEKS, date, ConstantImpl.create(weeks)); }
/** * 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 hours to the date * * @param date * @param hours * @return */ public static <D extends Comparable> DateTimeExpression<D> addHours(DateTimeExpression<D> date, int hours) { return DateTimeOperation.create((Class)date.getType(), Ops.DateTimeOps.ADD_HOURS, date, ConstantImpl.create(hours)); }