activerecord 7.1.4.1 → 7.2.2.1

data/lib/active_record/enum.rb

@@ -223,6 +223,13 @@ module ActiveRecord
       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
     end
 
     private
@@ -233,6 +240,7 @@ module ActiveRecord
 
       def _enum(name, values, prefix: nil, suffix: nil, scopes: true, instance_methods: true, validate: false, **options)
         assert_valid_enum_definition_values(values)
+        assert_valid_enum_options(options)
         # statuses = { }
         enum_values = ActiveSupport::HashWithIndifferentAccess.new
         name = name.to_s
@@ -245,9 +253,11 @@ module ActiveRecord
         detect_enum_conflict!(name, name)
         detect_enum_conflict!(name, "#{name}=")
 
-        attribute(name, **options) do |subtype|
+        attribute(name, **options)
+
+        decorate_attributes([name]) do |_name, subtype|
           if subtype == ActiveModel::Type.default_value
-            raise "Undeclared attribute type for enum '#{name}'. Enums must be" \
+            raise "Undeclared attribute type for enum '#{name}' in #{self.name}. Enums must be" \
               " backed by a database column or declared with an explicit type" \
               " via `attribute`."
           end
@@ -361,6 +371,13 @@ module ActiveRecord
         end
       end
 
+      def assert_valid_enum_options(options)
+        invalid_keys = options.keys & %i[_prefix _suffix _scopes _default _instance_methods]
+        unless invalid_keys.empty?
+          raise ArgumentError, "invalid option(s): #{invalid_keys.map(&:inspect).join(", ")}. Valid options are: :prefix, :suffix, :scopes, :default, :instance_methods, and :validate."
+        end
+      end
+
       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 " \

data/lib/active_record/errors.rb

@@ -1,20 +1,16 @@
 # frozen_string_literal: true
 
+require "active_support/deprecation"
+
 module ActiveRecord
+  include ActiveSupport::Deprecation::DeprecatedConstantAccessor
+
   # = Active Record Errors
   #
   # Generic Active Record exception class.
   class ActiveRecordError < StandardError
   end
 
-  # DEPRECATED: Previously raised when trying to use a feature in Active Record which
-  # requires Active Job but the gem is not present. Now raises a NameError.
-  include ActiveSupport::Deprecation::DeprecatedConstantAccessor
-  DeprecatedActiveJobRequiredError = Class.new(ActiveRecordError) # :nodoc:
-  deprecate_constant "ActiveJobRequiredError", "ActiveRecord::DeprecatedActiveJobRequiredError",
-    message: "ActiveRecord::ActiveJobRequiredError has been deprecated. If Active Job is not present, a NameError will be raised instead.",
-    deprecator: ActiveRecord.deprecator
-
   # 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]
@@ -66,7 +62,7 @@ module ActiveRecord
   end
 
   # Raised when connection to the database could not been established (for example when
-  # {ActiveRecord::Base.connection=}[rdoc-ref:ConnectionHandling#connection]
+  # {ActiveRecord::Base.lease_connection=}[rdoc-ref:ConnectionHandling#lease_connection]
   # is given a +nil+ object).
   class ConnectionNotEstablished < AdapterError
     def initialize(message = nil, connection_pool: nil)
@@ -137,8 +133,18 @@ module ActiveRecord
   end
 
   # Raised by {ActiveRecord::Base#save!}[rdoc-ref:Persistence#save!] and
-  # {ActiveRecord::Base.create!}[rdoc-ref:Persistence::ClassMethods#create!]
-  # methods when a record is invalid and cannot be saved.
+  # {ActiveRecord::Base.update_attribute!}[rdoc-ref:Persistence#update_attribute!]
+  # methods when a record failed to validate or cannot be saved due to any of the
+  # <tt>before_*</tt> callbacks throwing +:abort+. See
+  # ActiveRecord::Callbacks for further details.
+  #
+  #   class Product < ActiveRecord::Base
+  #     before_save do
+  #       throw :abort if price < 0
+  #     end
+  #   end
+  #
+  #   Product.create! # => raises an ActiveRecord::RecordNotSaved
   class RecordNotSaved < ActiveRecordError
     attr_reader :record
 
