activerecord 6.0.0.beta3 → 6.0.0.rc1

data/lib/active_record/attribute_methods/dirty.rb

@@ -29,9 +29,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
@@ -51,7 +49,7 @@ module ActiveRecord
       # +to+ When passed, this method will return false unless the value was
       # changed to the given value
       def saved_change_to_attribute?(attr_name, **options)
-        mutations_before_last_save.changed?(attr_name, **options)
+        mutations_before_last_save.changed?(attr_name.to_s, options)
       end
 
       # Returns the change to an attribute during the last save. If the
@@ -63,7 +61,7 @@ module ActiveRecord
       # invoked as +saved_change_to_name+ instead of
       # <tt>saved_change_to_attribute("name")</tt>.
       def saved_change_to_attribute(attr_name)
-        mutations_before_last_save.change_to_attribute(attr_name)
+        mutations_before_last_save.change_to_attribute(attr_name.to_s)
       end
 
       # Returns the original value of an attribute before the last save.
@@ -73,7 +71,7 @@ module ActiveRecord
       # invoked as +name_before_last_save+ instead of
       # <tt>attribute_before_last_save("name")</tt>.
       def attribute_before_last_save(attr_name)
-        mutations_before_last_save.original_value(attr_name)
+        mutations_before_last_save.original_value(attr_name.to_s)
       end
 
       # Did the last call to +save+ have any changes to change?
@@ -101,7 +99,7 @@ module ActiveRecord
       # +to+ When passed, this method will return false unless the value will be
       # changed to the given value
       def will_save_change_to_attribute?(attr_name, **options)
-        mutations_from_database.changed?(attr_name, **options)
+        mutations_from_database.changed?(attr_name.to_s, options)
       end
 
       # Returns the change to an attribute that will be persisted during the
@@ -115,7 +113,7 @@ module ActiveRecord
       # If the attribute will change, the result will be an array containing the
       # original value and the new value about to be saved.
       def attribute_change_to_be_saved(attr_name)
-        mutations_from_database.change_to_attribute(attr_name)
+        mutations_from_database.change_to_attribute(attr_name.to_s)
       end
 
       # Returns the value of an attribute in the database, as opposed to the
@@ -127,7 +125,7 @@ module ActiveRecord
       # saved. It can be invoked as +name_in_database+ instead of
       # <tt>attribute_in_database("name")</tt>.
       def attribute_in_database(attr_name)
-        mutations_from_database.original_value(attr_name)
+        mutations_from_database.original_value(attr_name.to_s)
       end
 
       # Will the next call to +save+ have any changes to persist?
@@ -158,16 +156,46 @@ module ActiveRecord
       end
 
       private
+        def mutations_from_database
+          sync_with_transaction_state if @transaction_state&.finalized?
+          super
+        end
+
+        def mutations_before_last_save
+          sync_with_transaction_state if @transaction_state&.finalized?
+          super
+        end
+
         def write_attribute_without_type_cast(attr_name, value)
-          name = attr_name.to_s
-          if self.class.attribute_alias?(name)
-            name = self.class.attribute_alias(name)
-          end
-          result = super(name, value)
-          clear_attribute_change(name)
+          result = super
+          clear_attribute_change(attr_name)
           result
         end
 
+        def _touch_row(attribute_names, time)
+          @_touch_attr_names = Set.new(attribute_names)
+
+          affected_rows = super
+
+          changes = {}
+          @attributes.keys.each do |attr_name|
+            next if @_touch_attr_names.include?(attr_name)
+
+            if attribute_changed?(attr_name)
+              changes[attr_name] = _read_attribute(attr_name)
+              _write_attribute(attr_name, attribute_was(attr_name))
+              clear_attribute_change(attr_name)
+            end
+          end
+
+          changes_applied
+          changes.each { |attr_name, value| _write_attribute(attr_name, value) }
+
+          affected_rows
+        ensure
+          @_touch_attr_names = nil
+        end
+
         def _update_record(attribute_names = attribute_names_for_partial_writes)
           affected_rows = super
           changes_applied

data/lib/active_record/attribute_methods/primary_key.rb

