activerecord 7.2.4 → 8.1.4

data/lib/active_record/explain_registry.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/module/delegation"
 
 module ActiveRecord
   # This is a thread locals registry for EXPLAIN. For example
@@ -9,8 +8,53 @@ module ActiveRecord
   #
   # returns the collected queries local to the current thread.
   class ExplainRegistry # :nodoc:
+    class Subscriber
+      MUTEX = Mutex.new
+      @subscribed = false
+
+      class << self
+        def ensure_subscribed
+          return if @subscribed
+          MUTEX.synchronize do
+            return if @subscribed
+
+            ActiveSupport::Notifications.subscribe("sql.active_record", new)
+            @subscribed = true
+          end
+        end
+      end
+
+      def start(name, id, payload)
+        # unused
+      end
+
+      def finish(name, id, payload)
+        if ExplainRegistry.collect? && !ignore_payload?(payload)
+          ExplainRegistry.queries << payload.values_at(:sql, :binds)
+        end
+      end
+
+      def silenced?(_name)
+        !ExplainRegistry.collect?
+      end
+
+      # SCHEMA queries cannot be EXPLAINed, also we do not want to run EXPLAIN on
+      # our own EXPLAINs no matter how loopingly beautiful that would be.
+      #
+      # On the other hand, we want to monitor the performance of our real database
+      # queries, not the performance of the access to the query cache.
+      IGNORED_PAYLOADS = %w(SCHEMA EXPLAIN)
+      EXPLAINED_SQLS = /\A\s*(\/\*.*\*\/)?\s*(with|select|update|delete|insert)\b/i
+      def ignore_payload?(payload)
+        payload[:exception] ||
+          payload[:cached] ||
+          IGNORED_PAYLOADS.include?(payload[:name]) ||
+          !payload[:sql].match?(EXPLAINED_SQLS)
+      end
+    end
+
     class << self
-      delegate :reset, :collect, :collect=, :collect?, :queries, to: :instance
+      delegate :start, :reset, :collect, :collect=, :collect?, :queries, to: :instance
 
       private
         def instance
@@ -25,6 +69,11 @@ module ActiveRecord
       reset
     end
 
+    def start
+      Subscriber.ensure_subscribed
+      @collect = true
+    end
+
     def collect?
       @collect
     end

data/lib/active_record/filter_attribute_handler.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class FilterAttributeHandler # :nodoc:
+    class << self
+      def on_sensitive_attribute_declared(&block)
+        @sensitive_attribute_declaration_listeners ||= Concurrent::Array.new
+        @sensitive_attribute_declaration_listeners << block
+      end
+
+      def sensitive_attribute_was_declared(klass, list)
+        @sensitive_attribute_declaration_listeners&.each do |block|
+          block.call(klass, list)
+        end
+      end
+    end
+
+    def initialize(app)
+      @app = app
+      @attributes_by_class = Concurrent::Map.new
+      @collecting = true
+    end
+
+    def enable
+      install_collecting_hook
+
+      apply_collected_attributes
+      @collecting = false
+    end
+
+    private
+      attr_reader :app
+
+      def install_collecting_hook
+        self.class.on_sensitive_attribute_declared do |klass, list|
+          attribute_was_declared(klass, list)
+        end
+      end
+
+      def attribute_was_declared(klass, list)
+        if collecting?
+          collect_for_later(klass, list)
+        else
+          apply_filter(klass, list)
+        end
+      end
+
+      def apply_collected_attributes
+        @attributes_by_class.each do |klass, list|
+          apply_filter(klass, list)
+        end
+      end
+
+      def collecting?
+        @collecting
+      end
+
+      def collect_for_later(klass, list)
+        @attributes_by_class[klass] ||= Concurrent::Array.new
+        @attributes_by_class[klass] += list
+      end
+
+      def apply_filter(klass, list)
+        list.each do |attribute|
+          next if klass.abstract_class? || klass == Base
+
+          case attribute
+          when Symbol, String
+            klass_name = klass.name ? klass.model_name.element : nil
+            filter = [klass_name, attribute.to_s].compact.join(".")
+            app.config.filter_parameters << filter unless app.config.filter_parameters.include?(filter)
+          end
+        end
+      end
+  end
+end

data/lib/active_record/fixtures.rb

@@ -2,8 +2,6 @@
 
 require "erb"
 require "yaml"
