activerecord 7.1.5.1 → 8.0.2

data/lib/active_record/internal_metadata.rb

@@ -13,17 +13,13 @@ module ActiveRecord
     class NullInternalMetadata # :nodoc:
     end
 
-    attr_reader :connection, :arel_table
+    attr_reader :arel_table
 
-    def initialize(connection)
-      @connection = connection
+    def initialize(pool)
+      @pool = pool
       @arel_table = Arel::Table.new(table_name)
     end
 
-    def enabled?
-      connection.use_metadata_table?
-    end
-
     def primary_key
       "key"
     end
@@ -36,50 +32,66 @@ module ActiveRecord
       "#{ActiveRecord::Base.table_name_prefix}#{ActiveRecord::Base.internal_metadata_table_name}#{ActiveRecord::Base.table_name_suffix}"
     end
 
+    def enabled?
+      @pool.db_config.use_metadata_table?
+    end
+
     def []=(key, value)
       return unless enabled?
 
-      update_or_create_entry(key, value)
+      @pool.with_connection do |connection|
+        update_or_create_entry(connection, key, value)
+      end
     end
 
     def [](key)
       return unless enabled?
 
-      if entry = select_entry(key)
-        entry[value_key]
+      @pool.with_connection do |connection|
+        if entry = select_entry(connection, key)
+          entry[value_key]
+        end
       end
     end
 
     def delete_all_entries
       dm = Arel::DeleteManager.new(arel_table)
 
-      connection.delete(dm, "#{self.class} Destroy")
+      @pool.with_connection do |connection|
+        connection.delete(dm, "#{self.class} Destroy")
+      end
     end
 
     def count
       sm = Arel::SelectManager.new(arel_table)
       sm.project(*Arel::Nodes::Count.new([Arel.star]))
 
-      connection.select_values(sm, "#{self.class} Count").first
+      @pool.with_connection do |connection|
+        connection.select_values(sm, "#{self.class} Count").first
+      end
     end
 
     def create_table_and_set_flags(environment, schema_sha1 = nil)
       return unless enabled?
 
-      create_table
-      update_or_create_entry(:environment, environment)
-      update_or_create_entry(:schema_sha1, schema_sha1) if schema_sha1
+      @pool.with_connection do |connection|
+        create_table
+        update_or_create_entry(connection, :environment, environment)
+        update_or_create_entry(connection, :schema_sha1, schema_sha1) if schema_sha1
+      end
     end
 
     # Creates an internal metadata table with columns +key+ and +value+
     def create_table
       return unless enabled?
 
-      unless connection.table_exists?(table_name)
-        connection.create_table(table_name, id: false) do |t|
-          t.string :key, **connection.internal_string_options_for_primary_key
-          t.string :value
-          t.timestamps
+      @pool.with_connection do |connection|
+        unless connection.table_exists?(table_name)
+          connection.create_table(table_name, id: false) do |t|
+            t.string :key, **connection.internal_string_options_for_primary_key
+            t.string :value
+            t.timestamps
+          end
         end
       end
     end
@@ -87,49 +99,51 @@ module ActiveRecord
     def drop_table
       return unless enabled?
 
-      connection.drop_table table_name, if_exists: true
+      @pool.with_connection do |connection|
+        connection.drop_table table_name, if_exists: true
+      end
     end
 
     def table_exists?
-      connection.schema_cache.data_source_exists?(table_name)
+      @pool.schema_cache.data_source_exists?(table_name)
     end
 
     private
-      def update_or_create_entry(key, value)
-        entry = select_entry(key)
+      def update_or_create_entry(connection, key, value)
+        entry = select_entry(connection, key)
 
         if entry
           if entry[value_key] != value
-            update_entry(key, value)
+            update_entry(connection, key, value)
           else
             entry[value_key]
           end
         else
-          create_entry(key, value)
+          create_entry(connection, key, value)
         end
       end
 
