Refine search
key = key.substring("defaultSku.".length()); } else if (key.contains("productAttributes.")) { pathToUse = product.join("productAttributes"); restrictions.add(builder.equal(pathToUse.get("name").as(String.class), key)); Predicate minRange = builder.greaterThan(pathToUse.get(key).as(BigDecimal.class), min); Predicate maxRange = null; if (max != null) { maxRange = builder.lessThan(pathToUse.get(key).as(BigDecimal.class), max); rangeRestrictions.add(builder.and(minRange, maxRange)); } else {
@Override public Predicate buildPredicate(CriteriaBuilder builder, FieldPathBuilder fieldPathBuilder, From root, String ceilingEntity, String fullPropertyName, Path explicitPath, List directValues) { Date currentTime = SystemTime.asDate(true); if (isActive) { return builder.and( builder.isNotNull(root.get("startDate")), builder.lessThan(root.get("startDate"), currentTime), builder.or( builder.isNull(root.get("endDate")), builder.greaterThan(root.get("endDate"), currentTime) ) ); } else { return builder.or( builder.isNull(root.get("startDate")), builder.greaterThan(root.get("startDate"), currentTime), builder.and( builder.isNotNull(root.get("endDate")), builder.lessThan(root.get("endDate"), currentTime) ) ); } } }
/** * Returns an existing join for the given attribute if one already exists or creates a new one if not. * * @param from the {@link From} to get the current joins from. * @param attribute the {@link Attribute} to look for in the current joins. * @return will never be {@literal null}. */ private static Join<?, ?> getOrCreateJoin(From<?, ?> from, String attribute) { for (Join<?, ?> join : from.getJoins()) { boolean sameName = join.getAttribute().getName().equals(attribute); if (sameName && join.getJoinType().equals(JoinType.LEFT)) { return join; } } return from.join(attribute, JoinType.LEFT); }
@SuppressWarnings("unchecked") public static <T> Expression defaultGetEntityField(CriteriaQuery<T> query, String listId, Attribute attr) { Expression entityField = null; if( attr != null ) { Class attrType = attr.getDeclaringType().getJavaType(); for( From from : query.getRoots() ) { if( from.getJavaType().equals(attrType) ) { if( attr != null ) { if( attr instanceof SingularAttribute ) { entityField = from.get((SingularAttribute) attr); } else if( attr instanceof PluralAttribute ) { entityField = from.get((PluralAttribute) attr); } else { throw new IllegalStateException("Unexpected attribute type when processing criteria with list id " + listId + ": " + attr.getClass().getName() ); } break; } } } } // if entityField == null, this is because this QueryCriteria is a implementation specific criteria, such as "LAST_VARIABLE_LIST" return entityField; }
@SuppressWarnings("unchecked") static <T> Expression<T> toExpressionRecursively(From<?, ?> from, PropertyPath property, boolean isForSelection) { Bindable<?> propertyPathModel; Bindable<?> model = from.getModel(); String segment = property.getSegment(); if (model instanceof ManagedType) { /* * Required to keep support for EclipseLink 2.4.x. TODO: Remove once we drop that (probably Dijkstra M1) * See: https://bugs.eclipse.org/bugs/show_bug.cgi?id=413892 */ propertyPathModel = (Bindable<?>) ((ManagedType<?>) model).getAttribute(segment); } else { propertyPathModel = from.get(segment).getModel(); } if (requiresJoin(propertyPathModel, model instanceof PluralAttribute, !property.hasNext(), isForSelection) && !isAlreadyFetched(from, segment)) { Join<?, ?> join = getOrCreateJoin(from, segment); return (Expression<T>) (property.hasNext() ? toExpressionRecursively(join, property.next(), isForSelection) : join); } else { Path<Object> path = from.get(segment); return (Expression<T>) (property.hasNext() ? toExpressionRecursively(path, property.next()) : path); } }
final Path<String> systemExpression = theFrom.get("mySystem"); final Path<String> valueExpression = theFrom.get("myValue"); for (Map.Entry<String, List<VersionIndependentConcept>> entry : map.entrySet()) { CriteriaBuilder.In<String> codePredicate = theBuilder.in(valueExpression); boolean haveAtLeastOneCode = false; for (VersionIndependentConcept nextCode : entry.getValue()) { singleCodePredicates.add(theBuilder.notEqual(theFrom.get("mySystem"), system)); } else { singleCodePredicates.add(theBuilder.equal(theFrom.get("mySystem"), system)); singleCodePredicates.add(theBuilder.isNull(theFrom.get("mySystem"))); singleCodePredicates.add(theBuilder.notEqual(theFrom.get("myValue"), code)); } else { singleCodePredicates.add(theBuilder.equal(theFrom.get("myValue"), code)); hashField = theFrom.get("myHashSystemAndValue").as(Long.class); } else if (haveSystem) { hashField = theFrom.get("myHashSystem").as(Long.class); } else { hashField = theFrom.get("myHashValue").as(Long.class); Predicate identityPredicate = theBuilder.equal(theFrom.get("myHashIdentity").as(Long.class), BaseResourceIndexedSearchParam.calculateHashIdentity(theResourceName, theParamName)); Predicate disjunctionPredicate = theBuilder.not(predicate); predicate = theBuilder.and(identityPredicate, disjunctionPredicate);
private Predicate combineParamIndexPredicateWithParamNamePredicate(String theResourceName, String theParamName, From<?, ? extends BaseResourceIndexedSearchParam> theFrom, Predicate thePredicate) { if (myDontUseHashesForSearch) { Predicate resourceTypePredicate = myBuilder.equal(theFrom.get("myResourceType"), theResourceName); Predicate paramNamePredicate = myBuilder.equal(theFrom.get("myParamName"), theParamName); Predicate outerPredicate = myBuilder.and(resourceTypePredicate, paramNamePredicate, thePredicate); return outerPredicate; } long hashIdentity = BaseResourceIndexedSearchParam.calculateHashIdentity(theResourceName, theParamName); Predicate hashIdentityPredicate = myBuilder.equal(theFrom.get("myHashIdentity"), hashIdentity); return myBuilder.and(hashIdentityPredicate, thePredicate); }
predicates.add(cb.isNull(from.get(attribute))); predicates.addAll(getPredicates(currentPath, cb, ((From<?, ?>) from).join(attribute.getName()), (ManagedType<?>) attribute.getType(), attributeValue, probeType, exampleAccessor, node)); expression = cb.lower(expression); attributeValue = attributeValue.toString().toLowerCase(); predicates.add(cb.equal(expression, attributeValue)); break; case CONTAINING:
Predicate singleCode = theBuilder.like(theFrom.get("myValueNormalized").as(String.class), likeExpression); if (theParameter instanceof StringParam && ((StringParam) theParameter).isExact()) { Predicate exactCode = theBuilder.equal(theFrom.get("myValueExact"), rawSearchTerm); singleCode = theBuilder.and(singleCode, exactCode); return theBuilder.equal(theFrom.get("myHashExact").as(Long.class), hash); Predicate hashCode = theBuilder.equal(theFrom.get("myHashNormalizedPrefix").as(Long.class), hash); Predicate singleCode = theBuilder.like(theFrom.get("myValueNormalized").as(String.class), likeExpression); return theBuilder.and(hashCode, singleCode);
private Predicate createNamePredicate(CriteriaBuilder criteriaBuilder, From<?, User> userFrom, String name) { Path<String> namePath = userFrom.get(User_.name); Path<String> emailPath = userFrom.get(User_.email); Predicate nameMatchPredicate = criteriaBuilder.equal(namePath, name); Predicate emailMatchPredicate = criteriaBuilder.equal(emailPath, name); return criteriaBuilder.or(nameMatchPredicate, emailMatchPredicate); }
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; } else { lb = theBuilder.or(gt, lt); Predicate gt = theBuilder.lessThanOrEqualTo(theFrom.get("myValueLow"), upperBound); Predicate lt = theBuilder.lessThanOrEqualTo(theFrom.get("myValueHigh"), upperBound); if (theRange.getUpperBound().getPrefix() == ParamPrefixEnum.ENDS_BEFORE || theRange.getUpperBound().getPrefix() == ParamPrefixEnum.EQUAL) { ub = lt;
@Override public Predicate getPredicate(Project project, QueryBuildContext<Issue> context, User user) { Path<String> attribute = context.getJoin(getFieldName()).get(IssueFieldUnary.FIELD_ATTR_VALUE); if (operator == IssueQueryLexer.Is) return context.getBuilder().equal(context.getBuilder().lower(attribute), value.toLowerCase()); else return context.getBuilder().like(context.getBuilder().lower(attribute), "%" + value.toLowerCase() + "%"); }
@Override public Predicate buildPredicate(CriteriaBuilder builder, FieldPathBuilder fieldPathBuilder, From root, String ceilingEntity, String fullPropertyName, Path<Character> explicitPath, List<Character> directValues) { CriteriaQuery<Serializable> criteria = fieldPathBuilder.getCriteria(); Root<CountryImpl> blcCountry = criteria.from(CountryImpl.class); Predicate join = builder.equal( root.get("alpha2").as(String.class), blcCountry.get("abbreviation").as(String.class) ); return join; } })
@Override public Predicate getPredicate(Project project, QueryBuildContext<PullRequest> context, User user) { From<?, ?> join = context.getJoin(PullRequestConstants.ATTR_BUILDS + "." + PullRequestBuild.ATTR_BUILD); Path<?> status = join.get(Build.STATUS); return context.getBuilder().or( context.getBuilder().isNull(status), context.getBuilder().equal(status, Build.Status.RUNNING)); }
From<?, ?> forcedIdJoin = theFrom.join("myForcedId", JoinType.LEFT); if (theSort.getOrder() == null || theSort.getOrder() == SortOrderEnum.ASC) { theOrders.add(theBuilder.asc(forcedIdJoin.get("myForcedId"))); theOrders.add(theBuilder.asc(theFrom.get("myId"))); } else { theOrders.add(theBuilder.desc(forcedIdJoin.get("myForcedId"))); theOrders.add(theBuilder.desc(theFrom.get("myId")));
@Override public Predicate getPredicate(Project project, QueryBuildContext<Issue> context, User user) { Path<Integer> attribute = context.getJoin(getFieldName()).get(IssueFieldUnary.FIELD_ATTR_ORDINAL); if (operator == IssueQueryLexer.Is) return context.getBuilder().equal(attribute, value); else if (operator == IssueQueryLexer.IsGreaterThan) return context.getBuilder().greaterThan(attribute, value); else return context.getBuilder().lessThan(attribute, value); }
if (frame.getMethod().equals(desc.getReadMethod())) { Predicate joinPredicate; if (joinRoot.get(property).getJavaType().equals(getFrom().getJavaType())) { joinPredicate = getBuilder().equal(getFrom(), joinRoot.get(property)); } else { EntityType type = (EntityType) getFrom().getModel(); String parentIdAttribute = type.getId(type.getIdType().getJavaType()).getName(); if (!getFrom().get(parentIdAttribute).getJavaType().equals(joinRoot.get(property).getJavaType())) { throw new IllegalArgumentException("Type mismatch: cannot join " + type.getName() + "." + parentIdAttribute + " to " + joinRoot.get(property)); joinPredicate = getBuilder().equal(getFrom().get(parentIdAttribute), joinRoot.get(property));
protected Predicate buildLikePredicate(CriteriaBuilder criteriaBuilder, CriteriaQuery<?> criteriaQuery, From<?, ?> root, String key, String value) { String pattern = value.trim(); // if (pattern.startsWith("*")) { pattern = "%" + pattern.substring(1); } if (pattern.endsWith("*")) { pattern = pattern.substring(0, pattern.length() - 1) + "%"; } // return criteriaBuilder.like(criteriaBuilder.lower(root.get(key)), pattern.toLowerCase()); }
/** * Creates a criteria API {@link javax.persistence.criteria.Order} from the given {@link Order}. * * @param order the order to transform into a JPA {@link javax.persistence.criteria.Order} * @param from the {@link From} the {@link Order} expression is based on * @param cb the {@link CriteriaBuilder} to build the {@link javax.persistence.criteria.Order} with * @return */ @SuppressWarnings("unchecked") private static javax.persistence.criteria.Order toJpaOrder(Order order, From<?, ?> from, CriteriaBuilder cb) { PropertyPath property = PropertyPath.from(order.getProperty(), from.getJavaType()); Expression<?> expression = toExpressionRecursively(from, property); if (order.isIgnoreCase() && String.class.equals(expression.getJavaType())) { Expression<String> lower = cb.lower((Expression<String>) expression); return order.isAscending() ? cb.asc(lower) : cb.desc(lower); } else { return order.isAscending() ? cb.asc(expression) : cb.desc(expression); } }