public EnvironmentVariables load(final Long entityId, final EnvironmentVariableType type) { List<EnvironmentVariable> result = (List<EnvironmentVariable>) transactionTemplate.execute((TransactionCallback) transactionStatus -> { Criteria criteria = sessionFactory.getCurrentSession().createCriteria(EnvironmentVariable.class).add(Restrictions.eq("entityId", entityId)).add( Restrictions.eq("entityType", type.toString())).addOrder(Order.asc("id")); criteria.setCacheable(true); return criteria.list(); }); return new EnvironmentVariables(result); }
@Override public LogSchema findLatestLogSchemaByAppId(String applicationId) { LOG.debug("Searching latest log schema by application id [{}]", applicationId); LogSchema logSchema = null; if (isNotBlank(applicationId)) { Criteria criteria = getCriteria(); criteria.createAlias(APPLICATION_PROPERTY, APPLICATION_ALIAS); Criterion criterion = Restrictions.eq(APPLICATION_REFERENCE, Long.valueOf(applicationId)); logSchema = (LogSchema) criteria.add(criterion).addOrder(Order.desc(VERSION_PROPERTY)) .setMaxResults(FIRST).uniqueResult(); } if (LOG.isTraceEnabled()) { LOG.trace("[{}] Search result: {}.", applicationId, logSchema); } else { LOG.debug("[{}] Search result: {}.", applicationId, logSchema != null); } return logSchema; }
protected Criteria getCriteria(Session s) { // should use PassThroughTransformer by default return s.createCriteria( Enrolment.class, "e" ) .setProjection( Projections.property( "e.semester" ) ) .addOrder( Order.asc( "e.studentNumber") ); } };
@Override public Object doInTransaction(TransactionStatus status) { PropertyProjection pipelineName = Projections.property("pipelineName"); Criteria criteria = sessionFactory.getCurrentSession().createCriteria(PipelineState.class).setProjection(pipelineName).add( Restrictions.eq("locked", true)); criteria.setCacheable(false); List<String> list = criteria.list(); return list; } });
@Override public Object doInTransaction(TransactionStatus transactionStatus) { return sessionFactory.getCurrentSession() .createCriteria(PipelineState.class) .add(Restrictions.eq("pipelineName", pipelineName)) .setCacheable(false).uniqueResult(); } });
Criteria criteria=session.createCriteria(Student.class); criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY); criteria.add(Restrictions.ne("enquiryStatus", ENQUIRY.JOINED)); criteria.setMaxResults(10); criteria.setFirstResult((paginate.getStartIndex()-1)*10); List<Student> students = criteria.list(); criteria.setProjection(null); criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY); Long resultCount = (Long)criteria.uniqueResult();
@TestForIssue(jiraKey = "HHH-4838") @Test public void testNaturalKeyLookupWithConstraint() { Session s = openSession(); Transaction newTx = s.getTransaction(); newTx.begin(); A a1 = new A(); a1.setName( "name1" ); s.persist( a1 ); newTx.commit(); newTx = s.beginTransaction(); getCriteria( s ).add( Restrictions.isNull( "singleD" ) ).uniqueResult(); // put query-result into cache A a2 = new A(); a2.setName( "xxxxxx" ); s.persist( a2 ); newTx.commit(); // Invalidates space A in UpdateTimeStamps region newTx = s.beginTransaction(); Assert.assertTrue( s.getSessionFactory().getStatistics().isStatisticsEnabled() ); s.getSessionFactory().getStatistics().clear(); // should not produce a hit in StandardQuery cache region because there is a constraint getCriteria( s ).add( Restrictions.isNull( "singleD" ) ).uniqueResult(); Assert.assertEquals( 0, s.getSessionFactory().getStatistics().getQueryCacheHitCount() ); s.createQuery( "delete from A" ).executeUpdate(); newTx.commit(); // Shutting down the application s.close(); }
.add( Restrictions.eq( "integer", f.getInteger() ) ) .add( Restrictions.eqProperty("integer", "integer") ) .add( Restrictions.like( "string", f.getString().toUpperCase(Locale.ROOT) ).ignoreCase() ) .add( Restrictions.in( "boolean", f.getBoolean(), f.getBoolean() ) ) .setFetchMode("foo", FetchMode.JOIN) .setFetchMode("baz", FetchMode.SELECT) .setFetchMode("abstracts", FetchMode.JOIN) .list(); assertTrue( list.size() == 1 && list.get( 0 ) == f ); list = s.createCriteria(Foo.class).add( .add( Restrictions.isNotNull("boolean") ) .list(); assertTrue( list.size() == 1 && list.get( 0 ) == f ); list = s.createCriteria(Foo.class).add( Example.create(example) .excludeZeroes() .list(); assertTrue( "Example API without like did not work correctly, size was " + list.size(), list = s.createCriteria(Foo.class).add( Example.create(example) .excludeZeroes() .list();
@Test public void testCriteriaRestrictionOnKeyManyToOne() { Session s = openSession(); s.beginTransaction(); s.createQuery( "from Order o where o.customer.name = 'Acme'" ).list(); Criteria criteria = s.createCriteria( Order.class ); criteria.createCriteria( "customer" ).add( Restrictions.eq( "name", "Acme" ) ); criteria.list(); s.getTransaction().commit(); s.close(); }
/** * @see org.openmrs.api.db.OpenmrsDataDAO#getAll(boolean, java.lang.Integer, java.lang.Integer) */ @Override public List<T> getAll(boolean includeVoided, Integer firstResult, Integer maxResults) { Criteria crit = sessionFactory.getCurrentSession().createCriteria(mappedClass); if (!includeVoided) { crit.add(Restrictions.eq("voided", false)); } crit.setFirstResult(firstResult); crit.setMaxResults(maxResults); return crit.list(); }
@Override public List<AssignedProductOptionDTO> findAssignedProductOptionsByProductId(Long productId) { Session session = em.unwrap(Session.class); Criteria criteria = session.createCriteria(SkuProductOptionValueXrefImpl.class); List dtoList = criteria .createAlias("sku", "sku") .createAlias("sku.product", "product") .createAlias("productOptionValue", "productOptionValue") .createAlias("productOptionValue.productOption", "productOption") .setProjection(Projections.distinct( Projections.projectionList() .add(Projections.property("product.id"), "productId") .add(Projections.property("productOption.attributeName"), "productOptionAttrName") .add(Projections.property("productOptionValue"), "productOptionValue") .add(Projections.property("sku"), "sku") ) ).setResultTransformer(Transformers.aliasToBean(AssignedProductOptionDTO.class)) .add(Restrictions.eq("product.id", productId)) .addOrder(Order.asc("productOption.attributeName")).list(); List<AssignedProductOptionDTO> results = new ArrayList<>(); for (Object o : dtoList) { AssignedProductOptionDTO dto = (AssignedProductOptionDTO) o; if (dto.getSku().isActive()) { results.add(dto); } } return results; }
protected Criteria getCriteria(Session s) throws Exception { return s.createCriteria( Student.class, "s" ) .setProjection( Projections.projectionList() .add( Projections.sqlProjection( "555 as studentNumber", new String[]{ "studentNumber" }, new Type[] { StandardBasicTypes.LONG } ) ) .add( Property.forName( "s.name" ).as( "name" ) ) ) .addOrder( Order.asc( "s.studentNumber" ) ) .setResultTransformer( new AliasToBeanConstructorResultTransformer( getConstructor() ) ); } private Constructor getConstructor() throws NoSuchMethodException {
Category category2 = new Category( 2, "Category2" ); Category category3 = new Category( 3, "Category3" ); session.persist( category1 ); session.persist( category2 ); session.persist( category3 ); session.flush(); session.persist( new Product2( 1, "Kit1", category1 ) ); List<Object[]> result = session.createCriteria( Category.class, "c" ).createAlias( "products", "p" ) .setProjection( Projections.projectionList() .add( Projections.groupProperty( "c.id" ) ) .add( Projections.countDistinct( "p.id" ) ) .addOrder( Order.asc( "c.id" ) ) .setFirstResult( 1 ).setMaxResults( 3 ).list();
@SuppressWarnings("unchecked") @Override public List<Encounter> getEncountersNotAssignedToAnyVisit(Patient patient) throws DAOException { return sessionFactory.getCurrentSession().createCriteria(Encounter.class).add(Restrictions.eq("patient", patient)) .add(Restrictions.isNull("visit")).add(Restrictions.eq("voided", false)).addOrder( Order.desc("encounterDatetime")).setMaxResults(100).list(); }
@Override public Spell findByName(String name) { Transaction tx = null; Spell result = null; try (Session session = getSessionFactory().openSession()) { tx = session.beginTransaction(); Criteria criteria = session.createCriteria(persistentClass); criteria.add(Restrictions.eq("name", name)); result = (Spell) criteria.uniqueResult(); tx.commit(); } catch (Exception e) { if (tx != null) { tx.rollback(); } throw e; } return result; } }
private EntityMapEnum assertFindCriteria( EntityMapEnum expected, String mapPath, Object param) { assertNotEquals( 0, expected.id ); Session session = openNewSession(); session.beginTransaction(); EntityMapEnum found = (EntityMapEnum) session.createCriteria( EntityMapEnum.class ) .createCriteria( mapPath, "m" ) .add( Restrictions.eq( "indices", param ) ) .uniqueResult(); //find assetEntityMapEnumEquals( expected, found ); session.getTransaction().commit(); session.close(); return found; }
/** * Use a Criteria query - see FORGE-247 */ public List listEventsWithCriteria() { Session session = sessionFactory.getCurrentSession(); session.beginTransaction(); List result = session.createCriteria(Event.class) .setCacheable(true) .list(); session.getTransaction().commit(); return result; }
@Test public void testEnablingJoinFetchProfileAgainstSelfReferentialAssociation() { Session s = openSession(); s.beginTransaction(); s.enableFetchProfile( Employee.FETCH_PROFILE_TREE ); s.createCriteria( Employee.class ) .add( Restrictions.isNull( "manager" ) ) .list(); s.getTransaction().commit(); s.close(); } }
/** * @see org.openmrs.api.db.FormDAO#getFormsByName(java.lang.String) */ @Override @SuppressWarnings("unchecked") public List<Form> getFormsByName(String name) throws DAOException { Criteria crit = sessionFactory.getCurrentSession().createCriteria(Form.class); crit.add(Restrictions.eq("name", name)); crit.add(Restrictions.eq("retired", false)); crit.addOrder(Order.desc("version")); return crit.list(); }
@Test public void testCriteria() { Session session = openSession(); session.beginTransaction(); Criteria criteria = session.createCriteria( Door.class ); criteria.setLockMode( LockMode.PESSIMISTIC_WRITE ); criteria.setFirstResult( 2 ); criteria.setMaxResults( 2 ); @SuppressWarnings("unchecked") List<Door> results = criteria.list(); assertEquals( 2, results.size() ); for ( Door door : results ) { assertEquals( LockMode.PESSIMISTIC_WRITE, session.getCurrentLockMode( door ) ); } session.getTransaction().commit(); session.close(); }