java类javax.persistence.criteria.Predicate的实例源码

@Override
public List<?> search(String entityName, String query, int limit, int pageNumber)
{
    List<T> resultsList = new ArrayList<>();

    Class<T> clazz = entityList.get(entityName);

    if(clazz == null) throw new RuntimeException("ENTITY.NOT.FOUND");

    boolean isValid = query == null ? true : validateQuery(query, clazz);  

    if(isValid) {

        CriteriaBuilder criteriaBuilder = entitymanager.getCriteriaBuilder();
        CriteriaQuery<T> cq = criteriaBuilder.createQuery(clazz);

        Root<T> root = cq.from(clazz);          

        if(query!=null) {
            Predicate predicate = populatePredicates(root, query);
            cq.where(predicate);                
        }

           cq.select(root);
           TypedQuery<T> q = entitymanager.createQuery(cq);
           q.setFirstResult((pageNumber-1) * limit);
           q.setMaxResults(limit);
           resultsList = q.getResultList();
           System.out.println(resultsList.size());
    } else {
        throw new RuntimeException("Property defined in the query is not valid, doesn't belong to the entity type:"+entityName);
    }
    return resultsList;
}

/**
 * input query = field:abcAND(field<bcdOR(field:defANDfield>=efg))
 * return field:abc,field<bcd,field:def,field>=efg,AND,OR,AND
 * @param root 
 * @param query
 * @param predicates 
 * @return 
 * @return
 */
private Predicate populatePredicates(Root<T> root, String query)
{
    if(StringUtils.countOccurrencesOf(query, Conjunctions.SP.toString()) == StringUtils.countOccurrencesOf(query, Conjunctions.EP.toString())) {
        LinkedList<String> postfix = createPostfixExpression(query);
        boolean hasSingleSearchField = postfix.size() == 1;  

        Map<String, Predicate> predicateMap = new LinkedHashMap<>();

        for (int i = 0; i < postfix.size(); i++)
        {
            String attr = postfix.get(i);
            if(Conjunctions.isConjunction(attr)) {

                String rightOperand = postfix.get(i-1);
                String leftOperand = postfix.get(i-2);

                String key = rightOperand + attr + leftOperand;

                Predicate rightPredicate = (predicateMap.containsKey(rightOperand))? predicateMap.get(rightOperand) : buildPredicate(root, new SearchField(rightOperand)); 

                Predicate leftPredicate = (predicateMap.containsKey(leftOperand))? predicateMap.get(leftOperand) : buildPredicate(root, new SearchField(leftOperand));

                postfix.set(i-2, key);
                postfix.remove(i);
                postfix.remove(i-1);

                //reset loop
                i=0;

                List<Predicate> combinedPredicates = new ArrayList<>();
                combinedPredicates.add(leftPredicate);
                combinedPredicates.add(rightPredicate);

                Predicate combinedPredicate = buildPredicateWithOperator(root, Conjunctions.getEnum(attr), combinedPredicates);
                predicateMap.put(key, combinedPredicate);
            }
        }

        if(hasSingleSearchField) {
            SearchField field = new SearchField(postfix.get(0));
            predicateMap.put(postfix.get(0), buildPredicate(root, field));
        }

        return (Predicate) predicateMap.values().toArray()[predicateMap.size()-1];
    } else {
        throw new RuntimeException("MALFORMED.QUERY");
    }
}

@Override
public Predicate toPredicate(final Root<T> root, final CriteriaQuery<?> query, final CriteriaBuilder cb) {
    final List<Predicate> predicates = new ArrayList<>();

    for (final PredicateBuilder predicateBuilder : predicateBuilders) {
        final Predicate predicate = predicateBuilder.toPredicate(root, query, cb);
        if (predicate != null) {
            predicates.add(predicate);
        }
    }

    return cb.and(predicates.toArray(new Predicate[] {}));
}