@@ -16,40 +16,32 @@ module ActiveRecord
 
       # Returns the primary key column's value.
       def id
-        sync_with_transaction_state
-        primary_key = self.class.primary_key
-        _read_attribute(primary_key) if primary_key
+        _read_attribute(@primary_key)
       end
 
       # Sets the primary key column's value.
       def id=(value)
-        sync_with_transaction_state
-        primary_key = self.class.primary_key
-        _write_attribute(primary_key, value) if primary_key
+        _write_attribute(@primary_key, value)
       end
 
       # Queries the primary key column's value.
       def id?
-        sync_with_transaction_state
-        query_attribute(self.class.primary_key)
+        query_attribute(@primary_key)
       end
 
       # Returns the primary key column's value before type cast.
       def id_before_type_cast
-        sync_with_transaction_state
-        read_attribute_before_type_cast(self.class.primary_key)
+        read_attribute_before_type_cast(@primary_key)
       end
 
       # Returns the primary key column's previous value.
       def id_was
-        sync_with_transaction_state
-        attribute_was(self.class.primary_key)
+        attribute_was(@primary_key)
       end
 
       # Returns the primary key column's value from the database.
       def id_in_database
-        sync_with_transaction_state
-        attribute_in_database(self.class.primary_key)
+        attribute_in_database(@primary_key)
       end
 
       private
@@ -122,7 +114,7 @@ module ActiveRecord
           #
           #   Project.primary_key # => "foo_id"
           def primary_key=(value)
-            @primary_key        = value && value.to_s
+            @primary_key        = value && -value.to_s
             @quoted_primary_key = nil
             @attributes_builder = nil
           end

data/lib/active_record/attribute_methods/query.rb

@@ -16,8 +16,7 @@ module ActiveRecord
         when true        then true
         when false, nil  then false
         else
-          column = self.class.columns_hash[attr_name]
-          if column.nil?
+          if !type_for_attribute(attr_name) { false }
             if Numeric === value || value !~ /[^0-9]/
               !value.to_i.zero?
             else
@@ -33,7 +32,7 @@ module ActiveRecord
       end
 
       private
-        # Handle *? for method_missing.
+        # Dispatch target for <tt>*?</tt> attribute methods.
         def attribute?(attribute_name)
           query_attribute(attribute_name)
         end

data/lib/active_record/attribute_methods/read.rb

@@ -9,14 +9,11 @@ module ActiveRecord
         private
 
           def define_method_attribute(name)
-            sync_with_transaction_state = "sync_with_transaction_state" if name == primary_key
-
             ActiveModel::AttributeMethods::AttrNames.define_attribute_accessor_method(
               generated_attribute_methods, name
             ) do |temp_method_name, attr_name_expr|
               generated_attribute_methods.module_eval <<-RUBY, __FILE__, __LINE__ + 1
                 def #{temp_method_name}
-                  #{sync_with_transaction_state}
                   name = #{attr_name_expr}
                   _read_attribute(name) { |n| missing_attribute(n, caller) }
                 end
@@ -30,19 +27,16 @@ module ActiveRecord
       # to a date object, like Date.new(2004, 12, 12)).
       def read_attribute(attr_name, &block)
         name = attr_name.to_s
-        if self.class.attribute_alias?(name)
-          name = self.class.attribute_alias(name)
-        end
+        name = self.class.attribute_aliases[name] || name
 
-        primary_key = self.class.primary_key
-        name = primary_key if name == "id" && primary_key
-        sync_with_transaction_state if name == primary_key
+        name = @primary_key if name == "id" && @primary_key
         _read_attribute(name, &block)
       end
 
       # This method exists to avoid the expensive primary_key check internally, without
       # breaking compatibility with the read_attribute API
       def _read_attribute(attr_name, &block) # :nodoc
+        sync_with_transaction_state if @transaction_state&.finalized?
         @attributes.fetch_value(attr_name.to_s, &block)
       end
 

data/lib/active_record/attribute_methods/write.rb

@@ -13,15 +13,12 @@ module ActiveRecord
         private
 
           def define_method_attribute=(name)
