activerecord 5.2.0.beta2 → 5.2.0.rc1

data/lib/active_record/associations/belongs_to_association.rb

@@ -12,17 +12,20 @@ module ActiveRecord
         if record
           raise_on_type_mismatch!(record)
           update_counters_on_replace(record)
-          replace_keys(record)
           set_inverse_instance(record)
           @updated = true
         else
           decrement_counters
-          remove_keys
         end
 
         self.target = record
       end
 
+      def target=(record)
+        replace_keys(record)
+        super
+      end
+
       def default(&block)
         writer(owner.instance_exec(&block)) if reader.nil?
       end
@@ -49,9 +52,9 @@ module ActiveRecord
         def update_counters(by)
           if require_counter_update? && foreign_key_present?
             if target && !stale_target?
-              target.increment!(reflection.counter_cache_column, by)
+              target.increment!(reflection.counter_cache_column, by, touch: reflection.options[:touch])
             else
-              klass.update_counters(target_id, reflection.counter_cache_column => by)
+              klass.update_counters(target_id, reflection.counter_cache_column => by, touch: reflection.options[:touch])
             end
           end
         end
@@ -78,11 +81,8 @@ module ActiveRecord
         end
 
         def replace_keys(record)
-          owner[reflection.foreign_key] = record._read_attribute(reflection.association_primary_key(record.class))
-        end
-
-        def remove_keys
-          owner[reflection.foreign_key] = nil
+          owner[reflection.foreign_key] = record ?
+            record._read_attribute(reflection.association_primary_key(record.class)) : nil
         end
 
         def foreign_key_present?

data/lib/active_record/associations/belongs_to_polymorphic_association.rb

@@ -13,12 +13,7 @@ module ActiveRecord
 
         def replace_keys(record)
           super
-          owner[reflection.foreign_type] = record.class.base_class.name
-        end
-
-        def remove_keys
-          super
-          owner[reflection.foreign_type] = nil
+          owner[reflection.foreign_type] = record ? record.class.base_class.name : nil
         end
 
         def different_target?(record)

data/lib/active_record/associations/builder/association.rb

@@ -104,8 +104,8 @@ module ActiveRecord::Associations::Builder # :nodoc:
 
     def self.define_readers(mixin, name)
       mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
-        def #{name}(*args)
-          association(:#{name}).reader(*args)
+        def #{name}
+          association(:#{name}).reader
         end
       CODE
     end

data/lib/active_record/associations/builder/belongs_to.rb

@@ -114,9 +114,13 @@ module ActiveRecord::Associations::Builder # :nodoc:
         BelongsTo.touch_record(record, record.send(changes_method), foreign_key, n, touch, belongs_to_touch_method)
       }}
 
-      model.after_save    callback.(:saved_changes), if: :saved_changes?
-      model.after_touch   callback.(:changes_to_save)
-      model.after_destroy callback.(:changes_to_save)
+      unless reflection.counter_cache_column
+        model.after_create callback.(:saved_changes), if: :saved_changes?
+        model.after_destroy callback.(:changes_to_save)
+      end
+
+      model.after_update callback.(:saved_changes), if: :saved_changes?
+      model.after_touch callback.(:changes_to_save)
     end
 
     def self.add_default_callbacks(model, reflection)

data/lib/active_record/associations/collection_association.rb

@@ -52,11 +52,11 @@ module ActiveRecord
 
       # Implements the ids writer method, e.g. foo.item_ids= for Foo.has_many :items
       def ids_writer(ids)
-        pk_type = reflection.association_primary_key_type
+        primary_key = reflection.association_primary_key
+        pk_type = klass.type_for_attribute(primary_key)
         ids = Array(ids).reject(&:blank?)
         ids.map! { |i| pk_type.cast(i) }
 
-        primary_key = reflection.association_primary_key
         records = klass.where(primary_key => ids).index_by do |r|
           r.public_send(primary_key)
         end.values_at(*ids).compact

data/lib/active_record/associations/collection_proxy.rb

@@ -32,7 +32,7 @@ module ActiveRecord
     class CollectionProxy < Relation
       def initialize(klass, association) #:nodoc:
         @association = association
-        super klass, klass.arel_table, klass.predicate_builder
+        super klass
 
         extensions = association.extensions
         extend(*extensions) if extensions.any?

data/lib/active_record/associations/has_many_association.rb

@@ -63,7 +63,7 @@ module ActiveRecord
           count = if reflection.has_cached_counter?
             owner._read_attribute(reflection.counter_cache_column).to_i
           else
