Java Examples for javax.persistence.criteria.Root

public UserWidget findByWidgetSpaceAndUser(Widget widget, WidgetSpace widgetSpace, UserEntity user) {
    EntityManager entityManager = getEntityManager();
    CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
    CriteriaQuery<UserWidget> criteria = criteriaBuilder.createQuery(UserWidget.class);
    Root<UserWidget> root = criteria.from(UserWidget.class);
    criteria.select(root);
    criteria.where(criteriaBuilder.and(criteriaBuilder.equal(root.get(UserWidget_.widgetSpace), widgetSpace), criteriaBuilder.equal(root.get(UserWidget_.user), user), criteriaBuilder.equal(root.get(UserWidget_.widget), widget)));
    return getSingleResult(entityManager.createQuery(criteria));
}

/** Find a SimpleAuth object with specific username and password.
   * 
   * @param username The username of the user to find.
   * @param password The password of the user to find.
   * @return The <code>SimpleAuth</code> object with the specified username and password,
   * or <code>null</code> if such object was not found. 
   */
public SimpleAuth findByUserNameAndPassword(String username, String password) {
    EntityManager entityManager = getEntityManager();
    CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
    CriteriaQuery<SimpleAuth> criteria = criteriaBuilder.createQuery(SimpleAuth.class);
    Root<SimpleAuth> root = criteria.from(SimpleAuth.class);
    criteria.select(root);
    criteria.where(criteriaBuilder.and(criteriaBuilder.equal(root.get(SimpleAuth_.username), username), criteriaBuilder.equal(root.get(SimpleAuth_.password), password)));
    return getSingleResult(entityManager.createQuery(criteria));
}

@Override
@Transactional(readOnly = true)
public User findByName(String name) {
    final CriteriaBuilder builder = this.getEntityManager().getCriteriaBuilder();
    final CriteriaQuery<User> criteriaQuery = builder.createQuery(this.entityClass);
    Root<User> root = criteriaQuery.from(this.entityClass);
    Path<String> namePath = root.get("name");
    criteriaQuery.where(builder.equal(namePath, name));
    TypedQuery<User> typedQuery = this.getEntityManager().createQuery(criteriaQuery);
    List<User> users = typedQuery.getResultList();
    if (users.isEmpty()) {
        return null;
    }
    return users.iterator().next();
}

@Override
public List<Predicate> createPredicate(CriteriaBuilder builder, Root<User> root, UserFilter filter) {
    List<Predicate> predicates = new ArrayList<>();
    if (filter.getId() != null) {
        predicates.add(builder.equal(root.get("id"), filter.getId()));
    }
    if (filter.getEmail() != null) {
        predicates.add(builder.like(root.get("email"), filter.getEmail() + "%"));
    }
    if (filter.getUsername() != null) {
        predicates.add(builder.like(root.get("username"), filter.getUsername() + "%"));
    }
    if (filter.getFirstName() != null) {
        predicates.add(builder.like(root.get("firstName"), filter.getFirstName() + "%"));
    }
    if (filter.getLastName() != null) {
        predicates.add(builder.like(root.get("lastName"), filter.getLastName() + "%"));
    }
    if (filter.getVerified() != null) {
        predicates.add(builder.equal(root.get("verified"), filter.getVerified()));
    }
    return predicates;
}

@Override
public Set<Beer> fetchAll() {
    CriteriaBuilder criteriaBuilder = em.getCriteriaBuilder();
    CriteriaQuery<Beer> query = criteriaBuilder.createQuery(Beer.class);
    Root<Beer> from = query.from(Beer.class);
    CriteriaQuery<Beer> select = query.select(from);
    final Set<Beer> result = new HashSet<Beer>();
    result.addAll(em.createQuery(select).getResultList());
    return result;
}

@Test
public void testEqualAll() {
    CriteriaBuilder builder = entityManagerFactory().getCriteriaBuilder();
    EntityManager em = getOrCreateEntityManager();
    em.getTransaction().begin();
    CriteriaQuery<Customer> criteria = builder.createQuery(Customer.class);
    Root<Customer> customerRoot = criteria.from(Customer.class);
    Join<Customer, Order> orderJoin = customerRoot.join(Customer_.orders);
    criteria.select(customerRoot);
    Subquery<Double> subCriteria = criteria.subquery(Double.class);
    Root<Order> subqueryOrderRoot = subCriteria.from(Order.class);
    subCriteria.select(builder.min(subqueryOrderRoot.get(Order_.totalPrice)));
    criteria.where(builder.equal(orderJoin.get("totalPrice"), builder.all(subCriteria)));
    em.createQuery(criteria).getResultList();
    em.getTransaction().commit();
    em.close();
}

public MenuItem getMenuItem(Long id) {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<MenuItem> query = cb.createQuery(MenuItem.class);
    Root<MenuItem> root = query.from(MenuItem.class);
    query.select(root);
    query.where(cb.equal(root.get(MenuItem_.id), id));
    TypedQuery<MenuItem> typedQuery = em.createQuery(query);
    return typedQuery.getSingleResult();
}

@Test
public void testImplicitJoinFromExplicitCollectionJoin() {
    EntityManager em = getOrCreateEntityManager();
    em.getTransaction().begin();
    final CriteriaBuilder builder = em.getCriteriaBuilder();
    final CriteriaQuery<Entity1> criteria = builder.createQuery(Entity1.class);
    final Root<Entity1> root = criteria.from(Entity1.class);
    // illegal with fetch join
    final Join<Entity1, Entity2> entity2Join = root.join(Entity1_.entity2, JoinType.INNER);
    // <=== REMOVE
    final Fetch<Entity1, Entity2> entity2Fetch = root.fetch(Entity1_.entity2, JoinType.INNER);
    // <=== REMOVE
    entity2Fetch.fetch(Entity2_.entity3);
    criteria.where(builder.equal(root.get(Entity1_.value), "test"), // illegal with fetch join
    builder.equal(entity2Join.get(Entity2_.value), "test"));
    em.createQuery(criteria).getResultList();
    em.getTransaction().commit();
    em.close();
}

public static void main(String[] args) {
    // Get the entity manager for the tests.
    EntityManagerFactory emf = Persistence.createEntityManagerFactory("Model");
    EntityManager em = emf.createEntityManager();
    try {
        CriteriaBuilder cb = em.getCriteriaBuilder();
        CriteriaQuery<Departments> cq = cb.createQuery(Departments.class);
        Root<Departments> c = cq.from(Departments.class);
        cq.where(cb.equal(c.get(Departments_.departmentName), "Finance"));
        cq.select(c);
        TypedQuery<Departments> tq = em.createQuery(cq);
        List<Departments> results = tq.getResultList();
        for (Departments department : results) {
            System.out.println(department.getDepartmentName().toString());
        }
    } catch (RuntimeException e) {
        e.printStackTrace();
    } finally {
        //Close the manager
        em.close();
        emf.close();
    }
}

@Override
public User getUser(String username) {
    CriteriaBuilder cb = emp.get().getCriteriaBuilder();
    CriteriaQuery<User> c = cb.createQuery(User.class);
    Root<User> account = c.from(User.class);
    Path<String> userQ = account.get("username");
    c.where(cb.equal(userQ, username));
    User user = null;
    try {
        user = emp.get().createQuery(c).getSingleResult();
    } catch (javax.persistence.NoResultException ex) {
    }
    return user;
}

@Override
public boolean existsInForumByName(String forumJid, String forumModuleName) {
    CriteriaBuilder cb = JPA.em().getCriteriaBuilder();
    CriteriaQuery<Long> query = cb.createQuery(Long.class);
    Root<ForumModuleModel> root = query.from(ForumModuleModel.class);
    query.select(cb.count(root)).where(cb.and(cb.equal(root.get(ForumModuleModel_.forumJid), forumJid), cb.equal(root.get(ForumModuleModel_.name), forumModuleName)));
    return JPA.em().createQuery(query).getSingleResult() != 0;
}

public List<PhysicalNetworkInterface> listSingles() {
    CriteriaBuilder cb = getCriteriaBuilder();
    CriteriaQuery<PhysicalNetworkInterface> cq = cb.createQuery(PhysicalNetworkInterface.class);
    Root<PhysicalNetworkInterface> r = cq.from(PhysicalNetworkInterface.class);
    cq.select(r).where(cb.isNull(r.get("l2Connection")));
    return getEntityManager().createQuery(cq).getResultList();
}

/**
     * Creates a specification used to find persons whose last name begins with
     * the given search term. This search is case insensitive.
     * @param searchTerm
     * @return
     */
public static Specification<Person> lastNameIsLike(final String searchTerm) {
    return new Specification<Person>() {

        @Override
        public Predicate toPredicate(Root<Person> personRoot, CriteriaQuery<?> query, CriteriaBuilder cb) {
            String likePattern = getLikePattern(searchTerm);
            return cb.like(cb.lower(personRoot.<String>get(Person_.lastName)), likePattern);
        }

        private String getLikePattern(final String searchTerm) {
            StringBuilder pattern = new StringBuilder();
            pattern.append(searchTerm.toLowerCase());
            pattern.append("%");
            return pattern.toString();
        }
    };
}