-            sync_with_transaction_state = "sync_with_transaction_state" if name == primary_key
-
             ActiveModel::AttributeMethods::AttrNames.define_attribute_accessor_method(
               generated_attribute_methods, name, writer: true,
             ) do |temp_method_name, attr_name_expr|
               generated_attribute_methods.module_eval <<-RUBY, __FILE__, __LINE__ + 1
                 def #{temp_method_name}(value)
                   name = #{attr_name_expr}
-                  #{sync_with_transaction_state}
                   _write_attribute(name, value)
                 end
               RUBY
@@ -34,31 +31,28 @@ module ActiveRecord
       # turned into +nil+.
       def write_attribute(attr_name, value)
         name = attr_name.to_s
-        if self.class.attribute_alias?(name)
-          name = self.class.attribute_alias(name)
-        end
+        name = self.class.attribute_aliases[name] || name
 
-        primary_key = self.class.primary_key
-        name = primary_key if name == "id" && primary_key
-        sync_with_transaction_state if name == primary_key
+        name = @primary_key if name == "id" && @primary_key
         _write_attribute(name, value)
       end
 
       # This method exists to avoid the expensive primary_key check internally, without
       # breaking compatibility with the write_attribute API
       def _write_attribute(attr_name, value) # :nodoc:
+        sync_with_transaction_state if @transaction_state&.finalized?
         @attributes.write_from_user(attr_name.to_s, value)
         value
       end
 
       private
         def write_attribute_without_type_cast(attr_name, value)
-          name = attr_name.to_s
-          @attributes.write_cast_value(name, value)
+          sync_with_transaction_state if @transaction_state&.finalized?
+          @attributes.write_cast_value(attr_name.to_s, value)
           value
         end
 
-        # Handle *= for method_missing.
+        # Dispatch target for <tt>*=</tt> attribute methods.
         def attribute=(attribute_name, value)
           _write_attribute(attribute_name, value)
         end

data/lib/active_record/attributes.rb

@@ -41,6 +41,9 @@ module ActiveRecord
       # +range+ (PostgreSQL only) specifies that the type should be a range (see the
       # examples below).
       #
+      # When using a symbol for +cast_type+, extra options are forwarded to the
+      # constructor of the type object.
+      #
       # ==== Examples
       #
       # The type detected by Active Record can be overridden.
@@ -112,6 +115,16 @@ module ActiveRecord
       #       my_float_range: 1.0..3.5
       #     }
       #
+      # Passing options to the type constructor
+      #
+      #   # app/models/my_model.rb
+      #   class MyModel < ActiveRecord::Base
+      #     attribute :small_int, :integer, limit: 2
+      #   end
+      #
+      #   MyModel.create(small_int: 65537)
+      #   # => Error: 65537 is out of range for the limit of two bytes
+      #
       # ==== Creating Custom Types
       #
       # Users may also define their own custom types, as long as they respond

data/lib/active_record/autosave_association.rb

@@ -382,10 +382,14 @@ module ActiveRecord
         if association = association_instance_get(reflection.name)
           autosave = reflection.options[:autosave]
 
+          # By saving the instance variable in a local variable,
+          # we make the whole callback re-entrant.
+          new_record_before_save = @new_record_before_save
+
           # reconstruct the scope now that we know the owner's id
           association.reset_scope
 
-          if records = associated_records_to_validate_or_save(association, @new_record_before_save, autosave)
+          if records = associated_records_to_validate_or_save(association, new_record_before_save, autosave)
             if autosave
               records_to_destroy = records.select(&:marked_for_destruction?)
               records_to_destroy.each { |record| association.destroy(record) }
@@ -397,7 +401,7 @@ module ActiveRecord
 
               saved = true
 
-              if autosave != false && (@new_record_before_save || record.new_record?)
+              if autosave != false && (new_record_before_save || record.new_record?)
                 if autosave
                   saved = association.insert_record(record, false)
                 elsif !reflection.nested?
@@ -457,10 +461,16 @@ module ActiveRecord
       # If the record is new or it has changed, returns true.
       def record_changed?(reflection, record, key)
         record.new_record? ||
-          (record.has_attribute?(reflection.foreign_key) && record[reflection.foreign_key] != key) ||
+          association_foreign_key_changed?(reflection, record, key) ||
           record.will_save_change_to_attribute?(reflection.foreign_key)
       end
 
