Eloquent Relationships By Example

Sign in Get started

This episode is for members only

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

Already a member? Sign in to continue

Playing

28. Syncing relations

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

02. One to one

02. Creating and accessing the relationship

03. Creating an address

04. Updating an address

05. Deleting an address

06. Scoping to get the most recent address

07. Building a working example

03. One to many

08. Defining one to many relationships

09. Two ways to insert

10. Accessing the relationship data

11. Deleting records

12. Updating records

13. Adding modifiers directly to the relationship

14. Creating a postable timeline app

04. Belongs to

15. Defining a belongs to relationship

16. Associating relations

17. Switching up keys

05. Eager loading

18. Debugging the issue

19. Eager loading

06. Many to many

20. Defining many to many relationships

21. Attaching relations

22. Detaching relations

23. Attaching and detaching multiple relations

24. Eager loading

25. Defining the inverse of the relationship

26. Intermediate table columns

27. Filtering by intermediate columns

28. Syncing relations

07. Has many through

29. Defining and using has many through relationships

08. Has one through

30. Using has one through relationships

09. Has one of many

31. Setting up a practical example

32. Defining and using a has one of many relationship

33. Using aggregate functions

Transcript

00:00

We've already covered attaching and detaching relationships, but there's a very, very important way of syncing relationships that you'll need to know about when you're working with many-to-many relationship types.

00:13

So let's demonstrate the problem that this gives us, and then we'll go ahead and implement the solution. Okay, so with eloquent relationships, by example, let's just double check the ID of this course, that is the first one.

00:27

Let's head over and try and attach Laravel again, see what happens. So we're gonna head over to courses slash one slash topics. Let's try and attach Laravel again, and again, we can give a version, it doesn't really matter here.

00:40

So if we go back to our homepage, I think I might have just attached that again, we have two topics in here, both with Laravel, both with version nine,

00:51

although the version can change with that intermediate pivot value. So this is a bit of a problem. What do we do about this? How can we get around this when we don't want two instances of these things in here?

01:04

Well, of course, what we could do is somewhere, create some sort of if statement to check this, maybe detach it if it already exists. You know, there's a load of complex ways that we can do this,

01:16

but Laravel provides us a solution, which is syncing our associations. So I'm gonna go ahead and show you this just within a web route really quickly. So we can get to grips with how this works, and then we'll go ahead and apply this to the functionality that we've already got.

01:31

So we need to go ahead and pluck out a course. So let's go ahead and do that really quickly. We'll grab the first course just here, and then let's just not grab any topics out just yet.

01:42

And we wanna go ahead and sync these up. So I'm gonna head over to our course topic table, get rid of this just so we can see what happens when we run this code. Let's make sure that we have this open just in here, like so.

01:54

Okay, so how do we do this? We're gonna say course topic in exactly the same way, but this time we're gonna use the sync method. Now the sync method allows you to pass in a list of IDs, kind of like attach.

02:05

So let's attach three topics to this particular course and just see what happens. So give that a refresh, come over, and the topic IDs one, two, and three have been attached. This looks like on the surface,

02:20

it's working exactly the same as the attach method. But what we can now do with this is we can say, well, I wanna go ahead and sync these. I want to include topics two and three.

02:31

Now what's gonna happen behind the scenes is Laravel is gonna automatically remove topic one because we just want two and three in there. It's not gonna re-add two and three,

02:41

it's gonna synchronize this so we just have two and three. Let's go over and give the page a refresh here, come over to the database, and you can see sure enough two and three have been added.

02:51

So this saves you having to manually check if a topic or any kind of association already exists and having to manually remove it and adding loads of complex code to get this to work.

03:02

So what we could do here is we could just sync this with an empty array as well, and that's gonna go ahead and just get rid of everything for us. It works regardless of what you pass in. So let's say that we already have topic one and we sync this up

03:16

and we want to add a new topic. What do we do? Well, if we were to just pass down topic ID two like this and then add this to our sync method,

03:27

we already know what's gonna happen. It's gonna get rid of topic one and it's gonna kind of replace that with topic two. So we also have a method called sync without detaching like so.

03:39

