activerecord 7.0.5 → 7.1.3.4

data/lib/active_record/message_pack.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module MessagePack # :nodoc:
+    FORMAT_VERSION = 1
+
+    class << self
+      def dump(input)
+        encoder = Encoder.new
+        [FORMAT_VERSION, encoder.encode(input), encoder.entries]
+      end
+
+      def load(dumped)
+        format_version, top_level, entries = dumped
+        unless format_version == FORMAT_VERSION
+          raise "Invalid format version: #{format_version.inspect}"
+        end
+        Decoder.new(entries).decode(top_level)
+      end
+    end
+
+    module Extensions
+      extend self
+
+      def install(registry)
+        registry.register_type 119, ActiveModel::Type::Binary::Data,
+          packer: :to_s,
+          unpacker: :new
+
+        registry.register_type 120, ActiveRecord::Base,
+          packer: method(:write_record),
+          unpacker: method(:read_record),
+          recursive: true
+      end
+
+      def write_record(record, packer)
+        packer.write(ActiveRecord::MessagePack.dump(record))
+      end
+
+      def read_record(unpacker)
+        ActiveRecord::MessagePack.load(unpacker.read)
+      end
+    end
+
+    class Encoder
+      attr_reader :entries
+
+      def initialize
+        @entries = []
+        @refs = {}.compare_by_identity
+      end
+
+      def encode(input)
+        if input.is_a?(Array)
+          input.map { |record| encode_record(record) }
+        elsif input
+          encode_record(input)
+        end
+      end
+
+      def encode_record(record)
+        ref = @refs[record]
+
+        if !ref
+          ref = @refs[record] = @entries.size
+          @entries << build_entry(record)
+          add_cached_associations(record, @entries.last)
+        end
+
+        ref
+      end
+
+      def build_entry(record)
+        [
+          ActiveSupport::MessagePack::Extensions.dump_class(record.class),
+          record.attributes_for_database,
+          record.new_record?
+        ]
+      end
+
+      def add_cached_associations(record, entry)
+        record.class.reflections.each_value do |reflection|
+          if record.association_cached?(reflection.name)
+            entry << reflection.name << encode(record.association(reflection.name).target)
+          end
+        end
+      end
+    end
+
+    class Decoder
+      def initialize(entries)
+        @records = entries.map { |entry| build_record(entry) }
+        @records.zip(entries) { |record, entry| resolve_cached_associations(record, entry) }
+      end
+
+      def decode(ref)
+        if ref.is_a?(Array)
+          ref.map { |r| @records[r] }
+        elsif ref
+          @records[ref]
+        end
+      end
+
+      def build_record(entry)
+        class_name, attributes_hash, is_new_record, * = entry
+        klass = ActiveSupport::MessagePack::Extensions.load_class(class_name)
+        attributes = klass.attributes_builder.build_from_database(attributes_hash)
+        klass.allocate.init_with_attributes(attributes, is_new_record)
+      end
+
+      def resolve_cached_associations(record, entry)
+        i = 3 # entry == [class_name, attributes_hash, is_new_record, *associations]
+        while i < entry.length
+          begin
+            record.association(entry[i]).target = decode(entry[i + 1])
+          rescue ActiveRecord::AssociationNotFoundError
+            # The association no longer exists, so just skip it.
+          end
+          i += 2
+        end
+      end
+    end
+  end
+end

data/lib/active_record/middleware/database_selector/resolver.rb

@@ -48,6 +48,10 @@ module ActiveRecord
           context.save(response)
         end
 
+        def reading_request?(request)
+          request.get? || request.head?
+        end
+
         private
           def read_from_primary(&blk)
             ActiveRecord::Base.connected_to(role: ActiveRecord.writing_role, prevent_writes: true) do

data/lib/active_record/middleware/database_selector.rb

@@ -4,8 +4,10 @@ require "active_record/middleware/database_selector/resolver"
 
 module ActiveRecord
   module Middleware
+    # = Database Selector \Middleware
+    #
     # The DatabaseSelector Middleware provides a framework for automatically