-require "zlib"
-require "set"
 require "active_support/dependencies"
 require "active_support/core_ext/digest/uuid"
 require "active_record/test_fixtures"
@@ -244,10 +242,10 @@ module ActiveRecord
   # and one for the humans. Why don't we generate the primary key instead?
   # Hashing each fixture's label yields a consistent ID:
   #
-  #   george: # generated id: 503576764
+  #   george: # generated id: 380982691
   #     name: George the Monkey
   #
-  #   reginald: # generated id: 324201669
+  #   reginald: # generated id: 41001176
   #     name: Reginald the Pirate
   #
   # Active Record looks at the fixture's model class, discovers the correct

data/lib/active_record/future_result.rb

@@ -100,17 +100,23 @@ module ActiveRecord
     def execute_or_skip
       return unless pending?
 
-      @pool.with_connection do |connection|
-        return unless @mutex.try_lock
-        begin
-          if pending?
-            @event_buffer = EventBuffer.new(self, @instrumenter)
-            connection.with_instrumenter(@event_buffer) do
+      @session.synchronize do
+        return unless pending?
+
+        @pool.with_connection do |connection|
+          return unless @mutex.try_lock
+          previous_instrumenter = ActiveSupport::IsolatedExecutionState[:active_record_instrumenter]
+          begin
+            if pending?
+              @event_buffer = EventBuffer.new(self, @instrumenter)
+              ActiveSupport::IsolatedExecutionState[:active_record_instrumenter] = @event_buffer
+
               execute_query(connection, async: true)
             end
+          ensure
+            ActiveSupport::IsolatedExecutionState[:active_record_instrumenter] = previous_instrumenter
+            @mutex.unlock
           end
-        ensure
-          @mutex.unlock
         end
       end
     end
@@ -163,7 +169,7 @@ module ActiveRecord
       end
 
       def exec_query(connection, *args, **kwargs)
-        connection.internal_exec_query(*args, **kwargs)
+        connection.raw_exec_query(*args, **kwargs)
       end
 
       class SelectAll < FutureResult # :nodoc:

data/lib/active_record/gem_version.rb

@@ -7,8 +7,8 @@ module ActiveRecord
   end
 
   module VERSION
-    MAJOR = 7
-    MINOR = 2
+    MAJOR = 8
+    MINOR = 1
     TINY  = 4
     PRE   = nil
 

data/lib/active_record/inheritance.rb

@@ -32,9 +32,9 @@ module ActiveRecord
   # be triggered. In that case, it'll work just like normal subclasses with no special magic
   # for differentiating between them or reloading the right type with find.
   #
-  # Note, all the attributes for all the cases are kept in the same table.
-  # Read more:
-  # * https://www.martinfowler.com/eaaCatalog/singleTableInheritance.html
+  # All subclasses share the same database table. See the
+  # {Single Table Inheritance pattern}[https://www.martinfowler.com/eaaCatalog/singleTableInheritance.html]
+  # for more background.
   #
   module Inheritance
     extend ActiveSupport::Concern
@@ -97,7 +97,7 @@ module ActiveRecord
       # Returns the first class in the inheritance hierarchy that descends from either an
       # abstract class or from <tt>ActiveRecord::Base</tt>.
       #
-      # Consider the following behaviour:
+      # Consider the following behavior:
       #
       #   class ApplicationRecord < ActiveRecord::Base
       #     self.abstract_class = true
@@ -237,6 +237,11 @@ module ActiveRecord
       end
 
       protected
+        def reload_schema_from_cache(*) # :nodoc:
+          @finder_needs_type_condition = nil
+          super
+        end
+
         # Returns the class type of the record using the current module as a prefix. So descendants of
         # MyApp::Business::Account would appear as MyApp::Business::AccountSubclass.
         def compute_type(type_name)

data/lib/active_record/insert_all.rb

@@ -11,7 +11,7 @@ module ActiveRecord
       def execute(relation, ...)
         relation.model.with_connection do |c|
           new(relation, c, ...).execute
-        end
+        end.tap { relation.reset }
       end
     end
 
@@ -39,7 +39,7 @@ module ActiveRecord
       @returning = (connection.supports_insert_returning? ? primary_keys : false) if @returning.nil?
       @returning = false if @returning == []
 