-      def current_time
+      def current_time(connection)
         connection.default_timezone == :utc ? Time.now.utc : Time.now
       end
 
-      def create_entry(key, value)
+      def create_entry(connection, key, value)
         im = Arel::InsertManager.new(arel_table)
         im.insert [
           [arel_table[primary_key], key],
           [arel_table[value_key], value],
-          [arel_table[:created_at], current_time],
-          [arel_table[:updated_at], current_time]
+          [arel_table[:created_at], current_time(connection)],
+          [arel_table[:updated_at], current_time(connection)]
         ]
 
         connection.insert(im, "#{self.class} Create", primary_key, key)
       end
 
-      def update_entry(key, new_value)
+      def update_entry(connection, key, new_value)
         um = Arel::UpdateManager.new(arel_table)
         um.set [
           [arel_table[value_key], new_value],
-          [arel_table[:updated_at], current_time]
+          [arel_table[:updated_at], current_time(connection)]
         ]
 
         um.where(arel_table[primary_key].eq(key))
@@ -137,9 +151,9 @@ module ActiveRecord
         connection.update(um, "#{self.class} Update")
       end
 
-      def select_entry(key)
+      def select_entry(connection, key)
         sm = Arel::SelectManager.new(arel_table)
-        sm.project(Arel::Nodes::SqlLiteral.new("*"))
+        sm.project(Arel::Nodes::SqlLiteral.new("*", retryable: true))
         sm.where(arel_table[primary_key].eq(Arel::Nodes::BindParam.new(key)))
         sm.order(arel_table[primary_key].asc)
         sm.limit = 1

data/lib/active_record/locking/optimistic.rb

@@ -9,7 +9,7 @@ module ActiveRecord
     # it was opened, an ActiveRecord::StaleObjectError exception is thrown if that has occurred
     # and the update is ignored.
     #
-    # Check out +ActiveRecord::Locking::Pessimistic+ for an alternative.
+    # Check out ActiveRecord::Locking::Pessimistic for an alternative.
     #
     # == Usage
     #
@@ -182,14 +182,15 @@ module ActiveRecord
             super
           end
 
-          def define_attribute(name, cast_type, **) # :nodoc:
-            if lock_optimistically && name == locking_column
-              cast_type = LockingType.new(cast_type)
+          private
+            def hook_attribute_type(name, cast_type)
+              if lock_optimistically && name == locking_column
+                cast_type = LockingType.new(cast_type)
+              end
+
+              super
             end
-            super
-          end
 
-          private
             def inherited(base)
               super
               base.class_eval do

data/lib/active_record/log_subscriber.rb

@@ -6,27 +6,6 @@ module ActiveRecord
 
     class_attribute :backtrace_cleaner, default: ActiveSupport::BacktraceCleaner.new
 
-    def self.runtime=(value)
-      ActiveRecord.deprecator.warn(<<-MSG.squish)
-        ActiveRecord::LogSubscriber.runtime= is deprecated and will be removed in Rails 7.2.
-      MSG
-      ActiveRecord::RuntimeRegistry.sql_runtime = value
-    end
-
-    def self.runtime
-      ActiveRecord.deprecator.warn(<<-MSG.squish)
-        ActiveRecord::LogSubscriber.runtime is deprecated and will be removed in Rails 7.2.
-      MSG
-      ActiveRecord::RuntimeRegistry.sql_runtime
-    end
-
-    def self.reset_runtime
-      ActiveRecord.deprecator.warn(<<-MSG.squish)
-        ActiveRecord::LogSubscriber.reset_runtime is deprecated and will be removed in Rails 7.2.
-      MSG
-      ActiveRecord::RuntimeRegistry.reset
-    end
-
     def strict_loading_violation(event)
       debug do
         owner = event.payload[:owner]
@@ -147,18 +126,12 @@ module ActiveRecord
         end
       end
 
