package io.ebean;

import java.util.Iterator;

Used to provide iteration over query results.

This can be used when you want to process a very large number of results and
means that you don't have to hold all the results in memory at once (unlike
findList(), findSet() etc where all the beans are held in the List or Set
etc).


Note that findIterate (and findEach and findEachWhile) uses a "per graph"
persistence context scope and adjusts jdbc fetch buffer size for large
queries. As such it is better to use findList for small queries.

 Remember that with QueryIterator you must call close() when you have finished iterating the results. Use "try with resources" or ensure it is closed in a finally block. 
Try finally style

 Query<Customer> query = server.find(Customer.class)
    .where().gt("id", 0)
    .orderBy("id")
    .setMaxRows(2);
 QueryIterator<Customer> it = query.findIterate();
 try {
   while (it.hasNext()) {
     Customer customer = it.next();
     // do something with customer ...
   }
 } finally {
   // close the underlying resources
   it.close();
 }


Try with resources style

 // try with resources
 try (QueryIterator<Customer> it = query.findIterate()) {
   while (it.hasNext()) {
     Customer customer = it.next();
     // do something with customer ...
   }
 }

Type parameters:
<T> – the type of entity bean in the iteration/**
 * Used to provide iteration over query results.
 * <p>
 * This can be used when you want to process a very large number of results and
 * means that you don't have to hold all the results in memory at once (unlike
 * findList(), findSet() etc where all the beans are held in the List or Set
 * etc).
 * </p>
 * <p>
 * Note that findIterate (and findEach and findEachWhile) uses a "per graph"
 * persistence context scope and adjusts jdbc fetch buffer size for large
 * queries. As such it is better to use findList for small queries.
 * </p>
 * <p>
 * Remember that with {@link QueryIterator} you must call {@link QueryIterator#close()}
 * when you have finished iterating the results. Use "try with resources" or ensure it
 * is closed in a finally block.
 * </p>
 * <h3>Try finally style</h3>
 * <pre>{@code
 *
 *  Query<Customer> query = server.find(Customer.class)
 *     .where().gt("id", 0)
 *     .orderBy("id")
 *     .setMaxRows(2);
 *
 *  QueryIterator<Customer> it = query.findIterate();
 *  try {
 *    while (it.hasNext()) {
 *      Customer customer = it.next();
 *      // do something with customer ...
 *    }
 *  } finally {
 *    // close the underlying resources
 *    it.close();
 *  }
 *
 * }</pre>
 * <p>
 * <h3>Try with resources style</h3>
 * <pre>{@code
 *
 *  // try with resources
 *  try (QueryIterator<Customer> it = query.findIterate()) {
 *    while (it.hasNext()) {
 *      Customer customer = it.next();
 *      // do something with customer ...
 *    }
 *  }
 *
 * }</pre>
 *
 * @param <T> the type of entity bean in the iteration
 */
public interface QueryIterator<T> extends Iterator<T>, java.io.Closeable {

  
Returns true if the iteration has more elements.
/**
   * Returns <tt>true</tt> if the iteration has more elements.
   */
  @Override
  boolean hasNext();

  
Returns the next element in the iteration.
/**
   * Returns the next element in the iteration.
   */
  @Override
  T next();

  
Remove is not allowed.
/**
   * Remove is not allowed.
   */
  @Override
  void remove();

  
Close the underlying resources held by this iterator.
/**
   * Close the underlying resources held by this iterator.
   */
  @Override
  void close();
}