activerecord 5.0.0 → 5.0.7.2

data/lib/active_record/associations.rb

@@ -197,13 +197,6 @@ module ActiveRecord
     autoload :CollectionAssociation
     autoload :ForeignAssociation
     autoload :CollectionProxy
-
-    autoload :BelongsToAssociation
-    autoload :BelongsToPolymorphicAssociation
-    autoload :HasManyAssociation
-    autoload :HasManyThroughAssociation
-    autoload :HasOneAssociation
-    autoload :HasOneThroughAssociation
     autoload :ThroughAssociation
 
     module Builder #:nodoc:
@@ -218,12 +211,24 @@ module ActiveRecord
     end
 
     eager_autoload do
+      autoload :BelongsToAssociation
+      autoload :BelongsToPolymorphicAssociation
+      autoload :HasManyAssociation
+      autoload :HasManyThroughAssociation
+      autoload :HasOneAssociation
+      autoload :HasOneThroughAssociation
+
       autoload :Preloader
       autoload :JoinDependency
       autoload :AssociationScope
       autoload :AliasTracker
     end
 
+    def self.eager_load!
+      super
+      Preloader.eager_load!
+    end
+
     # Returns the association instance for the given name, instantiating it if it doesn't already exist
     def association(name) #:nodoc:
       association = association_instance_get(name)
@@ -312,17 +317,18 @@ module ActiveRecord
     #                                     |            |  belongs_to  |
     #   generated methods                 | belongs_to | :polymorphic | has_one
     #   ----------------------------------+------------+--------------+---------
-    #   other(force_reload=false)         |     X      |      X       |    X
+    #   other                             |     X      |      X       |    X
     #   other=(other)                     |     X      |      X       |    X
     #   build_other(attributes={})        |     X      |              |    X
     #   create_other(attributes={})       |     X      |              |    X
     #   create_other!(attributes={})      |     X      |              |    X
+    #   reload_other                      |     X      |      X       |    X
     #
     # === Collection associations (one-to-many / many-to-many)
     #                                     |       |          | has_many
     #   generated methods                 | habtm | has_many | :through
     #   ----------------------------------+-------+----------+----------
-    #   others(force_reload=false)        |   X   |    X     |    X
+    #   others                            |   X   |    X     |    X
     #   others=(other,other,...)          |   X   |    X     |    X
     #   other_ids                         |   X   |    X     |    X
     #   other_ids=(id,id,...)             |   X   |    X     |    X
@@ -346,6 +352,7 @@ module ActiveRecord
     #   others.exists?                    |   X   |    X     |    X
     #   others.distinct                   |   X   |    X     |    X
     #   others.reset                      |   X   |    X     |    X
+    #   others.reload                     |   X   |    X     |    X
     #
     # === Overriding generated methods
     #
@@ -1157,9 +1164,9 @@ module ActiveRecord
       # +collection+ is a placeholder for the symbol passed as the +name+ argument, so
       # <tt>has_many :clients</tt> would add among others <tt>clients.empty?</tt>.
       #
-      # [collection(force_reload = false)]
-      #   Returns an array of all the associated objects.
-      #   An empty array is returned if none are found.
+      # [collection]
+      #   Returns a Relation of all the associated objects.
+      #   An empty Relation is returned if none are found.
       # [collection<<(object, ...)]
       #   Adds one or more objects to the collection by setting their foreign keys to the collection's primary key.
       #   Note that this operation instantly fires update SQL without waiting for the save or update call on the
@@ -1216,6 +1223,9 @@ module ActiveRecord
       # [collection.create!(attributes = {})]
       #   Does the same as <tt>collection.create</tt>, but raises ActiveRecord::RecordInvalid
       #   if the record is invalid.
+      # [collection.reload]
+      #   Returns a Relation of all of the associated objects, forcing a database read.
+      #   An empty Relation is returned if none are found.
       #
       # === Example
       #
@@ -1235,6 +1245,7 @@ module ActiveRecord
       # * <tt>Firm#clients.build</tt> (similar to <tt>Client.new("firm_id" => id)</tt>)
       # * <tt>Firm#clients.create</tt> (similar to <tt>c = Client.new("firm_id" => id); c.save; c</tt>)
       # * <tt>Firm#clients.create!</tt> (similar to <tt>c = Client.new("firm_id" => id); c.save!</tt>)