public static Boolean numeroDiDetermina(Determina determina) {
    Database db = (Database) Register.queryUtility(IDatabase.class);
    EntityManager em = db.getEntityManagerFactory().createEntityManager();
    int year = Calendar.getInstance().get(Calendar.YEAR);
    determina.setAnno(year);
    // cerchiamo il numero di determina
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<Determina> cq = cb.createQuery(Determina.class);
    Root<Determina> root = cq.from(Determina.class);
    cq.select(root);
    cq.where(cb.and(cb.equal(root.get("anno"), year), cb.isNotNull(root.get("numero"))));
    cq.orderBy(cb.desc(root.get("numero")));
    TypedQuery<Determina> tq = em.createQuery(cq).setMaxResults(1);
    Integer numero;
    try {
        numero = tq.getSingleResult().getNumero() + 1;
    } catch (NoResultException ex) {
        numero = 1;
    } catch (NullPointerException ex) {
        numero = 1;
    } catch (Exception ex) {
        System.out.println("Errore generico");
        return Boolean.FALSE;
    }
    determina.setNumero(numero);
    // setto anche la data della determina
    determina.setData(Calendar.getInstance().getTime());
    // commit
    Controller controller = db.createController(Determina.class);
    Validation validation = controller.commit(determina);
    return validation.getResponse();
}

@Override
protected CriteriaQuery<ContactTypeDO> getCriteria(DataGrid<ContactTypeDO> grid) {
    ScopeDO selectedScope = scopeDao.getById(scopeId);
    if (!selectedScope.getScopeType().isAllowOrg()) {
        throw new IllegalStateException("Contact types can only be defined at scopes that allow organizations.");
    }
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<ContactTypeDO> criteria = cb.createQuery(ContactTypeDO.class);
    Root<ContactTypeDO> contactType = criteria.from(ContactTypeDO.class);
    Join<ContactTypeDO, ScopeDO> scope = contactType.join(ContactTypeDO_.scope);
    Join<ScopeDO, ScopeTypeDO> scopeType = scope.join(ScopeDO_.scopeType);
    Join<ScopeDO, ScopeTreeDO> scopeTree = scope.join(ScopeDO_.scopeTrees);
    Predicate typeClause = cb.equal(scopeType.get(ScopeTypeDO_.allowOrg), Short.valueOf("1"));
    scopeTree.get(ScopeTreeDO_.scope);
    Predicate pathClause = cb.equal(scopeTree.get(ScopeTreeDO_.ancestorScope).get(ScopeDO_.scopeId), scopeId);
    criteria.where(typeClause, pathClause);
    return criteria;
}

/**
	 * Returns a session for a key
	 * 
	 * @param key
	 *            The key of the requested session
	 * @throws NoResultException
	 *             if no session with this key is stored
	 * @return The persisted Session
	 */
public List<SessionEntity> findBySessionKeyAndUsername(String key, String username) throws NoResultException {
    CriteriaBuilder criteriaBuilder = this.getCriteriaBuilder();
    CriteriaQuery<SessionEntity> criteriaQuery = criteriaBuilder.createQuery(SessionEntity.class);
    Root<SessionEntity> entityRoot = criteriaQuery.from(SessionEntity.class);
    List<Predicate> predicates = new ArrayList<>();
    predicates.add(criteriaBuilder.equal(entityRoot.get(SessionEntity_.key), key));
    Subquery<String> subQuery = criteriaQuery.subquery(String.class);
    Root<BundesbruderEntity> entityRoot2 = subQuery.from(BundesbruderEntity.class);
    predicates.add(criteriaBuilder.equal(entityRoot2.get(BundesbruderEntity_.userName), username));
    criteriaQuery.where(criteriaBuilder.and(predicates.toArray(new Predicate[predicates.size()])));
    TypedQuery<SessionEntity> typedQuery = this.createQuery(criteriaQuery);
    List<SessionEntity> searchResult = typedQuery.getResultList();
    return searchResult;
}

/**
     * ANDs the given {@link Specification} to the current one.
     * 
     * @param other
     * @return
     */
public Specifications<T> and(final Specification<T> other) {
    return new Specifications<T>(new Specification<T>() {

        public Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder builder) {
            return builder.and(spec.toPredicate(root, query, builder), other.toPredicate(root, query, builder));
        }
    });
}

/*
     * 
     */
@Override
public int count() {
    CriteriaQuery cq = getEntityManager().getCriteriaBuilder().createQuery().where();
    javax.persistence.criteria.Root<T> rt = cq.from(entityClass);
    cq.select(getEntityManager().getCriteriaBuilder().count(rt));
    Query q = getEntityManager().createQuery(cq);
    return ((Long) q.getSingleResult()).intValue();
}

@SuppressWarnings({ "rawtypes", "unchecked" })
protected static <T extends Model, S extends Model> TypedQuery<S> createQuery(Class<T> entityType, String attribute, Class<S> attributeType, Filter filter) {
    CriteriaBuilder builder = getEntityManager().getCriteriaBuilder();
    CriteriaQuery<S> cQuery = builder.createQuery(attributeType);
    Root<T> root = cQuery.from(entityType);
    if (attribute != null) {
        Join join = root.join(attribute);
        cQuery.select(join);
    }
    filter.constructQuery(builder, cQuery, root);
    return createQuery(cQuery, filter);
}

public int count() {
    javax.persistence.criteria.CriteriaQuery cq = getEntityManager().getCriteriaBuilder().createQuery();
    javax.persistence.criteria.Root<T> rt = cq.from(entityClass);
    cq.select(getEntityManager().getCriteriaBuilder().count(rt));
    javax.persistence.Query q = getEntityManager().createQuery(cq);
    return ((Long) q.getSingleResult()).intValue();
}

@Test
@Ignore
public void testFindAll() {
    CriteriaQuery criteriaQueryMock = createMock(CriteriaQuery.class);
    CriteriaBuilder criteriaBuilderMock = createMock(CriteriaBuilder.class);
    Root rootMock = createMock(Root.class);
    TypedQuery typedQueryMock = createMock(TypedQuery.class);
    List<AbdAccount> resultList = new ArrayList<AbdAccount>();
    resultList.add(accountEntity);
    resultList.add(new AbdAccount(22));
    expect(emMock.getCriteriaBuilder()).andReturn(criteriaBuilderMock);
    expect(criteriaBuilderMock.createQuery()).andReturn(criteriaQueryMock);
    expect(criteriaQueryMock.from(AbdAccount.class)).andReturn(rootMock);
    expect(criteriaQueryMock.select(rootMock)).andReturn(criteriaQueryMock);
    expect(emMock.createQuery(criteriaQueryMock)).andReturn(typedQueryMock);
    expect(typedQueryMock.getResultList()).andReturn(resultList);
    assertEquals(resultList, accountDAOunderTest.findAll());
    replay(emMock);
    replay(criteriaBuilderMock);
    replay(criteriaQueryMock);
    replay(rootMock);
    replay(typedQueryMock);
    accountDAOunderTest.findAll();
    verify(criteriaBuilderMock);
    verify(criteriaQueryMock);
    verify(rootMock);
    verify(typedQueryMock);
    verify(emMock);
}

@Test
public void simpleGroupBy() {
    BlazeCriteriaQuery<Long> cq = BlazeCriteria.get(em, cbf, Long.class);
    BlazeCriteriaBuilder cb = cq.getCriteriaBuilder();
    Root<Document> root = cq.from(Document.class, "document");
    cq.select(cb.count(root.get(Document_.id)));
    cq.groupBy(root.get(Document_.age));
    CriteriaBuilder<?> criteriaBuilder = cq.createCriteriaBuilder();
    assertEquals("SELECT COUNT(document.id) FROM Document document GROUP BY document.age", criteriaBuilder.getQueryString());
}

@Override
protected QueryResult executeQuery(IEntityType entityType, EntityQuery entityQuery) {
    entityQuery.validate(entityType);
    Class<?> clazz = MetadataHelper.lookupClass(entityType.getName());
    EntityManager em = _emFactory.createEntityManager();
    try {
        em.getTransaction().begin();
        CriteriaBuilder cb = em.getCriteriaBuilder();
        CriteriaQuery<?> cq = cb.createQuery(clazz);
        JPACriteriaBuilder.create(cq, cb, entityType, entityQuery);
        //            Root<?> pet = cq.from(clazz);
        //            pet.
        //            cq.select(pet);
        TypedQuery<?> q = em.createQuery(cq);
        Integer takeCount = entityQuery.getTakeCount();
        if (takeCount != null && takeCount == 0) {
            // Hack because setMaxResults(0) returns all records instead of none.
            // so we do then equiv of skip 'everything' instead.
            // and then insure that we don't overwrite this with another skip.
            q.setFirstResult(Integer.MAX_VALUE);
        } else {
            if (takeCount != null) {
                q.setMaxResults(takeCount);
            }
            Integer skipCount = entityQuery.getSkipCount();
            if (skipCount != null) {
                q.setFirstResult(skipCount);
            }
        }
        List<?> result = q.getResultList();
        QueryResult qr;
        if (entityQuery.isInlineCountEnabled()) {
            //                builder.applyInlineCount(crit);
            //(Long) crit.uniqueResult();
            long countResult = 7;
            //                log.debugv("query: inline count={0}", countResult);
            qr = new QueryResult(result, countResult);
        } else {
            qr = new QueryResult(result);
        }
        em.getTransaction().commit();
        return qr;
    } catch (Exception ex) {
        em.getTransaction().rollback();
        throw ex;
    } finally {
        em.clear();
        em.close();
    }
}

