activerecord 7.2.0 → 8.0.0.beta1

data/lib/active_record/migration.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require "benchmark"
 require "set"
-require "zlib"
 require "active_support/core_ext/array/access"
 require "active_support/core_ext/enumerable"
 require "active_support/core_ext/module/attribute_accessors"
@@ -21,7 +19,7 @@ module ActiveRecord
   # For example the following migration is not reversible.
   # Rolling back this migration will raise an ActiveRecord::IrreversibleMigration error.
   #
-  #   class IrreversibleMigrationExample < ActiveRecord::Migration[7.2]
+  #   class IrreversibleMigrationExample < ActiveRecord::Migration[8.0]
   #     def change
   #       create_table :distributors do |t|
   #         t.string :zipcode
@@ -39,7 +37,7 @@ module ActiveRecord
   #
   # 1. Define <tt>#up</tt> and <tt>#down</tt> methods instead of <tt>#change</tt>:
   #
-  #  class ReversibleMigrationExample < ActiveRecord::Migration[7.2]
+  #  class ReversibleMigrationExample < ActiveRecord::Migration[8.0]
   #    def up
   #      create_table :distributors do |t|
   #        t.string :zipcode
@@ -64,7 +62,7 @@ module ActiveRecord
   #
   # 2. Use the #reversible method in <tt>#change</tt> method:
   #
-  #   class ReversibleMigrationExample < ActiveRecord::Migration[7.2]
+  #   class ReversibleMigrationExample < ActiveRecord::Migration[8.0]
   #     def change
   #       create_table :distributors do |t|
   #         t.string :zipcode
@@ -250,7 +248,7 @@ module ActiveRecord
   #
   # Example of a simple migration:
   #
-  #   class AddSsl < ActiveRecord::Migration[7.2]
+  #   class AddSsl < ActiveRecord::Migration[8.0]
   #     def up
   #       add_column :accounts, :ssl_enabled, :boolean, default: true
   #     end
@@ -270,7 +268,7 @@ module ActiveRecord
   #
   # Example of a more complex migration that also needs to initialize data:
   #
-  #   class AddSystemSettings < ActiveRecord::Migration[7.2]
+  #   class AddSystemSettings < ActiveRecord::Migration[8.0]
   #     def up
   #       create_table :system_settings do |t|
   #         t.string  :name
@@ -357,7 +355,7 @@ module ActiveRecord
   #
   # === Deletion
   #
-  # * <tt>drop_table(name)</tt>: Drops the table called +name+.
+  # * <tt>drop_table(*names)</tt>: Drops the given tables.
   # * <tt>drop_join_table(table_1, table_2, options)</tt>: Drops the join table
   #   specified by the given arguments.
   # * <tt>remove_column(table_name, column_name, type, options)</tt>: Removes the column
@@ -399,7 +397,7 @@ module ActiveRecord
   #   $ bin/rails generate migration add_fieldname_to_tablename fieldname:string
   #
   # This will generate the file <tt>timestamp_add_fieldname_to_tablename.rb</tt>, which will look like this:
-  #   class AddFieldnameToTablename < ActiveRecord::Migration[7.2]
+  #   class AddFieldnameToTablename < ActiveRecord::Migration[8.0]
   #     def change
   #       add_column :tablenames, :fieldname, :string
   #     end
@@ -425,7 +423,7 @@ module ActiveRecord
   #
   # Not all migrations change the schema. Some just fix the data:
   #
-  #   class RemoveEmptyTags < ActiveRecord::Migration[7.2]
+  #   class RemoveEmptyTags < ActiveRecord::Migration[8.0]
   #     def up
   #       Tag.all.each { |tag| tag.destroy if tag.pages.empty? }
   #     end
@@ -438,7 +436,7 @@ module ActiveRecord
   #
   # Others remove columns when they migrate up instead of down:
   #
-  #   class RemoveUnnecessaryItemAttributes < ActiveRecord::Migration[7.2]
+  #   class RemoveUnnecessaryItemAttributes < ActiveRecord::Migration[8.0]
   #     def up
   #       remove_column :items, :incomplete_items_count
   #       remove_column :items, :completed_items_count
@@ -452,7 +450,7 @@ module ActiveRecord
   #
   # And sometimes you need to do something in SQL not abstracted directly by migrations:
   #
-  #   class MakeJoinUnique < ActiveRecord::Migration[7.2]
+  #   class MakeJoinUnique < ActiveRecord::Migration[8.0]
   #     def up
   #       execute "ALTER TABLE `pages_linked_pages` ADD UNIQUE `page_id_linked_page_id` (`page_id`,`linked_page_id`)"
   #     end
