Use `becomes` on a ActiveRecord::Relation (STI)

Question

# Models
class Animal < ActiveRecord::Base
  belongs_to :zoo
end

class Dog < Animal
  belongs_to :leg
end

class Snake < Animal
end

class Leg < ActiveRecord::Base
end

class Zoo
  has_many :animals
end

# Test, which fails with
# Association named 'leg' was not found on Animal; perhaps you misspelled it?
Zoo.first.animals.
         .where(:type => 'Dog')
         .includes(:leg)

In this example, Rails can not know the specific type of the objects queried (it would have to analyze the where statement for that, which it does not appear to do). Therefore, it fails, as the association is not defined on the generic model Animal, but on the Dog model.

Is there a way of specifying the type of the objects about to be retrieved, so that the example works?

cant you define a specific `has_many` instead of just `animals` something like `animals_with_legs`? — apneadiving, Sep 17 '14 at 09:58
`has_many :animals_with_legs, ->{ where(type: ['Dog', ...]) }` then `Zoo.first.animals_with_legs.where(:type => 'Dog').includes(:leg)` is it that terrible? — apneadiving, Sep 17 '14 at 10:04
`animals.where(:type => 'Dog').includes(:leg)` or with `scope` which I wrote should work, which `active_record/rails` version do you use? — Igor Guzak, Sep 17 '14 at 15:02

score 1 · Accepted Answer · answered Sep 08 '21 at 04:53

Here's a solution that looks inefficient at first, but is actually very performant due to the way ActiveRecord builds up its query object.

A good solution to your query is:

Dog.where(id: Zoo.first.animals.where(type: 'Dog').select(:id))
   .includes(:leg)

At first glance, it looks like it should execute 2 queries, but ActiveRecord is smart enough to produce the following SQL in a single DB call:

SELECT "animals".*
FROM "animals"
WHERE "animals"."id" IN (
  SELECT "animals"."id"
  FROM "animals"
  WHERE "animals"."id" = 111
    AND "animals"."type" = 'Dog'
)

Since the outer query is driven by the Dog class, then the .includes will work. And so this is a generic way of behaving like the becomes method on an ActiveRecord::Relation.

Note: The .select(:id) part of the code isn't actually required. I just included that for clarity, to show how AR uses that part of the query.

That's a very clever solution, many thanks! – sudoremo Sep 09 '21 at 08:06 — sudoremo, Sep 09 '21 at 08:06

sudoremo · Answer 2 · 2014-09-17T12:47:35.767

I've come up with a (at least temporary) solution. This monkey patch extends Rails with the functionality to specify a class override when accessing collection associations.

Usage:

Zoo.first.animals(false, Dog)
         .includes(Leg)

The monkey patch (rails 3!):

# This monkey patch extends the rails collection association reader (i.e. )
# zoo.animals by a second option called `class_override`. Using this option,
# a custom model class for the objects to be retrieved can be specified.
#
# Might only work with rails 3.
#
# @see http://stackoverflow.com/q/25887230
module ActiveRecord
  module Associations
    class CollectionAssociation < Association #:nodoc:
      # Implements the reader method, e.g. foo.items for Foo.has_many :items
      def reader(force_reload = false, class_override = nil)
        if force_reload
          klass.uncached { reload }
        elsif stale_target?
          reload
        end

        if class_override.nil?
          association = self
        else
          reflection = self.reflection.dup
          reflection.instance_variable_set(:@klass, class_override)
          association = self.dup
          association.instance_variable_set(:@reflection, reflection)
        end

        CollectionProxy.new(association)
      end
    end
  end
end

Probably, this can be achieved using association extensions as well. I'm looking into it.

score 0 · Answer 3 · answered Oct 21 '15 at 08:14

0

Just stubled across a nice blog post by Robert Pankowecki explaining a possible solution: http://blog.arkency.com/2013/07/sti/.

answered Oct 21 '15 at 08:14

sudoremo

2,274
2
22
39

Use `becomes` on a ActiveRecord::Relation (STI)

3 Answers3