Example usage for javax.persistence.criteria CriteriaQuery where

Introduction

In this page you can find the example usage for javax.persistence.criteria CriteriaQuery where.

Prototype

CriteriaQuery<T> where(Predicate... restrictions);

Source Link

Document

Modify the query to restrict the query result according to the conjunction of the specified restriction predicates.

Usage

From source file:ca.uhn.fhir.jpa.dao.SearchBuilder.java

private void addPredicateReference(String theParamName, List<? extends IQueryParameterType> theList) {
    assert theParamName.contains(".") == false;

    if (Boolean.TRUE.equals(theList.get(0).getMissing())) {
        addPredicateParamMissingResourceLink("myResourceLinks", theParamName);
        return;//from  w  ww  .  j a v a  2s  .c o m
    }

    CriteriaBuilder builder = myEntityManager.getCriteriaBuilder();
    CriteriaQuery<Long> cq = builder.createQuery(Long.class);
    Root<ResourceLink> from = cq.from(ResourceLink.class);
    cq.select(from.get("mySourceResourcePid").as(Long.class));

    List<Predicate> codePredicates = new ArrayList<Predicate>();

    for (IQueryParameterType nextOr : theList) {
        IQueryParameterType params = nextOr;

        if (addPredicateMissingFalseIfPresentForResourceLink(builder, theParamName, from, codePredicates,
                nextOr)) {
            continue;
        }

        if (params instanceof ReferenceParam) {
            ReferenceParam ref = (ReferenceParam) params;

            if (isBlank(ref.getChain())) {
                IIdType dt = new IdDt(ref.getBaseUrl(), ref.getResourceType(), ref.getIdPart(), null);

                if (dt.hasBaseUrl()) {
                    if (myCallingDao.getConfig().getTreatBaseUrlsAsLocal().contains(dt.getBaseUrl())) {
                        dt = dt.toUnqualified();
                    } else {
                        ourLog.debug("Searching for resource link with target URL: {}", dt.getValue());
                        Predicate eq = builder.equal(from.get("myTargetResourceUrl"), dt.getValue());
                        codePredicates.add(eq);
                        continue;
                    }
                }

                List<Long> targetPid;
                try {
                    targetPid = myCallingDao.translateForcedIdToPids(dt);
                } catch (ResourceNotFoundException e) {
                    doSetPids(new ArrayList<Long>());
                    return;
                }
                for (Long next : targetPid) {
                    ourLog.debug("Searching for resource link with target PID: {}", next);
                    Predicate eq = builder.equal(from.get("myTargetResourcePid"), next);
                    codePredicates.add(eq);
                }
            } else {

                List<Class<? extends IBaseResource>> resourceTypes;
                String resourceId;
                if (!ref.getValue().matches("[a-zA-Z]+\\/.*")) {

                    String paramPath = myContext.getResourceDefinition(myResourceType)
                            .getSearchParam(theParamName).getPath();
                    if (paramPath.endsWith(".as(Reference)")) {
                        paramPath = paramPath.substring(0, paramPath.length() - ".as(Reference)".length())
                                + "Reference";
                    }

                    BaseRuntimeChildDefinition def = myContext.newTerser().getDefinition(myResourceType,
                            paramPath);
                    if (def instanceof RuntimeChildChoiceDefinition) {
                        RuntimeChildChoiceDefinition choiceDef = (RuntimeChildChoiceDefinition) def;
                        resourceTypes = choiceDef.getResourceTypes();
                    } else if (def instanceof RuntimeChildResourceDefinition) {
                        RuntimeChildResourceDefinition resDef = (RuntimeChildResourceDefinition) def;
                        resourceTypes = resDef.getResourceTypes();
                    } else {
                        throw new ConfigurationException("Property " + paramPath + " of type " + myResourceName
                                + " is not a resource: " + def.getClass());
                    }

                    resourceId = ref.getValue();

                } else {
                    RuntimeResourceDefinition resDef = myContext.getResourceDefinition(ref.getResourceType());
                    resourceTypes = new ArrayList<Class<? extends IBaseResource>>(1);
                    resourceTypes.add(resDef.getImplementingClass());
                    resourceId = ref.getIdPart();
                }

                boolean foundChainMatch = false;

                String chain = ref.getChain();
                String remainingChain = null;
                int chainDotIndex = chain.indexOf('.');
                if (chainDotIndex != -1) {
                    remainingChain = chain.substring(chainDotIndex + 1);
                    chain = chain.substring(0, chainDotIndex);
                }

                for (Class<? extends IBaseResource> nextType : resourceTypes) {
                    RuntimeResourceDefinition typeDef = myContext.getResourceDefinition(nextType);

                    IFhirResourceDao<?> dao = myCallingDao.getDao(nextType);
                    if (dao == null) {
                        ourLog.debug("Don't have a DAO for type {}", nextType.getSimpleName());
                        continue;
                    }

                    int qualifierIndex = chain.indexOf(':');
                    String qualifier = null;
                    if (qualifierIndex != -1) {
                        qualifier = chain.substring(qualifierIndex);
                        chain = chain.substring(0, qualifierIndex);
                    }

                    boolean isMeta = BaseHapiFhirDao.RESOURCE_META_PARAMS.containsKey(chain);
                    RuntimeSearchParam param = null;
                    if (!isMeta) {
                        param = typeDef.getSearchParam(chain);
                        if (param == null) {
                            ourLog.debug("Type {} doesn't have search param {}", nextType.getSimpleName(),
                                    param);
                            continue;
                        }
                    }

                    IQueryParameterType chainValue;
                    if (remainingChain != null) {
                        if (param == null || param.getParamType() != RestSearchParameterTypeEnum.REFERENCE) {
                            ourLog.debug("Type {} parameter {} is not a reference, can not chain {}",
                                    new Object[] { nextType.getSimpleName(), chain, remainingChain });
                            continue;
                        }

                        chainValue = new ReferenceParam();
                        chainValue.setValueAsQueryToken(myContext, theParamName, qualifier, resourceId);
                        ((ReferenceParam) chainValue).setChain(remainingChain);
                    } else if (isMeta) {
                        IQueryParameterType type = BaseHapiFhirDao.newInstanceType(chain);
                        type.setValueAsQueryToken(myContext, theParamName, qualifier, resourceId);
                        chainValue = type;
                    } else {
                        chainValue = toParameterType(param, qualifier, resourceId);
                    }

                    foundChainMatch = true;

                    Set<Long> pids = dao.searchForIds(chain, chainValue);
                    if (pids.isEmpty()) {
                        continue;
                    }

                    Predicate eq = from.get("myTargetResourcePid").in(pids);
                    codePredicates.add(eq);

                }

                if (!foundChainMatch) {
                    throw new InvalidRequestException(
                            myContext.getLocalizer().getMessage(BaseHapiFhirResourceDao.class,
                                    "invalidParameterChain", theParamName + '.' + ref.getChain()));
                }
            }

        } else {
            throw new IllegalArgumentException(
                    "Invalid token type (expecting ReferenceParam): " + params.getClass());
        }

    }

    List<Predicate> predicates = new ArrayList<Predicate>();
    predicates.add(createResourceLinkPathPredicate(theParamName, from));
    predicates.add(builder.or(toArray(codePredicates)));
    createPredicateResourceId(builder, cq, predicates, from.get("mySourceResourcePid").as(Long.class));
    createPredicateLastUpdatedForResourceLink(builder, from, predicates);

    cq.where(builder.and(toArray(predicates)));

    TypedQuery<Long> q = myEntityManager.createQuery(cq);
    doSetPids(new HashSet<Long>(q.getResultList()));
}

From source file:sf.net.experimaestro.scheduler.Resource.java

/**
 * Get a resource by locator/* w w w. ja v a 2 s .  c  o  m*/
 *
 * @param em   The current entity manager
 * @param path The path of the resource
 * @return The resource or null if there is no such resource
 */
public static Resource getByLocator(EntityManager em, String path) {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<Resource> cq = cb.createQuery(Resource.class);
    Root<Resource> root = cq.from(Resource.class);
    cq.where(root.get("locator").in(cb.parameter(String.class, "locator")));

    TypedQuery<Resource> query = em.createQuery(cq);
    query.setParameter("locator", path);
    List<Resource> result = query.getResultList();
    assert result.size() <= 1;

    if (result.isEmpty())
        return null;

    return result.get(0);
}