activerecord 2.3.18 → 3.0.0.beta

data/CHANGELOG

@@ -1,35 +1,115 @@
-*2.3.11 (February 9, 2011)*
+*Edge*
 
-*2.3.10 (October 15, 2010)*
+* PostgreSQLAdapter: set time_zone to UTC when Base.default_timezone == :utc so that Postgres doesn't incorrectly offset-adjust values inserted into TIMESTAMP WITH TIME ZONE columns. #3777 [Jack Christensen]
 
-* Security Release to fix CVE-2010-3933
+* Allow relations to be used as scope.
 
-*2.3.9 (September 4, 2010)*
-*2.3.8 (May 24, 2010)*
-*2.3.7 (May 24, 2010)*
+  class Item
+    scope :red, where(:colour => 'red')
+  end
 
-* Version bump.
+  Item.red.limit(10) # Ten red items
 
+* Rename named_scope to scope. [Pratik Naik]
 
-*2.3.6 (May 23, 2010)*
+* Changed ActiveRecord::Base.store_full_sti_class to be true by default reflecting the previously announced Rails 3 default [DHH]
 
-* Add index length support for MySQL. #1852 [Emili Parreno, Pratik Naik]
+* Add Relation#except. [Pratik Naik]
 
-  Example:
+  one_red_item = Item.where(:colour => 'red').limit(1)
+  all_items = one_red_item.except(:where, :limit)
+
+* Add Relation#delete_all. [Pratik Naik]
+
+  Item.where(:colour => 'red').delete_all
+
+* Add Model.having and Relation#having. [Pratik Naik]
+
+  Developer.group("salary").having("sum(salary) >  10000").select("salary")
+
+* Add Relation#count. [Pratik Naik]
+
+  legends = People.where("age > 100")
+  legends.count
+  legends.count(:age, :distinct => true)
+  legends.select('id').count
+
+* Add Model.readonly and association_collection#readonly finder method. [Pratik Naik]
+
+  Post.readonly.to_a # Load all posts in readonly mode
+  @user.items.readonly(false).to_a # Load all the user items in writable mode
+
+* Add .lock finder method [Pratik Naik]
+
+  User.lock.where(:name => 'lifo').to_a
+
+  old_items = Item.where("age > 100")
+  old_items.lock.each {|i| .. }
+
+* Add Model.from and association_collection#from finder methods [Pratik Naik]
+
+  user = User.scoped
+  user.select('*').from('users, items')
+
+* Add relation.destroy_all [Pratik Naik]
+
+  old_items = Item.where("age > 100")
+  old_items.destroy_all
+
+* Add relation.exists? [Pratik Naik]
+
+  red_items = Item.where(:colours => 'red')
+  red_items.exists?
+  red_items.exists?(1)
 
-    add_index(:accounts, :name, :name => 'by_name', :length => 10)
-    => CREATE INDEX by_name ON accounts(name(10))
+* Add find(ids) to relations. [Pratik Naik]
 
-    add_index(:accounts, [:name, :surname], :name => 'by_name_surname', :length => {:name => 10, :surname => 15})
-    => CREATE INDEX by_name_surname ON accounts(name(10), surname(15))
+  old_users = User.order("age DESC")
+  old_users.find(1)
+  old_users.find(1, 2, 3)
 
-* find_or_create_by_attr(value, ...) works when attr is protected.  #4457 [Santiago Pastorino, Marc-André Lafortune]
+* Add new finder methods to association collection. [Pratik Naik]
 
