Sloth Framework - Orm

Retrieving Multiple Records AKA Collection

    $users = User::all();

Retrieving Multiple Records By Primary Key List

    $users = User::all([1, 2, 3]);

Retrieving Multiple Records By Conditions

    $users = User::all(['status = ?' => 1]);
    // or
    $users = User::all()->where('status = ?', 1);

Almost all sql Select method is visible in Collection: select, distinct, calcFoundRows, where, orWhere, having, orHaving, orderBy, groupBy, limit, offset, join, leftJoin, rightJoin,

Sql querying in Collection is Lazy, it mean there are no query is executed until you interacting with the collection data. So you could adding more query filter to the collection later.

    $users = User::all(); // no sql query executing here
    $users->where('status = ?', 1); // no sql query executing here too
    $users->toArray(); // That is! The query executed is: SELECT users.* FROM users WHERE (status = 1)

The Model Collection class is implemented of Countable, IteratorAggregate, JsonSerializable, ArrayAccess. So you could counting, iterate, encode as json or interacting it as array style.

    $users = User::all();

    // Counting
    count($users);

    // json encoding
    json_encode($users);

    // iterate
    foreach ($users as $user) {
        echo $user->name;
    }

    // interacting as array
    $user = $users[0];

Collection have 2 fallback method to model: save and delete and the model property setter.

    $users = User::all();

    // mass update models
    $users->status = 'active';
    $users->save();

    // mass delete models
    $users->delete();

Lazy Loading

Lazy Model support Lazy Loading. By default, the column types below considering as Lazy Loading:

Model::TEXT (text)
Model::MEDIUMTEXT (mediumtext)
Model::LONGTEXT (longtext)
Model::BLOB (blob)
Model::MEDIUMBLOB (mediumblob)
Model::LONGBLOB (longblob)

Feel free to custom you own lazy loading column by defining property $defaultLazyLoadColumnTypes or $defaultSelectColumns in your model definition.

    $posts = Posts::all([1, 2, 3]);

    foreach ($posts as $post) {
        echo $post->title;
    }

    /*
        The query executed is:
        SELECT posts.id, posts.creator_id, posts.title, posts.created_time, posts.modified_time
        FROM posts
        WHERE (id IN(1, 2, 3))
    */

As you see. The column content of posts table not selected yet. But when the first time you get the content property, it will select the content column related to the collection.

    foreach ($posts as $post) {
        echo $post->content;
    }

    /*
        The second query executed is:
        SELECT posts.id, posts.content FROM posts WHERE (id IN(1, 2, 3))
    */

Eager Loading

The Eager Loading existing to resolve the N + 1 query problem. For example, in the Defining Models, the Post model related to User model specified by Creator. See an example above, we retrieving the creator name of post collection:

    $posts = Posts::all();

    foreach ($posts as $post) {
        echo $post->Creator->name;
    }

Assume the posts table have 100 records.
Normally, you are guessing there are total 101 queries executed. 1 is for the posts list, and 100 queries for each post to retrieving the creator name.
Actually, there are just 2 queries executed:

    SELECT id, creator_id, title, created_time, modified_time FROM posts;
    SELECT id, name WHERE (id IN(/* the creator_id FROM post list*/))

Unlike some ORM libraries, they implemented Eager Loading by style look like this:

    $posts = Post::with('Creator');

    foreach ($posts as $post) {
        echo $post->Creator->name;
    }

Lazy ORM do this automatically. No need to call something like with('Creator')