@@ -469,7 +467,7 @@ module ActiveRecord
   # <tt>Base#reset_column_information</tt> in order to ensure that the model has the
   # latest column data from after the new column was added. Example:
   #
-  #   class AddPeopleSalary < ActiveRecord::Migration[7.2]
+  #   class AddPeopleSalary < ActiveRecord::Migration[8.0]
   #     def up
   #       add_column :people, :salary, :integer
   #       Person.reset_column_information
@@ -531,7 +529,7 @@ module ActiveRecord
   # To define a reversible migration, define the +change+ method in your
   # migration like this:
   #
-  #   class TenderloveMigration < ActiveRecord::Migration[7.2]
+  #   class TenderloveMigration < ActiveRecord::Migration[8.0]
   #     def change
   #       create_table(:horses) do |t|
   #         t.column :content, :text
@@ -561,7 +559,7 @@ module ActiveRecord
   # can't execute inside a transaction though, and for these situations
   # you can turn the automatic transactions off.
   #
-  #   class ChangeEnum < ActiveRecord::Migration[7.2]
+  #   class ChangeEnum < ActiveRecord::Migration[8.0]
   #     disable_ddl_transaction!
   #
   #     def up
@@ -604,7 +602,7 @@ module ActiveRecord
         end
       end
 
-      def drop_table(table_name, **options)
+      def drop_table(*table_names, **options)
         if block_given?
           super { |t| yield compatible_table_definition(t) }
         else
@@ -715,13 +713,7 @@ module ActiveRecord
 
       def load_schema_if_pending!
         if any_schema_needs_update?
-          # Roundtrip to Rake to allow plugins to hook into database initialization.
-          root = defined?(ENGINE_ROOT) ? ENGINE_ROOT : Rails.root
-
-          FileUtils.cd(root) do
-            Base.connection_handler.clear_all_connections!(:all)
-            system("bin/rails db:test:prepare")
-          end
+          load_schema!
         end
 
         check_pending_migrations
@@ -785,6 +777,16 @@ module ActiveRecord
         def env
           ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
         end
+
+        def load_schema!
+          # Roundtrip to Rake to allow plugins to hook into database initialization.
+          root = defined?(ENGINE_ROOT) ? ENGINE_ROOT : Rails.root
+
+          FileUtils.cd(root) do
+            Base.connection_handler.clear_all_connections!(:all)
+            system("bin/rails db:test:prepare")
+          end
+        end
     end
 
     def disable_ddl_transaction # :nodoc:
@@ -822,7 +824,7 @@ module ActiveRecord
     # and create the table 'apples' on the way up, and the reverse
     # on the way down.
     #
-    #   class FixTLMigration < ActiveRecord::Migration[7.2]
+    #   class FixTLMigration < ActiveRecord::Migration[8.0]
     #     def change
     #       revert do
     #         create_table(:horses) do |t|
@@ -841,7 +843,7 @@ module ActiveRecord
     #
     #   require_relative "20121212123456_tenderlove_migration"
     #
-    #   class FixupTLMigration < ActiveRecord::Migration[7.2]
+    #   class FixupTLMigration < ActiveRecord::Migration[8.0]
     #     def change
     #       revert TenderloveMigration
     #
@@ -892,7 +894,7 @@ module ActiveRecord
     # when the three columns 'first_name', 'last_name' and 'full_name' exist,
     # even when migrating down:
     #
-    #    class SplitNameMigration < ActiveRecord::Migration[7.2]
+    #    class SplitNameMigration < ActiveRecord::Migration[8.0]
     #      def change
     #        add_column :users, :first_name, :string
     #        add_column :users, :last_name, :string
@@ -920,7 +922,7 @@ module ActiveRecord
     # In the following example, the new column +published+ will be given
     # the value +true+ for all existing records.
     #
-    #    class AddPublishedToPosts < ActiveRecord::Migration[7.2]
+    #    class AddPublishedToPosts < ActiveRecord::Migration[8.0]
     #      def change
     #        add_column :posts, :published, :boolean, default: false
     #        up_only do
@@ -972,16 +974,16 @@ module ActiveRecord
       when :down then announce "reverting"
       end
 
-      time = nil
+      time_elapsed = nil
       ActiveRecord::Tasks::DatabaseTasks.migration_connection.pool.with_connection do |conn|
