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

public static List<SecurityGroupMember> listActiveSecurityGroupMembersBySecurityGroup(EntityManager em,
        SecurityGroup sg) {
    CriteriaBuilder cb = em.getCriteriaBuilder();

    CriteriaQuery<SecurityGroupMember> query = cb.createQuery(SecurityGroupMember.class);

    Root<SecurityGroupMember> root = query.from(SecurityGroupMember.class);

    query = query.select(root).distinct(true)
            .where(cb.equal(root.get("markedForDeletion"), false),
                    cb.equal(root.get("securityGroup"), sg))
            .orderBy(cb.asc(root.get("type")));

    return em.createQuery(query).getResultList();
}

public List<T> findAll() {
    final CriteriaBuilder builder = entityManager.getCriteriaBuilder();
    final CriteriaQuery<T> criteria = builder.createQuery(entityClass);
    final Root<T> root = criteria.from(entityClass);
    criteria.select(root);

    final TypedQuery<T> query = entityManager.createQuery(criteria);

    return query.getResultList();
}

/**
 * 查询实体类的所有数据
 * @param domainClass 领域类（实体类）
 * @param <T> 领域类（实体类）范型
 * @return 结果集合
 */
public static <T> List<T> findAll(Class<T> domainClass) {
    EntityManager em = getEntityManager(domainClass);
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<T> cq = cb.createQuery(domainClass);
    cq.from(domainClass);
    return em.createQuery(cq).getResultList();
}

public static List<SecurityGroup> listByProtectAllAndProjectId(EntityManager em, String projectId) {
    CriteriaBuilder cb = em.getCriteriaBuilder();

    CriteriaQuery<SecurityGroup> query = cb.createQuery(SecurityGroup.class);

    Root<SecurityGroup> root = query.from(SecurityGroup.class);
    query = query.select(root)
            .distinct(true)
            .where(cb.and(
                    cb.equal(root.get("projectId"), projectId),
                    cb.equal(root.get("protectAll"), true)));

    return em.createQuery(query).getResultList();
}

/**
   * 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 PortEntity txPortEntityByElementId(String elementId) {
    CriteriaBuilder cb = this.em.getCriteriaBuilder();

    CriteriaQuery<PortEntity> q = cb.createQuery(PortEntity.class);
    Root<PortEntity> r = q.from(PortEntity.class);
    q.where(cb.equal(r.get("elementId"), elementId));

    try {
        return this.em.createQuery(q).getSingleResult();
    } catch (Exception e) {
        LOG.error("Finding Network Element {} ", elementId, e);
        return null;
    }
}

@Override
public List<NodeResult> list(BigInteger jobId) {
    return execute(session -> {
        CriteriaBuilder builder = session.getCriteriaBuilder();
        CriteriaQuery<NodeResult> select = builder.createQuery(NodeResult.class);
        Root<NodeResult> nodeResultRoot = select.from(NodeResult.class);
        Predicate aCondition = builder.equal(nodeResultRoot.get("key").get("jobId"), jobId);
        select.where(aCondition);
        select.orderBy(builder.asc(nodeResultRoot.get("order")));
        return session.createQuery(select).list();
    });
}

public List<PortEntity> txPortEntities() {
    CriteriaBuilder criteriaBuilder = this.em.getCriteriaBuilder();

    CriteriaQuery<PortEntity> query = criteriaBuilder.createQuery(PortEntity.class);
    Root<PortEntity> r = query.from(PortEntity.class);
    query.select(r);

    return this.em.createQuery(query).getResultList();
}

public List<PlayerDetails> getPlayersByCity(String city) {
    logger.info("getPlayersByCity");
    List<Player> players = null;

    try {
        CriteriaQuery<Player> cq = cb.createQuery(Player.class);
        if (cq != null) {
            Root<Player> player = cq.from(Player.class);
            Join<Player, Team> team = player.join(Player_.teams);

            // Get MetaModel from Root
            //EntityType<Player> Player_ = player.getModel();

            // set the where clause
            cq.where(cb.equal(team.get(Team_.city), city));
            cq.select(player).distinct(true);
            TypedQuery<Player> q = em.createQuery(cq);
            players = q.getResultList();
        }
        return copyPlayersToDetails(players);
    } catch (Exception ex) {
        throw new EJBException(ex);
    }
}

/**
 * Creates the Policy for a given domain
 *
 * @return policy
 */
@Path("/{domainId}/policies")
@POST
public String createPolicy(@PathParam("domainId") Long domainId, PolicyEntity entity) {

    LOG.info("Creating Policy Entity...:" + entity.getName());

    return this.txControl.required(new Callable<PolicyEntity>() {

        @Override
        public PolicyEntity call() throws Exception {

            DomainEntity result = DomainApis.this.em.find(DomainEntity.class, domainId);
            if (result == null) {
                throw new Exception("Domain Entity does not exists...");
                //TODO - to add RETURN 404 error:Sudhir
            }
            CriteriaBuilder criteriaBuilder = DomainApis.this.em.getCriteriaBuilder();
            CriteriaQuery<PolicyEntity> query = criteriaBuilder.createQuery(PolicyEntity.class);
            Root<PolicyEntity> r = query.from(PolicyEntity.class);
            query.select(r).where(criteriaBuilder.and(criteriaBuilder.equal(r.get("name"), entity.getName())));

            List<PolicyEntity> policyresult = DomainApis.this.em.createQuery(query).getResultList();
            if (!policyresult.isEmpty()) {
                throw new Exception("Policy Entity name already exists...:");
                //TODO - to add RETURN 404 error:Sudhir
            }
            entity.setDomain(result);
            DomainApis.this.em.persist(entity);
            return entity;
        }
    }).getId();
}