@Override
public User findUserByName(String username) {
    CriteriaBuilder queryBuilder = getEntityManager().getCriteriaBuilder();
    CriteriaQuery<User> query = queryBuilder.createQuery(User.class);
    Root<User> userQuery = query.from(User.class);
    query.select(userQuery).where(queryBuilder.equal(userQuery.get(User_.username), username));
    try {
        return getEntityManager().createQuery(query).getSingleResult();
    } catch (NoResultException e) {
        return null;
    }
}

private List<Person> findAll() {
    CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
    CriteriaQuery<Person> criteriaQuery = criteriaBuilder.createQuery(Person.class);
    Root<Person> from = criteriaQuery.from(Person.class);
    //	criteriaQuery.orderBy(criteriaBuilder.asc(from.get("nickname")));
    CriteriaQuery<Person> select = criteriaQuery.select(from);
    TypedQuery<Person> typedQuery = entityManager.createQuery(select);
    List<Person> resultList = typedQuery.getResultList();
    return resultList;
}

@Override
public List<Member> retrieveAllMembersOrderedByName() {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<Member> criteria = cb.createQuery(Member.class);
    Root<Member> member = criteria.from(Member.class);
    // Swap criteria statements if you would like to try out type-safe criteria queries, a new
    // feature in JPA 2.0
    // criteria.select(member).orderBy(cb.asc(member.get(Member_.name)));
    criteria.select(member).orderBy(cb.asc(member.get("name")));
    return em.createQuery(criteria).getResultList();
}

@Override
public Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
    query.distinct(true);
    Join<T, P> permission = root.join("permissions", JoinType.LEFT);
    Path<Integer> userIdPath = permission.get("user").get("id");
    Path<Integer> maskPath = permission.get("mask");
    Predicate matchUserId = cb.equal(userIdPath, userId);
    Expression<Integer> readPermission = cb.mod(cb.quot(maskPath, READ_ONLY).as(Integer.class), 2);
    Predicate canRead = cb.equal(readPermission, 1);
    Predicate predicate = null;
    if (roleIds.length > 0) {
        Path<Group> group = permission.get("role");
        Predicate inGroups = group.in((Object[]) roleIds);
        predicate = cb.and(cb.or(inGroups, matchUserId), canRead);
    } else {
        predicate = cb.and(matchUserId, canRead);
    }
    return predicate;
}

@GET
@Path("stats/count")
@Produces("text/plain")
public String countStats() {
    javax.persistence.criteria.CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
    javax.persistence.criteria.Root<StatsEntity> rt = cq.from(StatsEntity.class);
    cq.select(em.getCriteriaBuilder().count(rt));
    javax.persistence.Query q = em.createQuery(cq);
    return String.valueOf(((Long) q.getSingleResult()).intValue());
}

@Override
public List<SchemaColumnEntity> getSchemaColumns(BusinessObjectDefinitionEntity businessObjectDefinitionEntity, String schemaColumnName) {
    // Create the criteria builder and the criteria.
    CriteriaBuilder builder = entityManager.getCriteriaBuilder();
    CriteriaQuery<SchemaColumnEntity> criteria = builder.createQuery(SchemaColumnEntity.class);
    // The criteria root is the schema column.
    Root<SchemaColumnEntity> schemaColumnEntityRoot = criteria.from(SchemaColumnEntity.class);
    // Join to the other tables we can filter on.
    Join<SchemaColumnEntity, BusinessObjectFormatEntity> businessObjectFormatEntityJoin = schemaColumnEntityRoot.join(SchemaColumnEntity_.businessObjectFormat);
    // Create the standard restrictions (i.e. the standard where clauses).
    List<Predicate> predicates = new ArrayList<>();
    if (businessObjectDefinitionEntity.getDescriptiveBusinessObjectFormat() == null) {
        predicates.add(builder.equal(businessObjectFormatEntityJoin.get(BusinessObjectFormatEntity_.businessObjectDefinition), businessObjectDefinitionEntity));
    } else {
        predicates.add(builder.equal(businessObjectFormatEntityJoin, businessObjectDefinitionEntity.getDescriptiveBusinessObjectFormat()));
    }
    predicates.add(builder.equal(builder.upper(schemaColumnEntityRoot.get(SchemaColumnEntity_.name)), schemaColumnName.toUpperCase()));
    // Add the clauses for the query.
    criteria.select(schemaColumnEntityRoot).where(builder.and(predicates.toArray(new Predicate[predicates.size()])));
    // Execute the query and return the results.
    return entityManager.createQuery(criteria).getResultList();
}

@Test
public void testEqualAll() {
    CriteriaBuilder builder = entityManagerFactory().getCriteriaBuilder();
    EntityManager em = getOrCreateEntityManager();
    em.getTransaction().begin();
    CriteriaQuery<Customer> criteria = builder.createQuery(Customer.class);
    Root<Customer> customerRoot = criteria.from(Customer.class);
    Join<Customer, Order> orderJoin = customerRoot.join(Customer_.orders);
    criteria.select(customerRoot);
    Subquery<Double> subCriteria = criteria.subquery(Double.class);
    Root<Order> subqueryOrderRoot = subCriteria.from(Order.class);
    subCriteria.select(builder.min(subqueryOrderRoot.get(Order_.totalPrice)));
    criteria.where(builder.equal(orderJoin.get("totalPrice"), builder.all(subCriteria)));
    em.createQuery(criteria).getResultList();
    em.getTransaction().commit();
    em.close();
}

@Override
public T next() {
    int currentIndex = pos % 100;
    if (currentIndex == 0) {
        em.clear();
        CriteriaQuery<T> criteriaQuery = em.getCriteriaBuilder().createQuery(rootClass);
        Root<T> from = criteriaQuery.from(rootClass);
        criteriaQuery.select(from);
        TypedQuery<T> query = em.createQuery(criteriaQuery);
        // I know scrolling would be better and safe, but! I want to stick to plain JPA
        query.setFirstResult(pos);
        query.setMaxResults(bulkSize);
        objects.clear();
        objects.addAll(query.getResultList());
    }
    if (currentIndex < objects.size()) {
        T retval = objects.get(currentIndex);
        pos++;
        return retval;
    } else {
        close();
    }
    throw new IllegalStateException("pos " + pos + " > " + objects.size());
}

public int count() {
    javax.persistence.criteria.CriteriaQuery cq = getEntityManager().getCriteriaBuilder().createQuery();
    javax.persistence.criteria.Root<T> rt = cq.from(entityClass);
    cq.select(getEntityManager().getCriteriaBuilder().count(rt));
    javax.persistence.Query q = getEntityManager().createQuery(cq);
    return ((Long) q.getSingleResult()).intValue();
}

@PostConstruct
public void retrieveAllMembersOrderedByName() {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<Person> criteria = cb.createQuery(Person.class);
    Root<Person> member = criteria.from(Person.class);
    // Swap criteria statements if you would like to try out type-safe criteria queries, a new
    // feature in JPA 2.0
    // criteria.select(member).orderBy(cb.asc(member.get(Member_.name)));
    criteria.select(member).orderBy(cb.asc(member.get("name")));
    members = em.createQuery(criteria).getResultList();
}

@Test
@SuppressWarnings({ "unchecked", "rawtypes" })
public void testTranslate() {
    SimpleStringFilter filter = new SimpleStringFilter("firstName", "Thomas", false, false);
    Path path = mock(Path.class);
    Expression<String> upper = mock(Expression.class);
    CriteriaBuilder builder = mock(CriteriaBuilder.class);
    when(builder.upper(path)).thenReturn(upper);
    Root<PersistentEntity> root = mock(Root.class);
    when(root.get("firstName")).thenReturn(path);
    Predicate predicate = mock(Predicate.class);
    when(builder.like(path, "%Thomas%")).thenReturn(predicate);
    Predicate translate = translator.translate(filter, builder, root, null);
    assertEquals(predicate, translate);
}

public Member findByEmail(String email) {
    CriteriaBuilder builder = em.getCriteriaBuilder();
    CriteriaQuery<Member> criteria = builder.createQuery(Member.class);
    Root<Member> member = criteria.from(Member.class);
    /*
         * Swap criteria statements if you would like to try out type-safe criteria queries, a new
         * feature in JPA 2.0 criteria.select(member).orderBy(cb.asc(member.get(Member_.name)));
         */
    criteria.select(member).where(builder.equal(member.get("email"), email));
    return em.createQuery(criteria).getSingleResult();
}

private void initIterator() {
    CriteriaBuilder criteriaBuilder = this.entityManager.getCriteriaBuilder();
    CriteriaQuery<MyEntity> criteriaQuery = criteriaBuilder.createQuery(MyEntity.class);
    Root<MyEntity> root = criteriaQuery.from(MyEntity.class);
    criteriaQuery.select(root);
    TypedQuery<MyEntity> typedQuery = this.entityManager.createQuery(criteriaQuery);
    typedQuery.setFirstResult(this.index);
    typedQuery.setMaxResults(10);
    this.iterator = typedQuery.getResultList().iterator();
}