-    # swapping from the primary to the replica database connection. Rails
+    # swapping from the primary to the replica database connection. \Rails
     # provides a basic framework to determine when to swap and allows for
     # applications to write custom strategy classes to override the default
     # behavior.
@@ -15,14 +17,14 @@ module ActiveRecord
     # resolver context class that sets a value that helps the resolver class
     # decide when to switch.
     #
-    # Rails default middleware uses the request's session to set a timestamp
+    # \Rails default middleware uses the request's session to set a timestamp
     # that informs the application when to read from a primary or read from a
     # replica.
     #
     # To use the DatabaseSelector in your application with default settings,
     # run the provided generator.
     #
-    #   bin/rails g active_record:multi_db
+    #   $ bin/rails g active_record:multi_db
     #
     # This will create a file named +config/initializers/multi_db.rb+ with the
     # following contents:
@@ -71,7 +73,7 @@ module ActiveRecord
           context = context_klass.call(request)
           resolver = resolver_klass.call(context, options)
 
-          response = if reading_request?(request)
+          response = if resolver.reading_request?(request)
             resolver.read(&blk)
           else
             resolver.write(&blk)
@@ -80,10 +82,6 @@ module ActiveRecord
           resolver.update_context(response)
           response
         end
-
-        def reading_request?(request)
-          request.get? || request.head?
-        end
     end
   end
 end

data/lib/active_record/middleware/shard_selector.rb

@@ -2,8 +2,10 @@
 
 module ActiveRecord
   module Middleware
+    # = Shard Selector \Middleware
+    #
     # The ShardSelector Middleware provides a framework for automatically
-    # swapping shards. Rails provides a basic framework to determine which
+    # swapping shards. \Rails provides a basic framework to determine which
     # shard to switch to and allows for applications to write custom strategies
     # for swapping if needed.
     #

data/lib/active_record/migration/command_recorder.rb

@@ -2,13 +2,17 @@
 
 module ActiveRecord
   class Migration
-    # <tt>ActiveRecord::Migration::CommandRecorder</tt> records commands done during
+    # = \Migration Command Recorder
+    #
+    # +ActiveRecord::Migration::CommandRecorder+ records commands done during
     # a migration and knows how to reverse those commands. The CommandRecorder
     # knows how to invert the following commands:
     #
     # * add_column
     # * add_foreign_key
     # * add_check_constraint
+    # * add_exclusion_constraint
+    # * add_unique_constraint
     # * add_index
     # * add_reference
     # * add_timestamps
@@ -16,9 +20,11 @@ module ActiveRecord
     # * change_column_null
     # * change_column_comment (must supply a +:from+ and +:to+ option)
     # * change_table_comment (must supply a +:from+ and +:to+ option)
+    # * create_enum
     # * create_join_table
     # * create_table
     # * disable_extension
+    # * drop_enum (must supply a list of values)
     # * drop_join_table
     # * drop_table (must supply a block)
     # * enable_extension
@@ -26,10 +32,14 @@ module ActiveRecord
     # * remove_columns (must supply a +:type+ option)
     # * remove_foreign_key (must supply a second table)
     # * remove_check_constraint
+    # * remove_exclusion_constraint
+    # * remove_unique_constraint
     # * remove_index
     # * remove_reference
     # * remove_timestamps
     # * rename_column
+    # * rename_enum (must supply a +:to+ option)
+    # * rename_enum_value (must supply a +:from+ and +:to+ option)
     # * rename_index
     # * rename_table
     class CommandRecorder
@@ -41,7 +51,10 @@ module ActiveRecord
         :change_column, :execute, :remove_columns, :change_column_null,
         :add_foreign_key, :remove_foreign_key,
         :change_column_comment, :change_table_comment,
-        :add_check_constraint, :remove_check_constraint
+        :add_check_constraint, :remove_check_constraint,
+        :add_exclusion_constraint, :remove_exclusion_constraint,
+        :add_unique_constraint, :remove_unique_constraint,
+        :create_enum, :drop_enum, :rename_enum, :add_enum_value, :rename_enum_value,
       ]
       include JoinTable
 
@@ -117,7 +130,15 @@ module ActiveRecord
       alias :remove_belongs_to :remove_reference
 
       def change_table(table_name, **options) # :nodoc:
-        yield delegate.update_table_definition(table_name, self)
+        if delegate.supports_bulk_alter? && options[:bulk]
+          recorder = self.class.new(self.delegate)
+          recorder.reverting = @reverting
+          yield recorder.delegate.update_table_definition(table_name, recorder)
+          commands = recorder.commands
+          @commands << [:change_table, [table_name], -> t { bulk_change_table(table_name, commands) }]
+        else
+          yield delegate.update_table_definition(table_name, self)
+        end
       end
 
       def replay(migration)
@@ -139,7 +160,10 @@ module ActiveRecord
               add_reference:     :remove_reference,
               add_foreign_key:   :remove_foreign_key,
               add_check_constraint: :remove_check_constraint,
-              enable_extension:  :disable_extension
+              add_exclusion_constraint: :remove_exclusion_constraint,
+              add_unique_constraint: :remove_unique_constraint,
+              enable_extension:  :disable_extension,
+              create_enum:       :drop_enum
             }.each do |cmd, inv|
               [[inv, cmd], [cmd, inv]].uniq.each do |method, inverse|
                 class_eval <<-EOV, __FILE__, __LINE__ + 1
@@ -164,7 +188,17 @@ module ActiveRecord
           [:transaction, args, invertions_proc]
         end
 
+        def invert_create_table(args, &block)
+          if args.last.is_a?(Hash)
+            args.last.delete(:if_not_exists)
+          end
+          super
+        end
+
         def invert_drop_table(args, &block)
+          if args.last.is_a?(Hash)
+            args.last.delete(:if_exists)
+          end
           if args.size == 1 && block == nil
             raise ActiveRecord::IrreversibleMigration, "To avoid mistakes, drop_table is only reversible if given options or a block (can be empty)."
           end
@@ -172,7 +206,10 @@ module ActiveRecord
         end
 
         def invert_rename_table(args)
-          [:rename_table, args.reverse]
+          old_name, new_name, options = args
+          args = [new_name, old_name]
+          args << options if options
+          [:rename_table, args]
         end
 
         def invert_remove_column(args)
@@ -234,6 +271,11 @@ module ActiveRecord
           [:change_column_null, args]
         end
 
+        def invert_add_foreign_key(args)
+          args.last.delete(:validate) if args.last.is_a?(Hash)
+          super
+        end
+
         def invert_remove_foreign_key(args)
           options = args.extract_options!
           from_table, to_table = args
@@ -268,11 +310,68 @@ module ActiveRecord
           [:change_table_comment, [table, from: options[:to], to: options[:from]]]
         end
 
+        def invert_add_check_constraint(args)
+          if (options = args.last).is_a?(Hash)
+            options.delete(:validate)
+            options[:if_exists] = options.delete(:if_not_exists) if options.key?(:if_not_exists)
+          end
+          super
+        end
+
         def invert_remove_check_constraint(args)
           raise ActiveRecord::IrreversibleMigration, "remove_check_constraint is only reversible if given an expression." if args.size < 2
+
+          if (options = args.last).is_a?(Hash)
+            options[:if_not_exists] = options.delete(:if_exists) if options.key?(:if_exists)
+          end
+          super
+        end
+
+        def invert_remove_exclusion_constraint(args)
+          raise ActiveRecord::IrreversibleMigration, "remove_exclusion_constraint is only reversible if given an expression." if args.size < 2
+          super
+        end
+
+        def invert_add_unique_constraint(args)
+          options = args.dup.extract_options!
+
+          raise ActiveRecord::IrreversibleMigration, "add_unique_constraint is not reversible if given an using_index." if options[:using_index]
           super
         end
 