What that's gonna do is sync these up, but it's not gonna detach anything that doesn't already exist or hasn't been included in this array. So sync without detaching, I can add two and three

03:49

and that's just gonna add them to here. So let's just take a look and come over and there we go. Now you might be thinking, well, isn't sync without detaching exactly the same thing as attach

04:00

if it's just attach them and not remove the existing ones? Well, it kind of works in the same way, but the difference now is if I were to add topics one, two, and three again, we already know that with attach, that's gonna attach another one.

04:13

So we're gonna have a duplicate. But if I were to refresh this as many times as possible and we come over, you can see that we only still have one, two, and three because behind the scenes, we already know that these exist.

04:26

So they've not been reattached. So sync is probably what you're gonna use in the majority of cases to just make sure that you're not attaching additional ones. So again, I could get rid of one and I could say,

04:39

well, I just want one, two, three, and four. That's gonna work again in exactly the same way. Not gonna read two and three, but it is gonna add four. And in our case, one is being kept as well.

04:50

But with sync, that would have removed one. So really just experiment with how you need this to actually work in reality, depending on how your UI works, what kind of data you're passing down. And this will sync everything up for you nicely.

05:03

You might also be wondering, well, if we're syncing like this, how do we attach our pivot data like our version that we've already included? Well, let's get rid of everything that we've got in the database. And let's just go with a really simple example.

05:15

And we're gonna sync the ID of one for that topic. All we do is we change this into a key value pair. So what we can do now is add in another array for this specific value. And we could bring this down so it makes a little bit more sense.

05:29

And in here, we can say version 10. So let's go over, give that a refresh, come over. And that has been inserted. So really, just depending on how your UI works,

05:40

you want to build up the key, which is the topic ID, and then the version which will come from your request. And you can do this for any of the items that you're passing down. So you can just do this, for example.

05:52

And if we come over, give that a refresh, you can see that works as normal. So in our case, what we can actually do with this example, we can go to where we are attaching our topics to our courses just here. And instead of using attach, we could actually use sync here.

06:10

We could go ahead and pass an ID here. So we're going to go ahead and assume that we are validating this. And get rid of this or add in this additional array. So now we're syncing the topic that we want with the version that has been passed in.

06:27

So the difference with this is this is going to go ahead and detach anything we don't pass through. So in this specific example, we would want sync without detaching in here. So let's go ahead and see the difference.

06:39

If we come over to courses slash one slash topics, we have a couple in there already. So we can just try and reattach Laravel, say version five. It does go ahead and replace that pivot data, but it does not add an additional Laravel topic to that particular course.

06:56

So you now pretty much have all of the methods available to you to build this up in the way that you need when you're working with many to many relationships. There are a couple more specific examples in the Laravel documentation.

07:08

So if you have something that's not quite working out or you need slightly more powerful functionality, now that you've got a good grasp on the basics, you can head over to the docs to find out more.

Episode summary

In this episode, we tackle a common issue you might run into when managing many-to-many relationships in Laravel: keeping things in sync! We've already looked at how to attach and detach relationships, but syncing is a super useful (and often necessary) next step.

First, we walk through the problem of duplicate entries when you keep attaching the same relationship. Instead of manually checking for duplicates or writing lots of extra code, Laravel gives us the handy sync method. We see how sync replaces the old related items with just those we pass in, automatically handling removals and additions for us. This is perfect for those times when you only want a specific set of relationships attached (and nothing else).

We also cover syncWithoutDetaching, which lets us add new items to the relationship list without removing the existing ones – very useful if you just want to add a few more connections and not replace everything.

Along the way, you'll see how to use pivot data (like a version number) with sync or syncWithoutDetaching by passing an array of key-value pairs. We finish up by updating some of our previous code to take advantage of syncWithoutDetaching so we don't get duplicate relationships, and show that updating pivot data is seamless too.

By the end of this episode, you'll be comfortable choosing the right method – attach, detach, sync, or syncWithoutDetaching – for any scenario, and you're ready to explore any extras in the Laravel documentation if you run into tricky edge cases. Sync up and keep your data squeaky clean!

Episode discussion

No comments, yet. Be the first!