How to use

setMaxResults

method

in

org.hibernate.Criteria

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

public ServerBackup lastBackup() {
  List results = (List) getHibernateTemplate().execute((HibernateCallback) session -> {
    Criteria criteria = session.createCriteria(ServerBackup.class);
    criteria.setMaxResults(1);
    criteria.addOrder(Order.desc("id"));
    return criteria.list();
  });
  return results.isEmpty() ? null : (ServerBackup) results.get(0);
}

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

 Criteria c = session.createCriteria(Thingy.class);
c.addOrder(Order.desc("id"));
c.setMaxResults(1);
return (Thingy)c.uniqueResult();

@Override
public EndpointProfileSchema findLatestByAppId(String appId) {
 EndpointProfileSchema latestSchema = null;
 LOG.debug("Searching latest profile schema by application id [{}] ", appId);
 if (isNotBlank(appId)) {
  Criteria criteria = getCriteria().createAlias(APPLICATION_PROPERTY, APPLICATION_ALIAS)
    .add(Restrictions.eq(APPLICATION_REFERENCE, Long.valueOf(appId)))
    .addOrder(Order.desc(VERSION_PROPERTY)).setMaxResults(FIRST);
  latestSchema = findOneByCriteria(criteria);
 }
 if (LOG.isTraceEnabled()) {
  LOG.trace("[{}] Search result: {}.", appId, latestSchema);
 } else {
  LOG.debug("[{}] Search result: {}.", appId, latestSchema != null);
 }
 return latestSchema;
}

@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;
}

@Override
public ConfigurationSchema findLatestByApplicationId(String appId) {
 ConfigurationSchema latestSchema = null;
 LOG.debug("Searching latest configuration schema by application id [{}] ", appId);
 if (isNotBlank(appId)) {
  Criteria criteria = getCriteria().createAlias(APPLICATION_PROPERTY, APPLICATION_ALIAS)
    .add(Restrictions.eq(APPLICATION_REFERENCE, Long.valueOf(appId)))
    .addOrder(Order.desc(VERSION_PROPERTY))
    .setMaxResults(FIRST);
  latestSchema = findOneByCriteria(criteria);
 }
 if (LOG.isTraceEnabled()) {
  LOG.trace("[{}] Search result: {}.", appId, latestSchema);
 } else {
  LOG.debug("[{}] Search result: {}.", appId, latestSchema != null);
 }
 return latestSchema;
}

@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
 public NotificationSchema findLatestNotificationSchemaByAppId(
     String appId, NotificationTypeDto type) {
  LOG.debug("Searching latest notification schema by application id [{}] type [{}]", appId, type);
  NotificationSchema latestSchema = null;
  if (isNotBlank(appId)) {
   Criteria criteria = getCriteria().add(Restrictions.and(
     Restrictions.eq(APPLICATION_REFERENCE, Long.valueOf(appId)),
     Restrictions.eq(NOTIFICATION_SCHEMA_TYPE_PROPERTY, type)
   )).addOrder(Order.desc(VERSION_PROPERTY)).setMaxResults(FIRST);
   latestSchema = findOneByCriteria(criteria);
  }
  if (LOG.isTraceEnabled()) {
   LOG.trace("[{},{}] Search result: {}.", appId, type, latestSchema);
  } else {
   LOG.debug("[{},{}] Search result: {}.", appId, type, latestSchema != null);
  }
  return latestSchema;
 }
}

@Override
public CtlSchema findLatestByMetaInfoId(String metaInfoId) {
 CtlSchema latestSchema = null;
 LOG.debug("Searching latest version of ctl schema by meta info id [{}]",
   metaInfoId);
 if (isNotBlank(metaInfoId)) {
  Criteria criteria = getCriteria()
    .createAlias(CTL_SCHEMA_META_INFO_PROPERTY, CTL_SCHEMA_META_INFO_ALIAS)
    .add(Restrictions.eq(CTL_SCHEMA_META_INFO_ALIAS_ID, Long.valueOf(metaInfoId)))
    .addOrder(Order.desc(CTL_SCHEMA_VERSION))
    .setMaxResults(FIRST);
  latestSchema = findOneByCriteria(criteria);
 }
 if (LOG.isTraceEnabled()) {
  LOG.trace("[{}] Search result: [{}].", metaInfoId, latestSchema);
 } else {
  LOG.debug("[{}] Search result: [{}].", metaInfoId, latestSchema != null);
 }
 return latestSchema;
}

