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

Field Summary

Fields inherited from class org.javalite.activejdbc.AbstractLazyList

delegate

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	LazyList() This is only used by SuperLazyList
protected	LazyList(boolean forPaginator, MetaModel metaModel, String fullQuery, Object... params)
protected	LazyList(String subQuery, MetaModel metaModel, Object... params)

Method Summary

Modifier and Type	Method and Description
List	collect(String attributeName) Collects values from a result set that correspond to a attribute name.
List	collect(String attributeName, String filterAttribute, Object filterValue)
Set	collectDistinct(String attributeName)
Set	collectDistinct(String attributeName, String filterAttribute, Object filterValue)
void	dump() Dumps contents of this list to System.out.
void	dump(OutputStream out) Dumps content of list to a stream.
protected void	hydrate()
<E extends Model> LazyList<E>	include(Class<? extends Model>... classes) This method includes associated objects.
<E extends Model> LazyList<E>	limit(long limit) This method limits the number of results in the resultset.
<E extends Model> LazyList<E>	load() This method exists to force immediate load from DB.
<E extends Model> LazyList<E>	offset(long offset) This method sets an offset of a resultset.
<E extends Model> LazyList<E>	orderBy(String orderBy) Use this method to order results by a column.
void	readExternal(ObjectInput in)
String	toJson(boolean pretty, String... attrs) Generates JSON from content of this list
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.
String	toSql() Same as toSql(true), see toSql(boolean);
String	toSql(boolean showParameters) Use to see what SQL will be sent to the database.
String	toXml(boolean pretty, boolean declaration, String... attrs) Generates a XML document from content of this list.
void	writeExternal(ObjectOutput out)

Methods inherited from class org.javalite.activejdbc.AbstractLazyList

add, add, addAll, addAll, clear, contains, containsAll, equals, get, hashCode, indexOf, isEmpty, iterator, lastIndexOf, listIterator, listIterator, remove, remove, removeAll, retainAll, set, size, subList, toArray, toArray, toString

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.List

replaceAll, sort, spliterator

Methods inherited from interface java.util.Collection

parallelStream, removeIf, stream

Methods inherited from interface java.lang.Iterable

forEach

Constructor Detail

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 Detail

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