@PostConstruct
public void retrieveAllMembersOrderedByName() {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<Member> criteria = cb.createQuery(Member.class);
    Root<Member> member = criteria.from(Member.class);
    // Swap criteria statements if you would like to try out type-safe criteria queries, a new
    // feature in JPA 2.0
    // criteria.select(member).orderBy(cb.asc(member.get(Member_.name)));
    criteria.select(member).orderBy(cb.asc(member.get("name")));
    members = em.createQuery(criteria).getResultList();
}

/**
	 * {@inheritDoc}
	 */
public UserPreference findUserPreference(User user, String name) {
    CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
    CriteriaQuery<UserPreference> criteria = cb.createQuery(getEntityClass());
    Root<UserPreference> root = criteria.from(getEntityClass());
    criteria.where(cb.and(cb.equal(root.<User>get(USER_PROPERTY), user), cb.equal(root.<String>get(NAME_PROPERTY), name)));
    TypedQuery<UserPreference> query = getEntityManager().createQuery(criteria);
    List<UserPreference> list = query.getResultList();
    return list.isEmpty() ? null : list.get(0);
}

@SuppressWarnings("unchecked")
private <E> Predicate bySelectors(Root<E> root, CriteriaBuilder builder, Selectors<E> selectors) {
    List<Predicate> predicates = new ArrayList<>();
    for (Selector<E, ?> selector : selectors.getSelectors()) {
        if (selector instanceof Selectors) {
            predicates.add(bySelectors(root, builder, (Selectors<E>) selector));
        } else if (selector instanceof PropertySelector) {
            predicates.add(byPropertySelectorUtil.byPropertySelectors(root, builder, (PropertySelector<? super E, ?>) selector));
        } else if (selector instanceof Range) {
            predicates.add(byRangeUtil.byRange(root, builder, (Range<E, ?>) selector));
        } else if (selector instanceof StringTermSelector) {
            predicates.add(byFullTextUtil.byFullText(root, builder, (StringTermSelector<E>) selector));
        } else if (selector instanceof ObjectTermSelector) {
            predicates.add(byFullTextUtil.byFullText(root, builder, (ObjectTermSelector<E>) selector));
        }
    }
    if (selectors.isAndMode()) {
        return jpaUtil.andPredicate(builder, predicates);
    } else {
        return jpaUtil.orPredicate(builder, predicates);
    }
}

@Override
public boolean isUserRegisteredAsMemberInAnyTeam(String userJid, List<String> teamJids) {
    if (teamJids.isEmpty()) {
        return false;
    }
    CriteriaBuilder cb = JPA.em().getCriteriaBuilder();
    CriteriaQuery<Long> query = cb.createQuery(Long.class);
    Root<ContestTeamMemberModel> root = query.from(ContestTeamMemberModel.class);
    query.select(cb.count(root)).where(cb.and(cb.equal(root.get(ContestTeamMemberModel_.memberJid), userJid), root.get(ContestTeamMemberModel_.teamJid).in(teamJids)));
    return (JPA.em().createQuery(query).getSingleResult() != 0);
}

public List<JpaOpsManagerFeed> findByName(String name) {
    LOG.debug("TestFeedSecuringRepository.findByName");
    CriteriaBuilder builder = entityManager.getCriteriaBuilder();
    CriteriaQuery<JpaOpsManagerFeed> query = builder.createQuery(JpaOpsManagerFeed.class);
    Root<JpaOpsManagerFeed> root = query.from(JpaOpsManagerFeed.class);
    Expression<Boolean> nameIsEqualToParam = builder.equal(root.get("name"), name);
    Specification<JpaOpsManagerFeed> spec = null;
    Specification<JpaOpsManagerFeed> secured = augmentor.augment(spec, JpaOpsManagerFeed.class, entityInformation);
    query.where(builder.and(nameIsEqualToParam, secured.toPredicate(root, query, builder)));
    return entityManager.createQuery(query).getResultList();
}

public int count() {
    javax.persistence.criteria.CriteriaQuery cq = getEntityManager().getCriteriaBuilder().createQuery();
    javax.persistence.criteria.Root<T> rt = cq.from(entityClass);
    cq.select(getEntityManager().getCriteriaBuilder().count(rt));
    javax.persistence.Query q = getEntityManager().createQuery(cq);
    return ((Long) q.getSingleResult()).intValue();
}

/**
	 * Create "Name Like" query spec.
	 * @param query query
	 * @return created spec
	 */
public static Specification<User> nameLike(final String query) {
    return new Specification<User>() {

        @Override
        public Predicate toPredicate(Root<User> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder cb) {
            String pattern = ("%" + query + "%").toLowerCase();
            return cb.or(cb.like(cb.lower(root.get("userName").as(String.class)), pattern), cb.like(cb.lower(root.get("userId").as(String.class)), pattern));
        }
    };
}

public void test() {
    CriteriaQuery<Department> q = cb.createQuery(Department.class);
    Root<Department> dept = q.from(Department.class);
    q.select(dept).where(cb.equal(dept.get(department_.getSingularAttribute("name", String.class)), "test"));
    EntityManager em = emf.createEntityManager();
    try {
        em.createQuery(q).getResultList();
    } finally {
        em.close();
    }
}

@Override
public MockAuditAction getAuditActionByEnum(MockAuditActionEnum auditActionEnum) {
    CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
    CriteriaQuery<MockAuditAction> cq = cb.createQuery(MockAuditAction.class);
    Root<MockAuditAction> root = cq.from(MockAuditAction.class);
    cq.select(root);
    cq.where(cb.equal(root.get("auditActionEnum"), auditActionEnum));
    cq.orderBy(cb.asc(root.get("position")));
    TypedQuery<MockAuditAction> query = getEntityManager().createQuery(cq);
    try {
        return query.getSingleResult();
    } catch (NoResultException e) {
        return null;
    } catch (NonUniqueResultException e) {
        return query.getResultList().iterator().next();
    }
}

@SuppressWarnings("unchecked")
protected CriteriaQuery<Serializable> constructCriteriaQuery(DynamicEntityDao dynamicEntityDao, String ceilingEntity, List<FilterMapping> filterMappings, boolean isCount) {
    CriteriaBuilder criteriaBuilder = dynamicEntityDao.getStandardEntityManager().getCriteriaBuilder();
    Class<Serializable> ceilingMarker;
    try {
        ceilingMarker = (Class<Serializable>) Class.forName(ceilingEntity);
    } catch (ClassNotFoundException e) {
        throw new RuntimeException(e);
    }
    Class<?>[] polyEntities = dynamicEntityDao.getAllPolymorphicEntitiesFromCeiling(ceilingMarker);
    Class<Serializable> ceilingClass = (Class<Serializable>) polyEntities[polyEntities.length - 1];
    CriteriaQuery<Serializable> criteria = criteriaBuilder.createQuery(ceilingMarker);
    Root<Serializable> original = criteria.from(ceilingClass);
    if (isCount) {
        criteria.select(criteriaBuilder.count(original));
    } else {
        criteria.select(original);
    }
    List<Predicate> restrictions = new ArrayList<Predicate>();
    List<Order> sorts = new ArrayList<Order>();
    addRestrictions(ceilingEntity, filterMappings, criteriaBuilder, original, restrictions, sorts);
    criteria.where(restrictions.toArray(new Predicate[restrictions.size()]));
    if (!isCount) {
        criteria.orderBy(sorts.toArray(new Order[sorts.size()]));
    }
    return criteria;
}

@Override
public List<UnitStat> get(String unitCode) {
    CriteriaBuilder builder = getEntityManager().getCriteriaBuilder();
    CriteriaQuery<UnitStat> criteria = builder.createQuery(UnitStat.class);
    Root<UnitStat> from = criteria.from(UnitStat.class);
    List<Predicate> wherePredicates = new ArrayList<Predicate>();
    wherePredicates.add(builder.equal(from.get(UnitStat_.unitcode), unitCode));
    buildWhereClause(criteria, wherePredicates);
    return getEntityManager().createQuery(criteria).getResultList();
}

public int count() {
    javax.persistence.criteria.CriteriaQuery cq = getEntityManager().getCriteriaBuilder().createQuery();
    javax.persistence.criteria.Root<T> rt = cq.from(entityClass);
    cq.select(getEntityManager().getCriteriaBuilder().count(rt));
    javax.persistence.Query q = getEntityManager().createQuery(cq);
    return ((Long) q.getSingleResult()).intValue();
}

@Override
@Transactional
public List<Role> findRole(Integer[] roleId) {
    CriteriaQuery<Role> criteria = em.getCriteriaBuilder().createQuery(Role.class);
    Root<Role> roleRoot = criteria.from(Role.class);
    criteria.select(roleRoot);
    Expression<String> exp = roleRoot.get("id");
    criteria.where(exp.in(roleId));
    return em.createQuery(criteria).getResultList();
}

public int count() {
    javax.persistence.criteria.CriteriaQuery cq = getEntityManager().getCriteriaBuilder().createQuery();
    javax.persistence.criteria.Root<T> rt = cq.from(entityClass);
    cq.select(getEntityManager().getCriteriaBuilder().count(rt));
    javax.persistence.Query q = getEntityManager().createQuery(cq);
    return ((Long) q.getSingleResult()).intValue();
}