+      # * <tt>Firm#clients.reload</tt>
       # The declaration can also include an +options+ hash to specialize the behavior of the association.
       #
       # === Scopes
@@ -1371,7 +1382,7 @@ module ActiveRecord
       # +association+ is a placeholder for the symbol passed as the +name+ argument, so
       # <tt>has_one :manager</tt> would add among others <tt>manager.nil?</tt>.
       #
-      # [association(force_reload = false)]
+      # [association]
       #   Returns the associated object. +nil+ is returned if none is found.
       # [association=(associate)]
       #   Assigns the associate object, extracts the primary key, sets it as the foreign key,
@@ -1388,6 +1399,8 @@ module ActiveRecord
       # [create_association!(attributes = {})]
       #   Does the same as <tt>create_association</tt>, but raises ActiveRecord::RecordInvalid
       #   if the record is invalid.
+      # [reload_association]
+      #   Returns the associated object, forcing a database read.
       #
       # === Example
       #
@@ -1397,6 +1410,7 @@ module ActiveRecord
       # * <tt>Account#build_beneficiary</tt> (similar to <tt>Beneficiary.new("account_id" => id)</tt>)
       # * <tt>Account#create_beneficiary</tt> (similar to <tt>b = Beneficiary.new("account_id" => id); b.save; b</tt>)
       # * <tt>Account#create_beneficiary!</tt> (similar to <tt>b = Beneficiary.new("account_id" => id); b.save!; b</tt>)
+      # * <tt>Account#reload_beneficiary</tt>
       #
       # === Scopes
       #
@@ -1503,7 +1517,7 @@ module ActiveRecord
       # +association+ is a placeholder for the symbol passed as the +name+ argument, so
       # <tt>belongs_to :author</tt> would add among others <tt>author.nil?</tt>.
       #
-      # [association(force_reload = false)]
+      # [association]
       #   Returns the associated object. +nil+ is returned if none is found.
       # [association=(associate)]
       #   Assigns the associate object, extracts the primary key, and sets it as the foreign key.
@@ -1517,6 +1531,8 @@ module ActiveRecord
       # [create_association!(attributes = {})]
       #   Does the same as <tt>create_association</tt>, but raises ActiveRecord::RecordInvalid
       #   if the record is invalid.
+      # [reload_association]
+      #   Returns the associated object, forcing a database read.
       #
       # === Example
       #
@@ -1526,6 +1542,7 @@ module ActiveRecord
       # * <tt>Post#build_author</tt> (similar to <tt>post.author = Author.new</tt>)
       # * <tt>Post#create_author</tt> (similar to <tt>post.author = Author.new; post.author.save; post.author</tt>)
       # * <tt>Post#create_author!</tt> (similar to <tt>post.author = Author.new; post.author.save!; post.author</tt>)
+      # * <tt>Post#reload_author</tt>
       # The declaration can also include an +options+ hash to specialize the behavior of the association.
       #
       # === Scopes
@@ -1661,9 +1678,9 @@ module ActiveRecord
       # +collection+ is a placeholder for the symbol passed as the +name+ argument, so
       # <tt>has_and_belongs_to_many :categories</tt> would add among others <tt>categories.empty?</tt>.
       #
-      # [collection(force_reload = false)]
-      #   Returns an array of all the associated objects.
-      #   An empty array is returned if none are found.
+      # [collection]
+      #   Returns a Relation of all the associated objects.
+      #   An empty Relation is returned if none are found.
       # [collection<<(object, ...)]
       #   Adds one or more objects to the collection by creating associations in the join table
       #   (<tt>collection.push</tt> and <tt>collection.concat</tt> are aliases to this method).
@@ -1701,6 +1718,9 @@ module ActiveRecord
       #   Returns a new object of the collection type that has been instantiated
       #   with +attributes+, linked to this object through the join table, and that has already been
       #   saved (if it passed the validation).
+      # [collection.reload]
+      #   Returns a Relation of all of the associated objects, forcing a database read.
+      #   An empty Relation is returned if none are found.
       #
       # === Example
       #
@@ -1719,6 +1739,7 @@ module ActiveRecord
       # * <tt>Developer#projects.exists?(...)</tt>
       # * <tt>Developer#projects.build</tt> (similar to <tt>Project.new("developer_id" => id)</tt>)
       # * <tt>Developer#projects.create</tt> (similar to <tt>c = Project.new("developer_id" => id); c.save; c</tt>)
