Laravel Performance
This episode is for members only

Sign up to access "Laravel Performance" right now.

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

Episodes

0%
Your progress
  • Total: 1h 9m
  • Played: 0m
  • Remaining: 1h 9m
Join or sign in to track your progress

Transcript

00:00
In the majority of apps that you build, you're going to be iterating over data and that data is going to have relationships. In our case, we have lots of posts on the home page here, probably way too many, and we have a user as part of that as well. So what we're doing is for every
00:17
single post on this page, we are querying the database to grab that user information. And you can see that over on the queries tab here. For every single post, we're selecting everything from a user's table. And the where clause here is where the ID equals the user that we're currently iterating through. So a query for every single iteration of this is not good.
00:40
First of all, we have a huge amount of milliseconds here for our database queries. We also have multiple database queries, which is going to slow things down because we have to make multiple requests to our database. And we also have a high memory usage as well, just because we're pulling in a huge amount of data and making all of these requests in a single page request.
01:01
So how do we solve this? Well, this really depends on how your data and relationships are set up. Let's just go over to the post model just to remind ourselves that we have a belongs to relationship on this user. So each of these posts has a user. If we head over to the user as well, a user has many posts. So what we can do is start to egoload this information in.
01:23
There's a load of information about this on the Laravel docs, but this will give you a really good head start. And most of the time, egoloading is very, very straightforward. Sometimes it can get a little bit more complicated depending on the kinds of relationships you're setting up. So let's just remind ourselves one more time, we have one query for every single user for every
01:42
single post. To solve this, what we can do very, very easily is use the with method on any model that we are pulling in. Now, there are a couple of ways that we can egoload in relationships. We can pass this into an array or we can just pass this in as a list of string values. So really, for a post, the only thing we want to egoload in is a user. So let's go over and have a look at
02:08
the difference this has made. And more importantly, have a look at the query and how this has changed. So what you'll notice now is Laravel, or Eloquent more appropriately behind the scenes, is performing one query to put in all of the possible users for each of these posts. So before, what we were doing is we were pulling in or querying a hundred times for user one, a hundred
02:33
times for user two and so on for all of these users. Now what we're doing is behind the scenes in Laravel, it's saying, well, we have five users for all of these posts. Let's just perform one query, pull all of that data in and then sort of bind it together so we can access it within each of these items within this collection. So that has reduced our query countdown from hundreds just to
02:57
two. We have one to pull in the posts and one to pull in any related data. Now, don't worry too much if these queries grow as you start to pull in more relationships. For example, over on your post model, you might have another relationship in here, say for a topic that you've included for each of the posts. You can egoload that in as well. So for example, you may have a topics relationship
03:21
that will create another query, but it's better than the alternative of querying for every single item in this list. So with that very simple change, we have reduced our query countdown from hundreds just to two. Like I said, things can get a little bit more complicated than this, and we will be looking at that later on in the course when we introduce some more advanced relationships
03:43
and the performance around them. But for now, this is pretty much a really quick win, making sure that you have egoloaded your data in. Now, if you really want to be strict with yourself, in the next episode, we're going to look at a little trick that you can use to force yourself to egoload in these kind of data.

Episode summary

In this episode, we dig into a super common issue in web apps: loading a ton of related data, like posts with their authors, and ending up accidentally hammering your database with way too many queries. You'll see how, by looping over posts on a page and pulling in each user's info one at a time, we end up with a database query for every single post—definitely not ideal!

To fix this, we take a look at how Laravel's Eloquent ORM handles relationships and the concept of eager loading. You'll learn how just a tiny tweak—adding the with method when querying for posts—can take us from hundreds of queries down to just two: one for the posts and one for all their related users. That's a huge speed win, and it keeps our database and server happy.

We also touch on how you can eager load additional relationships, like topics, all using the same method. While things might get a bit more complex with deeper relationships (which we’ll cover later), this episode is all about laying the foundation and giving you an easy performance boost right away.

If you're curious about how to make sure you never forget to eager load the right stuff, stay tuned—next episode is all about that trick!

Episode discussion

No comments, yet. Be the first!