-            scope.count
+            scope.count(:all)
           end
 
           # If there's nothing in the database and @target has no new records

data/lib/active_record/associations/has_many_through_association.rb

@@ -8,9 +8,7 @@ module ActiveRecord
 
       def initialize(owner, reflection)
         super
-
-        @through_records     = {}
-        @through_association = nil
+        @through_records = {}
       end
 
       def concat(*records)
@@ -50,11 +48,6 @@ module ActiveRecord
       end
 
       private
-
-        def through_association
-          @through_association ||= owner.association(through_reflection.name)
-        end
-
         # The through record (built with build_record) is temporarily cached
         # so that it may be reused if insert_record is subsequently called.
         #
@@ -140,21 +133,15 @@ module ActiveRecord
 
           scope = through_association.scope
           scope.where! construct_join_attributes(*records)
+          scope = scope.where(through_scope_attributes)
 
           case method
           when :destroy
             if scope.klass.primary_key
-              count = scope.destroy_all.length
+              count = scope.destroy_all.count(&:destroyed?)
             else
               scope.each(&:_run_destroy_callbacks)
-
-              arel = scope.arel
-
-              stmt = Arel::DeleteManager.new
-              stmt.from scope.klass.arel_table
-              stmt.wheres = arel.constraints
-
-              count = scope.klass.connection.delete(stmt, "SQL")
+              count = scope.delete_all
             end
           when :nullify
             count = scope.update_all(source_reflection.foreign_key => nil)

data/lib/active_record/associations/has_one_through_association.rb

@@ -6,17 +6,16 @@ module ActiveRecord
     class HasOneThroughAssociation < HasOneAssociation #:nodoc:
       include ThroughAssociation
 
-      def replace(record)
-        create_through_record(record)
+      def replace(record, save = true)
+        create_through_record(record, save)
         self.target = record
       end
 
       private
-
-        def create_through_record(record)
+        def create_through_record(record, save)
           ensure_not_nested
 
-          through_proxy  = owner.association(through_reflection.name)
+          through_proxy  = through_association
           through_record = through_proxy.load_target
 
           if through_record && !record
@@ -30,7 +29,7 @@ module ActiveRecord
 
             if through_record
               through_record.update(attributes)
-            elsif owner.new_record?
+            elsif owner.new_record? || !save
               through_proxy.build(attributes)
             else
               through_proxy.create(attributes)

data/lib/active_record/associations/preloader.rb

@@ -83,7 +83,7 @@ module ActiveRecord
       #   { author: :avatar }
       #   [ :books, { author: :avatar } ]
       def preload(records, associations, preload_scope = nil)
-        records = records.compact
+        records = Array.wrap(records).compact
 
         if records.empty?
           []

data/lib/active_record/associations/preloader/association.rb

@@ -82,11 +82,11 @@ module ActiveRecord
           end
 
           def association_key_type
-            @klass.type_for_attribute(association_key_name.to_s).type
+            @klass.type_for_attribute(association_key_name).type
           end
 
           def owner_key_type
-            @model.type_for_attribute(owner_key_name.to_s).type
+            @model.type_for_attribute(owner_key_name).type
           end
 
           def load_records(&block)

data/lib/active_record/associations/through_association.rb

@@ -4,9 +4,24 @@ module ActiveRecord
   module Associations
     # = Active Record Through Association
     module ThroughAssociation #:nodoc:
-      delegate :source_reflection, :through_reflection, to: :reflection
+      delegate :source_reflection, to: :reflection
 
       private
+        def through_reflection
+          @through_reflection ||= begin
+            refl = reflection.through_reflection
+
+            while refl.through_reflection?
+              refl = refl.through_reflection
+            end
+
+            refl
+          end
+        end
+
+        def through_association
+          @through_association ||= owner.association(through_reflection.name)
+        end
 
         # We merge in these scopes for two reasons:
         #
@@ -38,24 +53,22 @@ module ActiveRecord
         def construct_join_attributes(*records)
           ensure_mutable
 
-          if source_reflection.association_primary_key(reflection.klass) == reflection.klass.primary_key
+          association_primary_key = source_reflection.association_primary_key(reflection.klass)
+
+          if association_primary_key == reflection.klass.primary_key && !options[:source_type]
             join_attributes = { source_reflection.name => records }
           else
             join_attributes = {
-              source_reflection.foreign_key =>
-                records.map { |record|
-                  record.send(source_reflection.association_primary_key(reflection.klass))
-                }
+              source_reflection.foreign_key => records.map(&association_primary_key.to_sym)
             }
           end
 
           if options[:source_type]
