ORM Concepts in PHP 🗃️

<?php
// ACTIVE RECORD: the model class IS the table, and each object IS one row.
// The model knows how to save and find itself — data and persistence live together.
// A real ORM talks to a database via PDO; here an in-memory array stands in for
// the table so the whole CRUD lifecycle runs anywhere without a database.

abstract class Model
{
    protected static array $rows = [];   // the "table": id => attributes
    protected static int $nextId = 1;    // auto-increment primary key

    public function __construct(protected array $attributes = []) {}

    // CREATE: insert a new row and hand back a hydrated object.
    public static function create(array $attrs): static
    {
        $attrs["id"] = static::$nextId++;        // assign the next id
        static::$rows[$attrs["id"]] = $attrs;    // "INSERT" into the table
        return new static($attrs);               // return the saved object
    }

    // READ one: fetch a single row by primary key, or null if missing.
    public static function find(int $id): ?static
    {
        return isset(static::$rows[$id]) ? new static(static::$rows[$id]) : null;
    }

    // READ many: a mini "WHERE field = value" filter.
    /** @return static[] */
    public static function where(string $field, mixed $value): array
    {
        $hits = array_filter(static::$rows, fn($r) => ($r[$field] ?? null) === $value);
        return array_map(fn($r) => new static($r), $hits);
    }

    public function get(string $field): mixed { return $this->attributes[$field] ?? null; }

    public function set(string $field, mixed $value): static
    {
        $this->attributes[$field] = $value;
        return $this;                            // return $this so calls can chain
    }

    // UPDATE: write the current object's attributes back to the table.
    public function save(): static
    {
        static::$rows[$this->attributes["id"]] = $this->attributes;
        return $this;
    }
}

final class User extends Model
{
    // Each model needs its OWN storage, so re-declare these in the subclass.
    protected static array $rows = [];
    protected static int $nextId = 1;
}

// CREATE three users — create() inserts and returns the object.
User::create(["name" => "Alice", "role" => "admin"]);
User::create(["name" => "Bob",   "role" => "user"]);
User::create(["name" => "Carol", "role" => "user"]);

// READ one by id.
$bob = User::find(2);
echo "find(2) -> " . $bob->get("name") . "\n";   // find(2) -> Bob

// READ many with a filter.
$users = User::where("role", "user");
$names = array_map(fn($u) => $u->get("name"), $users);
echo "role=user -> " . implode(", ", $names) . "\n"; // role=user -> Bob, Carol

// UPDATE: change an attribute, then save() writes it back.
$bob->set("name", "Bobby")->save();
echo "after save -> " . User::find(2)->get("name") . "\n"; // after save -> Bobby
?>

find(2) -> Bob
role=user -> Bob, Carol
after save -> Bobby

<?php
// TWO PATTERNS for mapping objects to rows.

// 1) ACTIVE RECORD (Eloquent style): the model saves itself.
//    Domain logic + database logic live in ONE class.
class ArArticle
{
    public function __construct(public string $title, public int $id = 0) {}
    public function save(): void
    {
        // Pretend SQL: the object writes itself to the DB.
        echo "AR: INSERT INTO articles (title) VALUES ('{$this->title}')\n";
    }
}

$a = new ArArticle("Hello");
$a->save();                 // the object knows how to persist itself

// 2) DATA MAPPER (Doctrine style): a SEPARATE mapper persists a plain object.
//    The Article is a pure "entity" — it has no idea a database exists.
class Article            // a clean domain entity, no DB code at all
{
    public function __construct(public string $title, public int $id = 0) {}
}

class ArticleMapper      // the mapper is the ONLY thing that knows SQL
{
    public function insert(Article $article): void
    {
        echo "DM: INSERT INTO articles (title) VALUES ('{$article->title}')\n";
    }
}

$entity = new Article("Hello");      // entity stays clean...
(new ArticleMapper())->insert($entity); // ...mapper does the persistence
?>

AR: INSERT INTO articles (title) VALUES ('Hello')
DM: INSERT INTO articles (title) VALUES ('Hello')

<?php
// RELATIONSHIPS connect tables: one User hasMany Posts; each Post belongsTo a User.
// This example shows WHY eager loading matters — watch the query count.

$users = [1 => "Alice", 2 => "Bob"];
$posts = [                                  // post => owner's user_id
    "Post A" => 1, "Post B" => 1, "Post C" => 2,
];
$queries = 0;                               // count "database trips"