+      # * <tt>Developer#projects.reload</tt>
       # The declaration may include an +options+ hash to specialize the behavior of the association.
       #
       # === Scopes

data/lib/active_record/attribute.rb

@@ -65,7 +65,7 @@ module ActiveRecord
 
     def with_value_from_user(value)
       type.assert_valid_value(value)
-      self.class.from_user(name, value, type, self)
+      self.class.from_user(name, value, type, original_attribute || self)
     end
 
     def with_value_from_database(value)
@@ -132,7 +132,7 @@ module ActiveRecord
     end
 
     def _original_value_for_database
-      value_for_database
+      type.serialize(original_value)
     end
 
     class FromDatabase < Attribute # :nodoc:
@@ -160,7 +160,7 @@ module ActiveRecord
         value
       end
 
-      def changed_in_place_from?(old_value)
+      def changed_in_place?
         false
       end
     end

data/lib/active_record/attribute_methods/primary_key.rb

@@ -95,7 +95,8 @@ module ActiveRecord
             base_name.foreign_key
           else
             if ActiveRecord::Base != self && table_exists?
-              connection.schema_cache.primary_keys(table_name)
+              pk = connection.schema_cache.primary_keys(table_name)
+              suppress_composite_primary_key(pk)
             else
               'id'
             end
@@ -122,6 +123,18 @@ module ActiveRecord
           @quoted_primary_key = nil
           @attributes_builder = nil
         end
+
+        private
+
+        def suppress_composite_primary_key(pk)
+          return pk unless pk.is_a?(Array)
+
+          warn <<-WARNING.strip_heredoc
+            WARNING: Active Record does not support composite primary key.
+
+            #{table_name} has composite primary key. Composite primary key is ignored.
+          WARNING
+        end
       end
     end
   end

data/lib/active_record/attribute_methods/read.rb

@@ -49,7 +49,7 @@ module ActiveRecord
       # to a date object, like Date.new(2004, 12, 12)).
       def read_attribute(attr_name, &block)
         name = attr_name.to_s
-        name = self.class.primary_key if name == 'id'.freeze
+        name = self.class.primary_key if name == "id".freeze && self.class.primary_key
         _read_attribute(name, &block)
       end
 

data/lib/active_record/attribute_methods/time_zone_conversion.rb

@@ -39,7 +39,7 @@ module ActiveRecord
         end
 
         def set_time_zone_without_conversion(value)
-          ::Time.zone.local_to_utc(value).in_time_zone
+          ::Time.zone.local_to_utc(value).in_time_zone if value
         end
 
         def map_avoiding_infinite_recursion(value)
@@ -102,7 +102,7 @@ module ActiveRecord
 
                   config.active_record.time_zone_aware_types = [:datetime]
 
-              To silence this deprecation warning, add the following:
+              To use the new behavior, add the following:
 
                   config.active_record.time_zone_aware_types = [:datetime, :time]
             MESSAGE

data/lib/active_record/attribute_methods.rb

@@ -279,9 +279,8 @@ module ActiveRecord
     # Returns an <tt>#inspect</tt>-like string for the value of the
     # attribute +attr_name+. String attributes are truncated up to 50
     # characters, Date and Time attributes are returned in the
-    # <tt>:db</tt> format, Array attributes are truncated up to 10 values.
-    # Other attributes return the value of <tt>#inspect</tt> without
-    # modification.
+    # <tt>:db</tt> format. Other attributes return the value of
+    # <tt>#inspect</tt> without modification.
     #
     #   person = Person.create!(name: 'David Heinemeier Hansson ' * 3)
     #
@@ -292,7 +291,7 @@ module ActiveRecord
     #   # => "\"2012-10-22 00:15:07\""
     #
     #   person.attribute_for_inspect(:tag_ids)
-    #   # => "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ...]"
+    #   # => "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]"
     def attribute_for_inspect(attr_name)
       value = read_attribute(attr_name)
 
@@ -300,9 +299,6 @@ module ActiveRecord
         "#{value[0, 50]}...".inspect
       elsif value.is_a?(Date) || value.is_a?(Time)
         %("#{value.to_s(:db)}")
