Package org.javalite.activejdbc

Class LazyList<T extends Model>

    • Constructor Detail

      • 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.

      • 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)

      • 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 -