-* JSON supports a custom root option: to_json(:root => 'custom')  #4515 [Jatinder Singh]
+  class User < ActiveRecord::Base
+    has_many :items
+  end
+
+  user = User.first
+  user.items.where(:items => {:colour => 'red'})
+  user.items.select('items.id')
+
+* Add relation.reload to force reloading the records. [Pratik Naik]
+
+  topics = Topic.scoped
+  topics.to_a  # force load
+  topics.first # returns a cached record
+  topics.reload
+  topics.first # Fetches a new record from the database
+
+* Rename Model.conditions and relation.conditions to .where. [Pratik Naik]
+
+  Before :
+    User.conditions(:name => 'lifo')
+    User.select('id').conditions(["age > ?", 21])
+
+  Now :
+    User.where(:name => 'lifo')
+    User.select('id').where(["age > ?", 21])
+
+* Add Model.select/group/order/limit/joins/conditions/preload/eager_load class methods returning a lazy relation. [Pratik Naik]
+
+  Examples :
+
+    posts = Post.select('id).order('name') # Returns a lazy relation
+    posts.each {|p| puts p.id } # Fires "select id from posts order by name"
 
-* Destroy uses optimistic locking. If lock_version on the record you're destroying doesn't match lock_version in the database, a StaleObjectError is raised.  #1966 [Curtis Hawthorne]
+* Model.scoped now returns a relation if invoked without any arguments. [Pratik Naik]
 
-* To prefix the table names of all models in a module, define self.table_name_prefix on the module.  #4032 [Andrew White]
+  Example :
+
+    posts = Post.scoped
+    posts.size # Fires "select count(*) from  posts" and returns the count
+    posts.each {|p| puts p.name } # Fires "select * from posts" and loads post objects
 
 * Association inverses for belongs_to, has_one, and has_many. Optimization to reduce database queries.  #3533 [Murray Steele]
 
@@ -42,29 +122,20 @@
 
 * Reset your Active Record counter caches with the reset_counter_cache class method.  #1211 [Mike Breen, Gabe da Silveira]
 
-
-*2.3.5 (November 25, 2009)*
-
-* Minor Bug Fixes and deprecation warnings
-
-* 1.9 Compatibility
-
-* Numerous fixes to the nested attributes functionality
-
-
-*2.3.4 (September 4, 2009)*
+* Remove support for SQLite 2. Please upgrade to SQLite 3+ or install the plugin from git://github.com/rails/sqlite2_adapter.git [Pratik Naik]
 
 * PostgreSQL: XML datatype support.  #1874 [Leonardo Borges]
 
-* SQLite: deprecate the 'dbfile' option in favor of 'database.'  #2363 [Paul Hinze, Jeremy Kemper]
+* quoted_date converts time-like objects to ActiveRecord::Base.default_timezone before serialization. This allows you to use Time.now in find conditions and have it correctly be serialized as the current time in UTC when default_timezone == :utc. #2946 [Geoff Buesing]
 
-
-*2.3.3 (July 12, 2009)*
+* SQLite: drop support for 'dbfile' option in favor of 'database.'  #2363 [Paul Hinze, Jeremy Kemper]
 
 * Added :primary_key option to belongs_to associations.  #765 [Szymon Nowak, Philip Hallstrom, Noel Rocha]
     # employees.company_name references companies.name
     Employee.belongs_to :company, :primary_key => 'name', :foreign_key => 'company_name'
 
+* Implement #many? for NamedScope and AssociationCollection using #size. #1500 [Chris Kampmeier]
+
 * Added :touch option to belongs_to associations that will touch the parent record when the current record is saved or destroyed [DHH]
 
 * Added ActiveRecord::Base#touch to update the updated_at/on attributes (or another specified timestamp) with the current time [DHH]
@@ -2252,7 +2323,7 @@ during calendar reform.  #7649, #7724 [fedot, Geoff Buesing]
 
 * Escape database name in MySQL adapter when creating and dropping databases. #3409 [anna@wota.jp]
 
-* Disambiguate table names for columns in validates_uniquness_of's WHERE clause. #3423 [alex.borovsky@gmail.com]
+* Disambiguate table names for columns in validates_uniqueness_of's WHERE clause. #3423 [alex.borovsky@gmail.com]
 
 * .with_scope imposed create parameters now bypass attr_protected [Tobias Lütke]
 
@@ -3767,7 +3838,7 @@ in effect.  Added :readonly finder constraint.  Calling an association collectio
 
 * Escape database name in MySQL adapter when creating and dropping databases. #3409 [anna@wota.jp]
 
-* Disambiguate table names for columns in validates_uniquness_of's WHERE clause. #3423 [alex.borovsky@gmail.com]
+* Disambiguate table names for columns in validates_uniqueness_of's WHERE clause. #3423 [alex.borovsky@gmail.com]
 
 * .with_scope imposed create parameters now bypass attr_protected [Tobias Lütke]
 

data/examples/performance.rb

@@ -12,8 +12,6 @@ require 'rbench'
 
 __DIR__ = File.dirname(__FILE__)
 $:.unshift "#{__DIR__}/../lib"
-$:.unshift "#{__DIR__}/../../activesupport/lib"
-
 require 'active_record'
 
 conn = { :adapter => 'mysql',
@@ -27,7 +25,7 @@ conn[:socket] = Pathname.glob(%w[
   /tmp/mysql.sock
   /var/mysql/mysql.sock
   /var/run/mysqld/mysqld.sock
-]).find { |path| path.socket? }.to_s
+]).find { |path| path.socket? }
 
 ActiveRecord::Base.establish_connection(conn)
 