-      @unique_by = find_unique_index_for(@unique_by)
+      @unique_by = find_unique_index_for(@unique_by) if @on_duplicate != :raise
 
       configure_on_duplicate_update_logic
       ensure_valid_options_for_connection!
@@ -48,7 +48,7 @@ module ActiveRecord
     def execute
       return ActiveRecord::Result.empty if inserts.empty?
 
-      message = +"#{model} "
+      message = +"#{model.name} "
       message << "Bulk " if inserts.many?
       message << (on_duplicate == :update ? "Upsert" : "Insert")
       connection.exec_insert_all to_sql, message
@@ -225,7 +225,7 @@ module ActiveRecord
       class Builder # :nodoc:
         attr_reader :model
 
-        delegate :skip_duplicates?, :update_duplicates?, :keys, :keys_including_timestamps, :record_timestamps?, to: :insert_all
+        delegate :skip_duplicates?, :update_duplicates?, :keys, :keys_including_timestamps, :record_timestamps?, :primary_keys, to: :insert_all
 
         def initialize(insert_all)
           @insert_all, @model, @connection = insert_all, insert_all.model, insert_all.connection
@@ -236,11 +236,16 @@ module ActiveRecord
         end
 
         def values_list
-          types = extract_types_from_columns_on(model.table_name, keys: keys_including_timestamps)
+          types = extract_types_for(keys_including_timestamps)
 
           values_list = insert_all.map_key_with_value do |key, value|
-            next value if Arel::Nodes::SqlLiteral === value
-            connection.with_yaml_fallback(types[key].serialize(value))
+            if Arel::Nodes::SqlLiteral === value
+              value
+            elsif primary_keys.include?(key) && value.nil?
+              connection.default_insert_value(model.columns_hash[key])
+            else
+              ActiveModel::Type::SerializeCastValue.serialize(type = types[key], type.cast(value))
+            end
           end
 
           connection.visitor.compile(Arel::Nodes::ValuesList.new(values_list))
@@ -303,8 +308,8 @@ module ActiveRecord
             format_columns(insert_all.keys_including_timestamps)
           end
 
-          def extract_types_from_columns_on(table_name, keys:)
-            columns = @model.schema_cache.columns_hash(table_name)
+          def extract_types_for(keys)
+            columns = @model.columns_hash
 
             unknown_column = (keys - columns.keys).first
             raise UnknownAttributeError.new(model.new, unknown_column) if unknown_column

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
     #
@@ -101,6 +101,13 @@ module ActiveRecord
             attribute_names = attribute_names.dup if attribute_names.frozen?
             attribute_names << locking_column
 