-      if Thread.respond_to?(:each_caller_location)
-        def query_source_location
-          Thread.each_caller_location do |location|
-            frame = backtrace_cleaner.clean_frame(location)
-            return frame if frame
-          end
-          nil
-        end
-      else
-        def query_source_location
-          backtrace_cleaner.clean(caller(1).lazy).first
+      def query_source_location
+        Thread.each_caller_location do |location|
+          frame = backtrace_cleaner.clean_frame(location)
+          return frame if frame
         end
+        nil
       end
 
       def filter(name, value)

data/lib/active_record/message_pack.rb

@@ -79,7 +79,7 @@ module ActiveRecord
       end
 
       def add_cached_associations(record, entry)
-        record.class.reflections.each_value do |reflection|
+        record.class.normalized_reflections.each_value do |reflection|
           if record.association_cached?(reflection.name) && record.association(reflection.name).loaded?
             entry << reflection.name << encode(record.association(reflection.name).target)
           end

data/lib/active_record/migration/command_recorder.rb

@@ -22,10 +22,12 @@ module ActiveRecord
     # * change_table_comment (must supply a +:from+ and +:to+ option)
     # * create_enum
     # * create_join_table
+    # * create_virtual_table
     # * create_table
     # * disable_extension
     # * drop_enum (must supply a list of values)
     # * drop_join_table
+    # * drop_virtual_table (must supply options)
     # * drop_table (must supply a block)
     # * enable_extension
     # * remove_column (must supply a type)
@@ -38,7 +40,7 @@ module ActiveRecord
     # * remove_reference
     # * remove_timestamps
     # * rename_column
-    # * rename_enum (must supply a +:to+ option)
+    # * rename_enum
     # * rename_enum_value (must supply a +:from+ and +:to+ option)
     # * rename_index
     # * rename_table
@@ -55,6 +57,8 @@ module ActiveRecord
         :add_exclusion_constraint, :remove_exclusion_constraint,
         :add_unique_constraint, :remove_unique_constraint,
         :create_enum, :drop_enum, :rename_enum, :add_enum_value, :rename_enum_value,
+        :create_schema, :drop_schema,
+        :create_virtual_table, :drop_virtual_table
       ]
       include JoinTable
 
@@ -163,7 +167,9 @@ module ActiveRecord
               add_exclusion_constraint: :remove_exclusion_constraint,
               add_unique_constraint: :remove_unique_constraint,
               enable_extension:  :disable_extension,
-              create_enum:       :drop_enum
+              create_enum:       :drop_enum,
+              create_schema:     :drop_schema,
+              create_virtual_table: :drop_virtual_table
             }.each do |cmd, inv|
               [[inv, cmd], [cmd, inv]].uniq.each do |method, inverse|
                 class_eval <<-EOV, __FILE__, __LINE__ + 1
@@ -196,13 +202,20 @@ module ActiveRecord
         end
 
         def invert_drop_table(args, &block)
-          if args.last.is_a?(Hash)
-            args.last.delete(:if_exists)
+          options = args.extract_options!
+          options.delete(:if_exists)
+
+          if args.size > 1
+            raise ActiveRecord::IrreversibleMigration, "To avoid mistakes, drop_table is only reversible if given a single table name."
           end
-          if args.size == 1 && block == nil
+
+          if args.size == 1 && options == {} && block == nil
             raise ActiveRecord::IrreversibleMigration, "To avoid mistakes, drop_table is only reversible if given options or a block (can be empty)."
           end
-          super
+
+          args << options unless options.empty?
+
+          super(args, &block)
         end
 
         def invert_rename_table(args)
@@ -353,13 +366,13 @@ module ActiveRecord
         end
 
         def invert_rename_enum(args)
-          name, options = args
+          name, new_name, = args
 