@SuppressWarnings ({ "unchecked", "rawtypes" })
protected Predicate buildPredicate(Path<T> root, SearchField field)
{
    Path<T> tt = (!field.getField().contains(".")) ? root.get(field.getField()) : fetchNestedPath(root, field.getField());
    CriteriaBuilder criteriaBuilder = this.entitymanager.getCriteriaBuilder();

    Class<?> javaType = tt.getJavaType();

    if (!classCompatibleWithOperator(javaType, field.getOperator()))
    {
        throw new RuntimeException("operator incompatible with field");
    }

    Object valueObject = convertStringValueToObject(field.getValue(), javaType);
    switch (field.getOperator())
    {
        case GE:
            return criteriaBuilder.greaterThan((Expression) tt, (Comparable) valueObject);
        case GTE:
            return criteriaBuilder.greaterThanOrEqualTo((Expression) tt, (Comparable) valueObject);
        case LE:
            return criteriaBuilder.lessThan((Expression) tt, (Comparable) valueObject);
        case LTE:
            return criteriaBuilder.lessThanOrEqualTo((Expression) tt, (Comparable) valueObject);
        case NE: 
               return criteriaBuilder.notEqual(tt, valueObject); 
        case EX:
            return criteriaBuilder.like((Expression) tt, "%"+field.getValue()+"%");
        default:
        {
            //EQ
            return criteriaBuilder.equal(tt, valueObject);
        }
    }
}

@Override
public final Lo3Voorkomen zoekLo3VoorkomenVoorActie(final Long actieId) {
    final CriteriaBuilder criteriaBuilder = em.getCriteriaBuilder();
    final CriteriaQuery<Lo3Voorkomen> criteria = criteriaBuilder.createQuery(Lo3Voorkomen.class);
    final Root<Lo3Voorkomen> criteriaRoot = criteria.from(Lo3Voorkomen.class);
    criteria.select(criteriaRoot);
    criteria.where(new Predicate[] {criteriaBuilder.equal(criteriaRoot.get("actie").get("id"), actieId) });

    final List<Lo3Voorkomen> result = em.createQuery(criteria).getResultList();
    return result.isEmpty() ? null : result.get(0);
}

/**
   * gets an author from the database by determining the type of the provided id. if no author is present it builds one from the id.
   * @param id the author identifier
   * @return the author retrieved from the database or build with the identifier
* @throws JDOMException thrown upon parsing the source response
* @throws IOException thrown upon reading profiles from disc
* @throws SAXException thrown when parsing the files from disc
 */
  public PublicationAuthor retrieveAuthor(String id) throws JDOMException, IOException, SAXException {
      typeOfID = determineID(id);
      LOGGER.info("given ID: " + id + " is of type " + typeOfID);
      EntityManagerFactory emf = Persistence.createEntityManagerFactory("publicationAuthors");
      EntityManager em = emf.createEntityManager();
      CriteriaBuilder cb = em.getCriteriaBuilder();
      CriteriaQuery<PublicationAuthor> q = cb.createQuery(PublicationAuthor.class);
      Root<PublicationAuthor> c = q.from(PublicationAuthor.class);
      List<Predicate> predicates = new ArrayList<>();
      if (typeOfID.equals("surname")) {
          if (id.contains(",")) {
              predicates.add(cb.equal(c.get("surname"),id.substring(0,id.indexOf(","))));
              predicates.add(cb.equal(c.get("firstname"),id.substring(id.indexOf(",")+1)));
              LOGGER.info("retriving surname, firstname from database for " + id);
          } else if (id.contains(" ")) {
              predicates.add(cb.equal(c.get("firstname"),id.substring(0,id.indexOf(" "))));
              predicates.add(cb.equal(c.get("surname"),id.substring(id.indexOf(" ")+1)));
              LOGGER.info("retrieving firstname surname from database for " + id);
          } else {
              predicates.add(cb.equal(c.get("surname"), id));
              LOGGER.info("retrieving surname from database for " + id);
          }
      }
      predicates.add(cb.equal(c.get(typeOfID), id));
      q.select(c).where(cb.equal(c.get(typeOfID), id));
      TypedQuery<PublicationAuthor> query = em.createQuery(q);
      List<PublicationAuthor> authors = query.getResultList();
      em.close();
      if (authors.size() == 1) {
          LOGGER.info("found author in database");
          this.author = authors.get(0);
          return author;
      }
      LOGGER.info("no match in database");
      return buildAuthor(id);
  }