+            if self[locking_column].nil?
+              raise(<<-MSG.squish)
+                For optimistic locking, locking_column ('#{locking_column}') can't be nil.
+                Are you missing a default value or validation on '#{locking_column}'?
+              MSG
+            end
+
             self[locking_column] += 1
 
             affected_rows = self.class._update_record(

data/lib/active_record/locking/pessimistic.rb

@@ -67,6 +67,10 @@ module ActiveRecord
       # or pass true for "FOR UPDATE" (the default, an exclusive row lock). Returns
       # the locked record.
       def lock!(lock = true)
+        if self.class.current_preventing_writes
+          raise ActiveRecord::ReadOnlyError, "Lock query attempted while in readonly mode"
+        end
+
         if persisted?
           if has_changes_to_save?
             raise(<<-MSG.squish)
@@ -79,6 +83,7 @@ module ActiveRecord
 
           reload(lock: lock)
         end
+
         self
       end
 

data/lib/active_record/log_subscriber.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveRecord
-  class LogSubscriber < ActiveSupport::LogSubscriber
+  class LogSubscriber < ActiveSupport::LogSubscriber # :nodoc:
     IGNORE_PAYLOAD_NAMES = ["SCHEMA", "EXPLAIN"]
 
     class_attribute :backtrace_cleaner, default: ActiveSupport::BacktraceCleaner.new
@@ -86,23 +86,35 @@ module ActiveRecord
       end
 
       def sql_color(sql)
-        case sql
-        when /\A\s*rollback/mi
-          RED
-        when /select .*for update/mi, /\A\s*lock/mi
-          WHITE
-        when /\A\s*select/i
-          BLUE
-        when /\A\s*insert/i
-          GREEN
-        when /\A\s*update/i
-          YELLOW
-        when /\A\s*delete/i
-          RED
-        when /transaction\s*\Z/i
-          CYAN
+        color = if (match = sql.match(/\A\s*(\w+)(?:\s|\Z)/))
+          case match[1].downcase
+          when "rollback"
+            RED
+          when "lock"
+            WHITE
+          when "select"
+            if sql.match?(/for update/mi)
+              WHITE
+            else
+              BLUE
+            end
+          when "insert"
+            GREEN
+          when "update"
+            YELLOW
+          when "delete"
+            RED
+          end
+        end
+
+        if color
+          color
         else
-          MAGENTA
+          if sql.match?(/transaction\s*\Z/i)
+            CYAN
+          else
+            MAGENTA
+          end
         end
       end
 
@@ -126,18 +138,8 @@ 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
-        end
+      def query_source_location
+        backtrace_cleaner.first_clean_frame
       end
 
       def filter(name, value)

data/lib/active_record/message_pack.rb

@@ -23,6 +23,11 @@ module ActiveRecord
       extend self
 
       def install(registry)
+        registry.register_type 118, ActiveRecord::Type::Time::Value,
+          packer: method(:write_time_value),
+          unpacker: method(:read_time_value),
+          recursive: true
+
         registry.register_type 119, ActiveModel::Type::Binary::Data,
           packer: :to_s,
           unpacker: :new
@@ -33,6 +38,14 @@ module ActiveRecord
           recursive: true
       end
 
+      def write_time_value(value, packer)
+        packer.write(value.__getobj__)
+      end
+
+      def read_time_value(unpacker)
+        ActiveRecord::Type::Time::Value.new(unpacker.read)
+      end
+
       def write_record(record, packer)
         packer.write(ActiveRecord::MessagePack.dump(record))
       end

data/lib/active_record/middleware/shard_selector.rb

@@ -9,25 +9,40 @@ module ActiveRecord
     # 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
-    # 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
-    # code from mistakenly switching between tenants.
+    # == Setup
     #
-    # Options can be set in the config:
+    # Applications must provide a resolver that will provide application-specific logic for
+    # selecting the appropriate shard. Setting +config.active_record.shard_resolver+ will cause
+    # Rails to add ShardSelector to the default middleware stack.
     #
-    #   config.active_record.shard_selector = { lock: true }
+    # The resolver, along with any configuration options, can be set in the application
+    # configuration using an initializer like so:
     #
-    # Applications must also provide the code for the resolver as it depends on application
-    # specific models. An example resolver would look like this:
+    #   Rails.application.configure do
+    #     config.active_record.shard_selector = { lock: false, class_name: "AnimalsRecord" }
+    #     config.active_record.shard_resolver = ->(request) {
+    #       subdomain = request.subdomain
+    #       tenant = Tenant.find_by_subdomain!(subdomain)
+    #       tenant.shard
+    #     }
+    #   end
+    #
+    # == Configuration
+    #
+    # The behavior of ShardSelector can be altered through some configuration options.
+    #
+    # [+lock:+]
+    #   +lock+ is true by default and will prohibit the request from switching shards once inside
+    #   the block. If +lock+ is false, then shard switching will be allowed. For tenant based
+    #   sharding, +lock+ should always be true to prevent application code from mistakenly switching
+    #   between tenants.
+    #
+    # [+class_name:+]
+    #   +class_name+ is the name of the abstract connection class to switch. By
+    #   default, the ShardSelector will use ActiveRecord::Base, but if the
+    #   application has multiple databases, then this option should be set to
+    #   the name of the sharded database's abstract connection class.
     #
-    #   config.active_record.shard_resolver = ->(request) {
-    #     subdomain = request.subdomain
-    #     tenant = Tenant.find_by_subdomain!(subdomain)
-    #     tenant.shard
-    #   }
     class ShardSelector
       def initialize(app, resolver, options = {})
         @app = app
@@ -53,8 +68,10 @@ module ActiveRecord
         end
 
         def set_shard(shard, &block)
-          ActiveRecord::Base.connected_to(shard: shard.to_sym) do
-            ActiveRecord::Base.prohibit_shard_swapping(options.fetch(:lock, true), &block)
+          klass = options[:class_name]&.constantize || ActiveRecord::Base
+
+          klass.connected_to(shard: shard.to_sym) do
+            klass.prohibit_shard_swapping(options.fetch(:lock, true), &block)
           end
         end
     end