-          unless options.is_a?(Hash) && options.has_key?(:to)
-            raise ActiveRecord::IrreversibleMigration, "rename_enum is only reversible if given a :to option."
+          if new_name.is_a?(Hash) && new_name.key?(:to)
+            new_name = new_name[:to]
           end
 
-          [:rename_enum, [options[:to], to: name]]
+          [:rename_enum, [new_name, name]]
         end
 
         def invert_rename_enum_value(args)
@@ -369,7 +382,14 @@ module ActiveRecord
             raise ActiveRecord::IrreversibleMigration, "rename_enum_value is only reversible if given a :from and :to option."
           end
 
-          [:rename_enum_value, [type_name, from: options[:to], to: options[:from]]]
+          options[:to], options[:from] = options[:from], options[:to]
+          [:rename_enum_value, [type_name, options]]
+        end
+
+        def invert_drop_virtual_table(args)
+          _enum, values = args.dup.tap(&:extract_options!)
+          raise ActiveRecord::IrreversibleMigration, "drop_virtual_table is only reversible if given options." unless values
+          super
         end
 
         def respond_to_missing?(method, _)
@@ -377,14 +397,13 @@ module ActiveRecord
         end
 
         # Forwards any missing method call to the \target.
-        def method_missing(method, *args, &block)
+        def method_missing(method, ...)
           if delegate.respond_to?(method)
-            delegate.public_send(method, *args, &block)
+            delegate.public_send(method, ...)
           else
             super
           end
         end
-        ruby2_keywords(:method_missing)
     end
   end
 end

data/lib/active_record/migration/compatibility.rb

@@ -21,8 +21,7 @@ module ActiveRecord
       # New migration functionality that will never be backward compatible should be added directly to `ActiveRecord::Migration`.
       #
       # There are classes for each prior Rails version. Each class descends from the *next* Rails version, so:
-      # 7.0 < 7.1
-      # 5.2 < 6.0 < 6.1 < 7.0 < 7.1
+      # 5.2 < 6.0 < 6.1 < 7.0 < 7.1 < 7.2 < 8.0
       #
       # If you are introducing new migration functionality that should only apply from Rails 7 onward, then you should
       # find the class that immediately precedes it (6.1), and override the relevant migration methods to undo your changes.
@@ -30,7 +29,13 @@ module ActiveRecord
       # For example, Rails 6 added a default value for the `precision` option on datetime columns. So in this file, the `V5_2`
       # class sets the value of `precision` to `nil` if it's not explicitly provided. This way, the default value will not apply
       # for migrations written for 5.2, but will for migrations written for 6.0.
-      V7_1 = Current
+      V8_0 = Current
+
+      class V7_2 < V8_0
+      end
+
+      class V7_1 < V7_2
+      end
 
       class V7_0 < V7_1
         module LegacyIndexName

data/lib/active_record/migration/default_strategy.rb

@@ -6,13 +6,12 @@ module ActiveRecord
     # to the connection adapter.
     class DefaultStrategy < ExecutionStrategy # :nodoc:
       private
-        def method_missing(method, *arguments, &block)
-          connection.send(method, *arguments, &block)
+        def method_missing(method, ...)
+          connection.send(method, ...)
         end
-        ruby2_keywords(:method_missing)
 
-        def respond_to_missing?(method, *)
-          connection.respond_to?(method) || super
+        def respond_to_missing?(method, include_private = false)
+          connection.respond_to?(method, include_private) || super
         end
 
         def connection

data/lib/active_record/migration/pending_migration_connection.rb

@@ -2,10 +2,10 @@
 
 module ActiveRecord
   class PendingMigrationConnection # :nodoc:
-    def self.establish_temporary_connection(db_config, &block)
+    def self.with_temporary_pool(db_config, &block)
       pool = ActiveRecord::Base.connection_handler.establish_connection(db_config, owner_name: self)
 
-      yield pool.connection
+      yield pool
     ensure
       ActiveRecord::Base.connection_handler.remove_connection_pool(self.name)
     end