+        def invert_remove_unique_constraint(args)
+          _table, columns = args.dup.tap(&:extract_options!)
+
+          raise ActiveRecord::IrreversibleMigration, "remove_unique_constraint is only reversible if given an column_name." if columns.blank?
+          super
+        end
+
+        def invert_drop_enum(args)
+          _enum, values = args.dup.tap(&:extract_options!)
+          raise ActiveRecord::IrreversibleMigration, "drop_enum is only reversible if given a list of enum values." unless values
+          super
+        end
+
+        def invert_rename_enum(args)
+          name, options = args
+
+          unless options.is_a?(Hash) && options.has_key?(:to)
+            raise ActiveRecord::IrreversibleMigration, "rename_enum is only reversible if given a :to option."
+          end
+
+          [:rename_enum, [options[:to], to: name]]
+        end
+
+        def invert_rename_enum_value(args)
+          type_name, options = args
+
+          unless options.is_a?(Hash) && options.has_key?(:from) && options.has_key?(:to)
+            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]]]
+        end
+
         def respond_to_missing?(method, _)
           super || delegate.respond_to?(method)
         end

data/lib/active_record/migration/compatibility.rb

@@ -21,8 +21,8 @@ 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:
-      # 6.1 < 7.0
-      # 5.2 < 6.0 < 6.1 < 7.0
+      # 7.0 < 7.1
+      # 5.2 < 6.0 < 6.1 < 7.0 < 7.1
       #
       # 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 +30,125 @@ 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_0 = Current
+      V7_1 = Current
+
+      class V7_0 < V7_1
+        module LegacyIndexName
+          private
+            def legacy_index_name(table_name, options)
+              if Hash === options
+                if options[:column]
+                  "index_#{table_name}_on_#{Array(options[:column]) * '_and_'}"
+                elsif options[:name]
+                  options[:name]
+                else
+                  raise ArgumentError, "You must specify the index name"
+                end
+              else
+                legacy_index_name(table_name, index_name_options(options))
+              end
+            end
+
+            def index_name_options(column_names)
+              if expression_column_name?(column_names)
+                column_names = column_names.scan(/\w+/).join("_")
+              end
+
+              { column: column_names }
+            end
+
+            def expression_column_name?(column_name)
+              column_name.is_a?(String) && /\W/.match?(column_name)
+            end
+        end
+
+        module TableDefinition
+          include LegacyIndexName
+
+          def column(name, type, **options)
+            options[:_skip_validate_options] = true
+            super
+          end
+
+          def change(name, type, **options)
+            options[:_skip_validate_options] = true
+            super
+          end
+
+          def index(column_name, **options)
+            options[:name] = legacy_index_name(name, column_name) if options[:name].nil?
+            super
+          end
+
+          private
+            def raise_on_if_exist_options(options)
+            end
+        end
+
+        include LegacyIndexName
+
+        def add_column(table_name, column_name, type, **options)
+          options[:_skip_validate_options] = true
+          super
+        end
+
+        def add_index(table_name, column_name, **options)
+          options[:name] = legacy_index_name(table_name, column_name) if options[:name].nil?
+          super
+        end
+
+        def add_reference(table_name, ref_name, **options)
+          options[:_skip_validate_options] = true
+          super
+        end
+        alias :add_belongs_to :add_reference
+
+        def create_table(table_name, **options)
+          options[:_uses_legacy_table_name] = true
+          options[:_skip_validate_options] = true
+
+          super
+        end
+
+        def rename_table(table_name, new_name, **options)
+          options[:_uses_legacy_table_name] = true
+          super
+        end
+
+        def change_column(table_name, column_name, type, **options)
+          options[:_skip_validate_options] = true
+          if connection.adapter_name == "Mysql2" || connection.adapter_name == "Trilogy"
+            options[:collation] ||= :no_collation
+          end
+          super
+        end
+
+        def change_column_null(table_name, column_name, null, default = nil)
+          super(table_name, column_name, !!null, default)
+        end
+
+        def disable_extension(name, **options)
+          if connection.adapter_name == "PostgreSQL"
+            options[:force] = :cascade
+          end
+          super
+        end
+
+        def add_foreign_key(from_table, to_table, **options)
+          if connection.adapter_name == "PostgreSQL" && options[:deferrable] == true
+            options[:deferrable] = :immediate
+          end
+          super
+        end
+
+        private
+          def compatible_table_definition(t)
+            class << t
+              prepend TableDefinition
+            end
+            super
+          end
+      end
 
       class V6_1 < V7_0
         class PostgreSQLCompat
