activerecord 7.0.0 → 7.1.0

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,23 +17,26 @@ 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 add
-    # the following options to your environment config:
+    # To use the DatabaseSelector in your application with default settings,
+    # run the provided generator.
+    #
+    #   bin/rails g active_record:multi_db
     #
-    #   # This require is only necessary when using `rails new app --minimal`
-    #   require "active_support/core_ext/integer/time"
+    # This will create a file named +config/initializers/multi_db.rb+ with the
+    # following contents:
     #
-    #   class Application < Rails::Application
+    #   Rails.application.configure do
     #     config.active_record.database_selector = { delay: 2.seconds }
     #     config.active_record.database_resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver
     #     config.active_record.database_resolver_context = ActiveRecord::Middleware::DatabaseSelector::Resolver::Session
     #   end
     #
-    # New applications will include these lines commented out in the production.rb.
+    # Alternatively you can set the options in your environment config or
+    # any other config file loaded on boot.
     #
     # The default behavior can be changed by setting the config options to a
     # custom class:
@@ -39,6 +44,10 @@ module ActiveRecord
     #   config.active_record.database_selector = { delay: 2.seconds }
     #   config.active_record.database_resolver = MyResolver
     #   config.active_record.database_resolver_context = MyResolver::MySession
+    #
+    # Note: If you are using <tt>rails new my_app --minimal</tt> you will need
+    # to call <tt>require "active_support/core_ext/integer/time"</tt> to load
+    # the core extension in order to use +2.seconds+
     class DatabaseSelector
       def initialize(app, resolver_klass = nil, context_klass = nil, options = {})
         @app = app
@@ -64,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)
@@ -73,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,16 +2,18 @@
 
 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.
     #
-    # The ShardSelector takes a set of options (currently only `lock` is supported)
-    # that can be used by the middleware to alter behavior. `lock` is
+    # The ShardSelector takes a set of options (currently only +lock+ is supported)
+    # that can be used by the middleware to alter behavior. +lock+ is
     # true by default and will prohibit the request from switching shards once
-    # inside the block. If `lock` is false, then shard swapping will be allowed.
-    # For tenant based sharding, `lock` should always be true to prevent application
+    # inside the block. If +lock+ is false, then shard swapping will be allowed.
+    # For tenant based sharding, +lock+ should always be true to prevent application
     # code from mistakenly switching between tenants.
     #
     # Options can be set in the config:

data/lib/active_record/migration/command_recorder.rb

@@ -2,35 +2,44 @@
 
 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
-    # * change_column
-    # * change_column_default (must supply a :from and :to option)
+    # * change_column_default (must supply a +:from+ and +:to+ option)
     # * change_column_null
-    # * change_column_comment (must supply a :from and :to option)
-    # * change_table_comment (must supply a :from and :to option)
+    # * 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
     # * remove_column (must supply a type)
-    # * remove_columns (must specify at least one column name or more)
+    # * 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
@@ -42,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
 
@@ -118,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)
@@ -140,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
@@ -165,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
@@ -235,6 +268,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
@@ -269,11 +307,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