Recently I was working on my dissertation and came across an interesting problem with using the has_one association in Rails. But before we get into that, let’s take a step back to understand a little about how associations work in Rails.
Rails Associations
I’m not going to assume everyone reading this knows or understands in depth about databases and object relational mappers so I’ll try to keep this brief and simple. If you want a more in depth understanding, the Rails docs are a good starting point to understanding this in that specific context.
Let’s say you want to build a content site where different creators can create posts, you’d have a relational database with two tables Creator and Post that may look something like this:
Your creator table has an ID and Name column for every item that gets created and your post table has an ID, Title, Type and Body column for every item. In each column, the primary key will be the ID column since that’s going to be the unique identifier for each record. The primary key is important when creating associations because it acts as the foreign key in the associated table.
Now we need to decide what kind of relationship the two tables will have with each other since we’d likely want to know which creators created which posts. There are a few different kinds of associations you can create but I’ll only touch on two.
has_many
A has_many association, says one item in a table can be associated with many items in another table. For example, if our system is a standard content creation system then a creator can have many posts since one creator can create many posts in which case, the association in Rails would look like:
class Creator < ApplicationRecord
has_many :posts
end
class Post < ApplicationRecord
belongs_to :creator
end
And our database would look like:
The creator_id would be pulled from the id column, which is the primary key in the creator table and act as a foreign key in the post table. So if you wanted to find all the posts created by Tiffany Pollard, you’d do a search on the post table where the creator_id matches Tiffany Pollard’s id in the creator table.
has_one
A has_one relationship says one item in a table can only be associated with one item in another table, no more than one. We may want to create a system where a creator can only ever create one post in which case, our Rails code would look like:
class Creator < ApplicationRecord
has_one :post
end
class Post < ApplicationRecord
belongs_to :creator
end
A creator has_one post and a post belongs_to a creator. The database looks the same as before:
And just like with has_many the creator_id is the foreign key for the creator’s id in the post table.
Okay, so now onto the problem.
...
The Problem
In Rails when you create a has_one association, understandably the assumption is that a creator can only ever have one post. So what happens when a creator tries to create another post? You’d hope that it’d check to see if a post exists and ask the creator if they want to replace the post or just replace the post with the assumption that that’s the intention of the creator. But that’s not what happens, instead, you get this error:
This is a common error with has_one and is summed up nicely in this issue:
This is because prior to deleting, the foreign key of the target association is set to nil and a save operation is performed on the target.
It’s unclear why this happens, if you go through the issue you’ll notice it was created in 2014 and the discussion is still ongoing. It seems this started out as a bug but may have evolved to become the desired functionality.
The Fix
There are a number of ways to fix this and it all depends on your system. Essentially, you want to make sure the old association is deleted before you try to create a new one. So, you can do this in your model:
class Creator < ApplicationRecord
has_one :post, dependent: :destroy
end
class Post < ApplicationRecord
belongs_to :creator
end
Or in the method where you create your resource (either in your controller or specific lib file) you can run something like:
creator = Creator.find_by_id(id)
creator.post&.delete
before you create any post. Andy Croll from Coverage Book recommends rolling things up in a transaction and there are more suggestions in the GitHub issue too.
Top comments (0)