-      elsif value.is_a?(Array) && value.size > 10
-        inspected = value.first(10).inspect
-        %(#{inspected[0...-1]}, ...])
       else
         value.inspect
       end

data/lib/active_record/attribute_set/builder.rb

@@ -3,33 +3,30 @@ require 'active_record/attribute'
 module ActiveRecord
   class AttributeSet # :nodoc:
     class Builder # :nodoc:
-      attr_reader :types, :always_initialized
+      attr_reader :types, :default_attributes
 
-      def initialize(types, always_initialized = nil)
+      def initialize(types, default_attributes = {})
         @types = types
-        @always_initialized = always_initialized
+        @default_attributes = default_attributes
       end
 
       def build_from_database(values = {}, additional_types = {})
-        if always_initialized && !values.key?(always_initialized)
-          values[always_initialized] = nil
-        end
-
-        attributes = LazyAttributeHash.new(types, values, additional_types)
+        attributes = LazyAttributeHash.new(types, values, additional_types, default_attributes)
         AttributeSet.new(attributes)
       end
     end
   end
 
   class LazyAttributeHash # :nodoc:
-    delegate :transform_values, :each_key, to: :materialize
+    delegate :transform_values, :each_key, :fetch, :except, to: :materialize
 
-    def initialize(types, values, additional_types)
+    def initialize(types, values, additional_types, default_attributes, delegate_hash = {})
       @types = types
       @values = values
       @additional_types = additional_types
       @materialized = false
-      @delegate_hash = {}
+      @delegate_hash = delegate_hash
+      @default_attributes = default_attributes
     end
 
     def key?(key)
@@ -76,9 +73,31 @@ module ActiveRecord
       end
     end
 
+    def marshal_dump
+      [@types, @values, @additional_types, @default_attributes, @delegate_hash]
+    end
+
+    def marshal_load(values)
+      if values.is_a?(Hash)
+        empty_hash = {}.freeze
+        initialize(empty_hash, empty_hash, empty_hash, empty_hash, values)
+        @materialized = true
+      else
+        initialize(*values)
+      end
+    end
+
+    def encode_with(coder)
+      coder["delegate_hash"] = materialize
+    end
+
+    def init_with(coder)
+      marshal_load(coder["delegate_hash"])
+    end
+
     protected
 
-    attr_reader :types, :values, :additional_types, :delegate_hash
+    attr_reader :types, :values, :additional_types, :delegate_hash, :default_attributes
 
     def materialize
       unless @materialized
@@ -101,7 +120,12 @@ module ActiveRecord
       if value_present
         delegate_hash[name] = Attribute.from_database(name, value, type)
       elsif types.key?(name)
-        delegate_hash[name] = Attribute.uninitialized(name, type)
+        attr = default_attributes[name]
+        if attr
+          delegate_hash[name] = attr.dup
+        else
+          delegate_hash[name] = Attribute.uninitialized(name, type)
+        end
       end
     end
   end

data/lib/active_record/attribute_set.rb

@@ -2,6 +2,8 @@ require 'active_record/attribute_set/builder'
 
 module ActiveRecord
   class AttributeSet # :nodoc:
+    delegate :fetch, :except, to: :attributes
+
     def initialize(attributes)
       @attributes = attributes
     end

data/lib/active_record/attributes.rb

@@ -34,10 +34,10 @@ module ActiveRecord
       # is not passed, the previous default value (if any) will be used.
       # Otherwise, the default will be +nil+.
       #
-      # +array+ (PG only) specifies that the type should be an array (see the
+      # +array+ (PostgreSQL only) specifies that the type should be an array (see the
       # examples below).
       #
-      # +range+ (PG only) specifies that the type should be a range (see the
+      # +range+ (PostgreSQL only) specifies that the type should be a range (see the
       # examples below).
       #
       # ==== Examples
@@ -253,7 +253,7 @@ module ActiveRecord
             name,
             value,
             type,
-            _default_attributes[name],
+            _default_attributes.fetch(name.to_s) { nil },
           )
         else
           default_attribute = Attribute.from_database(name, value, type)

data/lib/active_record/autosave_association.rb

@@ -329,26 +329,20 @@ module ActiveRecord
         return true if record.destroyed? || (reflection.options[:autosave] && record.marked_for_destruction?)
 
         validation_context = self.validation_context unless [:create, :update].include?(self.validation_context)