+      def association_foreign_key_changed?(reflection, record, key)
+        return false if reflection.through_reflection?
+
+        record.has_attribute?(reflection.foreign_key) && record[reflection.foreign_key] != key
+      end
+
       # Saves the associated record if it's new or <tt>:autosave</tt> is enabled.
       #
       # In addition, it will destroy the association if it was marked for destruction.

data/lib/active_record/base.rb

@@ -288,7 +288,6 @@ module ActiveRecord #:nodoc:
     extend Explain
     extend Enum
     extend Delegation::DelegateCache
-    extend CollectionCacheKey
     extend Aggregations::ClassMethods
 
     include Core

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

@@ -810,6 +810,7 @@ module ActiveRecord
         def new_connection
           Base.send(spec.adapter_method, spec.config).tap do |conn|
             conn.schema_cache = schema_cache.dup if schema_cache
+            conn.check_version
           end
         end
 

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

@@ -5,20 +5,24 @@ require "active_support/deprecation"
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
     module DatabaseLimits
+      def max_identifier_length # :nodoc:
+        64
+      end
+
       # Returns the maximum length of a table alias.
       def table_alias_length
-        255
+        max_identifier_length
       end
 
       # Returns the maximum length of a column name.
       def column_name_length
-        64
+        max_identifier_length
       end
       deprecate :column_name_length
 
       # Returns the maximum length of a table name.
       def table_name_length
-        64
+        max_identifier_length
       end
       deprecate :table_name_length
 
@@ -33,7 +37,7 @@ module ActiveRecord
 
       # Returns the maximum length of an index name.
       def index_name_length
-        64
+        max_identifier_length
       end
 
       # Returns the maximum number of columns per table.

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

@@ -131,7 +131,7 @@ module ActiveRecord
       # +binds+ as the bind substitutes. +name+ is logged along with
       # the executed +sql+ statement.
       def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil)
-        sql, binds = sql_for_insert(sql, pk, sequence_name, binds)
+        sql, binds = sql_for_insert(sql, pk, binds)
         exec_query(sql, name, binds)
       end
 
@@ -142,11 +142,6 @@ module ActiveRecord
         exec_query(sql, name, binds)
       end
 
-      # Executes the truncate statement.
-      def truncate(table_name, name = nil)
-        raise NotImplementedError
-      end
-
       # Executes update +sql+ statement in the context of this connection using
       # +binds+ as the bind substitutes. +name+ is logged along with
       # the executed +sql+ statement.
@@ -181,6 +176,23 @@ module ActiveRecord
         exec_delete(sql, name, binds)
       end
 
+      # Executes the truncate statement.
+      def truncate(table_name, name = nil)
+        execute(build_truncate_statements(table_name), name)
+      end
+
+      def truncate_tables(*table_names) # :nodoc:
+        return if table_names.empty?
+
+        with_multi_statements do
+          disable_referential_integrity do
+            Array(build_truncate_statements(*table_names)).each do |sql|
+              execute_batch(sql, "Truncate Tables")
+            end
+          end
+        end
+      end
+
       # Runs the given block in a database transaction, and returns the result
       # of the block.
       #
@@ -341,46 +353,20 @@ module ActiveRecord
       # We keep this method to provide fallback
       # for databases like sqlite that do not support bulk inserts.
       def insert_fixture(fixture, table_name)