// --- LAZY LOADING (the N+1 trap) ---
// You load N users (1 query), then load each user's posts ON DEMAND inside the
// loop. N users => N more queries => N + 1 total. With 100 users that's 101 trips.
$queries++;                                 // 1 query: SELECT * FROM users
foreach ($users as $id => $name) {
    $queries++;                             // +1 query PER user (the "N")
    $owned = array_keys(array_filter($posts, fn($uid) => $uid === $id));
    echo "$name lazily loaded: " . implode(", ", $owned) . "\n";
}
echo "Lazy total queries: $queries\n\n"; // Lazy total queries: 3

// --- EAGER LOADING (the fix) ---
// Load the users AND all their posts up front in just 2 queries, no matter how
// many users there are. Eloquent spells this User::with('posts')->get().
$queries = 0;
$queries++;                                 // 1 query: SELECT * FROM users
$queries++;                                 // 1 query: SELECT * FROM posts WHERE user_id IN (...)
foreach ($users as $id => $name) {
    $owned = array_keys(array_filter($posts, fn($uid) => $uid === $id));
    echo "$name eagerly loaded: " . implode(", ", $owned) . "\n";
}
echo "Eager total queries: $queries\n";   // Eager total queries: 2
?>

Alice lazily loaded: Post A, Post B
Bob lazily loaded: Post C
Lazy total queries: 3

Alice eagerly loaded: Post A, Post B
Bob eagerly loaded: Post C
Eager total queries: 2

<?php
// MIGRATION (Laravel): schema lives in code, runs with "php artisan migrate".
Schema::create('users', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->string('email')->unique();
    $table->timestamps();
});

// ELOQUENT (Active Record): the model declares its relationships.
class User extends Model {
    public function posts() { return $this->hasMany(Post::class); }
}
$user = User::create(['name' => 'Alice']);   // INSERT
$all  = User::with('posts')->get();          // eager-load to avoid N+1
echo $user->posts->count();                  // walk the relationship

// DOCTRINE (Data Mapper): a clean entity + the EntityManager persists it.
#[Entity]
class Product {
    #[Id, GeneratedValue, Column]            public int $id;
    #[Column(type: 'string')]                public string $name;
}
$product = new Product();
$product->name = 'Mouse';
$em->persist($product);   // stage the entity...
$em->flush();             // ...then write all staged changes in one go
?>

<?php
// 🎯 YOUR TURN — finish this Active Record model, then run it.
// Two blanks marked ___ . Use the 👉 hints.

abstract class Model
{
    protected static array $rows = [];
    protected static int $nextId = 1;

    public function __construct(protected array $attributes = []) {}

    public static function create(array $attrs): static
    {
        $attrs["id"] = static::$nextId++;
        static::$rows[$attrs["id"]] = $attrs;
        return new static($attrs);
    }

    // 1) find() should look up a row by its id.
    public static function find(int $id): ?static
    {
        // 👉 return a new static(...) built from static::$rows[$id]
        //    if it exists, otherwise return null.
        return isset(static::$rows[$id]) ? new static(___) : null;
    }

    public function get(string $field): mixed { return $this->attributes[$field] ?? null; }
}

final class Product extends Model
{
    protected static array $rows = [];
    protected static int $nextId = 1;
}

Product::create(["name" => "Keyboard", "price" => 45]);
Product::create(["name" => "Mouse",    "price" => 20]);

$p = Product::find(2);                       // grab the second product
echo $p->get("name") . " costs $" . ___ . "\n"; // 👉 get the "price" field

// ✅ Expected output:
//    Mouse costs $20
?>

Mouse costs $20

<?php
// 🎯 YOUR TURN — avoid the N+1 problem by counting queries correctly.
// Fill in the two ___ blanks so the eager strategy uses exactly 2 queries.

$users   = [1 => "Alice", 2 => "Bob", 3 => "Carol"];
$queries = 0;

// Eager loading: grab the users in ONE query, then ALL their posts in ONE more —
// regardless of how many users there are.
$queries += ___;   // 👉 one query to SELECT the users
$queries += ___;   // 👉 one query to SELECT every post for those users (IN clause)

foreach ($users as $name) {
    echo "Loaded $name (no extra query)\n";
}
echo "Total queries: $queries\n";

// ✅ Expected output:
//    Loaded Alice (no extra query)
//    Loaded Bob (no extra query)
//    Loaded Carol (no extra query)
//    Total queries: 2
?>

Loaded Alice (no extra query)
Loaded Bob (no extra query)
Loaded Carol (no extra query)
Total queries: 2