@Override
public List<Navigation> findList(Navigation.Position position) {
    CriteriaBuilder localCriteriaBuilder = this.getEntityManager().getCriteriaBuilder();
    CriteriaQuery<Navigation> localCriteriaQuery = localCriteriaBuilder.createQuery(Navigation.class);
    Root<Navigation> localRoot = localCriteriaQuery.from(Navigation.class);
    localCriteriaQuery.select(localRoot);
    if (position != null)
        localCriteriaQuery.where(localCriteriaBuilder.equal(localRoot.get("position"), position));
    localCriteriaQuery.orderBy(new Order[] { localCriteriaBuilder.asc(localRoot.get("order")) });
    return this.getEntityManager().createQuery(localCriteriaQuery).setFlushMode(FlushModeType.COMMIT).getResultList();
}

@Override
public List<TagElaboracaoNormativa> buscaTagsElaboracaoNormativa(Long id) {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<TagElaboracaoNormativa> c = cb.createQuery(TagElaboracaoNormativa.class);
    Root<TagElaboracaoNormativa> ten = c.from(TagElaboracaoNormativa.class);
    c.select(ten);
    c.where(cb.equal(ten.get("elaboracaoNormativa"), id));
    Query query = getEntityManager().createQuery(c);
    List<TagElaboracaoNormativa> result = query.getResultList();
    return result;
}

@SuppressWarnings("rawtypes")
public static CriteriaQuery<?> toCriteria(EntityManager em, EntityRef entityRef) {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    Class<?> entityClass = entityRef.getEntityClass();
    CriteriaQuery cq = cb.createQuery(entityClass);
    @SuppressWarnings("unchecked") Root r = cq.from(entityClass);
    Map<String, Object> map = entityRef.getPropertyToValue();
    List<Predicate> predicates = new ArrayList<Predicate>(map.size());
    for (Entry<String, Object> entry : map.entrySet()) {
        String propertyName = entry.getKey();
        Object value = entry.getValue();
        Predicate predicate = cb.equal(r.get(propertyName), value);
        predicates.add(predicate);
    }
    cq.where(predicates.toArray(new Predicate[0]));
    @SuppressWarnings("unchecked") CriteriaQuery result = cq.select(r);
    return result;
//List<ConfigToExecution> result = em.createQuery(cq).getResultList();
}

@Override
public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
    Root<Account> accounts = query.from(Account.class);
    Path<Date> expiryDate = accounts.<Date>get("expiryDate");
    Predicate customerIsAccountOwner = cb.equal(accounts.<Customer>get("customer"), root);
    Predicate accountExpiryDateBefore = cb.lessThan(expiryDate, date.toDateTimeAtStartOfDay().toDate());
    return cb.and(customerIsAccountOwner, accountExpiryDateBefore);
}

public static Specification<Conference> inProgressConferences() {
    return new Specification<Conference>() {

        @Override
        public Predicate toPredicate(Root<Conference> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
            Expression<Timestamp> currentTimestamp = cb.currentTimestamp();
            return cb.and(cb.greaterThan(root.get("endedDate").as(Date.class), currentTimestamp), cb.lessThan(root.get("startedDate").as(Date.class), currentTimestamp));
        }
    };
}

/**
	 * Search by Workgroup example
	 */
public List<Workgroup> search(final Workgroup element) {
    final EntityManager em = getEntityManager();
    if (element != null) {
        CriteriaBuilder criteriaBuilder = em.getCriteriaBuilder();
        CriteriaQuery<Workgroup> criteriaQuery = criteriaBuilder.createQuery(Workgroup.class);
        Root<Workgroup> from = criteriaQuery.from(Workgroup.class);
        List<Predicate> listP = new ArrayList<Predicate>();
        if (CoreUtils.isNotBlank(element.getId())) {
            Predicate predicate = criteriaBuilder.equal(from.get("id"), element.getId());
            listP.add(predicate);
        }
        if (CoreUtils.isNotBlank(element.getName())) {
            Predicate predicate = criteriaBuilder.equal(from.get("name"), element.getName());
            listP.add(predicate);
        }
        if (CoreUtils.isNotBlank(element.getDescription())) {
            Predicate predicate = criteriaBuilder.equal(from.get("description"), element.getDescription());
            listP.add(predicate);
        }
        if (CoreUtils.isNotBlank(element.getCreationDate())) {
            Predicate predicate = criteriaBuilder.equal(from.get("creationDate"), element.getCreationDate());
            listP.add(predicate);
        }
        criteriaQuery.where(listP.toArray(ap));
        TypedQuery<Workgroup> tq = em.createQuery(criteriaQuery);
        return tq.getResultList();
    } else {
        return this.loadAll();
    }
}

public GridDataSource getSource() {
    return new JpaGridDataSource<User>(entityManager, User.class) {

        @Override
        protected void applyAdditionalConstraints(final CriteriaQuery<?> criteria, final Root<User> root, final CriteriaBuilder builder) {
            criteria.where(builder.equal(root.get("lastName"), "User"));
        }
    };
}

@Override
public Predicate toPredicate(Root<Task> task, CriteriaQuery<?> cq, CriteriaBuilder cb) {
    Predicate predicate = cb.conjunction();
    //project
    predicate = cb.and(predicate, cb.equal(task.get(Task_.project).get(Project_.id), taskFilter.getProject().getId()));
    //      no subtasks
    predicate = cb.and(predicate, task.get(Task_.parent).isNull());
    if (StringUtils.isNotBlank(taskFilter.getByState())) {
        if (TaskFilter.OPEN.equals(taskFilter.getByState())) {
            predicate = cb.and(predicate, task.get(Task_.state).in(TaskState.TO_DO, TaskState.ONGOING, TaskState.COMPLETE, TaskState.BLOCKED));
        } else {
            predicate = cb.and(predicate, task.get(Task_.state).in(TaskState.valueOf(taskFilter.getByState())));
        }
    }
    if (taskFilter.getType() != null) {
        predicate = cb.and(predicate, task.get(Task_.type).in(taskFilter.getType()));
    }
    if (taskFilter.getPriority() != null) {
        predicate = cb.and(predicate, task.get(Task_.priority).in(taskFilter.getPriority()));
    }
    if (taskFilter.getAssignee() != null) {
        predicate = cb.and(predicate, task.get(Task_.assignee).get(Account_.id).in(taskFilter.getAssignee().getId()));
    }
    return predicate;
}

@Override
public QueueEntity getByName(final String name) {
    final CriteriaQuery<QueueEntity> criteria = this.builder.createQuery(QueueEntity.class);
    final Root<QueueEntity> queueRoot = criteria.from(QueueEntity.class);
    criteria.select(queueRoot);
    final Predicate namePredicate = this.builder.like(queueRoot.<String>get("name"), name);
    criteria.where(namePredicate);
    try {
        return this.entityManager.createQuery(criteria).getSingleResult();
    } catch (final NoResultException ex) {
        return null;
    }
}

public static void main(final String[] args) throws Exception {
    createEntityManagerFactoryForOpenJPA();
    CodeGenerator.generateData(getEntityManagerFactory());
    final EntityManager em = getEntityManagerFactory().createEntityManager();
    final EntityManager entityManager = getEntityManagerFactory().createEntityManager();
    final CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
    final CriteriaQuery<Long> criteriaQuery = criteriaBuilder.createQuery(Long.class);
    final Root<Manufacturer> root = criteriaQuery.from(Manufacturer.class);
    criteriaQuery.select(criteriaBuilder.count(root));
    final TypedQuery<Long> countQuery = entityManager.createQuery(criteriaQuery);
    System.out.println(countQuery.getSingleResult());
    em.close();
    getEntityManagerFactory().close();
}

@SuppressWarnings("unchecked")
@Override
public Join<E, K> getJoin(Root<E> root) {
    for (Join<E, ?> join : root.getJoins()) {
        if (join.getAttribute().equals(attribute) && join.getJoinType().equals(type)) {
            return (Join<E, K>) join;
        }
    }
    for (Fetch<E, ?> join : root.getFetches()) {
        if (join.getAttribute().equals(attribute) && join.getJoinType().equals(type)) {
            return (Join<E, K>) join;
        }
    }
    if (fetch) {
        return (Join<E, K>) root.fetch(attribute, type);
    } else {
        return root.join(attribute, type);
    }
}

@SuppressWarnings("unchecked")
public int count() {
    javax.persistence.criteria.CriteriaQuery cq = getEntityManager().getCriteriaBuilder().createQuery();
    javax.persistence.criteria.Root<T> rt = cq.from(entityClass);
    cq.select(getEntityManager().getCriteriaBuilder().count(rt));
    javax.persistence.Query q = getEntityManager().createQuery(cq);
    return ((Long) q.getSingleResult()).intValue();
}

/**
     * {@inheritDoc}
     * <dl>
     * <dt>事��件</dt>
     * <dd>フィルタ��NULL��る��。</dd>
     * <dt>事後�件</dt>
     * <dd>指定��アカウント�検索�件��る。</dd>
     * </dl>
     */
@Override
protected Predicate expression(final MemberFilter filter) {
    Logger.getGlobal().info("filter = " + filter);
    assert filter != null;
    if (StringUtils.isEmpty(filter.getAccount())) {
        return super.expression(filter);
    }
    final CriteriaBuilder b = service.builder();
    final Root<Member> r = service.root();
    return b.equal(r.get(Member_.account), filter.getAccount());
}