-        fixture = fixture.stringify_keys
-
-        columns = schema_cache.columns_hash(table_name)
-        binds = fixture.map do |name, value|
-          if column = columns[name]
-            type = lookup_cast_type_from_column(column)
-            Relation::QueryAttribute.new(name, value, type)
-          else
-            raise Fixture::FixtureError, %(table "#{table_name}" has no column named #{name.inspect}.)
-          end
-        end
-
-        table = Arel::Table.new(table_name)
-
-        values = binds.map do |bind|
-          value = with_yaml_fallback(bind.value_for_database)
-          [table[bind.name], value]
-        end
-
-        manager = Arel::InsertManager.new
-        manager.into(table)
-        manager.insert(values)
-        execute manager.to_sql, "Fixture Insert"
+        execute(build_fixture_sql(Array.wrap(fixture), table_name), "Fixture Insert")
       end
 
       def insert_fixtures_set(fixture_set, tables_to_delete = [])
-        fixture_inserts = fixture_set.map do |table_name, fixtures|
-          next if fixtures.empty?
-
-          build_fixture_sql(fixtures, table_name)
-        end.compact
-
-        table_deletes = tables_to_delete.map { |table| +"DELETE FROM #{quote_table_name table}" }
-        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?
+        fixture_inserts = build_fixture_statements(fixture_set)
+        table_deletes = tables_to_delete.map { |table| "DELETE FROM #{quote_table_name(table)}" }
+        total_sql = Array(combine_multi_statements(table_deletes + fixture_inserts))
+
+        with_multi_statements do
+          disable_referential_integrity do
+            transaction(requires_new: true) do
+              total_sql.each do |sql|
+                execute_batch(sql, "Fixtures Load")
+              end
             end
           end
         end
@@ -404,15 +390,33 @@ module ActiveRecord
         end
       end
 
+      # Fixture value is quoted by Arel, however scalar values
+      # are not quotable. In this case we want to convert
+      # the column value to YAML.
+      def with_yaml_fallback(value) # :nodoc:
+        if value.is_a?(Hash) || value.is_a?(Array)
+          YAML.dump(value)
+        else
+          value
+        end
+      end
+
       private
+        def execute_batch(sql, name = nil)
+          execute(sql, name)
+        end
+
+        DEFAULT_INSERT_VALUE = Arel.sql("DEFAULT").freeze
+        private_constant :DEFAULT_INSERT_VALUE
+
         def default_insert_value(column)
-          Arel.sql("DEFAULT")
+          DEFAULT_INSERT_VALUE
         end
 
         def build_fixture_sql(fixtures, table_name)
           columns = schema_cache.columns_hash(table_name)
 
-          values = fixtures.map do |fixture|
+          values_list = fixtures.map do |fixture|
             fixture = fixture.stringify_keys
 
             unknown_columns = fixture.keys - columns.keys
@@ -423,8 +427,7 @@ module ActiveRecord
             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)
+                with_yaml_fallback(type.serialize(fixture[name]))
               else
                 default_insert_value(column)
               end
@@ -434,12 +437,43 @@ module ActiveRecord
           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)
 
+          if values_list.size == 1
+            values = values_list.shift
+            new_values = []
+            columns.each_key.with_index { |column, i|
+              unless values[i].equal?(DEFAULT_INSERT_VALUE)
+                new_values << values[i]
+                manager.columns << table[column]
+              end
+            }
+            values_list << new_values
+          else
+            columns.each_key { |column| manager.columns << table[column] }
+          end
+
+          manager.values = manager.create_values_list(values_list)
           manager.to_sql
         end
 
+        def build_fixture_statements(fixture_set)
+          fixture_set.map do |table_name, fixtures|
+            next if fixtures.empty?
+            build_fixture_sql(fixtures, table_name)
+          end.compact
+        end
+
+        def build_truncate_statements(*table_names)
+          truncate_tables = table_names.map do |table_name|
+            "TRUNCATE TABLE #{quote_table_name(table_name)}"
+          end
+          combine_multi_statements(truncate_tables)
+        end
+
+        def with_multi_statements
+          yield
+        end
+
         def combine_multi_statements(total_sql)
           total_sql.join(";\n")
         end
@@ -453,7 +487,7 @@ module ActiveRecord
           exec_query(sql, name, binds, prepare: true)
         end
 
-        def sql_for_insert(sql, pk, sequence_name, binds)
+        def sql_for_insert(sql, pk, binds)
           [sql, binds]
         end
 
@@ -473,17 +507,6 @@ module ActiveRecord
             relation
           end
         end
-
-        # Fixture value is quoted by Arel, however scalar values
-        # are not quotable. In this case we want to convert
-        # the column value to YAML.
-        def with_yaml_fallback(value)
-          if value.is_a?(Hash) || value.is_a?(Array)
-            YAML.dump(value)
-          else
-            value
-          end
-        end
     end
   end
 end