CriteriaBuilder qb = entityManager.getCriteriaBuilder(); CriteriaQuery<Long> cq = qb.createQuery(Long.class); cq.select(qb.count(cq.from(MyEntity.class))); cq.where(/*your stuff*/); return entityManager.createQuery(cq).getSingleResult();
@SuppressWarnings({ "unchecked" }) public MAX(CriteriaBuilderImpl criteriaBuilder, Expression<N> expression) { super( criteriaBuilder, ( Class<N> ) expression.getJavaType(), NAME , expression); } }
@SuppressWarnings("rawtypes") private static Expression getCountQuery(CriteriaQuery<?> query, CriteriaBuilder builder, Root<?> root) { return query.isDistinct() ? builder.countDistinct(root) : builder.count(root); } }
private List<RootEntity> getAllRows(EntityManager em) { CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<RootEntity> cq = cb.createQuery( RootEntity.class ); Root<RootEntity> c = cq.from( RootEntity.class ); return em.createQuery( cq.select( c ).orderBy( cb.desc( c.get( "status" ) ) ) ).getResultList(); }
private CriteriaQuery<TestEntity> createTestEntityCriteriaQuery( String entityName, Session session) { final CriteriaBuilder builder = session.getCriteriaBuilder(); final CriteriaQuery<TestEntity> query = builder.createQuery( TestEntity.class ); final Root<TestEntity> fromTestEntity = query.from( TestEntity.class ); query.select( fromTestEntity ); query.where( builder.equal( fromTestEntity.get( "name" ), entityName ) ); return query; }
@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); } };
@Override public Predicate buildPredicate(CriteriaBuilder builder, FieldPathBuilder fieldPathBuilder, From root, String ceilingEntity, String fullPropertyName, Path explicitPath, List directValues) { //expect it to be allParentCategoryXrefs.category.name, so we need to restrict on allParentCategoryXrefs - 2 levels up Predicate equal = builder.equal(explicitPath.getParentPath().getParentPath().get("defaultReference"), Boolean.TRUE); return equal; } })
private List<RootEntity> getLimitedRows(EntityManager em, int start, int end) { CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<RootEntity> cq = cb.createQuery( RootEntity.class ); Root<RootEntity> c = cq.from( RootEntity.class ); CriteriaQuery<RootEntity> select = cq.select( c ).orderBy( cb.desc( c.get( "status" ) ) ); TypedQuery<RootEntity> typedQuery = em.createQuery( select ); typedQuery.setFirstResult( start ); typedQuery.setMaxResults( end ); return typedQuery.getResultList(); }
@SuppressWarnings({ "unchecked" }) public LEAST(CriteriaBuilderImpl criteriaBuilder, Expression<X> expression) { super( criteriaBuilder, ( Class<X> ) expression.getJavaType(), NAME , expression); } }
@SuppressWarnings({ "unchecked" }) public UnaryArithmeticOperation( CriteriaBuilderImpl criteriaBuilder, Operation operation, Expression<T> operand) { super( criteriaBuilder, (Class)operand.getJavaType() ); this.operation = operation; this.operand = operand; }
@SuppressWarnings({ "unchecked" }) public MIN(CriteriaBuilderImpl criteriaBuilder, Expression<N> expression) { super( criteriaBuilder, ( Class<N> ) expression.getJavaType(), NAME , expression); } }
@SuppressWarnings({ "unchecked" }) public GREATEST(CriteriaBuilderImpl criteriaBuilder, Expression<X> expression) { super( criteriaBuilder, ( Class<X> ) expression.getJavaType(), NAME , expression); } }
public AbsFunction(CriteriaBuilderImpl criteriaBuilder, Expression expression) { super( criteriaBuilder, expression.getJavaType(), NAME, expression ); }
private static Class determineType(Class javaType, Expression primaryExpression) { return javaType != null ? javaType : primaryExpression.getJavaType(); }