activerecord 7.2.2.1 → 8.1.2

data/lib/active_record/enum.rb

@@ -119,7 +119,18 @@ module ActiveRecord
   #     enum :status, [ :active, :archived ], instance_methods: false
   #   end
   #
-  # If you want the enum value to be validated before saving, use the option +:validate+:
+  # By default, an +ArgumentError+ will be raised when assigning an invalid value:
+  #
+  #   class Conversation < ActiveRecord::Base
+  #     enum :status, [ :active, :archived ]
+  #   end
+  #
+  #   conversation = Conversation.new
+  #
+  #   conversation.status = :unknown # 'unknown' is not a valid status (ArgumentError)
+  #
+  # If, instead, you want the enum value to be validated before saving, use the
+  # +:validate+ option:
   #
   #   class Conversation < ActiveRecord::Base
   #     enum :status, [ :active, :archived ], validate: true
@@ -136,7 +147,7 @@ module ActiveRecord
   #   conversation.status = :active
   #   conversation.valid? # => true
   #
-  # It is also possible to pass additional validation options:
+  # You may also pass additional validation options:
   #
   #   class Conversation < ActiveRecord::Base
   #     enum :status, [ :active, :archived ], validate: { allow_nil: true }
@@ -152,16 +163,6 @@ module ActiveRecord
   #
   #   conversation.status = :active
   #   conversation.valid? # => true
-  #
-  # Otherwise +ArgumentError+ will raise:
-  #
-  #   class Conversation < ActiveRecord::Base
-  #     enum :status, [ :active, :archived ]
-  #   end
-  #
-  #   conversation = Conversation.new
-  #
-  #   conversation.status = :unknown # 'unknown' is not a valid status (ArgumentError)
   module Enum
     def self.extended(base) # :nodoc:
       base.class_attribute(:defined_enums, instance_writer: false, default: {})
@@ -213,34 +214,16 @@ module ActiveRecord
         attr_reader :name, :mapping
     end
 
-    def enum(name = nil, values = nil, **options)
-      if name
-        values, options = options, {} unless values
-        return _enum(name, values, **options)
-      end
-
-      definitions = options.slice!(:_prefix, :_suffix, :_scopes, :_default, :_instance_methods)
-      options.transform_keys! { |key| :"#{key[1..-1]}" }
-
-      definitions.each { |name, values| _enum(name, values, **options) }
-
-      ActiveRecord.deprecator.warn(<<~MSG)
-        Defining enums with keyword arguments is deprecated and will be removed
-        in Rails 8.0. Positional arguments should be used instead:
-
-        #{definitions.map { |name, values| "enum :#{name}, #{values}" }.join("\n")}
-      MSG
+    def enum(name, values = nil, **options)
+      values, options = options, {} unless values
+      _enum(name, values, **options)
     end
 
     private
-      def inherited(base)
-        base.defined_enums = defined_enums.deep_dup
-        super
-      end
-
       def _enum(name, values, prefix: nil, suffix: nil, scopes: true, instance_methods: true, validate: false, **options)
-        assert_valid_enum_definition_values(values)
+        values = assert_valid_enum_definition_values(values)
         assert_valid_enum_options(options)
+
         # statuses = { }
         enum_values = ActiveSupport::HashWithIndifferentAccess.new
         name = name.to_s
@@ -304,6 +287,11 @@ module ActiveRecord
         enum_values.freeze
       end
 
+      def inherited(base)
+        base.defined_enums = defined_enums.deep_dup
+        super
+      end
+
       class EnumMethods < Module # :nodoc:
         def initialize(klass)
           @klass = klass
@@ -354,6 +342,20 @@ module ActiveRecord
           if values.keys.any?(&:blank?)
             raise ArgumentError, "Enum values #{values} must not contain a blank name."
           end
+
+          values = values.transform_values do |value|
+            value.is_a?(Symbol) ? value.name : value
+          end
+
+          values.each_value do |value|
+            case value
+            when String, Integer, Float, true, false, nil
+              # noop
+            else
+              raise ArgumentError, "Enum values #{values} must be only booleans, integers, floats, symbols or strings, got: #{value.class}"
+            end
+          end
+
         when Array
           if values.empty?
             raise ArgumentError, "Enum values #{values} must not be empty."
@@ -369,6 +371,8 @@ module ActiveRecord
         else
           raise ArgumentError, "Enum values #{values} must be either a non-empty hash or an array."
         end
+
+        values
       end
 
       def assert_valid_enum_options(options)
@@ -380,25 +384,25 @@ module ActiveRecord
 
       ENUM_CONFLICT_MESSAGE = \
         "You tried to define an enum named \"%{enum}\" on the model \"%{klass}\", but " \
