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
09. Two ways to insert

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 have our relationship defined,
00:02
we're going to take a look at two different ways that we can insert data for a user's posts. So the first way that we're going to look at is probably the way that you're going to do this 99%
00:14
of the time. But there is a chance that you might want to create a model or make a model before you insert it. And I'll tell you why that is when we get to it.
00:23
So the first thing that we'll do is just create out a new route for this so we can see what's going on. And we'll just call this Insert or Create. And let's call this Create, actually,
00:32
because that makes a little bit more sense. And now we're going to go ahead and just say User. Remember, exactly like we did with the one-to-one, we access the method now.
00:41
So we end up with something, the actual relationship that we can then insert on. And then we're going to call the Create method. And into here, we can just pass an array
00:49
with all of the post information. And what will happen behind the scenes with Eloquent is it will automatically fill in the user ID for you because we're accessing this relationship via this user.
01:00
Now, at the moment, this isn't going to work because remember over in our address model earlier, we need to add a fillable field inside of here, a fillable column, to say that we can fill the body in.
01:11
We don't need to do that for user ID because that's done behind the scenes, but we're going to add in body to fillable. So now we can just add in a body here.
01:19
So let's say a first post, and let's go ahead and run this and see what happens. So let's head over to our Create endpoint here and hop over to the database directly, and there we go.
01:31
So as you can see, it works exactly the same. It's a one-to-one, but the relationship type now has changed. So if we create a second post here and give that a refresh, we can return to how we access this
01:44
and we'll see we get a collection. We don't get the first one, we get all of these because it's one to many. So if we head back over to our homepage here,
01:53
our collection now has two items. And don't worry too much about everything outside of here. We don't need to directly access this items property. We'll look at working with collections
02:04
when we dump these out to a page, but you can see when you do die and dump this, you get an array here internally within this collection with two posts.
02:12
And these look exactly as you would expect. They have all the data that you can read from them. So that's one way to insert these and a quick preview of how we see these.
02:22
In the next episode, we're gonna take a look at how we can iterate over these and access this data. So the second way to create an item like this really depends on if you need to do something to the post
02:35
or model that you're inserting before you insert it. So let's go ahead and just duplicate this route so we have a reference to both. Let's call this alternative.
02:44
And this will involve not passing an array directly through to create, it will involve creating the post before we go ahead and insert it. That doesn't mean that we're going to persist this post
02:56
to the database because if we were to create a post out first and then attach it to a user, the user ID wouldn't be filled and this is a required column in our database.
03:07
So what we're gonna do here instead is we're gonna use a make method on this post. So let's make sure we pull the post in at the top of our page, the namespace,
03:18
and then we're gonna pass the data in that we wanna see. So let's say body and a third post. And now what do we do? Well, let's go ahead and just say,
03:28
well, let's pass this post into create and just see what happens because that would kind of make logical sense. So let's come over to create and alt and see what we get.
03:38
Okay, so the method create on the has one or many relationship type needs to be an array. So obviously we can't do this.
03:47
We saw us passing an array into here before. Now, the whole point of doing this is if on this post, you need to do things to this post before you go ahead and insert it,
03:58
this is when you're gonna need to use this type of insertion but we can't use create here. What we need to do is use save. So we've already got a post
04:08
that isn't persisted at the database level just yet but then we wanna save this to the user's post now that it exists. So this will take in a model that we can then use.
04:18
So if we give this a refresh now, notice that that has worked. And if we head over to the database, sure enough, it is in there.
04:24
Now, let's just talk about the reason why we might need to do this before. Now, when we make up a model, we might have methods over on this model
04:33
that we need to do something to. We might even have relationships on this post that we need to insert before we save it to a user. I'm not gonna go too much into detail on this.
04:45
This is something that you will find that you will come back to if you do need to do this at any point, if you find things starting to get a little bit tricky
04:53
but this is another way that we can insert this in. So majority of the time, I'd say 99% of the time, you would just do this, very, very simple. But if you did need to build the post up,
05:02
modify anything about this post before you then went and inserted it into that post relationship, then this is what you would do.

Episode summary

In this episode, we dive into two different ways to insert related data into a database, specifically focusing on creating posts for users using Eloquent relationships.

First up, we look at the standard way (and the one you'll probably use 99% of the time): simply creating a new post through the relationship using the create method. This approach is super straightforward—just pass an array of data, and Eloquent handles linking the post to the user by filling in the user ID for you. We walk through setting this up, including making sure your Post model has the necessary fields marked as fillable (like the body). We then test it out by creating a couple of posts and exploring how they show up as a collection related to the user.

Then, we switch gears to explore an alternative method. If you need to do something special with your post model before saving it (like modifying fields or setting up relationships), you can use the make method to create the post, tweak as needed, and then persist it to the user's posts with the save method. We test this out and talk about some situations where this approach might be necessary, such as when you need to manipulate the model or set up more complex relationships before saving.

By the end of this episode, you'll have a good grasp on both methods and know when to use each. Next time, we'll look at iterating over these collections and displaying the related data. Stay tuned!

Episode discussion

No comments, yet. Be the first!