How to use

Criteria

in

org.hibernate

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();
}