-        time = Benchmark.measure do
+        time_elapsed = ActiveSupport::Benchmark.realtime do
           exec_migration(conn, direction)
         end
       end
 
       case direction
-      when :up   then announce "migrated (%.4fs)" % time.real; write
-      when :down then announce "reverted (%.4fs)" % time.real; write
+      when :up   then announce "migrated (%.4fs)" % time_elapsed; write
+      when :down then announce "reverted (%.4fs)" % time_elapsed; write
       end
     end
 
@@ -1022,8 +1024,8 @@ module ActiveRecord
     def say_with_time(message)
       say(message)
       result = nil
-      time = Benchmark.measure { result = yield }
-      say "%.4fs" % time.real, :subitem
+      time_elapsed = ActiveSupport::Benchmark.realtime { result = yield }
+      say "%.4fs" % time_elapsed, :subitem
       say("#{result} rows", :subitem) if result.is_a?(Integer)
       result
     end

data/lib/active_record/model_schema.rb

@@ -431,7 +431,6 @@ module ActiveRecord
       end
 
       def columns
-        load_schema unless @columns
         @columns ||= columns_hash.values.freeze
       end
 
@@ -503,7 +502,7 @@ module ActiveRecord
       # when just after creating a table you want to populate it with some default
       # values, e.g.:
       #
-      #  class CreateJobLevels < ActiveRecord::Migration[7.2]
+      #  class CreateJobLevels < ActiveRecord::Migration[8.0]
       #    def up
       #      create_table :job_levels do |t|
       #        t.integer :id
@@ -531,7 +530,9 @@ module ActiveRecord
         initialize_find_by_cache
       end
 
-      def load_schema # :nodoc:
+      # Load the model's schema information either from the schema cache
+      # or directly from the database.
+      def load_schema
         return if schema_loaded?
         @load_schema_monitor.synchronize do
           return if schema_loaded?
@@ -592,6 +593,8 @@ module ActiveRecord
           columns_hash = schema_cache.columns_hash(table_name)
           columns_hash = columns_hash.except(*ignored_columns) unless ignored_columns.empty?
           @columns_hash = columns_hash.freeze
+
+          _default_attributes # Precompute to cache DB-dependent attribute types
         end
 
         # Guesses the table name, but does not decorate it with prefix and suffix information.

data/lib/active_record/nested_attributes.rb

@@ -524,12 +524,12 @@ module ActiveRecord
             unless reject_new_record?(association_name, attributes)
               association.reader.build(attributes.except(*UNASSIGNABLE_KEYS))
             end
-          elsif existing_record = existing_records.detect { |record| record.id.to_s == attributes["id"].to_s }
+          elsif existing_record = find_record_by_id(association.klass, existing_records, attributes["id"])
             unless call_reject_if(association_name, attributes)
               # Make sure we are operating on the actual object which is in the association's
               # proxy_target array (either by finding it, or adding it if not found)
               # Take into account that the proxy_target may have changed due to callbacks
-              target_record = association.target.detect { |record| record.id.to_s == attributes["id"].to_s }
+              target_record = find_record_by_id(association.klass, association.target, attributes["id"])
               if target_record
                 existing_record = target_record
               else
@@ -620,5 +620,14 @@ module ActiveRecord
         raise RecordNotFound.new("Couldn't find #{model} with ID=#{record_id} for #{self.class.name} with ID=#{id}",
                                  model, "id", record_id)
       end
+
+      def find_record_by_id(klass, records, id)
+        if klass.composite_primary_key?
+          id = Array(id).map(&:to_s)
+          records.find { |record| Array(record.id).map(&:to_s) == id }
+        else
+          records.find { |record| record.id.to_s == id.to_s }
+        end
+      end
   end
 end

data/lib/active_record/persistence.rb

@@ -248,18 +248,16 @@ module ActiveRecord
 
         im = Arel::InsertManager.new(arel_table)
 
-        with_connection do |c|
-          if values.empty?
-            im.insert(connection.empty_insert_statement_value(primary_key))
-          else
-            im.insert(values.transform_keys { |name| arel_table[name] })
-          end
-
-          connection.insert(
-            im, "#{self} Create", primary_key || false, primary_key_value,
-            returning: returning
-          )
+        if values.empty?
+          im.insert(connection.empty_insert_statement_value(primary_key))
+        else
+          im.insert(values.transform_keys { |name| arel_table[name] })
         end
+
+        connection.insert(
+          im, "#{self} Create", primary_key || false, primary_key_value,
+          returning: returning
+        )
       end
 
       def _update_record(values, constraints) # :nodoc:
@@ -812,159 +810,159 @@ module ActiveRecord
       end
     end
 
-  private
-    def init_internals
-      super
-      @_trigger_destroy_callback = @_trigger_update_callback = nil
-      @previously_new_record = false
-    end
+    private
+      def init_internals
+        super
+        @_trigger_destroy_callback = @_trigger_update_callback = nil
+        @previously_new_record = false
+      end
 
-    def strict_loaded_associations
-      @association_cache.find_all do |_, assoc|
-        assoc.owner.strict_loading? && !assoc.owner.strict_loading_n_plus_one_only?
-      end.map(&:first)
-    end
+      def strict_loaded_associations
+        @association_cache.find_all do |_, assoc|
+          assoc.owner.strict_loading? && !assoc.owner.strict_loading_n_plus_one_only?
+        end.map(&:first)
+      end
 
-    def _find_record(options)
-      all_queries = options ? options[:all_queries] : nil
-      base = self.class.all(all_queries: all_queries).preload(strict_loaded_associations)
+      def _find_record(options)
+        all_queries = options ? options[:all_queries] : nil
+        base = self.class.all(all_queries: all_queries).preload(strict_loaded_associations)
 
-      if options && options[:lock]
-        base.lock(options[:lock]).find_by!(_in_memory_query_constraints_hash)
-      else
-        base.find_by!(_in_memory_query_constraints_hash)
+        if options && options[:lock]
+          base.lock(options[:lock]).find_by!(_in_memory_query_constraints_hash)
+        else
+          base.find_by!(_in_memory_query_constraints_hash)
+        end
       end
-    end
 
-    def _in_memory_query_constraints_hash
-      if self.class.query_constraints_list.nil?
-        { @primary_key => id }
-      else
-        self.class.query_constraints_list.index_with do |column_name|
-          attribute(column_name)
+      def _in_memory_query_constraints_hash
+        if self.class.query_constraints_list.nil?
+          { @primary_key => id }
+        else
+          self.class.query_constraints_list.index_with do |column_name|
+            attribute(column_name)
+          end
         end
       end
-    end
 
-    def apply_scoping?(options)
-      !(options && options[:unscoped]) &&
-        (self.class.default_scopes?(all_queries: true) || self.class.global_current_scope)
-    end
+      def apply_scoping?(options)
+        !(options && options[:unscoped]) &&
+          (self.class.default_scopes?(all_queries: true) || self.class.global_current_scope)
+      end
 
-    def _query_constraints_hash
-      if self.class.query_constraints_list.nil?
-        { @primary_key => id_in_database }
-      else
-        self.class.query_constraints_list.index_with do |column_name|
-          attribute_in_database(column_name)
+      def _query_constraints_hash
+        if self.class.query_constraints_list.nil?
+          { @primary_key => id_in_database }
+        else
+          self.class.query_constraints_list.index_with do |column_name|
+            attribute_in_database(column_name)
+          end
         end
       end
-    end
 
-    # A hook to be overridden by association modules.
-    def destroy_associations
-    end
-
-    def destroy_row
-      _delete_row
-    end
-
-    def _delete_row
-      self.class._delete_record(_query_constraints_hash)
-    end
+      # A hook to be overridden by association modules.
+      def destroy_associations
+      end
 
-    def _touch_row(attribute_names, time)
-      time ||= current_time_from_proper_timezone
+      def destroy_row
+        _delete_row
+      end
 
-      attribute_names.each do |attr_name|
-        _write_attribute(attr_name, time)
+      def _delete_row
+        self.class._delete_record(_query_constraints_hash)
       end
 
-      _update_row(attribute_names, "touch")
-    end
+      def _touch_row(attribute_names, time)
+        time ||= current_time_from_proper_timezone
 
-    def _update_row(attribute_names, attempted_action = "update")
-      self.class._update_record(
-        attributes_with_values(attribute_names),
-        _query_constraints_hash
-      )
-    end
+        attribute_names.each do |attr_name|
+          _write_attribute(attr_name, time)
+        end
 
-    def create_or_update(**, &block)
-      _raise_readonly_record_error if readonly?
-      return false if destroyed?
-      result = new_record? ? _create_record(&block) : _update_record(&block)
-      result != false
-    end
+        _update_row(attribute_names, "touch")
+      end
 