public int count() {
    javax.persistence.criteria.CriteriaQuery cq = getEntityManager().getCriteriaBuilder().createQuery();
    javax.persistence.criteria.Root<T> rt = cq.from(entityClass);
    cq.select(getEntityManager().getCriteriaBuilder().count(rt));
    javax.persistence.Query q = getEntityManager().createQuery(cq);
    return ((Long) q.getSingleResult()).intValue();
}

public Member findByEmail(String email) {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<Member> criteria = cb.createQuery(Member.class);
    Root<Member> member = criteria.from(Member.class);
    // Swap criteria statements if you would like to try out type-safe criteria queries, a new
    // feature in JPA 2.0
    // criteria.select(member).where(cb.equal(member.get(Member_.name), email));
    criteria.select(member).where(cb.equal(member.get("email"), email));
    return em.createQuery(criteria).getSingleResult();
}

public List<Game> fetchAllFor(Platform platform) {
    CriteriaBuilder criteriaBuilder = em.getCriteriaBuilder();
    CriteriaQuery<Game> query = criteriaBuilder.createQuery(Game.class);
    Root<Game> fromGames = query.from(Game.class);
    Join<Game, Platform> platformsOfGame = fromGames.join(Game_.supportedPlatforms);
    Predicate givenPlatfromIsAssigned = criteriaBuilder.equal(platformsOfGame.get(Platform_.name), platform.getName());
    CriteriaQuery<Game> allGamesForGivenPlatfrom = query.select(fromGames).where(givenPlatfromIsAssigned);
    return em.createQuery(allGamesForGivenPlatfrom).getResultList();
}

@Override
public List<URLHandler> findAllURLHandlers() {
    CriteriaBuilder builder = em.getCriteriaBuilder();
    CriteriaQuery<URLHandler> criteria = builder.createQuery(URLHandler.class);
    Root<URLHandlerImpl> handler = criteria.from(URLHandlerImpl.class);
    criteria.select(handler);
    TypedQuery<URLHandler> query = em.createQuery(criteria);
    query.setHint(QueryHints.HINT_CACHEABLE, true);
    try {
        return query.getResultList();
    } catch (NoResultException e) {
        return new ArrayList<URLHandler>();
    }
}

@Override
public List<URLHandler> findAllURLHandlers() {
    CriteriaBuilder builder = em.getCriteriaBuilder();
    CriteriaQuery<URLHandler> criteria = builder.createQuery(URLHandler.class);
    Root<URLHandlerImpl> handler = criteria.from(URLHandlerImpl.class);
    criteria.select(handler);
    TypedQuery<URLHandler> query = em.createQuery(criteria);
    query.setHint(QueryHints.HINT_CACHEABLE, true);
    try {
        return query.getResultList();
    } catch (NoResultException e) {
        return new ArrayList<URLHandler>();
    }
}

public static void list(EntityManagerFactory emf) {
    EntityManager em = emf.createEntityManager();
    CriteriaBuilder cb = emf.getCriteriaBuilder();
    CriteriaQuery<User> cq = cb.createQuery(User.class);
    Root<User> r = cq.from(User.class);
    Path<Long> idPath = r.get("id");
    cq.where(cb.ge(idPath, 5L), cb.and(cb.ge(idPath, 5L))).orderBy(cb.asc(r.get("id")));
    List<User> userList = em.createQuery(cq).setFirstResult(// = offset
    1).setMaxResults(// = limit
    10).getResultList();
    for (User user : userList) {
        System.out.println(user);
    }
    em.close();
    System.out.println("List finished.");
}

// ----- Transaction Methods -----
@SuppressWarnings("unchecked")
public List<Transaction> findTransactions(TransactionCriteriaInternal criteria) {
    CriteriaBuilder builder = entityManager.getCriteriaBuilder();
    CriteriaQuery<Transaction> query = builder.createQuery(Transaction.class);
    // select * from Transaction
    Root<Transaction> _transaction = query.from(Transaction.class);
    // Construct a predicate for the where clause using conjunction
    Predicate predicate = builder.conjunction();
    // accountIds
    if (!criteria.getAccountIds().isEmpty()) {
        Path<BaseAccount> _account = _transaction.get(Transaction_.account);
        Path<Long> _accountId = _account.get(BaseAccount_.id);
        CriteriaBuilder.In<Long> inExpr = builder.in(_accountId);
        for (Long accountId : criteria.getAccountIds()) {
            inExpr = inExpr.value(accountId);
        }
        predicate = builder.and(predicate, inExpr);
    }
    // fromDate
    if (criteria.getFromDate() != null) {
        predicate = builder.and(predicate, builder.greaterThanOrEqualTo(_transaction.get(Transaction_.creationTime), criteria.getFromDate().toDateTimeAtStartOfDay()));
    }
    if (criteria.getToDate() != null) {
        predicate = builder.and(predicate, builder.lessThan(_transaction.get(Transaction_.creationTime), criteria.getToDate().plusDays(1).toDateTimeAtStartOfDay()));
    }
    // Assign predicate to where clause
    query.where(predicate);
    // Execute the query
    return entityManager.createQuery(query).getResultList();
}

@SuppressWarnings({ "rawtypes", "unchecked" })
@Override
public Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder builder) {
    if (Collections3.isNotEmpty(filters)) {
        List<Predicate> predicates = Lists.newArrayList();
        for (SearchFilter filter : filters) {
            // nested path translate, 如Taskçš„å??为"user.name"çš„filedName,
            // 转�为Task.user.name属性
            String[] names = StringUtils.split(filter.fieldName, ".");
            Path expression = root.get(names[0]);
            for (int i = 1; i < names.length; i++) {
                expression = expression.get(names[i]);
            }
            switch(filter.operator) {
                case EQ:
                    predicates.add(builder.equal(expression, filter.value));
                    break;
                case LIKE:
                    predicates.add(builder.like(expression, "%" + filter.value + "%"));
                    break;
                case GT:
                    predicates.add(builder.greaterThan(expression, (Comparable) filter.value));
                    break;
                case LT:
                    predicates.add(builder.lessThan(expression, (Comparable) filter.value));
                    break;
                case GTE:
                    predicates.add(builder.greaterThanOrEqualTo(expression, (Comparable) filter.value));
                    break;
                case LTE:
                    predicates.add(builder.lessThanOrEqualTo(expression, (Comparable) filter.value));
                    break;
                case NOT:
                    predicates.add(builder.notEqual(expression, (Comparable) filter.value));
                    break;
                case IsNull:
                    predicates.add(builder.isNull(expression));
                    break;
                case NotNull:
                    predicates.add(builder.isNotNull(expression));
                    break;
            }
        }
        if (predicates.size() > 0) {
            return builder.and(predicates.toArray(new Predicate[predicates.size()]));
        }
    }
    return builder.conjunction();
}

@Override
public List<URLHandler> findAllURLHandlers() {
    CriteriaBuilder builder = em.getCriteriaBuilder();
    CriteriaQuery<URLHandler> criteria = builder.createQuery(URLHandler.class);
    Root<URLHandlerImpl> handler = criteria.from(URLHandlerImpl.class);
    criteria.select(handler);
    TypedQuery<URLHandler> query = em.createQuery(criteria);
    query.setHint(QueryHints.HINT_CACHEABLE, true);
    try {
        return query.getResultList();
    } catch (NoResultException e) {
        return new ArrayList<URLHandler>();
    }
}

@Override
public Iterator<? extends PeopleBean> iterator(final long first, final long count) {
    final EntityManager entityManager = getEntityManager();
    entityManager.getTransaction().begin();
    try {
        final CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
        final CriteriaQuery<PeopleBean> criteria = criteriaBuilder.createQuery(PeopleBean.class);
        final Root<PeopleBean> from = criteria.from(PeopleBean.class);
        // add the criteria if we have one
        if (companyId != null) {
            criteria.where(criteriaBuilder.equal(from.get("company"), companyId));
        }
        // setup the sort
        final SortParam<String> param = getSort();
        if (param == null || param.isAscending()) {
            LOG.debug("Setting order by to ascending for PeopleBean");
            criteria.orderBy(criteriaBuilder.asc(from.get("name")));
        } else {
            LOG.debug("Setting order by to descending for PeopleBean");
            criteria.orderBy(criteriaBuilder.desc(from.get("name")));
        }
        return entityManager.createQuery(criteria).setFirstResult((int) first).setMaxResults((int) count).getResultList().iterator();
    } finally {
        entityManager.getTransaction().commit();
    }
}

public List<Produto> filtrados(ProdutoFilter filtro) {
    CriteriaBuilder builder = manager.getCriteriaBuilder();
    CriteriaQuery<Produto> criteriaQuery = builder.createQuery(Produto.class);
    List<Predicate> predicates = new ArrayList<>();
    Root<Produto> produtoRoot = criteriaQuery.from(Produto.class);
    Fetch<Produto, Categoria> categoriaJoin = produtoRoot.fetch("categoria", JoinType.INNER);
    categoriaJoin.fetch("categoriaPai", JoinType.INNER);
    if (StringUtils.isNotBlank(filtro.getSku())) {
        predicates.add(builder.equal(produtoRoot.get("sku"), filtro.getSku()));
    }
    if (StringUtils.isNotBlank(filtro.getNome())) {
        predicates.add(builder.like(builder.lower(produtoRoot.get("nome")), "%" + filtro.getNome().toLowerCase() + "%"));
    }
    criteriaQuery.select(produtoRoot);
    criteriaQuery.where(predicates.toArray(new Predicate[0]));
    criteriaQuery.orderBy(builder.asc(produtoRoot.get("nome")));
    TypedQuery<Produto> query = manager.createQuery(criteriaQuery);
    return query.getResultList();
}