@Override
public ServerProfileSchema findLatestByAppId(String appId) {
 ServerProfileSchema latestSchema = null;
 LOG.debug("Searching latest server profile schema by application id [{}] ", appId);
 if (isNotBlank(appId)) {
  Criteria criteria = getCriteria().createAlias(APPLICATION_PROPERTY, APPLICATION_ALIAS)
    .add(Restrictions.eq(APPLICATION_REFERENCE, getLongId(appId)))
    .addOrder(Order.desc(VERSION_PROPERTY)).setMaxResults(FIRST);
  latestSchema = findOneByCriteria(criteria);
 }
 if (LOG.isTraceEnabled()) {
  LOG.trace("[{}] Search result: {}.", appId, latestSchema);
 } else {
  LOG.debug("[{}] Search result: {}.", appId, latestSchema != null);
 }
 return latestSchema;
}

@Override
public Configuration findLatestDeprecated(String schemaId, String groupId) {
 Configuration configuration = null;
 LOG.debug("Searching latest deprecated configurations by configuration schema id [{}] "
     + "and group id [{}] ",
   schemaId, groupId);
 if (isNotBlank(schemaId) && isNotBlank(groupId)) {
  Criteria criteria = getCriteria();
  criteria.createAlias(CONFIGURATION_SCHEMA_PROPERTY, CONFIGURATION_SCHEMA_ALIAS);
  criteria.createAlias(ENDPOINT_GROUP_PROPERTY, ENDPOINT_GROUP_ALIAS);
  criteria.add(Restrictions.and(
    Restrictions.eq(ENDPOINT_GROUP_REFERENCE, Long.valueOf(groupId)),
    Restrictions.eq(CONFIGURATION_SCHEMA_REFERENCE, Long.valueOf(schemaId)),
    Restrictions.eq(STATUS_PROPERTY, UpdateStatus.DEPRECATED)));
  criteria.addOrder(Order.desc(SEQUENCE_NUMBER_PROPERTY)).setMaxResults(FIRST);
  configuration = findOneByCriteria(criteria);
 }
 if (LOG.isTraceEnabled()) {
  LOG.trace("[{},{}] Search result: {}.", schemaId, groupId, configuration);
 } else {
  LOG.debug("[{},{}] Search result: {}.", schemaId, groupId, configuration != null);
 }
 return configuration;
}

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

  Restrictions.eq(STATUS_PROPERTY, UpdateStatus.DEPRECATED));
filter = (ProfileFilter) criteria.add(crit).addOrder(Order.desc(SEQUENCE_NUMBER_PROPERTY))
    .setMaxResults(FIRST).uniqueResult();

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

/**
 * Prepare the given Criteria object, applying cache settings and/or
 * a transaction timeout.
 * @param criteria the Criteria object to prepare
 * @see #setCacheQueries
 * @see #setQueryCacheRegion
 */
protected void prepareCriteria(Criteria criteria) {
  if (isCacheQueries()) {
    criteria.setCacheable(true);
    if (getQueryCacheRegion() != null) {
      criteria.setCacheRegion(getQueryCacheRegion());
    }
  }
  if (getFetchSize() > 0) {
    criteria.setFetchSize(getFetchSize());
  }
  if (getMaxResults() > 0) {
    criteria.setMaxResults(getMaxResults());
  }
  ResourceHolderSupport sessionHolder =
      (ResourceHolderSupport) TransactionSynchronizationManager.getResource(obtainSessionFactory());
  if (sessionHolder != null && sessionHolder.hasTimeout()) {
    criteria.setTimeout(sessionHolder.getTimeToLiveInSeconds());
  }
}

.setMaxResults(3)
.setReadOnly( true )
.list();

/**
 * Prepare the given Criteria object, applying cache settings and/or
 * a transaction timeout.
 * @param criteria the Criteria object to prepare
 * @see #setCacheQueries
 * @see #setQueryCacheRegion
 */
protected void prepareCriteria(Criteria criteria) {
  if (isCacheQueries()) {
    criteria.setCacheable(true);
    if (getQueryCacheRegion() != null) {
      criteria.setCacheRegion(getQueryCacheRegion());
    }
  }
  if (getFetchSize() > 0) {
    criteria.setFetchSize(getFetchSize());
  }
  if (getMaxResults() > 0) {
    criteria.setMaxResults(getMaxResults());
  }
  ResourceHolderSupport sessionHolder =
      (ResourceHolderSupport) TransactionSynchronizationManager.getResource(obtainSessionFactory());
  if (sessionHolder != null && sessionHolder.hasTimeout()) {
    criteria.setTimeout(sessionHolder.getTimeToLiveInSeconds());
  }
}

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