store_base_sti_class_for_3_0 0.0.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,10 @@
+source :rubygems
+
+gem "activerecord", "~> 3.0.3"
+gem "mysql2"
+
+group :development do
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+  gem "rcov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,35 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.0.3)
+      activesupport (= 3.0.3)
+      builder (~> 2.1.2)
+      i18n (~> 0.4)
+    activerecord (3.0.3)
+      activemodel (= 3.0.3)
+      activesupport (= 3.0.3)
+      arel (~> 2.0.2)
+      tzinfo (~> 0.3.23)
+    activesupport (3.0.3)
+    arel (2.0.8)
+    builder (2.1.2)
+    git (1.2.5)
+    i18n (0.5.0)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    mysql2 (0.2.6)
+    rake (0.8.7)
+    rcov (0.9.9)
+    tzinfo (0.3.24)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (~> 3.0.3)
+  bundler (~> 1.0.0)
+  jeweler (~> 1.5.2)
+  mysql2
+  rcov

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Paul Kmiec
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,65 @@
+== Description
+
+Given the following class definitions,
+
+  class Address
+    belongs_to :addressable, :polymorphic => true
+  end
+
+  class Person
+    has_many :addresses, :as => addressable
+  end
+
+  class Vendor < Person
+  end
+
+and given the following code,
+
+  vendor = Vendor.create(...)
+  address = vendor.addresses.create(...)
+
+  p vendor
+  p address
+
+will output,
+
+  #<Vendor id: 1, type: "Vendor" ...>
+  #<Address id: 1, addressable_id: 1, addressable_type: 'Person' ...>
+
+Notice that addressable_type column is Person even though the actual class is Vendor. 
+
+Normally, this isn't a problem, however it can have negative performance characteristic in certain circumstances. The most obvious one is that
+a join with persons or an extra query is required to find out the actual type of addressable.
+
+This gem add ActiveRecord::Base.store_base_sti_class configuration option. It defaults to true for backwards compatibility. Setting it false will alter ActiveRecord's behavior to store the actual class in polymorphic _type columns when STI is used.
+
+In the example above, if the ActiveRecord::Base.store_base_sti_class is false, the output will be,
+
+  #<Vendor id: 1, type: "Vendor" ...>
+  #<Address id: 1, addressable_id: 1, addressable_type: 'Vendor' ...>
+
+== Usage
+
+Add the following line to your Gemfile,
+
+  gem 'store_base_sti_class_for_3_0'
+
+then bundle install. Once you have the gem installed, add the following to one of the initializers (or make a new one) in config/initializers,
+
+  ActiveRecord::Base.store_base_sti_class = false
+
+When changing this behavior you will have write a migration to update all of your existing _type columns accordingly. You may also need to change your application if it explicitly relies on the _type columns.
+
+== Notes
+
+The gem has been extracted out of https://github.com/pkmiec/rails/tree/store_base_sti_class_for_3_0_4 patch. It allows the functionality to be used in applications that include Rails as a gem.
+
+I've tested this gem with Rails 3.0.3 and Rails 3.0.4. Please let me know if it works with earlier version of Rails 3.0.
+
+This gem will not work with Rails 3.1 as much of its ActiveRecord internals have been replaced with Arel. Similar but different changes need to be applied to Rails 3.1. Those changes will come.
+
+== Copyright
+
+Copyright (c) 2011 Paul Kmiec. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,76 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "store_base_sti_class_for_3_0"
+  gem.homepage = "http://github.com/pkmiec/store_base_sti_class_for_3_0"
+  gem.license = "MIT"
+  gem.summary = %Q{
+    Modifies ActiveRecord 3.0.x with the ability to store the actual class (instead of the base class) in polymorhic _type columns when using STI
+  }
+  gem.description = %Q{
+    ActiveRecord has always stored the base class in polymorphic _type columns when using STI. This can have non-trivial
+    performance implications in certain cases. This gem adds 'store_base_sti_class' configuration options which controls
+    whether ActiveRecord will store the base class or the actual class. Default to true for backwards compatibility.
+  }
+  gem.email = "paul.kmiec@appfolio.com"
+  gem.authors = ["Paul Kmiec"]
+  
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "store_base_sti_class_for_3_0 #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+namespace :mysql do
+  desc 'Build the MySQL test databases'
+  task :build_databases do
+    %x( echo "create DATABASE storebasestiname_unittest DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_unicode_ci " | mysql --user=root)
+  end
+
+  desc 'Drop the MySQL test databases'
+  task :drop_databases do
+    %x( mysqladmin --user=root -f drop storebasestiname_unittest )
+  end
+
+  desc 'Rebuild the MySQL test databases'
+  task :rebuild_databases => [:drop_databases, :build_databases]
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/store_base_sti_class_for_3_0.rb

