Rails Polymorphic has_many

You have to use STI on the producers, not on the products. This way you have different behavior for each type of producer, but in a single producers table.

(almost) No polymorphism at all!

class Product < ActiveRecord::Base
  # does not have a 'type' column, so there is no STI here,
  # it is like an abstract superclass.
  belongs_to :producer
end

class Bicycle < Product
end

class Popsicle < Product
end

class Producer < ActiveRecord::Base
  # it has a 'type' column so we have STI here!!
end

class BicycleProducer < Producer
  has_many :products, :class_name => "Bicycle", :inverse_of => :producer
end

class PopsicleProducer < Producer
  has_many :products, :class_name => "Popsicle", :inverse_of => :producer
end

please take it on format

class Bicycle < ActiveRecord::Base 
  belongs_to :bicycle_obj,:polymorphic => true 
end 

class Popsicle < ActiveRecord::Base
  belongs_to :popsicle_obj , :polymorphic => true 
end 

class Producer < ActiveRecord::Base 
  has_many :bicycles , :as=>:bicycle_obj 
  has_many :popsicle , :as=>:popsicle_obj 
end 

Use this code. If you have any problem with it, please leave a comment.

I find that polymorphic associations is under documented in Rails. There is a single table inheritance schema, which is what gets the most documentation, but if you are not using single table inheritance, then there is some missing information.

The belongs_to association can be enabled using the :polymorphic => true option. However, unless you are using single table inheritance, the has_many association does not work, because it would need to know the set of tables that could have a foreign key.

(From what I found), I think the clean solution is to have a table and model for the base class, and have the foreign key in the base table.

create_table "products", :force => true do |table|
    table.integer  "derived_product_id"
    table.string   "derived_product_type"
    table.integer  "producer_id"
  end

  class Product < ActiveRecord::Base
    belongs_to :producer
  end

  class Producer < ActiveRecord::Base
    has_many :products
  end

Then, for a Production object, producer, you should get the products with producer.products.derived_products.

I have not yet played with has_many through to condense the association to producer.derived_products, so I cannot comment on getting that to work.

Here is how I did it, which makes correct SQL queries:

class Message < ApplicationRecord
  module FromTypes
    USER = "User"
    PHONE_NUMBER = "PhoneNumber"
    ALL = [USER, PHONE_NUMBER]
  end

  module ToTypes
    USER = "User"
    PHONE_NUMBER = "PhoneNumber"
    ALL = [USER, PHONE_NUMBER]
  end

  belongs_to :from, polymorphic: true
  belongs_to :to, polymorphic: true

  scope :from_user, -> { where(from_type: FromTypes::USER) }
  scope :from_phone_number, -> { where(from_type: FromTypes::PHONE_NUMBER) }
  scope :to_user, -> { where(to_type: ToTypes::USER) }
  scope :to_phone_number, -> { where(from_type: ToTypes::PHONE_NUMBER) }

  validates :from_type, presence: true, inclusion: { in: FromTypes::ALL }
  validates :to_type, presence: true, inclusion: { in: ToTypes::ALL }

  def from_user?
    from_type == FromTypes::USER
  end

  def from_phone_number?
    from_type == FromTypes::PHONE_NUMBER
  end

  def to_user?
    to_type == ToTypes::USER
  end

  def to_phone_number?
    to_type == ToTypes::PHONE_NUMBER
  end
end

  has_many(
    :messages_sent,
    -> { from_phone_number },
    class_name: "Message",
    foreign_key: :from_id
  )
  has_many(
    :messages_received,
    -> { to_phone_number },
    class_name: "Message",
    foreign_key: :to_id
  )

Which makes SQL queries like this:

>> PhoneNumber.first.messages_received
  PhoneNumber Load (1.1ms)  SELECT "phone_numbers".* FROM "phone_numbers" ORDER BY "phone_numbers"."id" ASC LIMIT $1  [["LIMIT", 1]]
  Message Load (2.1ms)  SELECT "messages".* FROM "messages" WHERE "messages"."to_id" = $1 AND "messages"."from_type" = $2 /* loading for pp */ LIMIT $3  [["to_id", 1], ["from_type", "PhoneNumber"], ["LIMIT", 11]]