@Override public Boolean offerCodeIsUsed(OfferCode code) { CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaQuery<Order> criteria = builder.createQuery(Order.class); Root<OrderImpl> baseOrder = criteria.from(OrderImpl.class); criteria.select(baseOrder); Join<OrderImpl, OfferCodeImpl> join = baseOrder.join("addedOfferCodes"); criteria.where(builder.equal(join.get("id"), code.getId())); TypedQuery<Order> query = em.createQuery(criteria); try { query.getSingleResult(); } catch (NoResultException e) { return false; } return true; }
return fieldParentJoin.get(fieldAttr);
@Override public List<IndexField> readAllIndexFieldsByFieldId(Long fieldId) { CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaQuery<IndexField> criteria = builder.createQuery(IndexField.class); Root<IndexFieldImpl> search = criteria.from(IndexFieldImpl.class); criteria.select(search); criteria.where( builder.equal(search.join("field").get("id").as(Long.class), fieldId) ); TypedQuery<IndexField> query = em.createQuery(criteria); query.setHint(QueryHints.HINT_CACHEABLE, true); query.setHint(QueryHints.HINT_CACHE_REGION, "query.Search"); return query.getResultList(); }
@Override public IndexField readIndexFieldByFieldId(Long fieldId) { CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaQuery<IndexField> criteria = builder.createQuery(IndexField.class); Root<IndexFieldImpl> search = criteria.from(IndexFieldImpl.class); criteria.select(search); criteria.where( builder.equal(search.join("field").get("id").as(Long.class), fieldId) ); TypedQuery<IndexField> query = em.createQuery(criteria); query.setHint(QueryHints.HINT_CACHEABLE, true); query.setHint(QueryHints.HINT_CACHE_REGION, "query.Search"); try { return query.getSingleResult(); } catch (NoResultException e) { return null; } }
private TypedQuery<Long> getProductIdsUsingProductOptionByIdQuery(Long productOptionId, boolean count) { // Set up the criteria query that specifies we want to return Products CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaQuery<Long> criteria = builder.createQuery(Long.class); // The root of our search is ProductOptionXref Root<ProductOptionXrefImpl> productOptionXref = criteria.from(ProductOptionXrefImpl.class); Join<ProductOptionXref, Product> product = productOptionXref.join("product"); Join<ProductOptionXref, ProductOption> productOption = productOptionXref.join("productOption"); if (count) { criteria.select(builder.count(product)); } else { // Product IDs are what we want back criteria.select(product.get("id").as(Long.class)); } criteria.distinct(true); List<Predicate> restrictions = new ArrayList<Predicate>(); restrictions.add(productOption.get("id").in(sandBoxHelper.mergeCloneIds(ProductOptionImpl.class, productOptionId))); // Execute the query with the restrictions criteria.where(restrictions.toArray(new Predicate[restrictions.size()])); return em.createQuery(criteria); }
@Override public SearchFacet readSearchFacetForField(Field field) { CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaQuery<SearchFacet> criteria = builder.createQuery(SearchFacet.class); Root<SearchFacetImpl> facet = criteria.from(SearchFacetImpl.class); criteria.select(facet); criteria.where( builder.equal(facet.join("fieldType").join("indexField").join("field").get("id").as(Long.class), field.getId()) ); TypedQuery<SearchFacet> query = em.createQuery(criteria); query.setHint(QueryHints.HINT_CACHEABLE, true); query.setHint(QueryHints.HINT_CACHE_REGION, "query.Search"); try { return query.getSingleResult(); } catch (NoResultException e) { return null; } }
restrictions.add(category.get("id").in(sandBoxHelper.mergeCloneIds(CategoryImpl.class, categoryId)));
@Override public List<SearchFacet> readAllSearchFacets(FieldEntity entityType) { CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaQuery<SearchFacet> criteria = builder.createQuery(SearchFacet.class); Root<SearchFacetImpl> facet = criteria.from(SearchFacetImpl.class); criteria.select(facet); Path<Character> archived = facet.get("archiveStatus").get("archived"); criteria.where( builder.equal(facet.get("showOnSearch").as(Boolean.class), true), builder.or(builder.isNull(archived.as(String.class)), builder.notEqual(archived.as(Character.class), 'Y')), facet.join("fieldType") .join("indexField") .join("field") .get("entityType") .as(String.class) .in(entityType.getAllLookupTypes()) ); TypedQuery<SearchFacet> query = em.createQuery(criteria); query.setHint(QueryHints.HINT_CACHEABLE, true); query.setHint(QueryHints.HINT_CACHE_REGION, "query.Search"); return query.getResultList(); }
private void addPredicateParamMissing(String theResourceName, String theParamName, boolean theMissing, Join<ResourceTable, ? extends BaseResourceIndexedSearchParam> theJoin) { myPredicates.add(myBuilder.equal(theJoin.get("myResourceType"), theResourceName)); myPredicates.add(myBuilder.equal(theJoin.get("myParamName"), theParamName)); myPredicates.add(myBuilder.equal(theJoin.get("myMissing"), theMissing)); }
Predicate uriPredicate = join.get("myUri").as(String.class).in(toFind); Predicate hashAndUriPredicate = combineParamIndexPredicateWithParamNamePredicate(theResourceName, theParamName, join, uriPredicate); codePredicates.add(hashAndUriPredicate); Predicate uriPredicate = myBuilder.like(join.get("myUri").as(String.class), createLeftMatchLikeExpression(value)); Predicate hashAndUriPredicate = combineParamIndexPredicateWithParamNamePredicate(theResourceName, theParamName, join, uriPredicate); codePredicates.add(hashAndUriPredicate); Predicate predicate = myBuilder.equal(join.get("myUri").as(String.class), value); codePredicates.add(predicate); Predicate hashPredicate = myBuilder.equal(join.get("myHashUri"), hashUri); codePredicates.add(hashPredicate); Predicate predicate = myBuilder.isNull(join.get("myMissing").as(String.class)); myPredicates.add(predicate); return;
predicates.add(criteriaBuilder.equal(elementJoin.get("myCode"), coding.getCode())); } else { throw new InvalidRequestException("A code must be provided for translation to occur."); predicates.add(criteriaBuilder.equal(groupJoin.get("mySource"), coding.getSystem())); predicates.add(criteriaBuilder.equal(groupJoin.get("mySourceVersion"), coding.getVersion())); predicates.add(criteriaBuilder.equal(groupJoin.get("myTarget"), translationQuery.getTargetSystem().getValueAsString())); predicates.add(criteriaBuilder.equal(conceptMapJoin.get("mySource"), translationQuery.getSource().getValueAsString())); predicates.add(criteriaBuilder.equal(conceptMapJoin.get("myTarget"), translationQuery.getTarget().getValueAsString())); predicates.add(criteriaBuilder.equal(conceptMapJoin.get("myResourcePid"), translationQuery.getResourceId()));
String targetCodeSystem = null; if (coding.hasCode()) { predicates.add(criteriaBuilder.equal(targetJoin.get("myCode"), coding.getCode())); targetCode = coding.getCode(); } else { predicates.add(criteriaBuilder.equal(groupJoin.get("myTarget"), coding.getSystem())); targetCodeSystem = coding.getSystem(); predicates.add(criteriaBuilder.equal(groupJoin.get("myTargetVersion"), coding.getVersion())); predicates.add(criteriaBuilder.equal(groupJoin.get("mySource"), translationQuery.getTargetSystem().getValueAsString())); predicates.add(criteriaBuilder.equal(conceptMapJoin.get("myTarget"), translationQuery.getSource().getValueAsString())); predicates.add(criteriaBuilder.equal(conceptMapJoin.get("mySource"), translationQuery.getTarget().getValueAsString())); predicates.add(criteriaBuilder.equal(conceptMapJoin.get("myResourcePid"), translationQuery.getResourceId()));
private void addPredicateNumber(String theResourceName, String theParamName, List<? extends IQueryParameterType> theList) { Join<ResourceTable, ResourceIndexedSearchParamNumber> join = createOrReuseJoin(JoinEnum.NUMBER, theParamName); if (theList.get(0).getMissing() != null) { addPredicateParamMissing(theResourceName, theParamName, theList.get(0).getMissing(), join); return; } List<Predicate> codePredicates = new ArrayList<>(); for (IQueryParameterType nextOr : theList) { if (nextOr instanceof NumberParam) { NumberParam param = (NumberParam) nextOr; BigDecimal value = param.getValue(); if (value == null) { continue; } final Expression<BigDecimal> fromObj = join.get("myValue"); ParamPrefixEnum prefix = ObjectUtils.defaultIfNull(param.getPrefix(), ParamPrefixEnum.EQUAL); String invalidMessageName = "invalidNumberPrefix"; Predicate predicateNumeric = createPredicateNumeric(theResourceName, theParamName, join, myBuilder, nextOr, prefix, value, fromObj, invalidMessageName); Predicate predicateOuter = combineParamIndexPredicateWithParamNamePredicate(theResourceName, theParamName, join, predicateNumeric); codePredicates.add(predicateOuter); } else { throw new IllegalArgumentException("Invalid token type: " + nextOr.getClass()); } } myPredicates.add(myBuilder.or(toArray(codePredicates))); }
Expression<Long> hashPresence = paramPresentJoin.get("myHashPresence").as(Long.class); Long hash = SearchParamPresent.calculateHashPresence(theResourceName, theParamName, !theMissing); myPredicates.add(myBuilder.equal(hashPresence, hash));
Predicate predicate = join.get("mySourceResourcePid").in(match); myPredicates.add(predicate);
} else { ourLog.debug("Searching for resource link with target URL: {}", dt.getValue()); Predicate eq = myBuilder.equal(join.get("myTargetResourceUrl"), dt.getValue()); codePredicates.add(eq); continue; Predicate pidPredicate = myBuilder.equal(join.get("myTargetResourcePid"), next); codePredicates.add(myBuilder.and(pathPredicate, pidPredicate)); Predicate pidPredicate = join.get("myTargetResourcePid").in(subQ); codePredicates.add(myBuilder.and(pathPredicate, pidPredicate));
myPredicates.add(myBuilder.equal(join.get("myTargetResourcePid").as(Long.class), pid)); } else { Predicate targetTypePredicate = myBuilder.equal(join.get("myTargetResourceType").as(String.class), myResourceName); Predicate sourceTypePredicate = myBuilder.equal(myResourceTableRoot.get("myResourceType").as(String.class), myResourceName); myPredicates.add(myBuilder.or(sourceTypePredicate, targetTypePredicate));
thePredicates.add(join.get("mySourcePath").as(String.class).in(param.getPathsSplit())); } else { if (myDontUseHashesForSearch) { Predicate joinParam1 = theBuilder.equal(join.get("myParamName"), theSort.getParamName()); thePredicates.add(joinParam1); } else { Long hashIdentity = BaseResourceIndexedSearchParam.calculateHashIdentity(myResourceName, theSort.getParamName()); Predicate joinParam1 = theBuilder.equal(join.get("myHashIdentity"), hashIdentity); thePredicates.add(joinParam1); theOrders.add(theBuilder.asc(join.get(next))); } else { theOrders.add(theBuilder.desc(join.get(next)));
@Test public void testFilterChild() { doInJPA(entityManager -> { CriteriaBuilder builder = entityManager.getCriteriaBuilder(); CriteriaQuery<PostComment> criteria = builder.createQuery(PostComment.class); Root<PostComment> fromPost = criteria.from(PostComment.class); Join<PostComment, Post> postJoin = fromPost.join("post"); criteria.where(builder.like(postJoin.get(Post_.title), "high-performance%")); List<PostComment> comments = entityManager.createQuery(criteria).getResultList(); assertEquals(5, comments.size()); }); }