-        "this will generate a %{type} method \"%{method}\", which is already defined " \
+        "this will generate %{type} method \"%{method}\", which is already defined " \
         "by %{source}."
       private_constant :ENUM_CONFLICT_MESSAGE
 
       def detect_enum_conflict!(enum_name, method_name, klass_method = false)
         if klass_method && dangerous_class_method?(method_name)
-          raise_conflict_error(enum_name, method_name, type: "class")
+          raise_conflict_error(enum_name, method_name, "a class")
         elsif klass_method && method_defined_within?(method_name, Relation)
-          raise_conflict_error(enum_name, method_name, type: "class", source: Relation.name)
+          raise_conflict_error(enum_name, method_name, "a class", source: Relation.name)
         elsif klass_method && method_name.to_sym == :id
-          raise_conflict_error(enum_name, method_name)
+          raise_conflict_error(enum_name, method_name, "an instance")
         elsif !klass_method && dangerous_attribute_method?(method_name)
-          raise_conflict_error(enum_name, method_name)
+          raise_conflict_error(enum_name, method_name, "an instance")
         elsif !klass_method && method_defined_within?(method_name, _enum_methods_module, Module)
-          raise_conflict_error(enum_name, method_name, source: "another enum")
+          raise_conflict_error(enum_name, method_name, "an instance", source: "another enum")
         end
       end
 