@@ -0,0 +1,478 @@
+require 'active_record'
+require 'active_record/associations'
+require 'active_record/reflection'
+require 'active_record/association_preload'
+require 'active_record/associations/has_many_association'
+require 'active_record/associations/has_one_association'
+require 'active_record/associations/through_association_scope'
+require 'active_record/associations/association_proxy'
+require 'active_record/associations/belongs_to_polymorphic_association'
+
+class ActiveRecord::Base
+  
+  # Determine whether to store the base class or the actual class in polymorhic type columns when using STI
+  superclass_delegating_accessor :store_base_sti_class
+  self.store_base_sti_class = true
+  
+  class << self
+    
+    def polymorphic_sti_name
+      store_base_sti_class ? base_class.sti_name : sti_name
+    end
+
+    def in_or_equals_sti_names
+      if store_base_sti_class
+        "= #{quote_value(base_class.sti_name)}"
+      else
+        names = sti_names.map { |name| quote_value(name) }
+        names.length > 1 ? "IN (#{names.join(',')})" : "= #{names}"
+      end
+    end
+
+    def sti_names
+      ([self] + descendants).map { |model| model.sti_name }
+    end
+    
+  end
+  
+end
+
+module ActiveRecord
+  module Reflection
+    class AssociationReflection < MacroReflection #:nodoc:
+
+      def active_record_primary_key
+        @active_record_primary_key ||= options[:primary_key] || active_record.primary_key
+      end
+
+    end
+  end
+end
+
+module ActiveRecord
+  module AssociationPreload
+    module ClassMethods
+  
+      private
+  
+      def preload_through_records(records, reflection, through_association)
+        # p 'preload_through_records'
+        through_reflection = reflections[through_association]
+        through_primary_key = through_reflection.primary_key_name
+
+        through_records = []
+        if reflection.options[:source_type]
+          interface = reflection.source_reflection.options[:foreign_type]
+          source_type = reflection.options[:source_type].to_s.constantize
+          preload_options = { :conditions => "#{connection.quote_column_name interface} #{source_type.in_or_equals_sti_names}" }
+
+          records.compact!
+          records.first.class.preload_associations(records, through_association, preload_options)
+
+          # Dont cache the association - we would only be caching a subset
+          records.each do |record|
+            proxy = record.send(through_association)
+
+            if proxy.respond_to?(:target)
+              through_records.concat Array.wrap(proxy.target)
+              proxy.reset
+            else # this is a has_one :through reflection
+              through_records << proxy if proxy
+            end
+          end
+        else
+          options = {}
+          options[:include] = reflection.options[:include] || reflection.options[:source] if reflection.options[:conditions] || reflection.options[:order]
+          options[:order] = reflection.options[:order]
+          options[:conditions] = reflection.options[:conditions]
+          records.first.class.preload_associations(records, through_association, options)
+
+          records.each do |record|
+            through_records.concat Array.wrap(record.send(through_association))
+          end
+        end
+        through_records
+      end
+
+      def find_associated_records(ids, reflection, preload_options)
+        # p 'find_associated_records'
+        options = reflection.options
+        table_name = reflection.klass.quoted_table_name
+
+        if interface = reflection.options[:as]
+          conditions = "#{reflection.klass.quoted_table_name}.#{connection.quote_column_name "#{interface}_id"} #{in_or_equals_for_ids(ids)} and #{reflection.klass.quoted_table_name}.#{connection.quote_column_name "#{interface}_type"} #{self.in_or_equals_sti_names}"
+        else
+          foreign_key = reflection.primary_key_name
+          conditions = "#{reflection.klass.quoted_table_name}.#{foreign_key} #{in_or_equals_for_ids(ids)}"
+        end
+
+        # p 'append_conditions'
+        conditions << append_conditions(reflection, preload_options)
+
+        find_options = {
+          :select => preload_options[:select] || options[:select] || Arel::SqlLiteral.new("#{table_name}.*"),
+          :include => preload_options[:include] || options[:include],
+          :joins => options[:joins],
+          :group => preload_options[:group] || options[:group],
+          :order => preload_options[:order] || options[:order]
+        }
+
+        # p 'associated_records'
+        associated_records(ids) do |some_ids|
+          reflection.klass.scoped.apply_finder_options(find_options.merge(:conditions => [conditions, some_ids])).to_a
+        end
+      end
+
+      # Some databases impose a limit on the number of ids in a list (in Oracle its 1000)
+      # Make several smaller queries if necessary or make one query if the adapter supports it
+      def associated_records(ids)
+        # rails 3.0.4 introduced ids_in_list_limit
+        max_ids_in_a_list = (connection.respond_to?(:ids_in_list_limit) ? connection.ids_in_list_limit : nil) || ids.size
+        records = []
+        ids.each_slice(max_ids_in_a_list) do |some_ids|
+          records += yield(some_ids)
+        end
+        records
+      end
+
+    end
+  end
+end
+
+module ActiveRecord
+  module Associations
+    class HasManyAssociation < AssociationCollection
+
+      protected
+
+      def construct_sql
+        # p 'construct_sql :has_many'
+        
+        case
+          when @reflection.options[:finder_sql]
+            @finder_sql = interpolate_sql(@reflection.options[:finder_sql])
+
+          when @reflection.options[:as]
+            @finder_sql =
+              "#{@reflection.quoted_table_name}.#{@reflection.options[:as]}_id = #{owner_quoted_id} AND " +
+              "#{@reflection.quoted_table_name}.#{@reflection.options[:as]}_type #{@owner.class.in_or_equals_sti_names}"
+            @finder_sql << " AND (#{conditions})" if conditions
+
+          else
+            @finder_sql = "#{@reflection.quoted_table_name}.#{@reflection.primary_key_name} = #{owner_quoted_id}"
+            @finder_sql << " AND (#{conditions})" if conditions
+        end
+
+        construct_counter_sql
+      end
+      
+    end
+  end
+end
+
+module ActiveRecord
+  module Associations
+    class HasOneAssociation < AssociationProxy
+
+      protected
+
+      def construct_sql
+        # p 'construct_sql :has_one'
+
+        case
+          when @reflection.options[:as]
+            @finder_sql =
+              "#{@reflection.quoted_table_name}.#{@reflection.options[:as]}_id = #{owner_quoted_id} AND " +
+              "#{@reflection.quoted_table_name}.#{@reflection.options[:as]}_type #{@owner.class.in_or_equals_sti_names}"
+          else
+            @finder_sql = "#{@reflection.quoted_table_name}.#{@reflection.primary_key_name} = #{owner_quoted_id}"
+        end
+        @finder_sql << " AND (#{conditions})" if conditions
+      end
+      
+    end
+  end
+end
+
+module ActiveRecord
+  module Associations
+    module ThroughAssociationScope
+
+      protected
+
+      def construct_quoted_owner_attributes(reflection)
+        # p 'construct_quoted_owner_attributes'
+
+        if as = reflection.options[:as]
+          { 
+            "#{as}_id" => owner_quoted_id,
+            "#{as}_type" => @owner.class.quote_value(@owner.class.polymorphic_sti_name)
+          }
+        elsif reflection.macro == :belongs_to
+          { reflection.klass.primary_key => @owner.class.quote_value(@owner[reflection.primary_key_name]) }
+        else
+          { reflection.primary_key_name => owner_quoted_id }
+        end
+      end
+
+      def construct_joins(custom_joins = nil)
+        # p 'construct_joins'
+        
+        polymorphic_join = nil
+        if @reflection.source_reflection.macro == :belongs_to
+          reflection_primary_key = @reflection.klass.primary_key
+          source_primary_key     = @reflection.source_reflection.primary_key_name
+          if @reflection.options[:source_type]
+            source_type = @reflection.options[:source_type].to_s.constantize
+            polymorphic_join = "AND %s.%s #{source_type.in_or_equals_sti_names}" % [
+              @reflection.through_reflection.quoted_table_name, 
+              "#{@reflection.source_reflection.options[:foreign_type]}"
+            ]
+          end
+        else
+          reflection_primary_key = @reflection.source_reflection.primary_key_name
+          source_primary_key     = @reflection.through_reflection.klass.primary_key
+          if @reflection.source_reflection.options[:as]
+            polymorphic_join = "AND %s.%s #{@reflection.through_reflection.klass.in_or_equals_sti_names}" % [
+              @reflection.quoted_table_name, 
+              "#{@reflection.source_reflection.options[:as]}_type"
+            ]
+          end
+        end
+
+        "INNER JOIN %s ON %s.%s = %s.%s %s #{@reflection.options[:joins]} #{custom_joins}" % [
+          @reflection.through_reflection.quoted_table_name,
+          @reflection.quoted_table_name, reflection_primary_key,
+          @reflection.through_reflection.quoted_table_name, source_primary_key,
+          polymorphic_join
+        ]
+      end
+      
+      def construct_owner_attributes(reflection)
+        # p 'construct_owner_attributes'
+        
+        if as = reflection.options[:as]
+          { "#{as}_id" => @owner.id,
+            "#{as}_type" => @owner.class.polymorphic_sti_name }
+        else
+          { reflection.primary_key_name => @owner.id }
+        end
+      end
+      
+    end
+  end
+end
+
+module ActiveRecord
+  module Associations
+    class AssociationProxy
+
+      protected
+
+      def set_belongs_to_association_for(record)
+        # p 'set_belongs_to_association_for'
+
+        if @reflection.options[:as]
+          record["#{@reflection.options[:as]}_id"]   = @owner.id unless @owner.new_record?
+          record["#{@reflection.options[:as]}_type"] = @owner.class.polymorphic_sti_name
+        else
+          unless @owner.new_record?
+            primary_key = @reflection.options[:primary_key] || :id
+            record[@reflection.primary_key_name] = @owner.send(primary_key)
+          end
+        end
+      end
+      
+    end
+  end
+end
+
+module ActiveRecord
+  module Associations
+    class BelongsToPolymorphicAssociation < AssociationProxy
+      
+      def replace(record)
+        # p 'replace'
+        
+        if record.nil?
+          @target = @owner[@reflection.primary_key_name] = @owner[@reflection.options[:foreign_type]] = nil
+        else
+          @target = (AssociationProxy === record ? record.target : record)
+
+          @owner[@reflection.primary_key_name] = record_id(record)
+          @owner[@reflection.options[:foreign_type]] = record.class.polymorphic_sti_name
+
+          @updated = true
+        end
+
+        set_inverse_instance(record, @owner)
+        loaded
+        record
+      end
+      
+    end
+  end
+end
+
+module ActiveRecord
+  module Associations
+    module ThroughAssociationScope
+
+      protected
+
+      def construct_quoted_owner_attributes(reflection)
+        # p 'construct_quoted_owner_attributes'
+        if as = reflection.options[:as]
+          { 
+            "#{as}_id" => owner_quoted_id,
+            "#{as}_type" => @owner.class.quote_value(@owner.class.polymorphic_sti_name)
+          }
+        elsif reflection.macro == :belongs_to
+          { reflection.klass.primary_key => @owner.class.quote_value(@owner[reflection.primary_key_name]) }
+        else
+          { reflection.primary_key_name => owner_quoted_id }
+        end
+      end
+
+      def construct_owner_attributes(reflection)
+        # p 'construct_owner_attributes'
+        if as = reflection.options[:as]
+          { "#{as}_id" => @owner.id,
+            "#{as}_type" => @owner.class.polymorphic_sti_name }
+        else
+          { reflection.primary_key_name => @owner.id }
+        end
+      end
+
+      def construct_join_attributes(associate)
+        # p 'construct_join_attributes'
+        # TODO: revisit this to allow it for deletion, supposing dependent option is supported
+        raise ActiveRecord::HasManyThroughCantAssociateThroughHasOneOrManyReflection.new(@owner, @reflection) if [:has_one, :has_many].include?(@reflection.source_reflection.macro)
+
+        join_attributes = construct_owner_attributes(@reflection.through_reflection).merge(@reflection.source_reflection.primary_key_name => associate.id)
+
+        if @reflection.options[:source_type]
+          join_attributes.merge!(@reflection.source_reflection.options[:foreign_type] => associate.class.polymorphic_sti_name)
+        end
+
+        if @reflection.through_reflection.options[:conditions].is_a?(Hash)
+          join_attributes.merge!(@reflection.through_reflection.options[:conditions])
+        end
+
+        join_attributes
+      end
+
+    end
+  end
+end
+
+module ActiveRecord
+  module Associations
+    module ClassMethods
+      class JoinDependency # :nodoc:
+        class JoinAssociation < JoinBase # :nodoc:
+  
+          def association_join
+            # p 'association_join'
+            
+            return @join if @join
+
+            aliased_table = Arel::Table.new(table_name, :as      => @aliased_table_name,
+                                                        :engine  => arel_engine,
+                                                        :columns => klass.columns)
+
+            parent_table = Arel::Table.new(parent.table_name, :as      => parent.aliased_table_name,
+                                                              :engine  => arel_engine,
+                                                              :columns => parent.active_record.columns)
+
+            @join = case reflection.macro
+            when :has_and_belongs_to_many
+              join_table = Arel::Table.new(options[:join_table], :as => aliased_join_table_name, :engine => arel_engine)
+              fk = options[:foreign_key] || reflection.active_record.to_s.foreign_key
+              klass_fk = options[:association_foreign_key] || klass.to_s.foreign_key
+
+              [
+                join_table[fk].eq(parent_table[reflection.active_record.primary_key]),
+                aliased_table[klass.primary_key].eq(join_table[klass_fk])
+              ]
+            when :has_many, :has_one
+              if reflection.options[:through]
+                join_table = Arel::Table.new(through_reflection.klass.table_name, :as => aliased_join_table_name, :engine => arel_engine)
+                jt_as_extra = jt_source_extra = jt_sti_extra = nil
+                first_key = second_key = nil
+
+                if through_reflection.macro == :belongs_to
+                  jt_primary_key = through_reflection.primary_key_name
+                  jt_foreign_key = through_reflection.association_primary_key
+                else
+                  jt_primary_key = through_reflection.active_record_primary_key
+                  jt_foreign_key = through_reflection.primary_key_name
+
+                  if through_reflection.options[:as] # has_many :through against a polymorphic join
+                    jt_as_extra = join_table[through_reflection.options[:as].to_s + '_type'].in(parent.active_record.sti_names)
+                  end
+                end
+
+                case source_reflection.macro
+                when :has_many
+                  if source_reflection.options[:as]
+                    first_key   = "#{source_reflection.options[:as]}_id"
+                    second_key  = options[:foreign_key] || primary_key
+                  else
+                    first_key   = through_reflection.klass.base_class.to_s.foreign_key
+                    second_key  = options[:foreign_key] || primary_key
+                  end
+
+                  unless through_reflection.klass.descends_from_active_record?
+                    # there is no test for this condition
+                    jt_sti_extra = join_table[through_reflection.active_record.inheritance_column].eq(through_reflection.klass.sti_name)
+                  end
+                when :belongs_to
+                  first_key = primary_key
+                  if reflection.options[:source_type]
+                    source_type = reflection.options[:source_type].to_s.constantize
+                    second_key = source_reflection.association_foreign_key
+                    jt_source_extra = join_table[reflection.source_reflection.options[:foreign_type]].in(source_type.sti_names)
+                  else
+                    second_key = source_reflection.primary_key_name
+                  end
+                end
+
+                [
+                  [parent_table[jt_primary_key].eq(join_table[jt_foreign_key]), jt_as_extra, jt_source_extra, jt_sti_extra].reject{|x| x.blank? },
+                  aliased_table[first_key].eq(join_table[second_key])
+                ]
+              elsif reflection.options[:as]
+                id_rel = aliased_table["#{reflection.options[:as]}_id"].eq(parent_table[parent.primary_key])
+                type_rel = aliased_table["#{reflection.options[:as]}_type"].in(parent.active_record.sti_names)
+                [id_rel, type_rel]
+              else
+                foreign_key = options[:foreign_key] || reflection.active_record.name.foreign_key
+                [aliased_table[foreign_key].eq(parent_table[reflection.options[:primary_key] || parent.primary_key])]
+              end
+            when :belongs_to
+              [aliased_table[options[:primary_key] || reflection.klass.primary_key].eq(parent_table[options[:foreign_key] || reflection.primary_key_name])]
+            end
+
+            unless klass.descends_from_active_record?
+              sti_column = aliased_table[klass.inheritance_column]
+              sti_condition = sti_column.eq(klass.sti_name)
+              klass.descendants.each {|subclass| sti_condition = sti_condition.or(sti_column.eq(subclass.sti_name)) }
+
+              @join << sti_condition
+            end
+
+            [through_reflection, reflection].each do |ref|
+              if ref && ref.options[:conditions]
+                @join << interpolate_sql(sanitize_sql(ref.options[:conditions], aliased_table_name))
+              end
+            end
+
+            @join
+          end
+          
+        end
+      end
+    end
+  end
+end

