Map<String, Object> params = ...; CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<Tuple> cq = cb.createTupleQuery(); Root<Transaction> r = cq.from(Transaction.class); Predicate p= cb.conjunction(); for (Map.Entry<String, Object> param: params.entrySet()) p = cb.and(p, cb.equal(r.get(param.getKey()), param.getValue())); cq.multiselect(r.get("id"), r.get("status"), r.get("created_at")) .where(p) .orderBy(cb.asc(r.get("id"))); List<Tuple> result = em.createQuery(cq).getResultList();
/** * Creates the {@link CriteriaQuery} to apply predicates on. * * @param builder will never be {@literal null}. * @param type will never be {@literal null}. * @return must not be {@literal null}. */ protected CriteriaQuery<? extends Object> createCriteriaQuery(CriteriaBuilder builder, ReturnedType type) { Class<?> typeToRead = type.getTypeToRead(); return typeToRead == null || tree.isExistsProjection() ? builder.createTupleQuery() : builder.createQuery(typeToRead); }
Map<SingularAttribute<Transaction, ?>, Object> params = ...; CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<Tuple> cq = cb.createTupleQuery(); Root<Transaction> r = cq.from(Transaction.class); Predicate p= cb.conjunction(); for (Map.Entry<SingularAttribute<Transaction, ?>, Object> param: params.entrySet()) p = cb.and(p, cb.equal(r.get(param.getKey()), param.getValue())); cq.multiselect(r.get(Transaction_.id), r.get(Transaction_.status), r.get(Transaction_.created_at)) .where(p) .orderBy(cb.asc(r.get(Transaction_.id))); List<Tuple> result = em.createQuery(cq).getResultList();
CriteriaQuery<Tuple> criteriaQuery = builder.createTupleQuery();
@Test @TestForIssue(jiraKey = "HHH-11743") public void testTupleStream() { doInHibernate( this::sessionFactory, session -> { MyEntity entity = new MyEntity(); entity.id = 2; entity.name = "an entity"; session.persist( entity ); } ); //test tuple stream using criteria doInHibernate( this::sessionFactory, session -> { CriteriaBuilder cb = session.getCriteriaBuilder(); CriteriaQuery<Tuple> criteria = cb.createTupleQuery(); Root<MyEntity> me = criteria.from( MyEntity.class ); criteria.multiselect( me.get( "id" ), me.get( "name" ) ); Stream<Tuple> data = session.createQuery( criteria ).stream(); data.forEach( tuple -> assertTyping( Tuple.class, tuple ) ); } ); //test tuple stream using JPQL doInHibernate( this::sessionFactory, session -> { Stream<Tuple> data = session.createQuery( "SELECT me.id, me.name FROM MyEntity me", Tuple.class ).stream(); data.forEach( tuple -> assertTyping( Tuple.class, tuple ) ); } ); }
private void findMatchingTagIds(String theResourceName, IIdType theResourceId, Set<Long> tagIds, Class<? extends BaseTag> entityClass) { { CriteriaBuilder builder = myEntityManager.getCriteriaBuilder(); CriteriaQuery<Tuple> cq = builder.createTupleQuery(); Root<? extends BaseTag> from = cq.from(entityClass); cq.multiselect(from.get("myTagId").as(Long.class)).distinct(true); if (theResourceName != null) { Predicate typePredicate = builder.equal(from.get("myResourceType"), theResourceName); if (theResourceId != null) { cq.where(typePredicate, builder.equal(from.get("myResourceId"), myIdHelperService.translateForcedIdToPid(theResourceName, theResourceId.getIdPart()))); } else { cq.where(typePredicate); } } TypedQuery<Tuple> query = myEntityManager.createQuery(cq); for (Tuple next : query.getResultList()) { tagIds.add(next.get(0, Long.class)); } } }
private void done() { if (_selects.size() == 0) { _query = _builder.createQuery(_entityClass); } else if (_selects.size() == 1) { Class<?> selectType = _selects.get(0)._javaType; _query = _builder.createQuery(selectType); } else { _query = _builder.createTupleQuery(); } _root = _query.from(_entityClass); if (_selects.size() == 0) { } else if (_selects.size() == 1) { Path p = _root.get(_selects.get(0)._attr); _query.select(p); } else { for (AttrInfo info : _selects) { _paths.add(_root.get(info._attr)); } _query.multiselect(_paths); } _query.where(whereClause()); _query.orderBy(orderClause()); groupByClause(_query); }
CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<Tuple> cq= cb.createTupleQuery(); Root<Documents> root = cq.from(Documents.class); Expression<Integer> userId = root.get("USERID"); Expression<String> userType = root.get("USERTYPE"); Expression<Long> count = cb.count(userId); cq.multiselect(userId.alias("USERID"), count.alias("CNT")); cq.where(cb.equal(userType, "COMPANY"); cq.groupBy(userId); cq.orderBy(cb.desc(count)); TypedQuery<Tuple> tq = em.createQuery(cq); for (Tuple t : tq.getResultsList()) { System.out.println(t.get("USERID")); System.out.println(t.get("CNT")); }
CriteriaBuilder criteriaBuilder = getEntityManager().getCriteriaBuilder(); CriteriaQuery<Tuple> query= criteriaBuilder.createTupleQuery(); Root<Cargo> cargo= query.from(Cargo.class); Root<Currency> currency= query.from(Currency.class); query.multiselect(cargo.get("id"), currency.get("name")); Query query = em.createQuery(cq); List<Tuple> results = query.getResultList();
CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder(); CriteriaQuery<Tuple> query = criteriaBuilder.createTupleQuery(); Root<Table> root = query.from(Table.class); Expression<Long> funcExpr = criteriaBuilder.function("myfunction", Long.class, root.get("parameter")); query.multiselect(query.select(root), funcExpr); List<Tuple> resultList = entityManager.createQuery(query) .getResultList();
CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder(); CriteriaQuery<Tuple> criteriaQuery = criteriaBuilder.createTupleQuery(); Root root = criteriaQuery.from(/*The class youre searching*/); Predicate predicate = criteriaBuilder.like(root.<String>get(/*field name*/), /*search values*/); criteriaQuery.where(predicate); criteriaQuery.select(root); TypedQuery query = entityManager.createQuery(criteriaQuery); List<T> result = query.getResultList();
CriteriaBuilder b = em.getCriteriaBuilder(); CriteriaQuery<Tuple> c = b.createTupleQuery(); Root<EntityX> entityXRoot= c.from(EntityX.class); Root<EntityY> entityYRoot = c.from(EntityY.class); List<Predicate> predicates = new ArrayList<>(); //Here you need to add the predicates you need List<Predicate> andPredicates = new ArrayList<>(); andPredicates.add(b.equal(entityXRoot.get("id"), entityYRoot.get("id"))); andPredicates.add(b.and(predicates.toArray(new Predicate[0]))); c.multiselect(entityXRoot, entityYRoot); c.where(andPredicates.toArray(new Predicate[0])); TypedQuery<Tuple> q = em.createQuery(criteria); List<Tuple> result = q.getResultList();
CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaQuery<Tuple> criteria = builder.createTupleQuery(); Root<EntityA> entityARoot= criteria.from(EntityA.class); Root<EntityB> entityBRoot = criteria.from(EntityB.class); //Predicates List<Predicate> predicates = new ArrayList<>(); //Add the predicates you need //And predicates List<Predicate> andPredicates = new ArrayList<>(); andPredicates.add(builder.equal(entityARoot.get("id"), entityBRoot.get("id"))); andPredicates.add(builder.and(predicates.toArray(new Predicate[0]))); criteria.multiselect(entityARoot, entityBRoot); criteria.where(andPredicates.toArray(new Predicate[0])); TypedQuery<Tuple> query = em.createQuery(criteria); List<Tuple> result = query.getResultList();
/** * Creates the {@link CriteriaQuery} to apply predicates on. * * @param builder will never be {@literal null}. * @param type will never be {@literal null}. * @return must not be {@literal null}. */ protected CriteriaQuery<? extends Object> createCriteriaQuery(CriteriaBuilder builder, ReturnedType type) { Class<?> typeToRead = type.getTypeToRead(); return typeToRead == null || tree.isExistsProjection() ? builder.createTupleQuery() : builder.createQuery(typeToRead); }
CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<Tuple> cq = cb.createTupleQuery(); Root<ObjectMetadata> root = cq.from(ObjectMetadata.class); cq.multiselect( root.get("fileName").alias("filename"), cb.greatest(root.<Date>get("lastModified").alias("lastmodified") ); cq.groupBy(root.get("fileName")); List<Tuple> result = em.createQuery(cq).getResultList() for (Tuple t: result) { System.out.println(t.get("filename") + " " + t.get("lastmodified")); }
@Override public List<Tuple> group(GroupingSpecification<T> specification) { final CriteriaBuilder cb = em.getCriteriaBuilder(); final CriteriaQuery<Tuple> query = cb.createTupleQuery(); final Root<T> root = query.from(getDomainClass()); root.alias(SELECTION_OUTPUT); final Map<Expression<?>, String> paths = specification.buildPaths(root, cb); query.multiselect(specification.toSelect(paths, root, cb)); query.where(specification.toPredicate(root, query, cb)); query.groupBy(new ArrayList<>(paths.keySet())); return em.createQuery(query).getResultList(); } }
CriteriaBuilder cb = entityManager.getCriteriaBuilder(); CriteriaQuery<Tuple> crit = cb.createTupleQuery(); Subquery<Application> subquery = cb.subquery(Application.class); subquery.where(...); subquery.correlate(...); crit.select(cb.tuple(cb.from(Item.class), subquery);
CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<Tuple> q = cb.createTupleQuery(); Root<Test> c = q.from(Test.class); q.multiselect(c.get("type"), cb.count(c)); q.groupBy(c.get("type")); TypedQuery<Tuple> t = em.createQuery(q); List<Tuple> resultList = t.getResultList(); for(Tuple tuple : resultList){ logger.info(tuple.get(0) + " " + tuple.get(1)); }
public JPAAbstractJoinQuery(final OData odata, final JPAODataSessionContextAccess context, final JPAEntityType jpaEntityType, final EntityManager em, final Map<String, List<String>> requestHeaders, final UriInfoResource uriResource, final JPAODataPage page) throws ODataException { super(odata, context.getEdmProvider().getServiceDocument(), jpaEntityType, em, context.getDebugger()); this.locale = ExpressionUtil.determineLocale(requestHeaders); this.uriResource = uriResource; this.cq = cb.createTupleQuery(); this.context = context; this.page = page; }
private List<Tuple> getTuples() { return doInJPA(entityManager -> { Class<Post> entityClass = Post.class; CriteriaBuilder cb = entityManager.getCriteriaBuilder(); CriteriaQuery<Tuple> query = cb.createTupleQuery(); Root<?> root = query.from(entityClass); query.select( cb.tuple( root.get("id"), cb.function("now", Date.class) ) ); return entityManager.createQuery(query).getResultList(); }); }