Package org.javalite.activejdbc

Class LazyList<T extends Model>

java.lang.Object
org.javalite.activejdbc.AbstractLazyList<T>
org.javalite.activejdbc.LazyList<T>
All Implemented Interfaces:
Externalizable, Serializable, Iterable<T>, Collection<T>, List<T>, RandomAccess
Direct Known Subclasses:
SuperLazyList
public class LazyList<T extends Model> extends AbstractLazyList<T> implements Externalizable
While this class is public, it is never instantiated directly. This class provides a number of APIs for augmenting the query.
Author:
Igor Polevoy, Eric Nielsen
See Also:
Serialized Form

  • Constructor Details

    • LazyList

      protected LazyList​(String subQuery, MetaModel metaModel, Object... params)

    • LazyList

      protected LazyList​(boolean forPaginator, MetaModel metaModel, String fullQuery, Object... params)
      Parameters:
      metaModel -
      fullQuery -
      forPaginator - true is this list should not check usage of limit() and offset() methods.
      params -

    • LazyList

      protected LazyList()
      This is only used by SuperLazyList

  • Method Details

    • limit

      public <E extends Model> LazyList<E> limit​(long limit)
      This method limits the number of results in the resultset. It can be used in combination with the offset like this: List<Event> events = Event.find("mnemonic = ?", "GLUC").offset(101).limit(20).orderBy("history_event_id"); This will produce 20 records, starting from record 101. This is an efficient method, it will only retrieve records that are necessary.
      Parameters:
      limit - how many records to retrieve.
      Returns:
      instance of this LazyList

    • offset

      public <E extends Model> LazyList<E> offset​(long offset)
      This method sets an offset of a resultset. For instance, if the offset is 101, then the resultset will skip the first 100 records. It can be used in combination wit the limit like this: List events = Event.find("mnemonic = ?", "GLUC").offset(101).limit(20).orderBy("history_event_id"); This will produce 20 records, starting from record 101. This is an efficient method, it will only retrieve records that are necessary.
      Parameters:
      offset -
      Returns:
      instance of this LazyList

    • orderBy

      public <E extends Model> LazyList<E> orderBy​(String orderBy)
      Use this method to order results by a column. These methods can be chained: Person.find(...).orderBy("department").orderBy("age")
      Parameters:
      orderBy - order by clause. Examples: "department", "age desc", etc.
      Returns:
      instance of this LazyList

    • include

      public <E extends Model> LazyList<E> include​(Class<? extends Model>... classes)
      This method includes associated objects. It will eagerly load associated models of models selected by the query. For instance, if there are models Author, Post and Comment, where Author has many Posts and Post has many Comments, then this query: 
       List todayPosts = Post.where("post_date = ?", today).include(Author.class, Comment.class);
      or: 
       List todayPosts = Post.where("post_date = ?", today).include(Author.class).include(Comment.class);
      will generate only three queries to database - one per model. All the dependencies (includes) will be eagerly loaded, and iteration via the todayPosts list will not generate any more queries, even when a post author and comments are requested. Use this with caution as this method can allocate a lot of memory (obviously).

      This method will not follow relationships of related models, but rather only relationships of the current one.
      Parameters:
      classes - list of dependent classes. These classes represent models with which a current model has a relationship.
      Returns:
      instance of this LazyList

    • toMaps

      public List<Map<String,​Object>> toMaps()
      Converts the resultset to list of maps, where each map represents a row in the resultset keyed off column names.
      Returns:
      list of maps, where each map represents a row in the resultset keyed off column names.

    • toXml

      public String toXml​(boolean pretty, boolean declaration, String... attrs)
      Generates a XML document from content of this list.
      Parameters:
      pretty - pretty format (human readable), or one line text.
      declaration - true to include XML declaration at the top
      attrs - list of attributes to include. No arguments == include all attributes.
      Returns:
      generated XML.

    • toJson

      public String toJson​(boolean pretty, String... attrs)
      Generates JSON from content of this list
      Parameters:
      pretty - true if you want pretty format, false if not
      attrs - attributes to include, not providing any will include all.
      Returns:
      generated JSON

    • load

      public <E extends Model> LazyList<E> load()
      This method exists to force immediate load from DB. Example; Person.find("name = ?", "Smith").load();. It is not possible to call other methods after load(). The load() method should be the last to be called in the chain: Person.find("name = ?", "Smith").limit(10).load();. This: will generate exception: Person.find("name = ?", "Smith").load().limit();.
      Returns:
      fully loaded list.

    • toSql

      public String toSql()
      Same as toSql(true), see toSql(boolean);
      Returns:
      SQL in a dialect for current connection which will be used if you start querying this list.

    • toSql

      public String toSql​(boolean showParameters)
      Use to see what SQL will be sent to the database.
      Parameters:
      showParameters - true to see parameter values, false not to.
      Returns:
      SQL in a dialect for current connection which will be used if you start querying this list.

    • hydrate

      protected void hydrate()
      Specified by:
      hydrate in class AbstractLazyList<T extends Model>

    • collect

      public List collect​(String attributeName)
      Collects values from a result set that correspond to a attribute name. For example, if a list contains collection of Person models, then you can collect first names like this: 
       List firstNames = Person.findAll().collect("first_name");
      provided that the corresponding table has a column first_name.

      Keep in mind, that if all you need is a one column data, this method of getting it is not the most efficient (because since you are using a model, you will query all columns from a table, but will use only one). In these cases, you might want to consider Base.firstColumn(String, Object...) and DB.firstColumn(String, Object...).

      Parameters:
      attributeName - name of attribute to collect.
      Returns:
      list of collected values for a column.

    • collectDistinct

      public Set collectDistinct​(String attributeName)

    • collect

      public List collect​(String attributeName, String filterAttribute, Object filterValue)

    • collectDistinct

      public Set collectDistinct​(String attributeName, String filterAttribute, Object filterValue)

    • dump

      public void dump()
      Dumps contents of this list to System.out.

    • dump

      public void dump​(OutputStream out)
      Dumps content of list to a stream. Use for debugging.
      Parameters:
      out -

    • writeExternal

      public void writeExternal​(ObjectOutput out) throws IOException
      Specified by:
      writeExternal in interface Externalizable
      Throws:
      IOException

    • readExternal

      public void readExternal​(ObjectInput in) throws IOException, ClassNotFoundException
      Specified by:
      readExternal in interface Externalizable
      Throws:
      IOException
      ClassNotFoundException