data/store_base_sti_class_for_3_0.gemspec

@@ -0,0 +1,77 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{store_base_sti_class_for_3_0}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Paul Kmiec"]
+  s.date = %q{2011-02-15}
+  s.description = %q{
+    ActiveRecord has always stored the base class in polymorphic _type columns when using STI. This can have non-trivial
+    performance implications in certain cases. This gem adds 'store_base_sti_class' configuration options which controls
+    whether ActiveRecord will store the base class or the actual class. Default to true for backwards compatibility.
+  }
+  s.email = %q{paul.kmiec@appfolio.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "lib/store_base_sti_class_for_3_0.rb",
+    "store_base_sti_class_for_3_0.gemspec",
+    "test/connection.rb",
+    "test/helper.rb",
+    "test/models.rb",
+    "test/schema.rb",
+    "test/test_store_base_sti_class_for_3_0.rb"
+  ]
+  s.homepage = %q{http://github.com/pkmiec/store_base_sti_class_for_3_0}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Modifies ActiveRecord 3.0.x with the ability to store the actual class (instead of the base class) in polymorhic _type columns when using STI}
+  s.test_files = [
+    "test/connection.rb",
+    "test/helper.rb",
+    "test/models.rb",
+    "test/schema.rb",
+    "test/test_store_base_sti_class_for_3_0.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activerecord>, ["~> 3.0.3"])
+      s.add_runtime_dependency(%q<mysql2>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<activerecord>, ["~> 3.0.3"])
+      s.add_dependency(%q<mysql2>, [">= 0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<activerecord>, ["~> 3.0.3"])
+    s.add_dependency(%q<mysql2>, [">= 0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+

data/test/connection.rb

@@ -0,0 +1,16 @@
+require 'logger'
+
+ActiveRecord::Base.logger = Logger.new("debug.log")
+
+# GRANT ALL PRIVILEGES ON storebasestiname_unittest.* to 'root'@'localhost';
+
+ActiveRecord::Base.configurations = {
+  'unittest' => {
+    :adapter  => 'mysql2',
+    :username => 'root',
+    :encoding => 'utf8',
+    :database => 'storebasestiname_unittest',
+  }
+}
+
+ActiveRecord::Base.establish_connection 'unittest'

data/test/helper.rb

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'store_base_sti_class_for_3_0'
+
+require 'connection'
+
+# silence verbose schema loading
+original_stdout = $stdout
+$stdout = StringIO.new
+begin
+  require "schema.rb"
+ensure
+  $stdout = original_stdout
+end
+
+require 'models'

data/test/models.rb

@@ -0,0 +1,38 @@
+class Author < ActiveRecord::Base
+  has_many :posts
+  
+  has_many :tagging,  :through => :posts                       # through polymorphic has_one
+  has_many :taggings, :through => :posts, :source => :taggings # through polymorphic has_many
+  has_many :tags,     :through => :posts                       # through has_many :through
+end
+
+class Post < ActiveRecord::Base
+  belongs_to :author
+  
+  has_one  :tagging, :as => :taggable
+  has_many :taggings, :as => :taggable
+  has_many :tags, :through => :taggings
+end
+
+class SpecialPost < Post
+end
+
+class Tagging < ActiveRecord::Base
+  belongs_to :tag, :include => :tagging
+  belongs_to :polytag, :polymorphic => true
+  belongs_to :taggable, :polymorphic => true, :counter_cache => true  
+end
+
+class Tag < ActiveRecord::Base
+  has_one  :tagging
+
+  has_many :taggings
+  has_many :taggables, :through => :taggings
+  has_many :tagged_posts, :through => :taggings, :source => :taggable, :source_type => 'Post'
+  
+  has_many :polytaggings, :as => :polytag, :class_name => 'Tagging'
+  has_many :polytagged_posts, :through => :polytaggings, :source => :taggable, :source_type => 'Post'
+end
+
+class SpecialTag < Tag
+end

data/test/schema.rb

@@ -0,0 +1,35 @@
+ActiveRecord::Schema.define do
+
+  # Please keep these create table statements in alphabetical order
+  # unless the ordering matters.  In which case, define them below
+
+  create_table :authors, :force => true do |t|
+    t.string :name, :null => false
+  end
+
+  create_table :posts, :force => true do |t|
+    t.string  :type
+
+    t.integer :author_id
+    t.string  :title, :null => false
+    t.text    :body, :null => false
+    t.integer :taggings_count, :default => 0
+  end
+
+  create_table :taggings, :force => true do |t|
+    t.integer :tag_id
+
+    t.integer :polytag_id
+    t.string  :polytag_type
+    
+    t.string  :taggable_type
+    t.integer :taggable_id
+  end
+
+  create_table :tags, :force => true do |t|
+    t.string  :type
+    t.string  :name
+    t.integer :taggings_count, :default => 0
+  end
+
+end

data/test/test_store_base_sti_class_for_3_0.rb

@@ -0,0 +1,133 @@
+require 'helper'
+require 'active_record/test_case'
+
+class TestStoreBaseStiNameFor30 < ActiveRecord::TestCase
+
+  def setup
+    @old_store_base_sti_class = ActiveRecord::Base.store_base_sti_class
+    ActiveRecord::Base.store_base_sti_class = false
+    
+    @thinking_post = SpecialPost.create(:title => 'Thinking')
+    @misc_tag = Tag.create(:name => 'Misc')
+  end
+
+  def teardown
+    ActiveRecord::Base.store_base_sti_class = @old_store_base_sti_class
+  end
+
+  def test_polymorphic_belongs_to_assignment_with_inheritance
+    # should update when assigning a saved record
+    tagging = Tagging.new
+    post = SpecialPost.create(:title => 'Budget Forecasts Bigger 2011 Deficit')
+    tagging.taggable = post
+    assert_equal post.id, tagging.taggable_id
+    assert_equal "SpecialPost", tagging.taggable_type
+  
+    # should update when assigning a new record
+    tagging = Tagging.new
+    post = SpecialPost.new(:title => 'Budget Forecasts Bigger 2011 Deficit')
+    tagging.taggable = post
+    assert_nil tagging.taggable_id
+    assert_equal "SpecialPost", tagging.taggable_type
+  end
+  
+  def test_polymorphic_has_many_create_model_with_inheritance
+    post = SpecialPost.new(:title => 'Budget Forecasts Bigger 2011 Deficit')
+  
+    tagging = @misc_tag.taggings.create(:taggable => post)
+    assert_equal "SpecialPost", tagging.taggable_type
+  
+    post.reload
+    assert_equal [tagging], post.taggings
+  end
+  
+  def test_polymorphic_has_one_create_model_with_inheritance
+    post = SpecialPost.new(:title => 'Budget Forecasts Bigger 2011 Deficit')
+  
+    tagging = @misc_tag.create_tagging(:taggable => post)
+    assert_equal "SpecialPost", tagging.taggable_type
+  
+    post.reload
+    assert_equal tagging, post.tagging
+  end
+  
+  def test_include_polymorphic_has_one
+    post = SpecialPost.create!(:title => 'Budget Forecasts Bigger 2011 Deficit')
+    tagging = post.create_tagging(:tag => @misc_tag)
+  
+    post = Post.find(post.id, :include => :tagging)
+    assert_equal tagging, assert_no_queries { post.tagging }
+  end
+  
+  def test_include_polymorphic_has_many
+    tag = SpecialTag.create!(:name => 'Special')
+    tag.polytagged_posts << SpecialPost.create!(:title => 'Budget Forecasts Bigger 2011 Deficit')
+    tag.polytagged_posts << @thinking_post
+  
+    tag = Tag.find(tag.id, :include => :polytaggings)
+    assert_equal 2, assert_no_queries { tag.polytaggings.length }
+  end
+  
+  def test_include_polymorphic_has_many_through
+    tag = SpecialTag.create!(:name => 'Special')
+    tag.polytagged_posts << SpecialPost.create!(:title => 'Budget Forecasts Bigger 2011 Deficit')
+    tag.polytagged_posts << @thinking_post
+  
+    tag = Tag.find(tag.id, :include => :polytagged_posts)
+    assert_equal 2, assert_no_queries { tag.polytagged_posts.length }
+  end
+  
+  def test_join_polymorhic_has_many
+    tag = SpecialTag.create!(:name => 'Special')
+    tag.polytagged_posts << SpecialPost.create!(:title => 'Budget Forecasts Bigger 2011 Deficit')
+    tag.polytagged_posts << @thinking_post
+  
+    assert Tag.find_by_id(tag.id, :joins => :polytaggings, :conditions => [ 'taggings.id = ?', tag.polytaggings.first.id ])
+  end
+  
+  def test_join_polymorhic_has_many_through
+    tag = SpecialTag.create!(:name => 'Special')
+    tag.polytagged_posts << SpecialPost.create!(:title => 'Budget Forecasts Bigger 2011 Deficit')
+    tag.polytagged_posts << @thinking_post
+  
+    assert Tag.find_by_id(tag.id, :joins => :polytagged_posts, :conditions => [ 'posts.id = ?', tag.polytaggings.first.taggable_id ])
+  end
+  
+  def test_has_many_through_polymorphic_has_one
+    author       = Author.create!(:name => 'Bob')
+    post         = Post.create!(:title => 'Budget Forecasts Bigger 2011 Deficit', :author => author)
+    special_post = SpecialPost.create!(:title => 'IBM Watson''s Jeopardy play', :author => author)
+    special_tag  = SpecialTag.create!(:name => 'SpecialGeneral')
+  
+    taggings = [ post.taggings.create(:tag => special_tag), special_post.taggings.create(:tag => special_tag) ]
+    assert_equal taggings.sort_by(&:id), author.tagging.sort_by(&:id)
+  end
+    
+  def test_has_many_polymorphic_with_source_type
+    tag = SpecialTag.create!(:name => 'Special')
+    tag.polytagged_posts << SpecialPost.create!(:title => 'Budget Forecasts Bigger 2011 Deficit')
+    tag.polytagged_posts << @thinking_post
+  
+    tag = Tag.find(tag.id)
+    assert_equal 2, tag.polytagged_posts.length
+  end
+  
+  def test_polymorphic_has_many_through_with_double_sti_on_join_model
+    tag = SpecialTag.create!(:name => 'Special')
+    post = @thinking_post
+  
+    tag.polytagged_posts << post
+    tag.reload
+  
+    assert_equal 1, tag.polytaggings.length
+  
+    tagging = tag.polytaggings.first
+  
+    assert_equal 'SpecialTag',  tagging.polytag_type
+    assert_equal 'SpecialPost', tagging.taggable_type
+  
+    assert_equal tag,  tagging.polytag
+    assert_equal post, tagging.taggable
+  end
+
+end

metadata

@@ -0,0 +1,160 @@
+--- !ruby/object:Gem::Specification 
+name: store_base_sti_class_for_3_0
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Paul Kmiec
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-15 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :runtime
+  name: activerecord
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 1
+        segments: 
+        - 3
+        - 0
+        - 3
+        version: 3.0.3
+  requirement: *id001
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :runtime
+  name: mysql2
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id002
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  name: bundler
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  requirement: *id003
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  name: jeweler
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 5
+        - 2
+        version: 1.5.2
+  requirement: *id004
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  name: rcov
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id005
+description: "\n    ActiveRecord has always stored the base class in polymorphic _type columns when using STI. This can have non-trivial\n    performance implications in certain cases. This gem adds 'store_base_sti_class' configuration options which controls\n    whether ActiveRecord will store the base class or the actual class. Default to true for backwards compatibility.\n  "
+email: paul.kmiec@appfolio.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .document
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/store_base_sti_class_for_3_0.rb
+- store_base_sti_class_for_3_0.gemspec
+- test/connection.rb
+- test/helper.rb
+- test/models.rb
+- test/schema.rb
+- test/test_store_base_sti_class_for_3_0.rb
+has_rdoc: true
+homepage: http://github.com/pkmiec/store_base_sti_class_for_3_0
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Modifies ActiveRecord 3.0.x with the ability to store the actual class (instead of the base class) in polymorhic _type columns when using STI
+test_files: 
+- test/connection.rb
+- test/helper.rb
+- test/models.rb
+- test/schema.rb
+- test/test_store_base_sti_class_for_3_0.rb