Chapter 1: Eloquent Model Relationships

In Laravel, Eloquent model relationships are crucial for effectively managing data. For instance, consider the relationship between the Factory and Worker models, which reflects a one-to-many relationship.

When we initiate a request in the controller, such as:

public function index()

{

$factories = Factory::query()->find(1);

}

At this point, a single SQL query is executed:

select * from factories where factories.`id` = '1'

However, if we want to retrieve workers associated with the factory where id=1, we would write:

public function index()

{

$factories = Factory::query()->find(1);

$factories->workers;

}

This results in two SQL queries being executed:

select * from factories where factories.`id` = '1'

select * from workers where workers.`factory_id` = '1'

An additional query is generated because Eloquent only queries the Factory model and does not preload the associated Worker data, which can lead to inefficiencies.

To optimize this, we can tell Eloquent in advance to use the with() method to load related models, avoiding the N+1 query problem. For example, if we need to access all workers in multiple factories, we would write:

public function index()

{

$factories = Factory::query()->get();

foreach($factories as $factory)

{

$factory->workers;

}

}

This would generate numerous SQL queries, leading to N+1 issues:

select * from workers where workers.`factory_id` = '1'

select * from workers where workers.`factory_id` = '2'

...

select * from workers where workers.`factory_id` = '10'

In total, this results in 11 SQL queries.

To illustrate this concept, consider the analogy of a factory closing at 5:00 p.m. When workers are unexpectedly called back to work at night, they have to get out of bed, dress, and return to the assembly line—this scenario exemplifies "lazy loading".

While lazy loading is efficient for individual queries, it can become problematic with collections. To avoid N+1 issues, we should utilize eager loading with with(). For example:

public function index()

{

$factories = Factory::query()->with('workers')->get();

foreach($factories as $factory)

{

$factory->workers;

}

}

This approach results in just two SQL queries:

select * from factories

select * from workers where workers.`factory_id` in (1, 2, 3, ..., 10)

This scenario mirrors preloading, where all worker data is ready and waiting when needed.

In summary, while lazy loading and eager loading can yield similar results for single model queries, they differ significantly when handling collections. It's essential to leverage eager loading to prevent N+1 problems.

Chapter 2: The Role of load()

To further clarify, consider the load() method. This method cannot be used directly on an Eloquent query builder. Instead, it is employed after retrieving a model instance. For instance:

public function index()

{

$factory = Factory::query()->find(1);

$factory->load('workers');

}

At this point, the executed SQL commands are:

select * from factories where factories.`id` = '1' limit 1

select * from workers where workers.`factory_id` in (1)

This is similar to using with() during the initial query:

public function index()

{

$factory = Factory::query()->with('workers')->find(1);

}

The load() method is particularly useful in scenarios where you want to inject dependencies while still loading associated models:

public function index(Factory $factory)

{

return $factory->load('workers');

}

To conclude, understanding the distinctions between lazy loading, eager loading, and the use of load() is essential for efficient data management in Laravel.

Thanks for your attention! I look forward to sharing more insightful articles in the future.

This video discusses preloading strategies for lazy loading modules, providing insights into their implementation in Angular.

Explore the concepts of eager loading, lazy loading, and pre-loading in Angular, enhancing your understanding of model relationships.