activerecord 7.0.8.6 → 7.1.0.beta1

data/lib/active_record/integration.rb

@@ -10,7 +10,7 @@ module ActiveRecord
       ##
       # :singleton-method:
       # Indicates the format used to generate the timestamp in the cache key, if
-      # versioning is off. Accepts any of the symbols in <tt>Time::DATE_FORMATS</tt>.
+      # versioning is off. Accepts any of the symbols in +Time::DATE_FORMATS+.
       #
       # This is +:usec+, by default.
       class_attribute :cache_timestamp_format, instance_writer: false, default: :usec
@@ -20,7 +20,7 @@ module ActiveRecord
       # Indicates whether to use a stable #cache_key method that is accompanied
       # by a changing version in the #cache_version method.
       #
-      # This is +true+, by default on Rails 5.2 and above.
+      # This is +true+, by default on \Rails 5.2 and above.
       class_attribute :cache_versioning, instance_writer: false, default: false
 
       ##
@@ -28,7 +28,7 @@ module ActiveRecord
       # Indicates whether to use a stable #cache_key method that is accompanied
       # by a changing version in the #cache_version method on collections.
       #
-      # This is +false+, by default until Rails 6.1.
+      # This is +false+, by default until \Rails 6.1.
       class_attribute :collection_cache_versioning, instance_writer: false, default: false
     end
 
@@ -55,8 +55,8 @@ module ActiveRecord
     #   user = User.find_by(name: 'Phusion')
     #   user_path(user)  # => "/users/Phusion"
     def to_param
-      # We can't use alias_method here, because method 'id' optimizes itself on the fly.
-      id && id.to_s # Be sure to stringify the id for routes
+      return unless id
+      Array(id).join(self.class.param_delimiter)
     end
 
     # Returns a stable cache key that can be used to identify this record.
@@ -64,7 +64,7 @@ module ActiveRecord
     #   Product.new.cache_key     # => "products/new"
     #   Product.find(5).cache_key # => "products/5"
     #
-    # If ActiveRecord::Base.cache_versioning is turned off, as it was in Rails 5.1 and earlier,
+    # If ActiveRecord::Base.cache_versioning is turned off, as it was in \Rails 5.1 and earlier,
     # the cache key will also include a version.
     #
     #   Product.cache_versioning = false
@@ -106,7 +106,7 @@ module ActiveRecord
           timestamp.utc.to_fs(cache_timestamp_format)
         end
       elsif self.class.has_attribute?("updated_at")
-        raise ActiveModel::MissingAttributeError, "missing attribute: updated_at"
+        raise ActiveModel::MissingAttributeError, "missing attribute 'updated_at' for #{self.class}"
       end
     end
 
@@ -178,7 +178,7 @@ module ActiveRecord
       def can_use_fast_cache_version?(timestamp)
         timestamp.is_a?(String) &&
           cache_timestamp_format == :usec &&
-          ActiveRecord.default_timezone == :utc &&
+          self.class.connection.default_timezone == :utc &&
           !updated_at_came_from_user?
       end
 

data/lib/active_record/internal_metadata.rb

@@ -9,52 +9,140 @@ module ActiveRecord
   #
   # This is enabled by default. To disable this functionality set
   # `use_metadata_table` to false in your database configuration.
-  class InternalMetadata < ActiveRecord::Base # :nodoc:
-    self.record_timestamps = true
+  class InternalMetadata # :nodoc:
+    class NullInternalMetadata
+    end
 
-    class << self
-      def enabled?
-        ActiveRecord::Base.connection.use_metadata_table?
-      end
+    attr_reader :connection, :arel_table
 
-      def primary_key
-        "key"
-      end
+    def initialize(connection)
+      @connection = connection
+      @arel_table = Arel::Table.new(table_name)
+    end
 
-      def table_name
-        "#{table_name_prefix}#{internal_metadata_table_name}#{table_name_suffix}"
-      end
+    def enabled?
+      connection.use_metadata_table?
+    end
 
-      def []=(key, value)
-        return unless enabled?
+    def primary_key
+      "key"
+    end
+
+    def value_key
+      "value"
+    end
+
+    def table_name
+      "#{ActiveRecord::Base.table_name_prefix}#{ActiveRecord::Base.internal_metadata_table_name}#{ActiveRecord::Base.table_name_suffix}"
+    end
 
-        find_or_initialize_by(key: key).update!(value: value)
+    def []=(key, value)
+      return unless enabled?
+
+      update_or_create_entry(key, value)
+    end
+
+    def [](key)
+      return unless enabled?
+
+      if entry = select_entry(key)
+        entry[value_key]
       end
+    end
 
-      def [](key)
-        return unless enabled?
+    def delete_all_entries
+      dm = Arel::DeleteManager.new(arel_table)
+
+      connection.delete(dm, "#{self.class} Destroy")
+    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
+    end
 
-        where(key: key).pick(:value)
+    def create_table_and_set_flags(environment, schema_sha1 = nil)
+      create_table
+      update_or_create_entry(:environment, environment)
+      update_or_create_entry(:schema_sha1, schema_sha1) if schema_sha1
+    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
+        end
       end
+    end
+
+    def drop_table
+      return unless enabled?
+
+      connection.drop_table table_name, if_exists: true
+    end
+
+    def table_exists?
+      connection.schema_cache.data_source_exists?(table_name)
+    end
 
-      # Creates an internal metadata table with columns +key+ and +value+
-      def create_table
-        return unless enabled?
+    private
+      def update_or_create_entry(key, value)
+        entry = select_entry(key)
 
-        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
+        if entry
+          if entry[value_key] != value
+            update_entry(key, value)
+          else
+            entry[value_key]
           end
