Eloquent Relationships By Example
Playing
06. Scoping to get the most recent address

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
one-to-one relationships within Eloquent can actually be a little bit confusing because if we run the create route that we've created twice, this is actually going to create two address records. So really this catches a lot of people out in the sense that one-to-one
00:18
doesn't really just create one record, it allows you to access one record from a user. Let's explore that in a little bit more detail, but the first thing we're going to do is just demonstrate out the fact that this does create more than one record. So we don't have anything in the database at the moment, I'm going to head over to create and that's created 38 code
00:38
road. I'm going to go ahead and just change this around a little bit and I'm going to say one code lane and we're going to head over and run create again. There we go, we have two records in the database now, so technically this user has two addresses. So like I said the one-to-one relationship does not stop you from creating more than one thing for a particular user or any other
01:03
model that you're dealing with, the relationship works by just returning one thing. So this is why in the majority of cases you do not need to use a one-to-one relationship. It's important to learn about it, understand how it works, but most of the time you will use a one-to-many relationship which we will be covering and with a one-to-many relationship what you can do is still access the
01:28
latest record and there's in fact a modifier, a relationship modifier that allows you to do that very easily which we'll be covering. But let's look at how we, if we did want to use a one-to-one relationship, how we access the latest address because at the moment we've created two addresses but the user has one address. We kind of want to return the latest relationship. Now we can do this
01:52
with scopes. We can do this either at the level where we are accessing the addresses or we can do this at the relationship level itself. So let's take a look at how we would do this. So at the moment over on our home page we're grabbing the user, we're passing that through to our address view and over in the address view we are checking if the user has an address. If they do we're going
02:15
ahead and grabbing line one. So what we're going to do instead is we're going to say user or we're going to define a variable here. We're going to say address, user, address and we're going to say latest. Now notice that I have used the method here rather than the property which gives us back a Laravel collection that's just a collection of the models. So we're going to say that we want
02:44
to scope this by the latest. This is effectively a hidden order by which we'll look at the alternative in a minute and let's take a look at what we get. So I'm going to go ahead and die dump on this new address variable that we've created and let's head over to the home page and give this a refresh. So at the moment we don't actually have a record we just have a builder which is building up this
03:05
relationship. So what we want to do on here is save first. So now if we give this a refresh, notice that we have one code lane. So that will grab the latest record from the multiple addresses that we have. Now latest is just syntactic sugar over the order by. So we can order this by created at in ascending or descending order. So if we were to give this a refresh we get 38 code road.
03:34
If we were to do it in descending order we get of course one code lane. So this is just a query builder building up how we want the SQL query to be executed before it's returned to us. But order by is hidden behind within Laravel under latest. You can use either one it does not matter but latest tends to be a little bit more readable. Okay so this is a little bit annoying. We have a
03:57
one-to-one relationship we have two addresses in the database but we really only want the latest one. How do we get around this? Doing this probably isn't recommended unless you really need to. What we can do is instead over on the user model we can say well for this one-to-one relationship just here we always want to get back the latest address. It just makes sense for the logic of our
04:24
app. So what we can actually do is use the latest scope within the address relationship method that we have created. So now that we have done that let's head over to our home page and you can see sure enough we get one code lane. That means that over in our web route if we were to create another address let's say 100 code lane and we head over and create this and we head back to the home page
04:53
sure enough it will always show us the latest address that has been created. So this might be something that you want to do. A user adds a new address it adds it on to a kind of history of addresses but we always get back the first address and the difference between a has one and a has many relationship is that inside of your templates you're always accessing this like the user
05:19
only has one address. In terms of your application the user only ever has one address and it's a lot more convenient to access if you know that you only ever want one thing returned. If you are very new to Laravel once we get over to one-to-many relationships you'll very quickly start to see the difference between one-to-one and one-to-many and when these can be useful.

Episode summary

In this episode, we tackle a common confusion with Eloquent's one-to-one relationships in Laravel—specifically, how they're not as strict as you might expect. We see that if you run the address create route multiple times, you end up with multiple address records for the same user! So, even though it's a one-to-one relationship, Eloquent doesn't stop you from attaching more than one address to a user.

We investigate how the relationship only returns one record, but the database might actually store several. Most of the time, you'll probably want to use a one-to-many relationship since that's more flexible, but it's still good to understand what's going on behind the scenes.

Next, we explore how to always retrieve the most recent address for the user. We learn about the latest() relationship modifier in Laravel and how to apply it so you always get the newest address attached to a user, even if there are multiple in the database. We try it out, see what happens, and then refine things by adding the scope directly to the user model relationship, so it's automatic.

By the end of this episode, you'll know how to deal with multiple related records in a "one-to-one" setup, and ensure your code always grabs the most relevant (i.e. newest) one. This is a must-know trick for anyone working with relationships in Laravel!

Episode discussion

No comments, yet. Be the first!