-            join_attributes[source_reflection.foreign_type] =
-              records.map { |record| record.class.base_class.name }
+            join_attributes[source_reflection.foreign_type] = [ options[:source_type] ]
           end
 
           if records.count == 1
-            Hash[join_attributes.map { |k, v| [k, v.first] }]
+            join_attributes.transform_values!(&:first)
           else
             join_attributes
           end

data/lib/active_record/attribute_methods.rb

@@ -456,7 +456,7 @@ module ActiveRecord
         arel_table = self.class.arel_table
 
         attribute_names.each do |name|
-          attrs[arel_table[name]] = typecasted_attribute_value(name)
+          attrs[arel_table[name]] = _read_attribute(name)
         end
         attrs
       end
@@ -483,9 +483,5 @@ module ActiveRecord
       def pk_attribute?(name)
         name == self.class.primary_key
       end
-
-      def typecasted_attribute_value(name)
-        _read_attribute(name)
-      end
   end
 end

data/lib/active_record/attribute_methods/dirty.rb

@@ -32,9 +32,7 @@ module ActiveRecord
       # <tt>reload</tt> the record and clears changed attributes.
       def reload(*)
         super.tap do
-          @previously_changed = ActiveSupport::HashWithIndifferentAccess.new
           @mutations_before_last_save = nil
-          @attributes_changed_by_setter = ActiveSupport::HashWithIndifferentAccess.new
           @mutations_from_database = nil
         end
       end
@@ -114,12 +112,12 @@ module ActiveRecord
 
       # Alias for +changed+
       def changed_attribute_names_to_save
-        changes_to_save.keys
+        mutations_from_database.changed_attribute_names
       end
 
       # Alias for +changed_attributes+
       def attributes_in_database
-        changes_to_save.transform_values(&:first)
+        mutations_from_database.changed_values
       end
 
       private

data/lib/active_record/attributes.rb

@@ -57,7 +57,7 @@ module ActiveRecord
       #   store_listing = StoreListing.new(price_in_cents: '10.1')
       #
       #   # before
-      #   store_listing.price_in_cents # => BigDecimal.new(10.1)
+      #   store_listing.price_in_cents # => BigDecimal(10.1)
       #
       #   class StoreListing < ActiveRecord::Base
       #     attribute :price_in_cents, :integer

data/lib/active_record/autosave_association.rb

@@ -436,6 +436,9 @@ module ActiveRecord
             if (autosave && record.changed_for_autosave?) || new_record? || record_changed?(reflection, record, key)
               unless reflection.through_reflection
                 record[reflection.foreign_key] = key
+                if inverse_reflection = reflection.inverse_of
+                  record.association(inverse_reflection.name).loaded!
+                end
               end
 
               saved = record.save(validate: !autosave)

data/lib/active_record/callbacks.rb

@@ -232,7 +232,7 @@ module ActiveRecord
   #
   # For example:
   #
-  #   class Topic
+  #   class Topic < ActiveRecord::Base
   #     has_many :children
   #
   #     after_save :log_children
@@ -257,7 +257,7 @@ module ActiveRecord
   #
   # For example:
   #
-  #   class Topic
+  #   class Topic < ActiveRecord::Base
   #     has_many :children
   #
   #     after_commit :log_children

data/lib/active_record/collection_cache_key.rb

@@ -3,11 +3,11 @@
 module ActiveRecord
   module CollectionCacheKey
     def collection_cache_key(collection = all, timestamp_column = :updated_at) # :nodoc:
-      query_signature = Digest::MD5.hexdigest(collection.to_sql)
+      query_signature = ActiveSupport::Digest.hexdigest(collection.to_sql)
       key = "#{collection.model_name.cache_key}/query-#{query_signature}"
 
-      if collection.loaded?
-        size = collection.size
+      if collection.loaded? || collection.distinct_value
+        size = collection.records.size
         if size > 0
           timestamp = collection.max_by(&timestamp_column)._read_attribute(timestamp_column)
         end
@@ -15,13 +15,12 @@ module ActiveRecord
         if collection.eager_loading?
           collection = collection.send(:apply_join_dependency)
         end
-        column_type = type_for_attribute(timestamp_column.to_s)
+        column_type = type_for_attribute(timestamp_column)
         column = connection.column_name_from_arel_node(collection.arel_attribute(timestamp_column))
         select_values = "COUNT(*) AS #{connection.quote_column_name("size")}, MAX(%s) AS timestamp"
 
         if collection.has_limit_or_offset?
