@Override public Predicate buildPredicate(CriteriaBuilder builder, FieldPathBuilder fieldPathBuilder, From root, String ceilingEntity, String fullPropertyName, Path<String> explicitPath, List<String> directValues) { Path<String> path; if (explicitPath != null) { path = explicitPath; } else { path = fieldPathBuilder.getPath(root, fullPropertyName, builder); } return builder.like(builder.lower(path), directValues.get(0)); }
builder.lower(pathToUse.get("name").as(String.class)), fieldName.toLowerCase()));
Predicate defaultSkuExpression; if (delegateRestriction.getPredicateProvider() instanceof LikePredicateProvider) { propertyExpression = builder.like(builder.lower(targetPropertyPath), ((String) directValues.get(0)).toLowerCase()); defaultSkuExpression = builder.like(builder.lower(defaultSkuPropertyPath), ((String) directValues.get(0)).toLowerCase()); } else if (delegateRestriction.getPredicateProvider() instanceof IsNullPredicateProvider) {
expression = cb.lower(expression); attributeValue = attributeValue.toString().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); } }
CriteriaBuilder cb = entityManager.getCriteriaBuilder(); CriteriaQuery<ProfileBaseInfo> cq = cb.createQuery(ProfileBaseInfo.class); Root<ProfileBaseInfo> from = cq.from(ProfileBaseInfo.class); ... List<Predicate> predicates = Lists.newArrayList(); ... if (param.getFullName() != null) { predicates.add(cb.like(cb.lower(ProfileBaseInfo_.fullName)), param.getFullName().toLowerCase() + "%")) } ... cb.and(predicates.toArray(new Predicate[predicates.size()]));
@Override public Predicate toPredicate(Root<Template> root, CriteriaQuery<?> query, CriteriaBuilder cb) { return cb.like(cb.lower(root.<String>get("name").as(String.class)), searchBy); } }
private Predicate createTechnologyPredicate(final CriteriaBuilder criteriaBuilder, final Root<Request> root, final String technology) { final SetJoin<Object, Object> technologiesJoin = root.joinSet("technologies", INNER); return criteriaBuilder.equal(criteriaBuilder.lower(technologiesJoin.get("technology")), technology); } }
@Override public Predicate toPredicate(Root<Reference> root, CriteriaQuery<?> query, CriteriaBuilder cb) { Predicate number = cb.like(cb.lower(root.<String>get("number").as(String.class)), searchBy); Predicate name = cb.like(cb.lower(root.<String>get("name").as(String.class)), searchBy); Predicate author = cb.like(cb.lower(root.<String>get("author").as(String.class)), searchBy); return cb.or(number, name, author); } }
@Override public Predicate toPredicate(Root<Term> root, CriteriaQuery<?> query, CriteriaBuilder cb) { Predicate name = cb.like(cb.lower(root.<String>get("name").as(String.class)), searchBy); Predicate description = cb.like(cb.lower(root.<String>get("description").as(String.class)), searchBy); return cb.or(name, description); } }
@Override public <R> Selection<String> toSelection(CriteriaQuery<R> query, CriteriaBuilder builder, Path<? extends P> path) { return builder.lower(path.get(getAttribute())); }
@Override public Predicate toPredicate(Root<Document> root, CriteriaQuery<?> query, CriteriaBuilder cb) { Predicate status = cb.like(cb.lower(root.<String>get("status").as(String.class)), searchBy); Predicate documentType = cb.like(cb.lower(root.<String>get("template").get("name").as(String.class)), searchBy); return cb.or(status, documentType); } }
/** * Add a Field Search Condition that will search a field for a specified value using the following SQL logic: * {@code lower(field) = 'value'} * * @param propertyName The name of the field as defined in the Entity mapping class. * @param value The value to search against. */ protected void addEqualsIgnoreCaseCondition(final String propertyName, final String value) { final Expression<String> propertyNameField = getCriteriaBuilder().lower(getRootPath().get(propertyName).as(String.class)); fieldConditions.add(getCriteriaBuilder().equal(propertyNameField, value.toString())); }
@Override public Predicate getPredicate(Project project, QueryBuildContext<CodeComment> context, User user) { Path<String> attribute = CodeCommentQuery.getPath(context.getRoot(), CodeCommentConstants.ATTR_PATH); String normalized = value.toLowerCase().replace('*', '%'); if (normalized.endsWith("/")) normalized += "%"; return context.getBuilder().like(context.getBuilder().lower(attribute), normalized); }
@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 toPredicate(Root<User> root, CriteriaQuery<?> query, CriteriaBuilder cb) { Predicate firstName = cb.like(cb.lower(root.<String>get("person").get("firstName").as(String.class)), searchBy); Predicate lastName = cb.like(cb.lower(root.<String>get("person").get("lastName").as(String.class)), searchBy); Predicate email = cb.like(cb.lower(root.<String>get("person").get("contactInformation").get("email").as(String.class)), searchBy); return cb.or(firstName, lastName, email); } }
@Override public Predicate createPredicate(From<?, ?> from, CriteriaBuilder criteriaBuilder, String attributeName) { Expression<?> expression = from.get(attributeName); return criteriaBuilder.like(criteriaBuilder.lower(expression.as(String.class)), escapedRawValue, '~'); }
/** * Add a Field Search Condition that will search a field for values that aren't like a specified value using the following * SQL logic: {@code LOWER(field) NOT LIKE LOWER('%value%')} * * @param propertyName The name of the field as defined in the Entity mapping class. * @param value The value to search against. */ protected void addNotLikeIgnoresCaseCondition(final String propertyName, final String value) { final Expression<String> propertyNameField = getCriteriaBuilder().lower(getRootPath().get(propertyName).as(String.class)); fieldConditions.add(getCriteriaBuilder().notLike(propertyNameField, "%" + cleanLikeCondition(value).toLowerCase() + "%")); }
/** * Add a Field Search Condition that will search a field for a specified value using the following SQL logic: * {@code LOWER(field) LIKE LOWER('%value%')} * * @param propertyName The name of the field as defined in the Entity mapping class. * @param value The value to search against. */ protected void addLikeIgnoresCaseCondition(final String propertyName, final String value) { final Expression<String> propertyNameField = getCriteriaBuilder().lower(getRootPath().get(propertyName).as(String.class)); fieldConditions.add(getCriteriaBuilder().like(propertyNameField, "%" + cleanLikeCondition(value).toLowerCase() + "%")); }