How to use

setFirstResult

method

in

org.hibernate.Criteria

 DetachedCriteria idsOnlyCriteria = DetachedCriteria.forClass(MyClass.class);
//add other joins and query params here
idsOnlyCriteria.setProjection(Projections.distinct(Projections.id()));

Criteria criteria = getSession().createCriteria(myClass);
criteria.add(Subqueries.propertyIn("id", idsOnlyCriteria));
criteria.setFirstResult(0).setMaxResults(50);
return criteria.list();

@Override
@SuppressWarnings({"unchecked", "deprecation"})
public <T> List<T> findByExample(
    @Nullable final String entityName, final T exampleEntity, final int firstResult, final int maxResults)
    throws DataAccessException {
  Assert.notNull(exampleEntity, "Example entity must not be null");
  return nonNull(executeWithNativeSession((HibernateCallback<List<T>>) session -> {
    Criteria executableCriteria = (entityName != null ?
        session.createCriteria(entityName) : session.createCriteria(exampleEntity.getClass()));
    executableCriteria.add(Example.create(exampleEntity));
    prepareCriteria(executableCriteria);
    if (firstResult >= 0) {
      executableCriteria.setFirstResult(firstResult);
    }
    if (maxResults > 0) {
      executableCriteria.setMaxResults(maxResults);
    }
    return executableCriteria.list();
  }));
}

@Override
@SuppressWarnings("unchecked")
public List<?> findByCriteria(final DetachedCriteria criteria, final int firstResult, final int maxResults)
    throws DataAccessException {
  Assert.notNull(criteria, "DetachedCriteria must not be null");
  return nonNull(executeWithNativeSession((HibernateCallback<List<?>>) session -> {
    Criteria executableCriteria = criteria.getExecutableCriteria(session);
    prepareCriteria(executableCriteria);
    if (firstResult >= 0) {
      executableCriteria.setFirstResult(firstResult);
    }
    if (maxResults > 0) {
      executableCriteria.setMaxResults(maxResults);
    }
    return executableCriteria.list();
  }));
}

@Override
@SuppressWarnings({"unchecked", "deprecation"})
public <T> List<T> findByExample(
    @Nullable final String entityName, final T exampleEntity, final int firstResult, final int maxResults)
    throws DataAccessException {
  Assert.notNull(exampleEntity, "Example entity must not be null");
  return nonNull(executeWithNativeSession((HibernateCallback<List<T>>) session -> {
    Criteria executableCriteria = (entityName != null ?
        session.createCriteria(entityName) : session.createCriteria(exampleEntity.getClass()));
    executableCriteria.add(Example.create(exampleEntity));
    prepareCriteria(executableCriteria);
    if (firstResult >= 0) {
      executableCriteria.setFirstResult(firstResult);
    }
    if (maxResults > 0) {
      executableCriteria.setMaxResults(maxResults);
    }
    return executableCriteria.list();
  }));
}

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