-          query = collection.spawn
-          query.select_values = [column]
+          query = collection.select(column)
           subquery_alias = "subquery_for_cache_key"
           subquery_column = "#{subquery_alias}.#{timestamp_column}"
           subquery = query.arel.as(subquery_alias)

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

@@ -1005,9 +1005,7 @@ module ActiveRecord
       def retrieve_connection(spec_name) #:nodoc:
         pool = retrieve_connection_pool(spec_name)
         raise ConnectionNotEstablished, "No connection pool with '#{spec_name}' found." unless pool
-        conn = pool.connection
-        raise ConnectionNotEstablished, "No connection for '#{spec_name}' in connection pool" unless conn
-        conn
+        pool.connection
       end
 
       # Returns true if a connection that's accessible to this class has

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

@@ -356,35 +356,33 @@ module ActiveRecord
       # Inserts a set of fixtures into the table. Overridden in adapters that require
       # something beyond a simple insert (eg. Oracle).
       def insert_fixtures(fixtures, table_name)
+        ActiveSupport::Deprecation.warn(<<-MSG.squish)
+          `insert_fixtures` is deprecated and will be removed in the next version of Rails.
+          Consider using `insert_fixtures_set` for performance improvement.
+        MSG
         return if fixtures.empty?
 
-        columns = schema_cache.columns_hash(table_name)
+        execute(build_fixture_sql(fixtures, table_name), "Fixtures Insert")
+      end
 
-        values = fixtures.map do |fixture|
-          fixture = fixture.stringify_keys
+      def insert_fixtures_set(fixture_set, tables_to_delete = [])
+        fixture_inserts = fixture_set.map do |table_name, fixtures|
+          next if fixtures.empty?
 
-          unknown_columns = fixture.keys - columns.keys
-          if unknown_columns.any?
-            raise Fixture::FixtureError, %(table "#{table_name}" has no columns named #{unknown_columns.map(&:inspect).join(', ')}.)
-          end
+          build_fixture_sql(fixtures, table_name)
+        end.compact
 
-          columns.map do |name, column|
-            if fixture.key?(name)
-              type = lookup_cast_type_from_column(column)
-              bind = Relation::QueryAttribute.new(name, fixture[name], type)
-              with_yaml_fallback(bind.value_for_database)
-            else
-              Arel.sql("DEFAULT")
+        table_deletes = tables_to_delete.map { |table| "DELETE FROM #{quote_table_name table}".dup }
+        total_sql = Array.wrap(combine_multi_statements(table_deletes + fixture_inserts))
+
+        disable_referential_integrity do
+          transaction(requires_new: true) do
+            total_sql.each do |sql|
+              execute sql, "Fixtures Load"
+              yield if block_given?
             end
           end
         end
-
-        table = Arel::Table.new(table_name)
-        manager = Arel::InsertManager.new
-        manager.into(table)
-        columns.each_key { |column| manager.columns << table[column] }
-        manager.values = manager.create_values_list(values)
-        execute manager.to_sql, "Fixtures Insert"
       end
 
       def empty_insert_statement_value
@@ -416,6 +414,44 @@ module ActiveRecord
       alias join_to_delete join_to_update
 
       private
+        def default_insert_value(column)
+          Arel.sql("DEFAULT")
+        end
+
+        def build_fixture_sql(fixtures, table_name)
+          columns = schema_cache.columns_hash(table_name)
+
+          values = fixtures.map do |fixture|
+            fixture = fixture.stringify_keys
+
+            unknown_columns = fixture.keys - columns.keys
+            if unknown_columns.any?
+              raise Fixture::FixtureError, %(table "#{table_name}" has no columns named #{unknown_columns.map(&:inspect).join(', ')}.)
+            end
+
+            columns.map do |name, column|
+              if fixture.key?(name)
+                type = lookup_cast_type_from_column(column)
+                bind = Relation::QueryAttribute.new(name, fixture[name], type)
+                with_yaml_fallback(bind.value_for_database)
+              else
+                default_insert_value(column)
+              end
+            end
+          end
+
+          table = Arel::Table.new(table_name)
+          manager = Arel::InsertManager.new
+          manager.into(table)
+          columns.each_key { |column| manager.columns << table[column] }
+          manager.values = manager.create_values_list(values)
+
+          manager.to_sql
+        end
+
+        def combine_multi_statements(total_sql)
+          total_sql.join(";\n")
+        end
 
         # Returns a subquery for the given key using the join information.
         def subquery_for(key, select)