-    # Updates the associated record with values matching those of the instance attributes.
-    # Returns the number of affected rows.
-    def _update_record(attribute_names = self.attribute_names)
-      attribute_names = attributes_for_update(attribute_names)
+      def _update_row(attribute_names, attempted_action = "update")
+        self.class._update_record(
+          attributes_with_values(attribute_names),
+          _query_constraints_hash
+        )
+      end
 
-      if attribute_names.empty?
-        affected_rows = 0
-        @_trigger_update_callback = true
-      else
-        affected_rows = _update_row(attribute_names)
-        @_trigger_update_callback = affected_rows == 1
+      def create_or_update(**, &block)
+        _raise_readonly_record_error if readonly?
+        return false if destroyed?
+        result = new_record? ? _create_record(&block) : _update_record(&block)
+        result != false
       end
 
-      @previously_new_record = false
+      # Updates the associated record with values matching those of the instance attributes.
+      # Returns the number of affected rows.
+      def _update_record(attribute_names = self.attribute_names)
+        attribute_names = attributes_for_update(attribute_names)
 
-      yield(self) if block_given?
+        if attribute_names.empty?
+          affected_rows = 0
+          @_trigger_update_callback = true
+        else
+          affected_rows = _update_row(attribute_names)
+          @_trigger_update_callback = affected_rows == 1
+        end
 
-      affected_rows
-    end
+        @previously_new_record = false
 
-    # Creates a record with values matching those of the instance attributes
-    # and returns its id.
-    def _create_record(attribute_names = self.attribute_names)
-      attribute_names = attributes_for_create(attribute_names)
+        yield(self) if block_given?
 
-      self.class.with_connection do |connection|
-        returning_columns = self.class._returning_columns_for_insert(connection)
+        affected_rows
+      end
 
-        returning_values = self.class._insert_record(
-          connection,
-          attributes_with_values(attribute_names),
-          returning_columns
-        )
+      # Creates a record with values matching those of the instance attributes
+      # and returns its id.
+      def _create_record(attribute_names = self.attribute_names)
+        attribute_names = attributes_for_create(attribute_names)
 
-        returning_columns.zip(returning_values).each do |column, value|
-          _write_attribute(column, value) if !_read_attribute(column)
-        end if returning_values
-      end
+        self.class.with_connection do |connection|
+          returning_columns = self.class._returning_columns_for_insert(connection)
 
-      @new_record = false
-      @previously_new_record = true
+          returning_values = self.class._insert_record(
+            connection,
+            attributes_with_values(attribute_names),
+            returning_columns
+          )
 
-      yield(self) if block_given?
+          returning_columns.zip(returning_values).each do |column, value|
+            _write_attribute(column, value) if !_read_attribute(column)
+          end if returning_values
+        end
 
-      id
-    end
+        @new_record = false
+        @previously_new_record = true
 
-    def verify_readonly_attribute(name)
-      raise ActiveRecordError, "#{name} is marked as readonly" if self.class.readonly_attribute?(name)
-    end
+        yield(self) if block_given?
 
-    def _raise_record_not_destroyed
-      @_association_destroy_exception ||= nil
-      key = self.class.primary_key
-      raise @_association_destroy_exception || RecordNotDestroyed.new("Failed to destroy #{self.class} with #{key}=#{id}", self)
-    ensure
-      @_association_destroy_exception = nil
-    end
+        id
+      end
 
-    def _raise_readonly_record_error
-      raise ReadOnlyRecord, "#{self.class} is marked as readonly"
-    end
+      def verify_readonly_attribute(name)
+        raise ActiveRecordError, "#{name} is marked as readonly" if self.class.readonly_attribute?(name)
+      end
 
-    def _raise_record_not_touched_error
-      raise ActiveRecordError, <<~MSG.squish
-        Cannot touch on a new or destroyed record object. Consider using
-        persisted?, new_record?, or destroyed? before touching.
-      MSG
-    end
+      def _raise_record_not_destroyed
+        @_association_destroy_exception ||= nil
+        key = self.class.primary_key
+        raise @_association_destroy_exception || RecordNotDestroyed.new("Failed to destroy #{self.class} with #{key}=#{id}", self)
+      ensure
+        @_association_destroy_exception = nil
+      end
+
+      def _raise_readonly_record_error
+        raise ReadOnlyRecord, "#{self.class} is marked as readonly"
+      end
+
+      def _raise_record_not_touched_error
+        raise ActiveRecordError, <<~MSG.squish
+          Cannot touch on a new or destroyed record object. Consider using
+          persisted?, new_record?, or destroyed? before touching.
+        MSG
+      end
   end
 end