@Override public Predicate buildPredicate(CriteriaBuilder builder, FieldPathBuilder fieldPathBuilder, From root, String ceilingEntity, String fullPropertyName, Path<Comparable> explicitPath, List<Comparable> directValues) { Path<Comparable> path; if (explicitPath != null) { path = explicitPath; } else { path = fieldPathBuilder.getPath(root, fullPropertyName, builder); } if (directValues.size() == 2) { if (directValues.get(0) == null) { return builder.lessThan(path, directValues.get(1)); } else if (directValues.get(1) == null) { return builder.greaterThanOrEqualTo(path, directValues.get(0)); } return builder.between(path, directValues.get(0), directValues.get(1)); } else { // The user passed in a single date which is only down to the second granularity. The database stores things // down to the millisecond, so we can't just do equals we have to filter dates between the date provided and // 1000 milliseconds later than the date provided to get all records for that particular second Date secondFromNow = new Date(((Date)directValues.get(0)).getTime() + 1000); return builder.between(path, directValues.get(0), secondFromNow); } } }
protected void addActiveDateRestrictions(final CriteriaBuilder builder, final Root pageRoot, final List<Predicate> restrictions, Date afterStartDate, Date beforeEndDate) { restrictions.add(builder.or( builder.isNull(pageRoot.get("activeStartDate")), builder.lessThanOrEqualTo(pageRoot.get("activeStartDate").as(Date.class), afterStartDate))); restrictions.add(builder.or( builder.isNull(pageRoot.get("activeEndDate")), builder.greaterThanOrEqualTo(pageRoot.get("activeEndDate").as(Date.class), beforeEndDate))); }
/** * Helper method for creating a ranged (between, open-ended) {@link Predicate} * * @param builder The {@link CriteriaBuilder}, helpful when creating {@link Predicate}s to add to the {@link CriteriaQuery} * @param entityField The {@link Expression} representing a field/column in an entity/table. * @param start The start value of the range, or null if open-ended (on the lower end) * @param end The end value of the range, or null if open-ended (on the upper end) * @param rangeType The {@link Class} or the parameter values * @return The created {@link Predicate} */ @SuppressWarnings("unchecked") private static <Y extends Comparable<? super Y>> Predicate createRangePredicate( CriteriaBuilder builder, Expression field, Object start, Object end, Class<Y> rangeType ) { if( start != null && end != null ) { // TODO :asserts! return builder.between(field, (Y) start, (Y) end); } else if ( start != null ) { return builder.greaterThanOrEqualTo(field, (Y) start); } else { return builder.lessThanOrEqualTo(field, (Y) end); } }
defaultSkuExpression = builder.lessThan(defaultSkuPropertyPath, (Comparable) directValues.get(1)); } else if (directValues.get(1) == null) { propertyExpression = builder.greaterThanOrEqualTo(targetPropertyPath, (Comparable) directValues.get(0)); defaultSkuExpression = builder.greaterThanOrEqualTo(defaultSkuPropertyPath, (Comparable) directValues.get(0)); } else {
predicates.add(cb.greaterThanOrEqualTo(root.<Date>get("plndStartDate"), searchCriteria.getPlannedStartDate()));
} else if (op == Op.GTE) { assert vals.length == 1 : String.format("Op.GT_EQ needs one value, but %s given", vals.length); preds.add(_builder.greaterThanOrEqualTo(p, (Comparable)vals[0])); } else if (op == Op.LTE) { assert vals.length == 1 : String.format("Op.LT_EQ needs one value, but %s given", vals.length);
predicates.add(cb.greaterThanOrEqualTo(from.get("myUpdated").as(Date.class), mySearchEntity.getLastUpdatedLow()));
private static List<Predicate> createLastUpdatedPredicates(final DateRangeParam theLastUpdated, CriteriaBuilder builder, From<?, ResourceTable> from) { List<Predicate> lastUpdatedPredicates = new ArrayList<>(); if (theLastUpdated != null) { if (theLastUpdated.getLowerBoundAsInstant() != null) { ourLog.debug("LastUpdated lower bound: {}", new InstantDt(theLastUpdated.getLowerBoundAsInstant())); Predicate predicateLower = builder.greaterThanOrEqualTo(from.get("myUpdated"), theLastUpdated.getLowerBoundAsInstant()); lastUpdatedPredicates.add(predicateLower); } if (theLastUpdated.getUpperBoundAsInstant() != null) { Predicate predicateUpper = builder.lessThanOrEqualTo(from.get("myUpdated"), theLastUpdated.getUpperBoundAsInstant()); lastUpdatedPredicates.add(predicateUpper); } } return lastUpdatedPredicates; }
provider.next(part, Comparable.class).getExpression()); case GREATER_THAN_EQUAL: return builder.greaterThanOrEqualTo(getComparablePath(root, part), provider.next(part, Comparable.class).getExpression()); case BEFORE:
@Override public Predicate build(final CriteriaBuilder cb, final Expression<?> x, final Object y) { @SuppressWarnings("rawtypes") final Expression w = x; @SuppressWarnings("rawtypes") final Comparable k = ( Comparable ) y; @SuppressWarnings("unchecked") final Predicate p = cb.greaterThanOrEqualTo(w, k); return p; }
Predicate gt = theBuilder.greaterThanOrEqualTo(theFrom.get("myValueLow"), lowerBound); Predicate lt = theBuilder.greaterThanOrEqualTo(theFrom.get("myValueHigh"), lowerBound); if (theRange.getLowerBound().getPrefix() == ParamPrefixEnum.STARTS_AFTER || theRange.getLowerBound().getPrefix() == ParamPrefixEnum.EQUAL) { lb = gt;
protected <X extends Comparable<? super X>> Specification<ENTITY> greaterThanOrEqualTo(Function<Root<ENTITY>, Expression<X>> metaclassFunction, final X value) { return (root, query, builder) -> builder.greaterThanOrEqualTo(metaclassFunction.apply(root), value); }
@Override public EventQuery fromDate(Date fromDate) { predicates.add(cb.greaterThanOrEqualTo(root.<Long>get("time"), fromDate.getTime())); return this; }
/** * Creates a specification used to find LineStop whose arrival delay is greater than the expected one. * * @param delay the expected delay * @return a predicate */ public static Specification<LineStop> arrivalDelayGreaterThanOrEqualTo(final Long delay) { return (root, query, builder) -> builder.greaterThanOrEqualTo(root.get(LineStop_.arrivalTime).get(TimestampDelay_.delay), delay); }
public static <Y extends Comparable<? super Y>> Predicate createGreaterOrEqualToPredicate(final boolean toLowerCase, final CriteriaBuilder criteriaBuilder, final Expression<? extends Y> path, final Y value) { if (toLowerCase) { final String loweredValue = createLoweredValue(value); final Expression<String> loweredExpression = createLoweredExpression(criteriaBuilder, path); return criteriaBuilder.greaterThanOrEqualTo(loweredExpression, loweredValue); } return criteriaBuilder.greaterThanOrEqualTo(path, value); }
public List<Predicate> createFilterCondition(CriteriaBuilder criteriaBuilder, Root<SLASummaryBean> root) { return Collections.singletonList(criteriaBuilder.and( criteriaBuilder.isNotNull(root.get(DBFIELD_EXPECTED_END_TS)), criteriaBuilder.isNotNull(root.get(DBFIELD_ACTUAL_END_TS)), criteriaBuilder.greaterThanOrEqualTo(root.get(DBFIELD_EXPECTED_END_TS), root.get(DBFIELD_ACTUAL_END_TS)))); }}, END_MISS_FILTER {
public List<Predicate> createFilterCondition(CriteriaBuilder criteriaBuilder, Root<SLASummaryBean> root) { return Collections.singletonList(criteriaBuilder.and( criteriaBuilder.isNotNull(root.get(DBFIELD_EXPECTED_END_TS)), criteriaBuilder.isNotNull(root.get(DBFIELD_ACTUAL_END_TS)), criteriaBuilder.greaterThanOrEqualTo(root.get(DBFIELD_EXPECTED_END_TS), root.get(DBFIELD_ACTUAL_END_TS)))); }}, END_MISS_FILTER {
protected final <T extends Comparable<T>> Predicate createGreaterThanPredicate(String propName, T propValue, boolean inclusive, Root<?> root, CriteriaBuilder cb, boolean useJoin) { if (propValue != null) { Path<T> path = this.<T> createPath(propName, root, useJoin); Predicate predicate = inclusive ? cb.greaterThanOrEqualTo(path, propValue) : cb.greaterThan(path, propValue); return predicate; } return null; }
@Override public Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb) { From from = getRoot(property, root); String field = getProperty(property); return cb.greaterThanOrEqualTo(from.get(field), compare); } }
@Override public long getProgramStageInstanceCountLastUpdatedAfter( Date time ) { CriteriaBuilder builder = getCriteriaBuilder(); return getCount( builder, newJpaParameters() .addPredicate( root -> builder.greaterThanOrEqualTo( root.get( "lastUpdated" ), time ) ) .count( root -> builder.countDistinct( root ) ) ); }