@@ -149,15 +155,17 @@ module ActiveRecord
   end
 
   # Raised by {ActiveRecord::Base#destroy!}[rdoc-ref:Persistence#destroy!]
-  # when a call to {#destroy}[rdoc-ref:Persistence#destroy]
-  # would return false.
+  # when a record cannot be destroyed due to any of the
+  # <tt>before_destroy</tt> callbacks throwing +:abort+. See
+  # ActiveRecord::Callbacks for further details.
   #
-  #   begin
-  #     complex_operation_that_internally_calls_destroy!
-  #   rescue ActiveRecord::RecordNotDestroyed => invalid
-  #     puts invalid.record.errors
+  #   class User < ActiveRecord::Base
+  #     before_destroy do
+  #       throw :abort if still_active?
+  #     end
   #   end
   #
+  #   User.first.destroy! # => raises an ActiveRecord::RecordNotDestroyed
   class RecordNotDestroyed < ActiveRecordError
     attr_reader :record
 
@@ -374,6 +382,12 @@ module ActiveRecord
   end
 
   # Raised on attempt to lazily load records that are marked as strict loading.
+  #
+  # You can resolve this error by eager loading marked records before accessing
+  # them. The
+  # {Eager Loading Associations}[https://guides.rubyonrails.org/active_record_querying.html#eager-loading-associations]
+  # guide covers solutions, such as using
+  # {ActiveRecord::Base.includes}[rdoc-ref:QueryMethods#includes].
   class StrictLoadingViolationError < ActiveRecordError
   end
 
@@ -466,10 +480,15 @@ module ActiveRecord
   #   relation.loaded? # => true
   #
   #   # Methods which try to mutate a loaded relation fail.
-  #   relation.where!(title: 'TODO')  # => ActiveRecord::ImmutableRelation
-  #   relation.limit!(5)              # => ActiveRecord::ImmutableRelation
-  class ImmutableRelation < ActiveRecordError
+  #   relation.where!(title: 'TODO')  # => ActiveRecord::UnmodifiableRelation
+  #   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:
   #
@@ -577,4 +596,11 @@ module ActiveRecord
   # values, such as request parameters or model attributes to query methods.
   class UnknownAttributeReference < ActiveRecordError
   end
+
+  # DatabaseVersionError will be raised when the database version is not supported, or when
+  # the database version cannot be determined.
+  class DatabaseVersionError < ActiveRecordError
+  end
 end
+
+require "active_record/associations/errors"

data/lib/active_record/explain.rb

@@ -17,16 +17,17 @@ module ActiveRecord
     # Makes the adapter execute EXPLAIN for the tuples of queries and bindings.
     # Returns a formatted string ready to be logged.
     def exec_explain(queries, options = []) # :nodoc:
-      str = queries.map do |sql, binds|
-        msg = +"#{build_explain_clause(options)} #{sql}"
-        unless binds.empty?
-          msg << " "
-          msg << binds.map { |attr| render_bind(attr) }.inspect
-        end
-        msg << "\n"
-        msg << connection_explain(sql, binds, options)
-      end.join("\n")
-
+      str = with_connection do |c|
+        queries.map do |sql, binds|
+          msg = +"#{build_explain_clause(c, options)} #{sql}"
+          unless binds.empty?
+            msg << " "
+            msg << binds.map { |attr| render_bind(c, attr) }.inspect
+          end
+          msg << "\n"
+          msg << c.explain(sql, binds, options)
+        end.join("\n")
+      end
       # Overriding inspect to be more human readable, especially in the console.
       def str.inspect
         self
@@ -36,7 +37,7 @@ module ActiveRecord
     end
 
     private
-      def render_bind(attr)
+      def render_bind(connection, attr)
         if ActiveModel::Attribute === attr
           value = if attr.type.binary? && attr.value
             "<#{attr.value_for_database.to_s.bytesize} bytes of binary data>"
@@ -51,24 +52,12 @@ module ActiveRecord
         [attr&.name, value]
       end
 
-      def build_explain_clause(options = [])
+      def build_explain_clause(connection, options = [])
         if connection.respond_to?(:build_explain_clause, true)
           connection.build_explain_clause(options)
         else
           "EXPLAIN for:"
         end
       end