@@ -60,7 +58,7 @@ end
 sqlfile = "#{__DIR__}/performance.sql"
 
 if File.exists?(sqlfile)
-  mysql_bin = %w[mysql mysql5].detect { |bin| `which #{bin}`.length > 0 }
+  mysql_bin = %w[mysql mysql5].select { |bin| `which #{bin}`.length > 0 }
   `#{mysql_bin} -u #{conn[:username]} #{"-p#{conn[:password]}" unless conn[:password].blank?} #{conn[:database]} < #{sqlfile}`
 else
   puts 'Generating data...'
@@ -90,7 +88,7 @@ else
     )
   end
 
-  mysqldump_bin = %w[mysqldump mysqldump5].detect { |bin| `which #{bin}`.length > 0 }
+  mysqldump_bin = %w[mysqldump mysqldump5].select { |bin| `which #{bin}`.length > 0 }
   `#{mysqldump_bin} -u #{conn[:username]} #{"-p#{conn[:password]}" unless conn[:password].blank?} #{conn[:database]} exhibits users > #{sqlfile}`
 end
 
@@ -157,40 +155,6 @@ RBench.run(TIMES) do
     ar { Exhibit.transaction { Exhibit.new } }
   end
 
-  report 'Model.find(id)' do
-    id = Exhibit.first.id
-    ar { Exhibit.find(id) }
-  end
-
-  report 'Model.find_by_sql' do
-    ar { Exhibit.find_by_sql("SELECT * FROM exhibits WHERE id = #{(rand * 1000 + 1).to_i}").first }
-  end
-
-  report 'Model.log', (TIMES * 10) do
-    ar { Exhibit.connection.send(:log, "hello", "world") {} }
-  end
-
-  report 'AR.execute(query)', (TIMES / 2) do
-    ar { ActiveRecord::Base.connection.execute("Select * from exhibits where id = #{(rand * 1000 + 1).to_i}") }
-  end
-
-  report 'Model.find(id)' do
-    id = Exhibit.first.id
-    ar { Exhibit.find(id) }
-  end
-
-  report 'Model.find_by_sql' do
-    ar { Exhibit.find_by_sql("SELECT * FROM exhibits WHERE id = #{(rand * 1000 + 1).to_i}").first }
-  end
-
-  report 'Model.log', (TIMES * 10) do
-    ar { Exhibit.connection.send(:log, "hello", "world") {} }
-  end
-
-  report 'AR.execute(query)', (TIMES / 2) do
-    ar { ActiveRecord::Base.connection.execute("Select * from exhibits where id = #{(rand * 1000 + 1).to_i}") }
-  end
-
   summary 'Total'
 end
 

data/examples/simple.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
+require 'active_record'
+
+class Person < ActiveRecord::Base
+  establish_connection :adapter => 'sqlite3', :database => 'foobar.db'
+  connection.create_table table_name, :force => true do |t|
+    t.string :name
+  end
+end
+
+bob = Person.create!(:name => 'bob')
+puts Person.all.inspect
+bob.destroy
+puts Person.all.inspect

data/lib/active_record.rb

@@ -21,63 +21,97 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
-begin
-  require 'active_support'
-rescue LoadError
-  activesupport_path = "#{File.dirname(__FILE__)}/../../activesupport/lib"
-  if File.directory?(activesupport_path)
-    $:.unshift activesupport_path
-    require 'active_support'
-  end
-end
+
+activesupport_path = File.expand_path('../../../activesupport/lib', __FILE__)
+$:.unshift(activesupport_path) if File.directory?(activesupport_path) && !$:.include?(activesupport_path)
+
+activemodel_path = File.expand_path('../../../activemodel/lib', __FILE__)
+$:.unshift(activemodel_path) if File.directory?(activemodel_path) && !$:.include?(activemodel_path)
+
+require 'active_support'
+require 'active_model'
+require 'arel'
 
 module ActiveRecord