@Override
public Collection<Role> getRoles(Set<String> roleNames) {
    CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
    CriteriaQuery<Role> criteriaQuery = criteriaBuilder.createQuery(Role.class);
    Root<Role> root = criteriaQuery.from(Role.class);
    criteriaQuery.select(root);
    criteriaQuery.where(root.get(Role_.name).in(roleNames));
    return entityManager.createQuery(criteriaQuery).getResultList();
}

public int count() {
    javax.persistence.criteria.CriteriaQuery<Long> cq = getEntityManager().getCriteriaBuilder().createQuery(Long.class);
    javax.persistence.criteria.Root<T> rt = cq.from(entityClass);
    cq.select(getEntityManager().getCriteriaBuilder().count(rt));
    javax.persistence.TypedQuery<Long> q = getEntityManager().createQuery(cq);
    return q.getSingleResult().intValue();
}

public List<Hook> all() {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<Hook> cq = cb.createQuery(Hook.class);
    Root<Hook> rootEntry = cq.from(Hook.class);
    CriteriaQuery<Hook> all = cq.select(rootEntry);
    TypedQuery<Hook> allQuery = em.createQuery(all);
    return allQuery.getResultList();
}

/**
     * Read all.
     */
public void test() throws Exception {
    EntityManager em = createEntityManager();
    CriteriaBuilder qb = em.getCriteriaBuilder();
    CriteriaQuery<Employee> criteriaQuery = qb.createQuery(Employee.class);
    Root<Employee> emp = criteriaQuery.from(Employee.class);
    Join<Employee, PhoneNumber> phone = emp.join("phoneNumbers");
    criteriaQuery.where(qb.and(qb.equal(emp.get("firstName"), qb.parameter(String.class, "firstName")), qb.equal(emp.get("lastName"), qb.parameter(String.class, "lastName")), qb.equal(emp.get("address").get("city"), qb.parameter(String.class, "city")), qb.equal(phone.get("areaCode"), qb.parameter(String.class, "areaCode"))));
    Query query = em.createQuery(criteriaQuery);
    query.setParameter("firstName", "Bob");
    query.setParameter("lastName", "Smith%");
    query.setParameter("city", "Toronto");
    query.setParameter("areaCode", "123");
    List result = list(query, em);
    result.size();
    em.close();
}

public void testPersist() {
    {
        beginTransaction();
        final Writer writer = LibraryModelPackage.INSTANCE.getModelFactory().createWriter();
        //$NON-NLS-1$
        writer.setName("test");
        getEntityManager().persist(writer);
        commitTransaction();
    }
    {
        beginTransaction();
        final Writer writer = (Writer) getEntityManager().createQuery("select w from library_Writer w where w.name = :name").setParameter("name", //$NON-NLS-3$  //$NON-NLS-2$  //$NON-NLS-1$
        "test").getSingleResult();
        assertTrue(writer != null);
        commitTransaction();
    }
    // do a count using the criteriabuilder
    {
        beginTransaction();
        // do a select
        {
            final CriteriaBuilder criteriaBuilder = getEntityManager().getCriteriaBuilder();
            final CriteriaQuery<Object> criteriaQuery = criteriaBuilder.createQuery();
            final Root<Writer> from = criteriaQuery.from(Writer.class);
            final CriteriaQuery<Object> select = criteriaQuery.select(from);
            final TypedQuery<Object> typedQuery = getEntityManager().createQuery(select);
            final List<Object> resultList = typedQuery.getResultList();
            Assert.assertEquals(1, resultList.size());
        }
        // and do the count
        {
            final CriteriaBuilder criteriaBuilder = getEntityManager().getCriteriaBuilder();
            final CriteriaQuery<Object> criteriaQuery = criteriaBuilder.createQuery();
            final Root<Writer> from = criteriaQuery.from(Writer.class);
            final Expression<Long> countExpression = criteriaBuilder.countDistinct(from);
            final CriteriaQuery<Object> select = criteriaQuery.select(countExpression);
            final TypedQuery<Object> typedQuery = getEntityManager().createQuery(select);
            final Long cnt = (Long) typedQuery.getSingleResult();
            Assert.assertEquals(new Long(1), cnt);
        }
        commitTransaction();
    }
}

public int selectCount() {
    CriteriaBuilder critBuilder = entityManager.getCriteriaBuilder();
    CriteriaQuery<Long> critQuery = critBuilder.createQuery(Long.class);
    Root<ExpenseEntity> root = critQuery.from(ExpenseEntity.class);
    critQuery.select(critBuilder.countDistinct(root));
    int count = entityManager.createQuery(critQuery).getSingleResult().intValue();
    return count;
}

public Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder builder) {
    List<Predicate> predicates = new ArrayList<Predicate>();
    // Query by map filter
    for (Entry<String, Object> entry : filter.entrySet()) {
        if (root.get(entry.getKey()) == null)
            throw new RuntimeException("Invalid filter mapping, path: " + entry.getKey());
        Predicate predicate = FilterSpecUtil.buildPredicate(root, builder, null, entry.getKey(), entry.getValue());
        if (predicate != null)
            predicates.add(predicate);
    }
    if (predicates.size() > 0)
        return builder.and(predicates.toArray(new Predicate[predicates.size()]));
    return null;
}

@Override
public final void attach() {
    super.attach();
    final EntityManager entityManager = ((AbstractSiteUI) getUI().getUI()).getSite().getSiteContext().getObject(EntityManager.class);
    final Company company = ((AbstractSiteUI) getUI().getUI()).getSite().getSiteContext().getObject(Company.class);
    final CriteriaBuilder queryBuilder = entityManager.getCriteriaBuilder();
    final CriteriaQuery<Repository> criteriaQuery = queryBuilder.createQuery(Repository.class);
    final Root<Repository> root = criteriaQuery.from(Repository.class);
    final Expression<Comparable> owner = root.get("owner");
    criteriaQuery.where(queryBuilder.equal(owner, company));
    criteriaQuery.orderBy(queryBuilder.asc(root.get("path")));
    final TypedQuery<Repository> typedQuery = entityManager.createQuery(criteriaQuery);
    for (final Repository group : typedQuery.getResultList()) {
        addItem(group);
    }
}

private List<Author> getAuthorsWithQuery(String logMessage, String country) {
    EntityManager em = EntityTestUtils.start();
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<Author> cq = cb.createQuery(Author.class);
    Root<Author> author = cq.from(Author.class);
    cq.select(author);
    cq.where(cb.equal(author.get("country"), country));
    TypedQuery<Author> query = em.createQuery(cq);
    query.setHint("org.hibernate.cacheable", true);
    query.setHint("org.hibernate.cacheRegion", "author-by-country");
    log.warn("before call {} --", logMessage);
    List<Author> beforeResults = query.getResultList();
    log.warn("{} : {}", logMessage, beforeResults);
    EntityTestUtils.stop(em);
    return beforeResults;
}

@Override
public final void attach() {
    super.attach();
    final EntityManager entityManager = ((AbstractSiteUI) getUI().getUI()).getSite().getSiteContext().getObject(EntityManager.class);
    final Company company = ((AbstractSiteUI) getUI().getUI()).getSite().getSiteContext().getObject(Company.class);
    final CriteriaBuilder queryBuilder = entityManager.getCriteriaBuilder();
    final CriteriaQuery<User> criteriaQuery = queryBuilder.createQuery(User.class);
    final Root<User> root = criteriaQuery.from(User.class);
    final Expression<Comparable> owner = root.get("owner");
    criteriaQuery.where(queryBuilder.equal(owner, company));
    criteriaQuery.orderBy(queryBuilder.asc(root.get("owner")), queryBuilder.asc(root.get("lastName")), queryBuilder.asc(root.get("firstName")));
    final TypedQuery<User> companyQuery = entityManager.createQuery(criteriaQuery);
    for (final User user : companyQuery.getResultList()) {
        addItem(user);
    }
}

@Test
public void shouldExecuteCriteriaUpdate() throws Exception {
    CriteriaBuilder builder = em.getCriteriaBuilder();
    CriteriaUpdate<Employee> c = builder.createCriteriaUpdate(Employee.class);
    Root<Employee> p = c.from(Employee.class);
    Predicate condition = builder.ge(p.get(Employee_.salary), new BigDecimal("50000"));
    c.where(condition);
    TaxCode directorTaxCode = new TaxCode(504, "Director");
    c.set(p.get(Employee_.taxCode), directorTaxCode);
    utx.begin();
    Query query = em.createQuery(c);
    int rowsAffected = query.executeUpdate();
    assertTrue(rowsAffected > 0);
    utx.commit();
}