+
         unless valid = record.valid?(validation_context)
           if reflection.options[:autosave]
             indexed_attribute = !index.nil? && (reflection.options[:index_errors] || ActiveRecord::Base.index_nested_attribute_errors)
 
             record.errors.each do |attribute, message|
-              if indexed_attribute
-                attribute = "#{reflection.name}[#{index}].#{attribute}"
-              else
-                attribute = "#{reflection.name}.#{attribute}"
-              end
+              attribute = normalize_reflection_attribute(indexed_attribute, reflection, index, attribute)
               errors[attribute] << message
               errors[attribute].uniq!
             end
 
             record.errors.details.each_key do |attribute|
-              if indexed_attribute
-                reflection_attribute = "#{reflection.name}[#{index}].#{attribute}"
-              else
-                reflection_attribute = "#{reflection.name}.#{attribute}"
-              end
+              reflection_attribute =
+                normalize_reflection_attribute(indexed_attribute, reflection, index, attribute).to_sym
 
               record.errors.details[attribute].each do |error|
                 errors.details[reflection_attribute] << error
@@ -362,6 +356,14 @@ module ActiveRecord
         valid
       end
 
+      def normalize_reflection_attribute(indexed_attribute, reflection, index, attribute)
+        if indexed_attribute
+          "#{reflection.name}[#{index}].#{attribute}"
+        else
+          "#{reflection.name}.#{attribute}"
+        end
+      end
+
       # Is used as a before_save callback to check while saving a collection
       # association whether or not the parent was a new record before saving.
       def before_save_collection_association
@@ -457,7 +459,9 @@ module ActiveRecord
       # In addition, it will destroy the association if it was marked for destruction.
       def save_belongs_to_association(reflection)
         association = association_instance_get(reflection.name)
-        record      = association && association.load_target
+        return unless association && association.loaded? && !association.stale_target?
+
+        record = association.load_target
         if record && !record.destroyed?
           autosave = reflection.options[:autosave]
 

data/lib/active_record/base.rb

@@ -312,8 +312,8 @@ module ActiveRecord #:nodoc:
     include NestedAttributes
     include Aggregations
     include Transactions
-    include NoTouching
     include TouchLater
+    include NoTouching
     include Reflection
     include Serialization
     include Store

data/lib/active_record/collection_cache_key.rb

@@ -8,17 +8,27 @@ module ActiveRecord
       if collection.loaded?
         size = collection.size
         if size > 0
-          timestamp = collection.max_by(&timestamp_column).public_send(timestamp_column)
+          timestamp = collection.max_by(&timestamp_column)._read_attribute(timestamp_column)
         end
       else
         column_type = type_for_attribute(timestamp_column.to_s)
         column = "#{connection.quote_table_name(collection.table_name)}.#{connection.quote_column_name(timestamp_column)}"
+        select_values = "COUNT(*) AS #{connection.quote_column_name("size")}, MAX(%s) AS timestamp"
 
-        query = collection
-          .unscope(:select)
-          .select("COUNT(*) AS #{connection.quote_column_name("size")}", "MAX(#{column}) AS timestamp")
-          .unscope(:order)
-        result = connection.select_one(query)
+        if collection.limit_value || collection.offset_value
+          query = collection.spawn
+          query.select_values = [column]
+          subquery_alias = "subquery_for_cache_key"
+          subquery_column = "#{subquery_alias}.#{timestamp_column}"
+          subquery = query.arel.as(subquery_alias)
+          arel = Arel::SelectManager.new(query.engine).project(select_values % subquery_column).from(subquery)
+        else
+          query = collection.unscope(:order)
+          query.select_values = [select_values % column]
+          arel = query.arel
+        end
+
+        result = connection.select_one(arel, nil, query.bound_attributes)
 
         if result.blank?
           size = 0

data/lib/active_record/connection_adapters/abstract/connection_pool.rb

@@ -307,6 +307,7 @@ module ActiveRecord
       end
 
       include MonitorMixin
+      include QueryCache::ConnectionPoolConfiguration
 
       attr_accessor :automatic_reconnect, :checkout_timeout, :schema_cache
       attr_reader :spec, :connections, :size, :reaper
@@ -349,8 +350,7 @@ module ActiveRecord
         # currently in the process of independently establishing connections to the DB.
         @now_connecting = 0
 