-  # TODO: Review explicit loads to see if they will automatically be handled by the initilizer.
-  def self.load_all!
-    [Base, DynamicFinderMatch, ConnectionAdapters::AbstractAdapter]
+  extend ActiveSupport::Autoload
+
+  eager_autoload do
+    autoload :VERSION
+
+    autoload :ActiveRecordError, 'active_record/base'
+    autoload :ConnectionNotEstablished, 'active_record/base'
+
+    autoload :Aggregations
+    autoload :AssociationPreload
+    autoload :Associations
+    autoload :AttributeMethods
+    autoload :AutosaveAssociation
+
+    autoload :Relation
+
+    autoload_under 'relation' do
+      autoload :QueryMethods
+      autoload :FinderMethods
+      autoload :Calculations
+      autoload :PredicateBuilder
+      autoload :SpawnMethods
+    end
+
+    autoload :Base
+    autoload :Batches
+    autoload :Callbacks
+    autoload :DynamicFinderMatch
+    autoload :DynamicScopeMatch
+    autoload :Migration
+    autoload :Migrator, 'active_record/migration'
+    autoload :NamedScope
+    autoload :NestedAttributes
+    autoload :Observer
+    autoload :QueryCache
+    autoload :Reflection
+    autoload :Schema
+    autoload :SchemaDumper
+    autoload :Serialization
+    autoload :SessionStore
+    autoload :Timestamp
+    autoload :Transactions
+    autoload :Validations
   end
 
-  autoload :VERSION, 'active_record/version'
-
-  autoload :ActiveRecordError, 'active_record/base'
-  autoload :ConnectionNotEstablished, 'active_record/base'
-
-  autoload :Aggregations, 'active_record/aggregations'
-  autoload :AssociationPreload, 'active_record/association_preload'
-  autoload :Associations, 'active_record/associations'
-  autoload :AttributeMethods, 'active_record/attribute_methods'
-  autoload :AutosaveAssociation, 'active_record/autosave_association'
-  autoload :Base, 'active_record/base'
-  autoload :Batches, 'active_record/batches'
-  autoload :Calculations, 'active_record/calculations'
-  autoload :Callbacks, 'active_record/callbacks'
-  autoload :Dirty, 'active_record/dirty'
-  autoload :DynamicFinderMatch, 'active_record/dynamic_finder_match'
-  autoload :DynamicScopeMatch, 'active_record/dynamic_scope_match'
-  autoload :Migration, 'active_record/migration'
-  autoload :Migrator, 'active_record/migration'
-  autoload :NamedScope, 'active_record/named_scope'
-  autoload :NestedAttributes, 'active_record/nested_attributes'
-  autoload :Observing, 'active_record/observer'
-  autoload :QueryCache, 'active_record/query_cache'
-  autoload :Reflection, 'active_record/reflection'
-  autoload :Schema, 'active_record/schema'
-  autoload :SchemaDumper, 'active_record/schema_dumper'
-  autoload :Serialization, 'active_record/serialization'
-  autoload :SessionStore, 'active_record/session_store'
-  autoload :TestCase, 'active_record/test_case'
-  autoload :Timestamp, 'active_record/timestamp'
-  autoload :Transactions, 'active_record/transactions'
-  autoload :Validations, 'active_record/validations'
+  module AttributeMethods
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :BeforeTypeCast
+      autoload :Dirty
+      autoload :PrimaryKey
+      autoload :Query
+      autoload :Read
+      autoload :TimeZoneConversion
+      autoload :Write
+    end
+  end
 
   module Locking
-    autoload :Optimistic, 'active_record/locking/optimistic'
-    autoload :Pessimistic, 'active_record/locking/pessimistic'
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :Optimistic
+      autoload :Pessimistic
+    end
   end
 
   module ConnectionAdapters
-    autoload :AbstractAdapter, 'active_record/connection_adapters/abstract_adapter'
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :AbstractAdapter
+    end
   end
+
+  autoload :TestCase
+  autoload :TestFixtures, 'active_record/fixtures'
 end
 
