What is the best way to check multiple has_many associations? - ruby-on-rails

Question

I want to check if any of a set of has_many associations of a Ruby Class has, at least, one item.
Currently the method in_use? is written this way:
class Venue < ApplicationRecord
has_many :destination_day_items
has_many :user_bookmarks
has_many :attachments
has_many :notes
has_many :notifications
has_many :expenses
def in_use?
destination_day_items.any? ||
user_bookmarks.any? ||
attachments.any? ||
notes.any? ||
notifications.any? ||
expenses.any?
end
end
I think that adding a local variable may prevent a lot of repetead calls if this method is called a few times.
def in_use?
#in_use ||= destination_day_items.any? ||
user_bookmarks.any? ||
(...)
#in_use
end
But I still feel it's not the best approach.
My question is: Does anyone know a better idea on how to implement this using "The RoR Way"?

Answer 1

At first this was intendend to check if a Venue is associated to any other of these classes (Bookmarks, Notes, Attachments...) and validate if it's safe to delete it
You can use option :restrict_with_error. This option causes an error to be added to the owner if there is an associated object
class Venue < ApplicationRecord
has_many :destination_day_items, dependent: :restrict_with_error
has_many :user_bookmarks, dependent: :restrict_with_error
has_many :attachments, dependent: :restrict_with_error
has_many :notes, dependent: :restrict_with_error
has_many :notifications, dependent: :restrict_with_error
has_many :expenses, dependent: :restrict_with_error
end
Let's assume venue has some destination day item and we try to destroy it
venue.destroy
Output will something like this:
BEGIN
DestinationDayItem Exists? SELECT 1 AS one FROM "destination_day_items" WHERE "destination_day_items"."venue_id" = $1 LIMIT $2 [["venue_id", 1], ["LIMIT", 1]]
ROLLBACK
=> false
venue.errors[:base]
# => ["Cannot delete record because dependent destination day item exist"]
So you can show this message to the user if you need
Another option -- dependent: :restrict_with_exception. It causes an ActiveRecord::DeleteRestrictionError exception to be raised if there is an associated record
These options work when you apply destroy method and don't work when delete

Answer 2

As they say, there's only two hard problems in computer science: "Cache invalidation, naming things, and off-by-one errors". The cached result can fall out of date if any relationships are added or removed during the life of the object.
Also, associations are cached, so there isn't much use in caching the result. destination_day_items will only query the database once during the life of the object. However, the cache is not always properly invalidated if the relationships change.
You could add a counter_cache to all the associations, then it only has to query the cache number, but see above.
Instead of a query for each association, you can increase performance by doing it in a single query.
def in_use?
left_joins(:destination_day_items)
.left_joins(:user_bookmarks)
...
.where.not(destination_day_items: { venue_id: nil })
.or( UserBookmarks.where.not(venue_id: nil )
.or( ... )
.exists?
end
The upside is this query will always get the correct result. The downside is it will always run the query. You could cache the result, but see above.
The real advantage is this can be turned into a scope to search for all in-use venues efficiently.
scope :left_join_all_associations(
left_joins(:destination_day_items)
.left_joins(:user_bookmarks)
...
)
scope :in_use, -> {
left_join_all_associations
.where.not(destination_day_items: { venue_id: nil })
.or( UserBookmarks.where.not(venue_id: nil )
.or( ... )
}
And you can query for those which are not in use with a left excluding join.
scope :not_in_use, -> {
left_join_all_associations
.where(
destination_day_items: { venue_id: nil },
user_bookmarks: { venue_id; nil },
...
)
}
I'm not 100% sure I got the Rails queries right, so here's a SQL demonstration.

Answer 3

def in_use?
# define a relations array
relations = Venue.reflect_on_all_associations(:has_many).map(&:name).map(&:to_s)
# check condition
relations.any? { |association| public_send(association).any? }
end