-
-      def connection_explain(sql, binds, options)
-        if connection.method(:explain).parameters.size == 2
-          ActiveRecord.deprecator.warn(<<~MSG.squish)
-            The current database adapter, #{connection.adapter_name}, does not support explain options.
-            To remove this warning, the adapter must implement `build_explain_clause(options = [])`.
-          MSG
-          connection.explain(sql, binds)
-        else
-          connection.explain(sql, binds, options)
-        end
-      end
   end
 end

data/lib/active_record/fixtures.rb

@@ -110,6 +110,12 @@ module ActiveRecord
   #     assert_raise(StandardError) { web_sites(:reddit) }
   #   end
   #
+  # If the model names conflicts with a +TestCase+ methods, you can use the generic +fixture+ accessor
+  #
+  #   test "generic find" do
+  #     assert_equal "Ruby on Rails", fixture(:web_sites, :rubyonrails).name
+  #   end
+  #
   # Alternatively, you may enable auto-instantiation of the fixture data. For instance, take the
   # following tests:
   #
@@ -492,8 +498,8 @@ module ActiveRecord
   #   # app/models/book_orders.rb
   #   class BookOrder < ApplicationRecord
   #     self.primary_key = [:shop_id, :id]
-  #     belongs_to :order, query_constraints: [:shop_id, :order_id]
-  #     belongs_to :book, query_constraints: [:author_id, :book_id]
+  #     belongs_to :order, foreign_key: [:shop_id, :order_id]
+  #     belongs_to :book, foreign_key: [:author_id, :book_id]
   #   end
   #
   # <code></code>
@@ -553,24 +559,24 @@ module ActiveRecord
         @@all_cached_fixtures.clear
       end
 
-      def cache_for_connection(connection)
-        @@all_cached_fixtures[connection]
+      def cache_for_connection_pool(connection_pool)
+        @@all_cached_fixtures[connection_pool]
       end
 
-      def fixture_is_cached?(connection, table_name)
-        cache_for_connection(connection)[table_name]
+      def fixture_is_cached?(connection_pool, table_name)
+        cache_for_connection_pool(connection_pool)[table_name]
       end
 
-      def cached_fixtures(connection, keys_to_fetch = nil)
+      def cached_fixtures(connection_pool, keys_to_fetch = nil)
         if keys_to_fetch
-          cache_for_connection(connection).values_at(*keys_to_fetch)
+          cache_for_connection_pool(connection_pool).values_at(*keys_to_fetch)
         else
-          cache_for_connection(connection).values
+          cache_for_connection_pool(connection_pool).values
         end
       end
 
-      def cache_fixtures(connection, fixtures_map)
-        cache_for_connection(connection).update(fixtures_map)
+      def cache_fixtures(connection_pool, fixtures_map)
+        cache_for_connection_pool(connection_pool).update(fixtures_map)
       end
 
       def instantiate_fixtures(object, fixture_set, load_instances = true)
@@ -588,15 +594,13 @@ module ActiveRecord
         end
       end
 
-      def create_fixtures(fixtures_directories, fixture_set_names, class_names = {}, config = ActiveRecord::Base, &block)
+      def create_fixtures(fixtures_directories, fixture_set_names, class_names = {}, config = ActiveRecord::Base)
         fixture_set_names = Array(fixture_set_names).map(&:to_s)
         class_names.stringify_keys!
 
-        # FIXME: Apparently JK uses this.
-        connection = block_given? ? block : lambda { ActiveRecord::Base.connection }
-
+        connection_pool = config.connection_pool
         fixture_files_to_read = fixture_set_names.reject do |fs_name|
-          fixture_is_cached?(connection.call, fs_name)
+          fixture_is_cached?(connection_pool, fs_name)
         end
 
         if fixture_files_to_read.any?
@@ -604,11 +608,11 @@ module ActiveRecord
             Array(fixtures_directories),
             fixture_files_to_read,
             class_names,
-            connection,
+            connection_pool,
           )
-          cache_fixtures(connection.call, fixtures_map)
+          cache_fixtures(connection_pool, fixtures_map)
         end
-        cached_fixtures(connection.call, fixture_set_names)
+        cached_fixtures(connection_pool, fixture_set_names)
       end
 
       # Returns a consistent, platform-independent identifier for +label+.
@@ -641,7 +645,7 @@ module ActiveRecord
       end
 
       private