+Arel::Table.engine = Arel::Sql::Engine.new(ActiveRecord::Base)
 I18n.load_path << File.dirname(__FILE__) + '/active_record/locale/en.yml'

data/lib/active_record/aggregations.rb

@@ -1,8 +1,6 @@
 module ActiveRecord
   module Aggregations # :nodoc:
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
+    extend ActiveSupport::Concern
 
     def clear_aggregation_cache #:nodoc:
       self.class.reflect_on_all_aggregations.to_a.each do |assoc|

data/lib/active_record/association_preload.rb

@@ -1,9 +1,10 @@
+require 'active_support/core_ext/array/wrap'
+require 'active_support/core_ext/enumerable'
+
 module ActiveRecord
   # See ActiveRecord::AssociationPreload::ClassMethods for documentation.
   module AssociationPreload #:nodoc:
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
+    extend ActiveSupport::Concern
 
     # Implements the details of eager loading of ActiveRecord associations.
     # Application developers should not use this module directly.
@@ -30,7 +31,7 @@ module ActiveRecord
     # 'books' table is useful; the joined 'authors' data is just redundant, and
     # processing this redundant data takes memory and CPU time. The problem
     # quickly becomes worse and worse as the level of eager loading increases
-    # (i.e. if ActiveRecord is to eager load the associations' assocations as
+    # (i.e. if ActiveRecord is to eager load the associations' associations as
     # well).
     #
     # The second strategy is to use multiple database queries, one for each
@@ -60,7 +61,7 @@ module ActiveRecord
       # +associations+ specifies one or more associations that you want to
       # preload. It may be:
       # - a Symbol or a String which specifies a single association name. For
-      #   example, specifiying +:books+ allows this method to preload all books
+      #   example, specifying +:books+ allows this method to preload all books
       #   for an Author.
       # - an Array which specifies multiple association names. This array
       #   is processed recursively. For example, specifying <tt>[:avatar, :books]</tt>
@@ -84,7 +85,7 @@ module ActiveRecord
       # only one level deep in the +associations+ argument, i.e. it's not passed
       # to the child associations when +associations+ is a Hash.
       def preload_associations(records, associations, preload_options={})
-        records = [records].flatten.compact.uniq
+        records = Array.wrap(records).compact.uniq
         return if records.empty?
         case associations
         when Array then associations.each {|association| preload_associations(records, association, preload_options)}
@@ -94,7 +95,7 @@ module ActiveRecord
             raise "parent must be an association name" unless parent.is_a?(String) || parent.is_a?(Symbol)
             preload_associations(records, parent, preload_options)
             reflection = reflections[parent]
-            parents = records.map {|record| record.send(reflection.name)}.flatten.compact
+            parents = records.sum { |record| Array.wrap(record.send(reflection.name)) }
             unless parents.empty?
               parents.first.class.preload_associations(parents, child)
             end
@@ -125,7 +126,8 @@ module ActiveRecord
         parent_records.each do |parent_record|
           association_proxy = parent_record.send(reflection_name)
           association_proxy.loaded
-          association_proxy.target.push(*[associated_record].flatten)
+          association_proxy.target.push *Array.wrap(associated_record)
+
           association_proxy.__send__(:set_inverse_instance, associated_record, parent_record)
         end
       end
@@ -157,11 +159,6 @@ module ActiveRecord
             association_proxy.__send__(:set_inverse_instance, associated_record, mapped_record)
           end
         end
-
-        id_to_record_map.each do |id, records|
-          next if seen_keys.include?(id.to_s)
-          records.each {|record| record.send("set_#{reflection_name}_target", nil) }            
-        end
       end
 
       # Given a collection of ActiveRecord objects, constructs a Hash which maps
@@ -190,13 +187,12 @@ module ActiveRecord
         conditions = "t0.#{reflection.primary_key_name} #{in_or_equals_for_ids(ids)}"
         conditions << append_conditions(reflection, preload_options)
 
