Eloquent Relationships By Example
This episode is for members only

Sign up to access "Eloquent Relationships By Example" right now.

Get started
Already a member? Sign in to continue
Playing
19. Eager loading

Episodes

0%
Your progress
  • Total: 4h 18m
  • Played: 0m
  • Remaining: 4h 18m
Join or sign in to track your progress
01. Introduction
01. Installation, database and migration refresher
7m 28s
0%
02. One to one
02. Creating and accessing the relationship
12m 1s
0%
03. Creating an address
5m 47s
0%
04. Updating an address
1m 49s
0%
05. Deleting an address
1m 6s
0%
06. Scoping to get the most recent address
5m 42s
0%
07. Building a working example
24m 34s
0%
03. One to many
08. Defining one to many relationships
5m 25s
0%
09. Two ways to insert
5m 10s
0%
10. Accessing the relationship data
11m 53s
0%
11. Deleting records
8m 19s
0%
12. Updating records
2m 9s
0%
13. Adding modifiers directly to the relationship
4m 50s
0%
14. Creating a postable timeline app
19m 38s
0%
04. Belongs to
15. Defining a belongs to relationship
10m 34s
0%
16. Associating relations
6m 4s
0%
17. Switching up keys
4m 16s
0%
05. Eager loading
18. Debugging the issue
3m 59s
0%
19. Eager loading
4m 10s
0%
06. Many to many
20. Defining many to many relationships
13m 46s
0%
21. Attaching relations
8m 58s
0%
22. Detaching relations
1m 52s
0%
23. Attaching and detaching multiple relations
3m 58s
0%
24. Eager loading
2m 15s
0%
25. Defining the inverse of the relationship
7m 40s
0%
26. Intermediate table columns
7m 54s
0%
27. Filtering by intermediate columns
8m 16s
0%
28. Syncing relations
7m 19s
0%
07. Has many through
29. Defining and using has many through relationships
15m 43s
0%
08. Has one through
30. Using has one through relationships
15m 54s
0%
09. Has one of many
31. Setting up a practical example
5m 13s
0%
32. Defining and using a has one of many relationship
10m 6s
0%
33. Using aggregate functions
5m 5s
0%

Transcript

00:00
Now that we can see the problem, let's go ahead and implement the solution to bump this query count down to the minimum that we need for this to run. And throughout the course, we're going to be egoloading as we get into more advanced relationships.
00:13
So this is going to be very simple, but it's going to give you a good understanding of the problem, how to solve it. And then we can dive into some more advanced egoloading a little bit later. OK, so let's go over to our web routes where we're actually outputting this data just here. And we know that we're grabbing the posts, grabbing all posts and just passing them down.
00:33
What we want to do at the point that we get the posts is think to ourselves, what additional data does this post use? Well, we know that over on the post, we're actually accessing the user. This is the problem here. When we access this, even if we access it like a property that brings the model back, this is performing an additional query.
00:55
So what we want to do is upfront load all of the potential users for the posts that we are getting into one query and then go ahead and just use them. So this sounds a lot more complicated than it is. What we actually want to do, probably the first thing that we want to do here, doesn't matter which order you do this in, is we want to use the with method. And the with method allows you to define the relationships like user that you want to load up front, be kept in memory and then used as we iterate through these posts and access each of the users.
01:32
So we want to say, well, for every single post, we want to load in all the potential users or user in this case to go ahead and use them when we need them. So just with that very, very simple change, let's head over to here and see what's different. So I'm going to give this a refresh and you can now see we're down to two queries. Now, you might be thinking, well, surely this could be done in one query.
01:55
Well, the difference here is we now do not have an n plus one problem. If we were to add a new post to this, even with a completely different user, it would not go ahead and execute an additional query. What it would do is it would add this in where it's loading in all of the potential users that we have here, which are three users. And then behind the scenes, it's piecing these together with each of the posts with that data.
02:19
So for every single iteration, it's using data in memory rather than performing an additional SQL query. Let's just demonstrate that by going over to the database and creating out another user here. In fact, we could do that in Tinker. So let's say PHP Artisan and Tinker.
02:35
And let's go ahead and create just one more user. OK, so now that we have another user, let's go and assign another post to user ID of four. So let's go ahead and assign that and another one and save this out, head back over. And now we still have two queries, despite the fact we have an additional post and additional user.
02:58
All that's happened behind the scenes is this one query is now pulling in this user just in one query and again is attaching it. So we can go ahead and still output that data, but not perform an additional query. So for every project you build, I'd always recommend pulling in Laravel Debug Bar so you can see the query count that you've got. This will also tell you if you have any duplicate queries.
03:21
So, for example, let's just bring that back to the point where we were not eager loading. And get rid of this. And then let's go over and give that a refresh. And you can see here six of which were duplicated.
03:35
So you can click to show only the duplicated ones. And if all of these look very similar, you pretty much know you have an N plus one problem. So that could be really useful to pull this into every project. This is the most basic form of eager loading where we don't have any kind of advanced relationships.
03:52
We don't have any nested relationships or anything like that. But we will cover that in the rest of the course. But just doing that is going to increase the performance of your application, decrease the memory usage. And it's a really good habit to get into monitoring your queries so you can eager load that data in.

Episode summary

In this episode, we're tackling the classic N+1 query problem in Laravel by introducing eager loading. We start by identifying where our code is causing multiple unnecessary database queries, especially when loading related data (like fetching users for each post). Then, we implement the simple solution—using the with method to eager load the user relationship on our Post model.

You'll see how this little change drops our query count down dramatically (from multiple to just two!) no matter how many posts or users we add. We demonstrate this by adding extra users and posts, checking the query count with Laravel Debug Bar, and verifying that even with more data, we don't run into more queries.

We also show how to spot duplicated queries using the Debug Bar, so you can quickly see if you have any N+1 issues lurking. The episode wraps up by emphasizing that this basic form of eager loading will vastly improve your application's performance, and gives a teaser that we'll dive into more advanced scenarios (like nested relationships) later in the course.

Episode discussion

No comments, yet. Be the first!