-        # A boolean toggle that allows/disallows new connections.
-        @new_cons_enabled = true
+        @threads_blocking_new_connections = 0
 
         @available = ConnectionLeasingQueue.new self
       end
@@ -415,7 +415,10 @@ module ActiveRecord
         with_exclusively_acquired_all_connections(raise_on_acquisition_timeout) do
           synchronize do
             @connections.each do |conn|
-              checkin conn
+              if conn.in_use?
+                conn.steal!
+                checkin conn
+              end
               conn.disconnect!
             end
             @connections = []
@@ -442,33 +445,19 @@ module ActiveRecord
       #   connections in the pool within a timeout interval (default duration is
       #   <tt>spec.config[:checkout_timeout] * 2</tt> seconds).
       def clear_reloadable_connections(raise_on_acquisition_timeout = true)
-        num_new_conns_required = 0
-
         with_exclusively_acquired_all_connections(raise_on_acquisition_timeout) do
           synchronize do
             @connections.each do |conn|
-              checkin conn
+              if conn.in_use?
+                conn.steal!
+                checkin conn
+              end
               conn.disconnect! if conn.requires_reloading?
             end
             @connections.delete_if(&:requires_reloading?)
-
             @available.clear
-
-            if @connections.size < @size
-              # because of the pruning done by this method, we might be running
-              # low on connections, while threads stuck in queue are helpless
-              # (not being able to establish new connections for themselves),
-              # see also more detailed explanation in +remove+
-              num_new_conns_required = num_waiting_in_queue - @connections.size
-            end
-
-            @connections.each do |conn|
-              @available.add conn
-            end
           end
         end
-
-        bulk_make_new_connections(num_new_conns_required) if num_new_conns_required > 0
       end
 
       # Clears the cache which maps classes and re-connects connections that
@@ -556,17 +545,17 @@ module ActiveRecord
         stale_connections = synchronize do
           @connections.select do |conn|
             conn.in_use? && !conn.owner.alive?
+          end.each do |conn|
+            conn.steal!
           end
         end
 
         stale_connections.each do |conn|
-          synchronize do
-            if conn.active?
-              conn.reset!
-              checkin conn
-            else
-              remove conn
-            end
+          if conn.active?
+            conn.reset!
+            checkin conn
+          else
+            remove conn
           end
         end
       end
@@ -675,13 +664,32 @@ module ActiveRecord
       end
 
       def with_new_connections_blocked
-        previous_value = nil
         synchronize do
-          previous_value, @new_cons_enabled = @new_cons_enabled, false
+          @threads_blocking_new_connections += 1
         end
+
         yield
       ensure
-        synchronize { @new_cons_enabled = previous_value }
+        num_new_conns_required = 0
+
+        synchronize do
+          @threads_blocking_new_connections -= 1
+
+          if @threads_blocking_new_connections.zero?
+            @available.clear
+
+            num_new_conns_required = num_waiting_in_queue
+
+            @connections.each do |conn|
+              next if conn.in_use?
+
+              @available.add conn
+              num_new_conns_required -= 1
+            end
+          end
+        end
+
+        bulk_make_new_connections(num_new_conns_required) if num_new_conns_required > 0
       end
 
       # Acquire a connection by one of 1) immediately removing one
@@ -733,7 +741,7 @@ module ActiveRecord
         # and increment @now_connecting, to prevent overstepping this pool's @size
         # constraint
         do_checkout = synchronize do
-          if @new_cons_enabled && (@connections.size + @now_connecting) < @size
+          if @threads_blocking_new_connections.zero? && (@connections.size + @now_connecting) < @size
             @now_connecting += 1
           end
         end
@@ -927,7 +935,7 @@ module ActiveRecord
       end
 
       def pool_from_any_process_for(spec_name)
-        owner_to_pool = @owner_to_pool.values.find { |v| v[spec_name] }
+        owner_to_pool = @owner_to_pool.values.reverse.find { |v| v[spec_name] }
         owner_to_pool && owner_to_pool[spec_name]
       end
     end

data/lib/active_record/connection_adapters/abstract/database_statements.rb

@@ -244,7 +244,7 @@ module ActiveRecord
       end
 
       def reset_transaction #:nodoc:
-        @transaction_manager = TransactionManager.new(self)
+        @transaction_manager = ConnectionAdapters::TransactionManager.new(self)
       end
 
       # Register a record with the current transaction so that its after_commit and after_rollback callbacks