How to update data in a Many-to-Many linking table? - database

Question

For simplicity’s sake lets assume there’s a Post table and a Tags table (not the actual use case but this will keep it simple)
posts Table
id | title
--------------------------------
1 | Random Text Here
2 | Another Post About Stuff
tags Table
id | tag
--------------------------------
1 | javascript
2 | node
3 | unrelated-thing
posts_tags table
id| post_id | tag_id
--------------------------------
1 | 1 | 1
2 | 1 | 2
3 | 1 | 3
4 | 2 | 2
A Post can have many Tags and a single Tag could be associated with many Posts.
Web App Assumptions Lets pretend adding/removing a Tag doesn't trigger a single aysnchronous action within the web app against the linking table.
Instead the user would edit the Post (adding or removing any tags already created) then hit Save. The web app would submit JSON including an array of Tags ids associated with the Post to the server which would then process the update request in the code.
For example, post_id=1 is submitted with only tag_id=[1,2] so tag=3 needs to be removed as an association in the linking table.
If a Post or a Tag is deleted, I'd have an ON DELETE CASCADE set on
posts_tags.post_id
posts_tags.tag_id
But what is the best way to update the linking table data in the instance of updating the tags associated with a post?

Option 1:
Get all the Post-Tags for the edited Post 
SELECT * FROM posts_tags WHERE post_id = 1
Determine which tags have been added (and INSERT into linking table)
Determine which tags have been removed (and DELETE from linking table)
Option 2:
Delete ALL tags with the post_id in the linking table
Insert all submitted tags into the linking table
Option 3:
Something I'm not thinking about :)
Would Option 2 have a bigger performance impact on indexes as the table grows?
EDIT:
For clarity, the actual Post and Tag data isn't changed or removed. This is purely about Updating a post's associated tags
The database I'm using is PostgreSQL 9.6

Answer 1

Option 2 would be fine from a performance point of view - much better than option 1, because you have a single operation to delete the old associations, and then a bunch on insert statements. In option 1, you have more queries (your first query to retrieve the associations, and then the deletes if applicable).
As long as your table has an index on post_id, then delete * from posts_tags where post_id = ? will be lightning fast, even on a huge table.
There is an alternative...
posts_tags table
id| post_id | tag_id | version_id
--------------------------------
1 | 1 | 1 | 0
2 | 1 | 2 | 0
3 | 1 | 3 | 1
4 | 2 | 2 | 0
5 | 1 | 1 | 2
6 | 1 | 3 | 2
In this case, you use a versioning mechanism to determine the "current" associations (max(version_id)), so you never have to delete anything - you just insert new rows.
In practice, this is probably no faster, but it does save you that "delete" query.