-        def read_and_insert(fixtures_directories, fixture_files, class_names, connection) # :nodoc:
+        def read_and_insert(fixtures_directories, fixture_files, class_names, connection_pool) # :nodoc:
           fixtures_map = {}
           directory_glob = "{#{fixtures_directories.join(",")}}"
           fixture_sets = fixture_files.map do |fixture_set_name|
@@ -655,21 +659,21 @@ module ActiveRecord
           end
           update_all_loaded_fixtures(fixtures_map)
 
-          insert(fixture_sets, connection)
+          insert(fixture_sets, connection_pool)
 
           fixtures_map
         end
 
-        def insert(fixture_sets, connection) # :nodoc:
-          fixture_sets_by_connection = fixture_sets.group_by do |fixture_set|
+        def insert(fixture_sets, connection_pool) # :nodoc:
+          fixture_sets_by_pool = fixture_sets.group_by do |fixture_set|
             if fixture_set.model_class
-              fixture_set.model_class.connection
+              fixture_set.model_class.connection_pool
             else
-              connection.call
+              connection_pool
             end
           end
 
-          fixture_sets_by_connection.each do |conn, set|
+          fixture_sets_by_pool.each do |pool, set|
             table_rows_for_connection = Hash.new { |h, k| h[k] = [] }
 
             set.each do |fixture_set|
@@ -678,13 +682,15 @@ module ActiveRecord
               end
             end
 
-            conn.insert_fixtures_set(table_rows_for_connection, table_rows_for_connection.keys)
+            pool.with_connection do |conn|
+              conn.insert_fixtures_set(table_rows_for_connection, table_rows_for_connection.keys)
 
-            check_all_foreign_keys_valid!(conn)
+              check_all_foreign_keys_valid!(conn)
 
-            # Cap primary key sequences to max(pk).
-            if conn.respond_to?(:reset_pk_sequence!)
-              set.each { |fs| conn.reset_pk_sequence!(fs.table_name) }
+              # Cap primary key sequences to max(pk).
+              if conn.respond_to?(:reset_pk_sequence!)
+                set.each { |fs| conn.reset_pk_sequence!(fs.table_name) }
+              end
             end
           end
         end

data/lib/active_record/future_result.rb

@@ -32,8 +32,11 @@ module ActiveRecord
 
       def instrument(name, payload = {}, &block)
         event = @instrumenter.new_event(name, payload)
-        @events << event
-        event.record(&block)
+        begin
+          event.record(&block)
+        ensure
+          @events << event
+        end
       end
 
       def flush
@@ -57,7 +60,6 @@ module ActiveRecord
     end
 
     delegate :empty?, :to_a, to: :result
-    delegate_missing_to :result
 
     attr_reader :lock_wait
 
@@ -140,7 +142,9 @@ module ActiveRecord
           start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
           @mutex.synchronize do
             if pending?
-              execute_query(@pool.connection)
+              @pool.with_connection do |connection|
+                execute_query(connection)
+              end
             else
               @lock_wait = (Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond) - start)
             end

data/lib/active_record/gem_version.rb

@@ -8,8 +8,8 @@ module ActiveRecord
 
   module VERSION
     MAJOR = 7
-    MINOR = 1
-    TINY  = 4
+    MINOR = 2
+    TINY  = 2
     PRE   = "1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")

data/lib/active_record/inheritance.rb

@@ -165,7 +165,7 @@ module ActiveRecord
 
       # Returns whether this class is an abstract class or not.
       def abstract_class?
-        defined?(@abstract_class) && @abstract_class == true
+        @abstract_class == true
       end
 
       # Sets the application record class for Active Record
@@ -202,7 +202,9 @@ module ActiveRecord
           "The single-table inheritance mechanism failed to locate the subclass: '#{type_name}'. " \
           "This error is raised because the column '#{inheritance_column}' is reserved for storing the class in case of inheritance. " \
           "Please rename this column if you didn't intend it to be used for storing the inheritance class " \
-          "or overwrite #{name}.inheritance_column to use another column for that information."
+          "or overwrite #{name}.inheritance_column to use another column for that information. " \
+          "If you wish to disable single-table inheritance for #{name} set " \
+          "#{name}.inheritance_column to nil"
       end
 
       # Returns the value to be stored in the polymorphic type column for Polymorphic Associations.