-        associated_records = reflection.klass.with_exclusive_scope do
-          reflection.klass.find(:all, :conditions => [conditions, ids],
-            :include => options[:include],
-            :joins => "INNER JOIN #{connection.quote_table_name options[:join_table]} t0 ON #{reflection.klass.quoted_table_name}.#{reflection.klass.primary_key} = t0.#{reflection.association_foreign_key}",
-            :select => "#{options[:select] || table_name+'.*'}, t0.#{reflection.primary_key_name} as the_parent_record_id",
-            :order => options[:order])
-        end
+        associated_records = reflection.klass.unscoped.where([conditions, ids]).
+            includes(options[:include]).
+            joins("INNER JOIN #{connection.quote_table_name options[:join_table]} t0 ON #{reflection.klass.quoted_table_name}.#{reflection.klass.primary_key} = t0.#{reflection.association_foreign_key}").
+            select("#{options[:select] || table_name+'.*'}, t0.#{reflection.primary_key_name} as the_parent_record_id").
+            order(options[:order]).to_a
+
         set_association_collection_records(id_to_record_map, reflection.name, associated_records, 'the_parent_record_id')
       end
 
@@ -261,6 +257,7 @@ module ActiveRecord
         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]
           preload_options = {:conditions => ["#{connection.quote_column_name interface} = ?", reflection.options[:source_type]]}
@@ -269,27 +266,22 @@ module ActiveRecord
           records.first.class.preload_associations(records, through_association, preload_options)
 
           # Dont cache the association - we would only be caching a subset
-          through_records = []
           records.each do |record|
             proxy = record.send(through_association)
 
             if proxy.respond_to?(:target)
-              through_records << proxy.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
-          through_records.flatten!
         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)
-          through_records = records.map {|record| record.send(through_association)}.flatten
+          records.first.class.preload_associations(records, through_association)
+          records.each do |record|
+            through_records.concat Array.wrap(record.send(through_association))
+          end
         end
-        through_records.compact!
         through_records
       end
 
@@ -332,8 +324,9 @@ module ActiveRecord
           klass = klass_name.constantize
 
           table_name = klass.quoted_table_name
-          primary_key = reflection.options[:primary_key] || klass.primary_key
+          primary_key = klass.primary_key
           column_type = klass.columns.detect{|c| c.name == primary_key}.type
+
           ids = id_map.keys.map do |id|
             if column_type == :integer
               id.to_i
@@ -343,15 +336,12 @@ module ActiveRecord
               id
             end
           end
+
           conditions = "#{table_name}.#{connection.quote_column_name(primary_key)} #{in_or_equals_for_ids(ids)}"
           conditions << append_conditions(reflection, preload_options)
-          associated_records = klass.with_exclusive_scope do
-            klass.find(:all, :conditions => [conditions, ids],
-                                          :include => options[:include],
-                                          :select => options[:select],
-                                          :joins => options[:joins],
-                                          :order => options[:order])
-          end
+
+          associated_records = klass.unscoped.where([conditions, ids]).apply_finder_options(options.slice(:include, :select, :joins, :order)).to_a
+
           set_association_single_records(id_map, reflection.name, associated_records, primary_key)
         end
       end
@@ -361,13 +351,7 @@ module ActiveRecord
         table_name = reflection.klass.quoted_table_name
 
         if interface = reflection.options[:as]
-          parent_type = if reflection.active_record.abstract_class?
-            self.base_class.sti_name
-          else
-            reflection.active_record.sti_name
-          end
-
-          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"} = '#{parent_type}'"
+          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.base_class.sti_name}'"
         else
           foreign_key = reflection.primary_key_name
           conditions = "#{reflection.klass.quoted_table_name}.#{foreign_key} #{in_or_equals_for_ids(ids)}"
@@ -375,15 +359,16 @@ module ActiveRecord
 
         conditions << append_conditions(reflection, preload_options)
 
-        reflection.klass.with_exclusive_scope do
-          reflection.klass.find(:all,
-                              :select => (preload_options[:select] || options[:select] || "#{table_name}.*"),
-                              :include => preload_options[:include] || options[:include],
-                              :conditions => [conditions, ids],
-                              :joins => options[:joins],
-                              :group => preload_options[:group] || options[:group],
-                              :order => preload_options[:order] || options[:order])
-        end
+        find_options = {
+          :select => preload_options[:select] || options[:select] || "#{table_name}.*",
+          :include => preload_options[:include] || options[:include],
+          :conditions => [conditions, ids],
+          :joins => options[:joins],
+          :group => preload_options[:group] || options[:group],
+          :order => preload_options[:order] || options[:order]
+        }
+
+        reflection.klass.unscoped.apply_finder_options(find_options).to_a
       end