-      def raise_conflict_error(enum_name, method_name, type: "instance", source: "Active Record")
+      def raise_conflict_error(enum_name, method_name, type, source: "Active Record")
         raise ArgumentError, ENUM_CONFLICT_MESSAGE % {
           enum: enum_name,
           klass: name,

data/lib/active_record/errors.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/deprecation"
 
 module ActiveRecord
   include ActiveSupport::Deprecation::DeprecatedConstantAccessor
@@ -13,7 +12,7 @@ module ActiveRecord
 
   # Raised when the single-table inheritance mechanism fails to locate the subclass
   # (for example due to improper usage of column that
-  # {ActiveRecord::Base.inheritance_column}[rdoc-ref:ModelSchema::ClassMethods#inheritance_column]
+  # {ActiveRecord::Base.inheritance_column}[rdoc-ref:ModelSchema.inheritance_column]
   # points to).
   class SubclassNotFound < ActiveRecordError
   end
@@ -84,6 +83,19 @@ module ActiveRecord
   class ConnectionTimeoutError < ConnectionNotEstablished
   end
 
+  # Raised when a database connection pool is requested but
+  # has not been defined.
+  class ConnectionNotDefined < ConnectionNotEstablished
+    def initialize(message = nil, connection_name: nil, role: nil, shard: nil)
+      super(message)
+      @connection_name = connection_name
+      @role = role
+      @shard = shard
+    end
+
+    attr_reader :connection_name, :role, :shard
+  end
+
   # Raised when connection to the database could not been established because it was not
   # able to connect to the host or when the authorization failed.
   class DatabaseConnectionError < ConnectionNotEstablished
@@ -280,6 +292,14 @@ module ActiveRecord
   class NotNullViolation < StatementInvalid
   end
 
+  # Raised when a record cannot be inserted or updated because it would violate a check constraint.
+  class CheckViolation < StatementInvalid
+  end
+
+  # Raised when a record cannot be inserted or updated because it would violate an exclusion constraint.
+  class ExclusionViolation < StatementInvalid
+  end
+
   # Raised when a record cannot be inserted or updated because a value too long for a column type.
   class ValueTooLong < StatementInvalid
   end
@@ -326,15 +346,15 @@ module ActiveRecord
     class << self
       def db_error(db_name)
         NoDatabaseError.new(<<~MSG)
-          We could not find your database: #{db_name}. Available database configurations can be found in config/database.yml.
+          Database not found: #{db_name}. Available database configurations can be found in config/database.yml.
 
           To resolve this error:
 
-          - Did you not create the database, or did you delete it? To create the database, run:
+          - Create the database by running:
 
               bin/rails db:create
 
-          - Has the database name changed? Verify that config/database.yml contains the correct database name.
+          - Verify that config/database.yml contains the correct database name.
         MSG
       end
     end
@@ -431,7 +451,7 @@ module ActiveRecord
   UnknownAttributeError = ActiveModel::UnknownAttributeError
 
   # Raised when an error occurred while doing a mass assignment to an attribute through the
-  # {ActiveRecord::Base#attributes=}[rdoc-ref:AttributeAssignment#attributes=] method.
+  # {ActiveRecord::Base#attributes=}[rdoc-ref:ActiveModel::AttributeAssignment#attributes=] method.
   # The exception has an +attribute+ property that is the name of the offending attribute.
   class AttributeAssignmentError < ActiveRecordError
     attr_reader :exception, :attribute
@@ -444,7 +464,7 @@ module ActiveRecord
   end
 
   # Raised when there are multiple errors while doing a mass assignment through the
-  # {ActiveRecord::Base#attributes=}[rdoc-ref:AttributeAssignment#attributes=]
+  # {ActiveRecord::Base#attributes=}[rdoc-ref:ActiveModel::AttributeAssignment#attributes=]
   # method. The exception has an +errors+ property that contains an array of AttributeAssignmentError
   # objects, each corresponding to the error while assigning to an attribute.
   class MultiparameterAssignmentErrors < ActiveRecordError
@@ -477,6 +497,7 @@ module ActiveRecord
   #   end
   #
   #   relation = Task.all
+  #   relation.load
   #   relation.loaded? # => true
   #
   #   # Methods which try to mutate a loaded relation fail.
@@ -484,11 +505,6 @@ module ActiveRecord
   #   relation.limit!(5)              # => ActiveRecord::UnmodifiableRelation
   class UnmodifiableRelation < ActiveRecordError
   end
-  deprecate_constant(
-    :ImmutableRelation,
-    "ActiveRecord::UnmodifiableRelation",
-    deprecator: ActiveRecord.deprecator
-  )
 
   # TransactionIsolationError will be raised under the following conditions:
   #
@@ -544,6 +560,11 @@ module ActiveRecord
   class Deadlocked < TransactionRollbackError
   end
 
+  # MissingRequiredOrderError is raised when a relation requires ordering but
+  # lacks any +order+ values in scope or any model order columns to use.
+  class MissingRequiredOrderError < ActiveRecordError
+  end
+
   # IrreversibleOrderError is raised when a relation's order is too complex for
   # +reverse_order+ to automatically reverse.
   class IrreversibleOrderError < ActiveRecordError
@@ -601,6 +622,9 @@ module ActiveRecord
   # the database version cannot be determined.
   class DatabaseVersionError < ActiveRecordError
   end
+
+  class DeprecatedAssociationError < ActiveRecordError
+  end
 end
 
 require "active_record/associations/errors"

data/lib/active_record/explain.rb

@@ -7,7 +7,7 @@ module ActiveRecord
     # Executes the block with the collect flag enabled. Queries are collected
     # asynchronously by the subscriber and returned.
     def collecting_queries_for_explain # :nodoc:
-      ExplainRegistry.collect = true
+      ExplainRegistry.start
       yield
       ExplainRegistry.queries
     ensure

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

data/lib/active_record/fixture_set/table_row.rb

@@ -193,8 +193,25 @@ module ActiveRecord
 
             targets = targets.is_a?(Array) ? targets : targets.split(/\s*,\s*/)
             joins   = targets.map do |target|
-              join = { lhs_key => @row[model_metadata.primary_key_name],
-                       rhs_key => ActiveRecord::FixtureSet.identify(target, column_type) }
+              join = {}
+
+              if rhs_key.is_a?(Array)
+                composite_key = ActiveRecord::FixtureSet.composite_identify(target, rhs_key)
+                composite_key.each do |column, value|
+                  join[column] = value
+                end
+              else
+                join[rhs_key] = ActiveRecord::FixtureSet.identify(target, column_type)
+              end
+
+              if lhs_key.is_a?(Array)
+                lhs_key.zip(model_metadata.primary_key_name).each do |fkey, pkey|
+                  join[fkey] = @row[pkey]
+                end
+              else
+                join[lhs_key] = @row[model_metadata.primary_key_name]
+              end
+
               association.timestamp_column_names.each do |col|
                 join[col] = @now
               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,21 @@ 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
+          begin
+            if pending?
+              @event_buffer = EventBuffer.new(self, @instrumenter)
+              ActiveSupport::IsolatedExecutionState[:active_record_instrumenter] = @event_buffer
+
               execute_query(connection, async: true)
             end
+          ensure
+            @mutex.unlock
           end
-        ensure
-          @mutex.unlock
         end
       end
     end
@@ -163,7 +167,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,10 +7,10 @@ module ActiveRecord
   end
 
   module VERSION
-    MAJOR = 7
-    MINOR = 2
+    MAJOR = 8
+    MINOR = 1
     TINY  = 2
-    PRE   = "1"
+    PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_record/inheritance.rb

@@ -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

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
 
@@ -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
@@ -126,18 +126,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)