+        else
+          create_entry(key, value)
         end
       end
 
-      def drop_table
-        return unless enabled?
+      def current_time
+        connection.default_timezone == :utc ? Time.now.utc : Time.now
+      end
+
+      def create_entry(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]
+        ]
 
-        connection.drop_table table_name, if_exists: true
+        connection.insert(im, "#{self.class} Create", primary_key, key)
+      end
+
+      def update_entry(key, new_value)
+        um = Arel::UpdateManager.new(arel_table)
+        um.set [
+          [arel_table[value_key], new_value],
+          [arel_table[:updated_at], current_time]
+        ]
+
+        um.where(arel_table[primary_key].eq(key))
+
+        connection.update(um, "#{self.class} Update")
+      end
+
+      def select_entry(key)
+        sm = Arel::SelectManager.new(arel_table)
+        sm.project(Arel::Nodes::SqlLiteral.new("*"))
+        sm.where(arel_table[primary_key].eq(Arel::Nodes::BindParam.new(key)))
+        sm.order(arel_table[primary_key].asc)
+        sm.limit = 1
+
+        connection.select_all(sm, "#{self.class} Load").first
       end
-    end
   end
 end

data/lib/active_record/locking/pessimistic.rb

@@ -2,6 +2,8 @@
 
 module ActiveRecord
   module Locking
+    # = \Pessimistic \Locking
+    #
     # Locking::Pessimistic provides support for row-level locking using
     # SELECT ... FOR UPDATE and other lock types.
     #
@@ -71,6 +73,7 @@ module ActiveRecord
               Locking a record with unpersisted changes is not supported. Use
               `save` to persist the changes, or `reload` to discard them
               explicitly.
+              Changed attributes: #{changed.map(&:inspect).join(', ')}.
             MSG
           end
 
@@ -79,8 +82,8 @@ module ActiveRecord
         self
       end
 
-      # Wraps the passed block in a transaction, locking the object
-      # before yielding. You can pass the SQL locking clause
+      # Wraps the passed block in a transaction, reloading the object with a
+      # lock before yielding. You can pass the SQL locking clause
       # as an optional argument (see #lock!).
       #
       # You can also pass options like <tt>requires_new:</tt>, <tt>isolation:</tt>,

data/lib/active_record/log_subscriber.rb

@@ -7,16 +7,24 @@ 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::RuntimeRegistry.sql_runtime ||= 0
+      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
-      rt, self.runtime = runtime, 0
-      rt
+      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)
@@ -26,11 +34,9 @@ module ActiveRecord
         color(reflection.strict_loading_violation_message(owner), RED)
       end
     end
+    subscribe_log_level :strict_loading_violation, :debug
 
     def sql(event)
-      self.class.runtime += event.duration
-      return unless logger.debug?
-
       payload = event.payload
 
       return if IGNORE_PAYLOAD_NAMES.include?(payload[:name])
@@ -66,10 +72,11 @@ module ActiveRecord
       end
 
       name = colorize_payload_name(name, payload[:name])
-      sql  = color(sql, sql_color(sql), true) if colorize_logging
+      sql  = color(sql, sql_color(sql), bold: true) if colorize_logging
 
       debug "  #{name}  #{sql}#{binds}"
     end
+    subscribe_log_level :sql, :debug
 
     private
       def type_casted_binds(casted_binds)
@@ -93,9 +100,9 @@ module ActiveRecord
 
       def colorize_payload_name(name, payload_name)
         if payload_name.blank? || payload_name == "SQL" # SQL vs Model Load/Exists
-          color(name, MAGENTA, true)
+          color(name, MAGENTA, bold: true)
         else
-          color(name, CYAN, true)
+          color(name, CYAN, bold: true)
         end
       end
 
@@ -133,15 +140,25 @@ module ActiveRecord
       end
 
       def log_query_source
-        source = extract_query_source_location(caller)
+        source = query_source_location
 
         if source
           logger.debug("  ↳ #{source}")
         end
       end
 
-      def extract_query_source_location(locations)
-        backtrace_cleaner.clean(locations.lazy).first
+      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
+        end
       end
 
       def filter(name, value)

data/lib/active_record/marshalling.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Marshalling
+    @format_version = 6.1
+
+    class << self
+      attr_reader :format_version
+
+      def format_version=(version)
+        case version
+        when 6.1
+          Methods.remove_method(:marshal_dump) if Methods.method_defined?(:marshal_dump)
+        when 7.1
+          Methods.alias_method(:marshal_dump, :_marshal_dump_7_1)
+        else
+          raise ArgumentError, "Unknown marshalling format: #{version.inspect}"
+        end
+        @format_version = version
+      end
+    end
+
+    module Methods
+      def _marshal_dump_7_1
+        payload = [attributes_for_database, new_record?]
+
+        cached_associations = self.class.reflect_on_all_associations.select do |reflection|
+          association_cached?(reflection.name)
+        end
+
+        unless cached_associations.empty?
+          payload << cached_associations.map do |reflection|
+            [reflection.name, association(reflection.name).target]
+          end
+        end
+
+        payload
+      end
+
+      def marshal_load(state)
+        attributes_from_database, new_record, associations = state
+
+        attributes = self.class.attributes_builder.build_from_database(attributes_from_database)
+        init_with_attributes(attributes, new_record)
+
+        if associations
+          associations.each do |name, target|
+            association(name).target = target
+          rescue ActiveRecord::AssociationNotFoundError
+            # the association no longer exist, we can just skip it.
+          end
+        end
+      end
+    end
+  end
+end

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,7 +17,7 @@ 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.
     #
@@ -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.
     #