public Member findByEmail(String email) {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<Member> criteria = cb.createQuery(Member.class);
    Root<Member> member = criteria.from(Member.class);
    // Swap criteria statements if you would like to try out type-safe criteria queries, a new
    // feature in JPA 2.0
    // criteria.select(member).where(cb.equal(member.get(Member_.email), email));
    criteria.select(member).where(cb.equal(member.get("email"), email));
    return em.createQuery(criteria).getSingleResult();
}

@Factory
@Observer("bookingConfirmed")
public //   @Transactional
void getBookings() {
    // JPA 1.0 way      
    //    bookings = em.createQuery("select b from Booking b where b.user.username = :username order by b.checkinDate")
    //          .setParameter("username", user.getUsername())
    //          .getResultList();      
    //JPA 2.0 way - using new CriteriaBuilder API for dynamic query execution
    //this easily check the typos in comparison to usage of string query
    CriteriaBuilder criteriaBuilder = em.getCriteriaBuilder();
    CriteriaQuery<Booking> query = criteriaBuilder.createQuery(Booking.class);
    Root<Booking> hotelBooking = query.from(Booking.class);
    query.where(criteriaBuilder.equal(hotelBooking.get("user"), user));
    query.orderBy(criteriaBuilder.asc(hotelBooking.get("checkinDate")));
    bookings = em.createQuery(query).getResultList();
}

public Member findByEmail(String email) {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<Member> criteria = cb.createQuery(Member.class);
    Root<Member> member = criteria.from(Member.class);
    // Swap criteria statements if you would like to try out type-safe criteria queries, a new
    // feature in JPA 2.0
    // criteria.select(member).where(cb.equal(member.get(Member_.email), email));
    criteria.select(member).where(cb.equal(member.get("email"), email));
    return em.createQuery(criteria).getSingleResult();
}

public static Specification<SkillRaceClassInfoEntity> isRaceMatchToRaceMask(final Races race) {
    return new Specification<SkillRaceClassInfoEntity>() {

        @Override
        public Predicate toPredicate(final Root<SkillRaceClassInfoEntity> root, final CriteriaQuery<?> query, final CriteriaBuilder cb) {
            final Expression<Integer> racemask = cb.literal(race.getMask());
            final Expression<Integer> raceFunction = cb.function("bitwise_and", Integer.class, root.<Integer>get("racemask"), racemask);
            return cb.greaterThan(raceFunction, 0);
        }
    };
}

/*
     * Lookup entities having at least one String attribute matching the passed sp's pattern
     */
@SuppressWarnings("unchecked")
public <T> Predicate byPattern(Root<T> root, CriteriaBuilder builder, SearchParameters sp, Class<T> type) {
    if (!sp.hasSearchPattern()) {
        return null;
    }
    List<Predicate> predicates = newArrayList();
    EntityType<T> entity = em.getMetamodel().entity(type);
    String pattern = sp.getSearchPattern();
    for (SingularAttribute<? super T, ?> attr : entity.getSingularAttributes()) {
        if (attr.getPersistentAttributeType() == MANY_TO_ONE || attr.getPersistentAttributeType() == ONE_TO_ONE) {
            continue;
        }
        if (attr.getJavaType() == String.class) {
            predicates.add(jpaUtil.stringPredicate((Expression<String>) root.get(jpaUtil.attribute(entity, attr)), pattern, sp, builder));
        }
    }
    return jpaUtil.orPredicate(builder, predicates);
}

public Member findByEmail(String email) {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<Member> criteria = cb.createQuery(Member.class);
    Root<Member> member = criteria.from(Member.class);
    // Swap criteria statements if you would like to try out type-safe criteria queries, a new
    // feature in JPA 2.0
    // criteria.select(member).where(cb.equal(member.get(Member_.email), email));
    criteria.select(member).where(cb.equal(member.get("email"), email));
    return em.createQuery(criteria).getSingleResult();
}

@Override
public Endpoint endpointOfResource(ResourceId id) {
    CriteriaBuilder cb = entityManager().getCriteriaBuilder();
    CriteriaQuery<JPAEndpoint> query = cb.createQuery(JPAEndpoint.class);
    Root<JPAEndpoint> descriptor = query.from(JPAEndpoint.class);
    query.select(descriptor).where(cb.equal(descriptor.get("resourceId"), Key.newInstance(id))).distinct(true);
    List<JPAEndpoint> results = entityManager().createQuery(query).getResultList();
    if (results.isEmpty()) {
        return null;
    }
    return results.get(0);
}

private void queryReceipts() {
    CriteriaBuilder builder = em.getCriteriaBuilder();
    CriteriaQuery<Receipt> cquery = builder.createQuery(Receipt.class);
    Root<Receipt> receipt = cquery.from(Receipt.class);
    // QUESTION can like create the pattern for us?
    cquery.select(receipt);
    List<Receipt> results = em.createQuery(cquery).getResultList();
    allReceipts = results;
    log.searchExecuted(allReceipts);
}

public Member findByEmail(String email) {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<Member> criteria = cb.createQuery(Member.class);
    Root<Member> member = criteria.from(Member.class);
    /*
         * Swap criteria statements if you would like to try out type-safe criteria queries, a new
         * feature in JPA 2.0 criteria.select(member).orderBy(cb.asc(member.get(Member_.name)));
         */
    criteria.select(member).where(cb.equal(member.get("email"), email));
    return em.createQuery(criteria).getSingleResult();
}

/**
     * Gets property path.
     *
     * @param root the root where path starts form
     * @param propertyId the property ID
     * @return the path to property
     */
private Path<Object> getPropertyPath(final Root<?> root, final Object propertyId) {
    final String[] propertyIdParts = ((String) propertyId).split("\\.");
    Path<Object> path = null;
    for (final String part : propertyIdParts) {
        if (path == null) {
            path = root.get(part);
        } else {
            path = path.get(part);
        }
    }
    return path;
}

/**
     * Creates a specification used to find terms with the specified testUuid.
     * 
     * @param testRun
     * @return
     */
public static Specification<Term> testRunIs(final TestRun testRun) {
    return new Specification<Term>() {

        @Override
        public Predicate toPredicate(Root<Term> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
            Predicate p = null;
            if (testRun == null || testRun.getUuid() == null) {
                p = cb.isNull(root.<Term_>get("testRun"));
            } else {
                p = cb.equal(root.<Term_>get("testRun").<TestRun_>get("uuid"), testRun.getUuid());
            }
            return p;
        }
    };
}

public Member findByEmail(String email) {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<Member> criteria = cb.createQuery(Member.class);
    Root<Member> member = criteria.from(Member.class);
    // Swap criteria statements if you would like to try out type-safe criteria queries, a new
    // feature in JPA 2.0
    // criteria.select(member).where(cb.equal(member.get(Member_.name), email));
    criteria.select(member).where(cb.equal(member.get("email"), email));
    return em.createQuery(criteria).getSingleResult();
}

public Person findByEmail(String email) {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<Person> criteria = cb.createQuery(Person.class);
    Root<Person> member = criteria.from(Person.class);
    criteria.select(member).where(cb.equal(member.get("email"), email));
    return em.createQuery(criteria).getSingleResult();
}

private Long rowCount(final IEntity entity, final List<String> attributeNames, final EntityManager em) {
    final Class<? extends IEntity> entityClass = entity.getClass();
    final CriteriaBuilder cb = em.getCriteriaBuilder();
    final CriteriaQuery<Long> query = cb.createQuery(Long.class);
    final Root<? extends IEntity> root = query.from(entityClass);
    query.select(cb.count(root));
    Predicate condition = null;
    for (final String attributeName : attributeNames) {
        Predicate tmp;
        try {
            tmp = cb.equal(root.<Object>get(attributeName), PropertyUtils.getProperty(entity, attributeName));
        // CHECKSTYLE IGNORE 1 LINES
        } catch (final Exception e) {
            throw new RuntimeException(e);
        }
        condition = (condition == null) ? tmp : cb.and(condition, tmp);
    }
    // update on existing element? exclude the element itself
    if (!entity.isNew()) {
        condition = cb.and(condition, cb.notEqual(root.<Long>get("id"), "" + entity.getId()));
    }
    query.where(condition);
    return em.createQuery(query).getSingleResult();
}

public int count() {
    javax.persistence.criteria.CriteriaQuery cq = getEntityManager().getCriteriaBuilder().createQuery();
    javax.persistence.criteria.Root<T> rt = cq.from(entityClass);
    cq.select(getEntityManager().getCriteriaBuilder().count(rt));
    javax.persistence.Query q = getEntityManager().createQuery(cq);
    return ((Long) q.getSingleResult()).intValue();
}

@Override
public Country getCountryByName(String name) {
    //JPA Criteria
    CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
    CriteriaQuery<Country> query = criteriaBuilder.createQuery(Country.class);
    Root<Country> country = query.from(Country.class);
    query.where(criteriaBuilder.equal(country.<String>get("name"), criteriaBuilder.parameter(String.class, "param")));
    TypedQuery<Country> typedQuery = entityManager.createQuery(query);
    typedQuery.setParameter("param", name);
    return typedQuery.getResultList().get(0);
//		//Hibernate Criteria
//	  Session session = entityManager.unwrap(Session.class);
//	  Criteria criteria = session.createCriteria(Country.class);
//	  criteria.add(Restrictions.eq("name", name));
//	  return (Country) criteria.uniqueResult();  
}