data/lib/active_record/insert_all.rb

@@ -7,8 +7,17 @@ module ActiveRecord
     attr_reader :model, :connection, :inserts, :keys
     attr_reader :on_duplicate, :update_only, :returning, :unique_by, :update_sql
 
-    def initialize(model, inserts, on_duplicate:, update_only: nil, returning: nil, unique_by: nil, record_timestamps: nil)
-      @model, @connection, @inserts = model, model.connection, inserts.map(&:stringify_keys)
+    class << self
+      def execute(relation, ...)
+        relation.model.with_connection do |c|
+          new(relation, c, ...).execute
+        end
+      end
+    end
+
+    def initialize(relation, connection, inserts, on_duplicate:, update_only: nil, returning: nil, unique_by: nil, record_timestamps: nil)
+      @relation = relation
+      @model, @connection, @inserts = relation.model, connection, inserts.map(&:stringify_keys)
       @on_duplicate, @update_only, @returning, @unique_by = on_duplicate, update_only, returning, unique_by
       @record_timestamps = record_timestamps.nil? ? model.record_timestamps : record_timestamps
 
@@ -23,10 +32,8 @@ module ActiveRecord
         @keys = @inserts.first.keys
       end
 
-      if model.scope_attributes?
-        @scope_attributes = model.scope_attributes
-        @keys |= @scope_attributes.keys
-      end
+      @scope_attributes = relation.scope_for_create.except(@model.inheritance_column)
+      @keys |= @scope_attributes.keys
       @keys = @keys.to_set
 
       @returning = (connection.supports_insert_returning? ? primary_keys : false) if @returning.nil?
@@ -52,10 +59,9 @@ module ActiveRecord
     end
 
     def primary_keys
-      Array(connection.schema_cache.primary_keys(model.table_name))
+      Array(@model.schema_cache.primary_keys(model.table_name))
     end
 
-
     def skip_duplicates?
       on_duplicate == :skip
     end
@@ -67,7 +73,7 @@ module ActiveRecord
     def map_key_with_value
       inserts.map do |attributes|
         attributes = attributes.stringify_keys
-        attributes.merge!(scope_attributes) if scope_attributes
+        attributes.merge!(@scope_attributes)
         attributes.reverse_merge!(timestamps_for_create) if record_timestamps?
 
         verify_attributes(attributes)
@@ -92,8 +98,6 @@ module ActiveRecord
     end
 
     private
-      attr_reader :scope_attributes
-
       def has_attribute_aliases?(attributes)
         attributes.keys.any? { |attribute| model.attribute_alias?(attribute) }
       end
@@ -163,10 +167,9 @@ module ActiveRecord
       end
 
       def unique_indexes
-        connection.schema_cache.indexes(model.table_name).select(&:unique)
+        @model.schema_cache.indexes(model.table_name).select(&:unique)
       end
 
-
       def ensure_valid_options_for_connection!
         if returning && !connection.supports_insert_returning?
           raise ArgumentError, "#{connection.class} does not support :returning"
@@ -192,7 +195,7 @@ module ActiveRecord
 
 
       def readonly_columns
-        primary_keys + model.readonly_attributes.to_a
+        primary_keys + model.readonly_attributes
       end
 
       def unique_by_columns
@@ -301,7 +304,7 @@ module ActiveRecord
           end
 
           def extract_types_from_columns_on(table_name, keys:)
-            columns = connection.schema_cache.columns_hash(table_name)
+            columns = @model.schema_cache.columns_hash(table_name)
 
             unknown_column = (keys - columns.keys).first
             raise UnknownAttributeError.new(model.new, unknown_column) if unknown_column

data/lib/active_record/integration.rb

@@ -178,7 +178,10 @@ module ActiveRecord
       def can_use_fast_cache_version?(timestamp)
         timestamp.is_a?(String) &&
           cache_timestamp_format == :usec &&
-          self.class.connection.default_timezone == :utc &&
+          # FIXME: checking out a connection for this is wasteful
+          # we should store/cache this information in the schema cache
+          # or similar.
+          self.class.with_connection(&:default_timezone) == :utc &&
           !updated_at_came_from_user?
       end