How to use

scroll

method

in

org.hibernate.Criteria

@Test
public void testScrollCriteria() {
  Session session = openSession();
  Transaction t = session.beginTransaction();
  Course course = new Course();
  course.setCourseCode("HIB");
  course.setDescription("Hibernate Training");
  session.persist(course);
  session.flush();
  session.clear();
  ScrollableResults sr = session.createCriteria(Course.class).setReadOnly( true ).scroll();
  assertTrue( sr.next() );
  course = (Course) sr.get(0);
  assertNotNull(course);
  assertTrue( session.isReadOnly( course ) );
  sr.close();
  session.delete(course);
  t.commit();
  session.close();
}

@Override
public ScrollableResults scroll(Criteria criteria) {
 return criteria.scroll();
}

@Override
public ScrollableResults scroll(Criteria criteria, ScrollMode scrollMode) {
 return criteria.scroll(scrollMode);
}

@Override
public ScrollableResults scroll(final ScrollMode scrollMode) throws HibernateException {
 return criteria.scroll();
}

@Override
public ScrollableResults scroll() throws HibernateException {
 return criteria.scroll();
}

@Override
public ScrollableResults scroll(ScrollMode scrollMode) throws HibernateException {
 return backingCriteria.scroll(scrollMode);
}

@Override
public ScrollableResults scroll() throws HibernateException {
 return backingCriteria.scroll();
}

ScrollableResults results = session.createCriteria(type).setFetchSize(1000).scroll(ScrollMode.FORWARD_ONLY);
int index = 0;
while (results.next()) {

public static <T> ScrollableIterable<T> fromCriteria(Criteria c) {
  return new ScrollableIterable<>(c.scroll());
}

public static <T> ScrollableIterable<T> fromCriteria(Criteria c) {
  return new ScrollableIterable<>(c.scroll());
}

 Criteria criteria = getCurrentSession().createCriteria(LargeVolumeEntity.class);
criteria.add(Restrictions.eq("archived", Boolean.FALSE));
criteria.setReadOnly(true);
criteria.setCacheable(false);
List<E> result = new IterableListScrollableResults<E>(getCurrentSession(),
    criteria.scroll(ScrollMode.FORWARD_ONLY));
for(E entity : result) {
  dumpEntity(file, entity);
}

 Criteria criteria = getCurrentSession().createCriteria(LargeVolumeEntity.class);
criteria.add(Restrictions.eq("archived", Boolean.FALSE));
criteria.setReadOnly(true);
criteria.setCacheable(false);
List<E> result = new IterableListScrollableResults<E>(getCurrentSession(),
    criteria.scroll(ScrollMode.FORWARD_ONLY));
for(E entity : result) {
  dumpEntity(file, entity);
}

/**
 * Construct a new HibernateQueryPager.
 * 
 * @param criteria The Hibernate criteria.
 */
public HibernateCriteriaPager(final Criteria criteria) {
 this.criteria = criteria;
 final ScrollableResults scrollableResults = criteria.scroll();
 scrollableResults.last();
 this.numResults = scrollableResults.getRowNumber() + 1;
}

@Override
public ScrollableResults scroll(DetachedCriteria dc) {
 return dc.getExecutableCriteria(getSession()).scroll();
}

@Override
public ScrollableResults scroll(DetachedCriteria dc, ScrollMode scrollMode) {
 return dc.getExecutableCriteria(getSession()).scroll(scrollMode);
}

protected void deleteOldValues(String id, Session session) {
  Criteria criteria = session.createCriteria(getHibernateEntityClass());
  criteria.createCriteria(I18nEntity.PROPERTY_ENTITY)
      .add(Restrictions.eq(DescribableEntity.IDENTIFIER, id));
  ScrollableResults scroll = null;
  try {
    scroll = criteria.scroll();
    while (scroll.next()) {
      @SuppressWarnings("unchecked")
      H h18n = (H) scroll.get()[0];
      session.delete(h18n);
    }
  } finally {
    if (scroll != null) {
      scroll.close();
    }
  }
  session.flush();
}

protected void deleteOldValues(String id, Session session) {
  Criteria criteria = session.createCriteria(getHibernateEntityClass());
  criteria.createCriteria(I18nEntity.PROPERTY_ENTITY)
      .add(Restrictions.eq(DescribableEntity.IDENTIFIER, id));
  ScrollableResults scroll = null;
  try {
    scroll = criteria.scroll();
    while (scroll.next()) {
      @SuppressWarnings("unchecked")
      H h18n = (H) scroll.get()[0];
      session.delete(h18n);
    }
  } finally {
    if (scroll != null) {
      scroll.close();
    }
  }
  session.flush();
}

 Criteria criteria = ...;
ScrollableResults scroll = criteria.scroll();
Object[] firstRow = scroll.get();  // or use other methods for getting the data
scroll.last();
Object[] lastRow = scroll.get();

final Criteria criteria = session.createCriteria(clazz);  
     List<Criterion> restrictions = factory.assemble(command.getFilter());
     for (Criterion restriction : restrictions)
       criteria.add(restriction);
     criteria.add(Restrictions.conjunction());
     if(this.projections != null)
       criteria.setProjection(factory.loadProjections(this.projections));
     criteria.addOrder(command.getDir().equals("ASC")?Order.asc(command.getSort()):Order.desc(command.getSort()));
     ScrollableResults scrollable = criteria.scroll(ScrollMode.SCROLL_INSENSITIVE);
     if(scrollable.last()){//returns true if there is a resultset
       genericDTO.setTotalCount(scrollable.getRowNumber() + 1);
       criteria.setFirstResult(command.getStart())
           .setMaxResults(command.getLimit());
       genericDTO.setLineItems(Collections.unmodifiableList(criteria.list()));
     }
     scrollable.close();
     return genericDTO;

@Override
public Flowable<K> publishKeys(Predicate<? super K> filter) {
 return Flowable.using(() -> {
   EntityManager emStream = emf.createEntityManager();
   Session session = emStream.unwrap(Session.class);
   Criteria criteria = session.createCriteria(configuration.entityClass()).setProjection(Projections.id()).setReadOnly(true);
   if (setFetchSizeMinInteger) {
    criteria.setFetchSize(Integer.MIN_VALUE);
   }
   ScrollableResults results = criteria.scroll(ScrollMode.FORWARD_ONLY);
   return new KeyValuePair<>(emStream, results);
 }, kvp -> {
   ScrollableResults results = kvp.getValue();
   return Flowable.fromIterable(() -> new ScrollableResultsIterator(results, filter)
   );
 }, kvp -> {
   try {
    kvp.getValue().close();
   } finally {
    kvp.getKey().close();
   }
 });
}