@@ -56,12 +174,13 @@ module ActiveRecord
           super
         end
 
-        def create_table(table_name, **options)
-          if block_given?
-            super { |t| yield compatible_table_definition(t) }
-          else
-            super
+        def change_column(table_name, column_name, type, **options)
+          if type == :datetime
+            options[:precision] ||= nil
           end
+
+          type = PostgreSQLCompat.compatible_timestamp_type(type, connection)
+          super
         end
 
         module TableDefinition
@@ -70,10 +189,19 @@ module ActiveRecord
             super
           end
 
+          def change(name, type, index: nil, **options)
+            options[:precision] ||= nil
+            super
+          end
+
           def column(name, type, index: nil, **options)
             options[:precision] ||= nil
             super
           end
+
+          private
+            def raise_on_if_exist_options(options)
+            end
         end
 
         private
@@ -81,7 +209,7 @@ module ActiveRecord
             class << t
               prepend TableDefinition
             end
-            t
+            super
           end
       end
 
@@ -103,30 +231,10 @@ module ActiveRecord
             options[:precision] ||= nil
             super
           end
-        end
 
-        def create_table(table_name, **options)
-          if block_given?
-            super { |t| yield compatible_table_definition(t) }
-          else
-            super
-          end
-        end
-
-        def change_table(table_name, **options)
-          if block_given?
-            super { |t| yield compatible_table_definition(t) }
-          else
-            super
-          end
-        end
-
-        def create_join_table(table_1, table_2, **options)
-          if block_given?
-            super { |t| yield compatible_table_definition(t) }
-          else
-            super
-          end
+          private
+            def raise_on_if_exist_options(options)
+            end
         end
 
         def add_reference(table_name, ref_name, **options)
@@ -182,30 +290,6 @@ module ActiveRecord
           end
         end
 
-        def create_table(table_name, **options)
-          if block_given?
-            super { |t| yield compatible_table_definition(t) }
-          else
-            super
-          end
-        end
-
-        def change_table(table_name, **options)
-          if block_given?
-            super { |t| yield compatible_table_definition(t) }
-          else
-            super
-          end
-        end
-
-        def create_join_table(table_1, table_2, **options)
-          if block_given?
-            super { |t| yield compatible_table_definition(t) }
-          else
-            super
-          end
-        end
-
         def add_timestamps(table_name, **options)
           options[:precision] ||= nil
           super
@@ -241,7 +325,7 @@ module ActiveRecord
         end
 
         def create_table(table_name, **options)
-          if connection.adapter_name == "Mysql2"
+          if connection.adapter_name == "Mysql2" || connection.adapter_name == "Trilogy"
             super(table_name, options: "ENGINE=InnoDB", **options)
           else
             super
@@ -260,6 +344,10 @@ module ActiveRecord
             super(*args, type: :integer, **options)
           end
           alias :belongs_to :references
+
+          private
+            def raise_on_if_exist_options(options)
+            end
         end
 
         def create_table(table_name, **options)
@@ -269,7 +357,7 @@ module ActiveRecord
             end
           end
 
-          unless connection.adapter_name == "Mysql2" && options[:id] == :bigint
+          unless ["Mysql2", "Trilogy"].include?(connection.adapter_name) && options[:id] == :bigint
             if [:integer, :bigint].include?(options[:id]) && !options.key?(:default)
               options[:default] = nil
             end
@@ -326,6 +414,10 @@ module ActiveRecord
             options[:null] = true if options[:null].nil?
             super
           end
+
+          private
+            def raise_on_if_exist_options(options)
+            end
         end
 
         def add_reference(table_name, ref_name, **options)

data/lib/active_record/migration/default_strategy.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class Migration
+    # The default strategy for executing migrations. Delegates method calls
+    # to the connection adapter.
+    class DefaultStrategy < ExecutionStrategy # :nodoc:
+      private
+        def method_missing(method, *arguments, &block)
+          connection.send(method, *arguments, &block)
+        end
+        ruby2_keywords(:method_missing)
+
+        def respond_to_missing?(method, *)
+          connection.respond_to?(method) || super
+        end
+
+        def connection
+          migration.connection
+        end
+    end
+  end
+end