@Override
@SuppressWarnings("unchecked")
public List<?> findByCriteria(final DetachedCriteria criteria, final int firstResult, final int maxResults)
    throws DataAccessException {
  Assert.notNull(criteria, "DetachedCriteria must not be null");
  return nonNull(executeWithNativeSession((HibernateCallback<List<?>>) session -> {
    Criteria executableCriteria = criteria.getExecutableCriteria(session);
    prepareCriteria(executableCriteria);
    if (firstResult >= 0) {
      executableCriteria.setFirstResult(firstResult);
    }
    if (maxResults > 0) {
      executableCriteria.setMaxResults(maxResults);
    }
    return executableCriteria.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();
}

assertTrue( list.size()==1 && list.get(0)==f );
list = s.createCriteria(Foo.class)
  .setFirstResult(1)
  .addOrder( Order.asc("date") )
  .addOrder( Order.desc("string") )

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

/**
 * @see org.openmrs.api.db.OpenmrsMetadataDAO#getAll(boolean, java.lang.Integer, java.lang.Integer)
 */
@Override
public List<T> getAll(boolean includeRetired, Integer firstResult, Integer maxResults) {
  Criteria crit = sessionFactory.getCurrentSession().createCriteria(mappedClass);
  
  if (!includeRetired) {
    crit.add(Restrictions.eq("retired", false));
  }
  crit.setFirstResult(firstResult);
  crit.setMaxResults(maxResults);
  
  return crit.list();
  
}

.setFirstResult( 1 ).setMaxResults( 3 ).list();

 Criteria crit = HibernateUtil.getSession().createCriteria( persistentClass );
crit.setFirstResult(startIndex);
crit.setFetchSize(fetchSize);
crit.setCachable(true); // Enable caching of this query result
return crit.list();

/**
 * @see org.openmrs.api.db.EncounterDAO#getEncounters(String, Integer, Integer, Integer,
 *      boolean)
 */
@Override
@SuppressWarnings("unchecked")
public List<Encounter> getEncounters(String query, Integer patientId, Integer start, Integer length,
    boolean includeVoided) {
  if (StringUtils.isBlank(query) && patientId == null) {
    return Collections.emptyList();
  }
  
  Criteria criteria = createEncounterByQueryCriteria(query, patientId, includeVoided, true);
  
  if (start != null) {
    criteria.setFirstResult(start);
  }
  if (length != null && length > 0) {
    criteria.setMaxResults(length);
  }
  
  return criteria.list();
}

/**
 * @see org.openmrs.api.db.ConceptDAO#getConceptReferenceTerms(String, ConceptSource, Integer,
 *      Integer, boolean)
 */
@SuppressWarnings("unchecked")
@Override
public List<ConceptReferenceTerm> getConceptReferenceTerms(String query, ConceptSource conceptSource, Integer start,
    Integer length, boolean includeRetired) throws APIException {
  Criteria criteria = createConceptReferenceTermCriteria(query, conceptSource, includeRetired);
  
  if (start != null) {
    criteria.setFirstResult(start);
  }
  if (length != null && length > 0) {
    criteria.setMaxResults(length);
  }
  
  return criteria.list();
}

private void setFirstAndMaxResult(Criteria criteria, Integer start, Integer length) {
  if (start != null) {
    criteria.setFirstResult(start);
  }
  
  int maximumSearchResults = HibernatePersonDAO.getMaximumSearchResults();
  if (length != null && length < maximumSearchResults) {
    criteria.setMaxResults(length);
  } else {
    if (log.isDebugEnabled()) {
      log.debug("Limiting the size of the number of matching patients to " + maximumSearchResults);
    }
    criteria.setMaxResults(maximumSearchResults);
  }
}

@Override
public ListPart<T> listPart(Long firstResult, Long maxResults) {
  criteria.setProjection(null);
  criteria.setResultTransformer(Criteria.ROOT_ENTITY);
  
  if (firstResult != null) {
    criteria.setFirstResult(firstResult.intValue());
  }
  
  if (maxResults != null) {
    criteria.setMaxResults(maxResults.intValue());
  }
  
  @SuppressWarnings("unchecked")
  List<T> list = criteria.list();
  
  return ListPart.newListPart(list, firstResult, maxResults, null, null);
}

/**
 * @see org.openmrs.hl7.db.HL7DAO#getHL7Batch(Class, int, int, Integer, String)
 */
@Override
@SuppressWarnings( { "rawtypes", "unchecked" })
public <T> List<T> getHL7Batch(Class clazz, int start, int length, Integer messageState, String query)
    throws DAOException {
  Criteria crit = getHL7SearchCriteria(clazz, messageState, query);
  crit.setFirstResult(start);
  crit.setMaxResults(length);
  crit.addOrder(Order.asc("dateCreated"));
  return crit.list();
}

public List<?> getListByCriteria(DetachedCriteria criteria, Integer startPage, Integer pageSize) {
  if (startPage != null && pageSize != null) {
    return criteria.getExecutableCriteria(getCurrentSession()).setProjection(null)
        .setResultTransformer(CriteriaSpecification.ROOT_ENTITY).setFirstResult(startPage).setMaxResults(pageSize).list();
  } else {
    return criteria.getExecutableCriteria(getCurrentSession()).setProjection(null)
        .setResultTransformer(CriteriaSpecification.ROOT_ENTITY).list();
  }
}

/**
 * @see org.openmrs.api.db.ProviderDAO#getProviders(String, Map, Integer, Integer, boolean)
 */
@Override
public List<Provider> getProviders(String name, Map<ProviderAttributeType, String> serializedAttributeValues,
    Integer start, Integer length, boolean includeRetired) {
  Criteria criteria = prepareProviderCriteria(name, includeRetired);
  if (start != null) {
    criteria.setFirstResult(start);
  }
  if (length != null) {
    criteria.setMaxResults(length);
  }
  
  if (includeRetired) {
    //push retired Provider to the end of the returned list
    criteria.addOrder(Order.asc("retired"));
  }
  
  List<Provider> providers = criteria.list();
  if (serializedAttributeValues != null) {
    CollectionUtils.filter(providers, new AttributeMatcherPredicate<Provider, ProviderAttributeType>(
        serializedAttributeValues));
  }
  return providers;
}

public <T> List<T> getListByCriteria(DetachedCriteria criteria, PageInfo page) {
  if (page == null) {
    return criteria.getExecutableCriteria(getCurrentSession()).setProjection(null)
        .setResultTransformer(CriteriaSpecification.ROOT_ENTITY).list();
  } else {
    return criteria.getExecutableCriteria(getCurrentSession()).setProjection(null)
        .setResultTransformer(CriteriaSpecification.ROOT_ENTITY).setFirstResult((page.getPageNum() - 1) * page.getPageSize())
        .setMaxResults(page.getPageSize()).list();
  }
}