Multi table Inheritance for rails
Latest commit 387b8b1 Jul 29, 2014 @hzamani add forgoten Gemfile.lock


Gem Version Build Status Coverage Status


This gem is depricated, please use {active_record-acts_as}( which is a full refactor of this one.


This gem helps implement multiple-table-inheritance (MTI) methods to your ActiveRecord models. By default, ActiveRecord only supports single-table inheritance (STI). MTI gives you the benefits of STI but without having to place dozens of empty fields into a single table.

Take a traditional e-commerce application for example… A product has common attributes (name, price, image …), while each type of product has its own attributes… pen has color, book has author and publisher and so on.


For Rails 4 installation add the following line to your Gemfile

gem 'acts_as_relation', '~> 1.0'


$ bundle install

If you are using Rails 3 you must use '~> 0.1' version specifier in Gemfile.


acts_as_relation uses a polymorphic has_one association to simulate multiple-table inheritance. For the e-commerce example you would declare the product as a supermodel and all types of it as acts_as :product (if you prefer you can use their aliases is_a and is_a_superclass)

class Product < ActiveRecord::Base

class Pen < ActiveRecord::Base
  acts_as :product

class Book < ActiveRecord::Base
  acts_as :product

class Store < ActiveRecord::Base
  has_many :products

To make this work, you need to declare both a foreign key column and a type column in the model that declares superclass. To do this you can set :as_relation_superclass option to true on products create_table (or pass it name of the association):

create_table :products, :as_relation_superclass => true do |t|
  # ...

Or declare them as you do on a polymorphic belongs_to association, it this case you must pass name to acts_as and acts_as_superclass in :as option:

change_table :products do |t|
  t.integer :producible_id
  t.string  :producible_type

class Product < ActiveRecord::Base
  acts_as_superclass :as => :producible

class Pen < ActiveRecord::Base
  acts_as :product, :as => :producible

class Book < ActiveRecord::Base
  acts_as :product, :as => :producible

Now Pen and Book act as Product. This means that they inherit Product attributes, associations, validations and methods.

To see its functionality lets add some stuff to product:

class Product
  validates_presence_of :name, :price

  def to_s
    "#{name} $#{price}"

now we can to things like this:

Pen.create :name => "Nice Pen", :price => 1.3, :color => "Red"
Pen.where "name = ?", "Some Pen"
pen =
pen.valid?      # => false
pen.errors.keys # => [:name, :price]
Pen.first.to_s  # => "Nice Pen $1.3"

When you declare an acts_as relation, the declaring class automatically gains parent methods (includeing accessors) so you can access them directly.

On the other hand you can always access a specific object from its parent by calling specific method on it:

Product.first.specific # will return a specific product, a pen for example

In has_many case you can use subclasses:

store = Store.create
store.products << Pen.create
store.products.first # => <Pen: ...>


The acts_as relation support these options:

  • :as

  • :auto_join

  • :class_name

  • :dependent

when :auto_join option set to true (which is by default), every query on child will automatically joins the parent table. For example:

Pen.where("name = ?", "somename")

will result in the following SQL:

SELECT "pens".* FROM "pens" INNER JOIN "products" ON "products"."as_product_id" = "pens"."id" AND "products"."as_product_type" = 'Pen' WHERE (name = 'somename')

All other options are same as has_one options.

Note that support for :conditions and :include has been removed. In their place, you can use +where()+ and +includes()+:

acts_as :product, -> { where(color: "yellow") }
acts_as :person, -> { includes(:friends) }