public static Specification<Sense> filter(SenseCriteriaDTO dto) {

        return (root, query, cb) -> {

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

            if (dto.getLemma() != null && !dto.getLemma().isEmpty()) {
                criteria.add(byLemma(dto.getLemma()).toPredicate(root, query, cb));
            }

            if (dto.getVariant() != null) {
                criteria.add(byVarinat(dto.getVariant()).toPredicate(root, query, cb));
            }

            if (dto.getPartOfSpeechId() != null) {
                criteria.add(byPartOfSpeech(dto.getPartOfSpeechId()).toPredicate(root, query, cb));
            }

            if (dto.getDomainId() != null) {
                criteria.add(byDomain(dto.getDomainId()).toPredicate(root, query, cb));
            }

            if (dto.getSynsetId() != null) {
                criteria.add(bySynsetId(dto.getSynsetId()).toPredicate(root, query, cb));
            }

            if (dto.getLexicons() != null && dto.getLexicons().size() > 0) {
                criteria.add(byLexiconIds(dto.getLexicons()).toPredicate(root, query, cb));
            }

            return cb.and(criteria.toArray(new Predicate[criteria.size()]));
        };
    }

public Collection<ExtGraph> findByWordAndPackageNo(String word, int packageno) {

        Long pkg = new Long(packageno);
        CriteriaBuilder criteriaBuilder = getEntityManager().getCriteriaBuilder();
        CriteriaQuery<ExtGraph> criteriaQuery = criteriaBuilder.createQuery(ExtGraph.class
        );

        Root<ExtGraph> root = criteriaQuery.from(ExtGraph.class);
        Join<ExtGraph, Synset> synset = root.join("synset", JoinType.INNER);
        Join<Synset, Sense> sts = synset.join("sense", JoinType.LEFT);
        List<Predicate> criteriaList = new ArrayList<>();

        Predicate firstCondition = criteriaBuilder.equal(root.get("word"), word);
        criteriaList.add(firstCondition);

        Predicate secondCondition = criteriaBuilder.equal(root.get("packageno"), pkg);
        criteriaList.add(secondCondition);

        Predicate thirdCondition = criteriaBuilder.equal(sts.get("senseIndex"), 0);
        criteriaList.add(thirdCondition);

        criteriaQuery.where(criteriaBuilder.and(criteriaList.toArray(new Predicate[0])));
        final TypedQuery<ExtGraph> query = getEntityManager().createQuery(criteriaQuery);

        return query.getResultList();
    }

@Override
public List<Agent> list(final String zone, final String orderByField, final AgentStatus... status) {
    if (zone == null) {
        throw new IllegalArgumentException("Zone name is required");
    }

    if (orderByField != null && !orderByFields.contains(orderByField)) {
        throw new IllegalArgumentException(
            "The orderByField only availabe among 'createdDate', 'updateDate' or 'sessionDate'");
    }

    return (List<Agent>) execute(session -> {
        CriteriaBuilder builder = session.getCriteriaBuilder();
        CriteriaQuery<Agent> criteria = builder.createQuery(Agent.class);

        Root<Agent> root = criteria.from(Agent.class);
        criteria.select(root);

        Predicate whereCriteria = builder.equal(root.get("path").get("zone"), zone);

        if (status != null && status.length > 0) {
            Predicate inStatus = root.get("status").in(status);
            whereCriteria = builder.and(whereCriteria, inStatus);
        }
        criteria.where(whereCriteria);

        // order by created date
        if (orderByField != null) {
            criteria.orderBy(builder.asc(root.get(orderByField)));
        }

        Query<Agent> query = session.createQuery(criteria);
        return query.getResultList();
    });
}

@Override
public Predicate toPredicate(Criterion c, Root<?> r, CriteriaBuilder b) {
    Object o = c.getCompareTo();
    if(o == null)
        return r.get(c.getPropertyName()).in();
    if(o instanceof Collection)
        return r.get(c.getPropertyName()).in((Collection) o);
    throw new IllegalArgumentException(c.getPropertyName());
}