activerecord 7.0.8 → 7.1.2

data/lib/active_record/enum.rb

@@ -111,23 +111,70 @@ module ActiveRecord
   #
   #   conversation.comments_inactive!
   #   conversation.comments_active? # => false
+  #
+  # If you want to disable the auto-generated methods on the model, you can do
+  # so by setting the +:instance_methods+ option to false:
+  #
+  #   class Conversation < ActiveRecord::Base
+  #     enum :status, [ :active, :archived ], instance_methods: false
+  #   end
+  #
+  # If you want the enum value to be validated before saving, use the option +:validate+:
+  #
+  #   class Conversation < ActiveRecord::Base
+  #     enum :status, [ :active, :archived ], validate: true
+  #   end
+  #
+  #   conversation = Conversation.new
+  #
+  #   conversation.status = :unknown
+  #   conversation.valid? # => false
+  #
+  #   conversation.status = nil
+  #   conversation.valid? # => false
+  #
+  #   conversation.status = :active
+  #   conversation.valid? # => true
+  #
+  # It is also possible to pass additional validation options:
+  #
+  #   class Conversation < ActiveRecord::Base
+  #     enum :status, [ :active, :archived ], validate: { allow_nil: true }
+  #   end
+  #
+  #   conversation = Conversation.new
+  #
+  #   conversation.status = :unknown
+  #   conversation.valid? # => false
+  #
+  #   conversation.status = nil
+  #   conversation.valid? # => true
+  #
+  #   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: {})
     end
 
-    def inherited(base) # :nodoc:
-      base.defined_enums = defined_enums.deep_dup
-      super
-    end
-
     class EnumType < Type::Value # :nodoc:
       delegate :type, to: :subtype
 
-      def initialize(name, mapping, subtype)
+      def initialize(name, mapping, subtype, raise_on_invalid_values: true)
         @name = name
         @mapping = mapping
         @subtype = subtype
+        @_raise_on_invalid_values = raise_on_invalid_values
       end
 
       def cast(value)
@@ -153,6 +200,8 @@ module ActiveRecord
       end
 
       def assert_valid_value(value)
+        return unless @_raise_on_invalid_values
+
         unless value.blank? || mapping.has_key?(value) || mapping.has_value?(value)
           raise ArgumentError, "'#{value}' is not a valid #{name}"
         end
@@ -170,14 +219,19 @@ module ActiveRecord
         return _enum(name, values, **options)
       end
 
-      definitions = options.slice!(:_prefix, :_suffix, :_scopes, :_default)
+      definitions = options.slice!(:_prefix, :_suffix, :_scopes, :_default, :_instance_methods)
       options.transform_keys! { |key| :"#{key[1..-1]}" }
 
       definitions.each { |name, values| _enum(name, values, **options) }
     end
 
     private
-      def _enum(name, values, prefix: nil, suffix: nil, scopes: true, **options)
+      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)
         # statuses = { }
         enum_values = ActiveSupport::HashWithIndifferentAccess.new
@@ -192,8 +246,14 @@ module ActiveRecord
         detect_enum_conflict!(name, "#{name}=")
 
         attribute(name, **options) do |subtype|
+          if subtype == ActiveModel::Type.default_value
+            raise "Undeclared attribute type for enum '#{name}'. Enums must be" \
+              " backed by a database column or declared with an explicit type" \
+              " via `attribute`."
+          end
+
           subtype = subtype.subtype if EnumType === subtype
-          EnumType.new(name, enum_values, subtype)
+          EnumType.new(name, enum_values, subtype, raise_on_invalid_values: !validate)
         end
 
         value_method_names = []
@@ -213,18 +273,24 @@ module ActiveRecord
 
             value_method_name = "#{prefix}#{label}#{suffix}"
             value_method_names << value_method_name
-            define_enum_methods(name, value_method_name, value, scopes)
+            define_enum_methods(name, value_method_name, value, scopes, instance_methods)
 
             method_friendly_label = label.gsub(/[\W&&[:ascii:]]+/, "_")
             value_method_alias = "#{prefix}#{method_friendly_label}#{suffix}"
 
             if value_method_alias != value_method_name && !value_method_names.include?(value_method_alias)
               value_method_names << value_method_alias
-              define_enum_methods(name, value_method_alias, value, scopes)
+              define_enum_methods(name, value_method_alias, value, scopes, instance_methods)
             end
           end
         end
         detect_negative_enum_conditions!(value_method_names) if scopes
+
+        if validate
+          validate = {} unless Hash === validate
+          validates_inclusion_of name, in: enum_values.keys, **validate
+        end
+
         enum_values.freeze
       end
 
@@ -236,21 +302,23 @@ module ActiveRecord
         private
           attr_reader :klass
 
-          def define_enum_methods(name, value_method_name, value, scopes)
-            # def active?() status_for_database == 0 end
-            klass.send(:detect_enum_conflict!, name, "#{value_method_name}?")
-            define_method("#{value_method_name}?") { public_send(:"#{name}_for_database") == value }
+          def define_enum_methods(name, value_method_name, value, scopes, instance_methods)
+            if instance_methods
+              # def active?() status_for_database == 0 end
+              klass.send(:detect_enum_conflict!, name, "#{value_method_name}?")
+              define_method("#{value_method_name}?") { public_send(:"#{name}_for_database") == value }
 
-            # def active!() update!(status: 0) end
-            klass.send(:detect_enum_conflict!, name, "#{value_method_name}!")
-            define_method("#{value_method_name}!") { update!(name => value) }
+              # def active!() update!(status: 0) end
+              klass.send(:detect_enum_conflict!, name, "#{value_method_name}!")
+              define_method("#{value_method_name}!") { update!(name => value) }
+            end
 
-            # scope :active, -> { where(status: 0) }
-            # scope :not_active, -> { where.not(status: 0) }
             if scopes
+              # scope :active, -> { where(status: 0) }
               klass.send(:detect_enum_conflict!, name, value_method_name, true)
               klass.scope value_method_name, -> { where(name => value) }
 
+              # scope :not_active, -> { where.not(status: 0) }
               klass.send(:detect_enum_conflict!, name, "not_#{value_method_name}", true)
               klass.scope "not_#{value_method_name}", -> { where.not(name => value) }
             end
@@ -267,15 +335,29 @@ module ActiveRecord
       end
 
       def assert_valid_enum_definition_values(values)
-        unless values.is_a?(Hash) || values.all?(Symbol) || values.all?(String)
-          error_message = <<~MSG
-            Enum values #{values} must be either a hash, an array of symbols, or an array of strings.
-          MSG
-          raise ArgumentError, error_message
-        end
+        case values
+        when Hash
+          if values.empty?
+            raise ArgumentError, "Enum values #{values} must not be empty."
+          end
 
-        if values.is_a?(Hash) && values.keys.any?(&:blank?) || values.is_a?(Array) && values.any?(&:blank?)
-          raise ArgumentError, "Enum label name must not be blank."
+          if values.keys.any?(&:blank?)
+            raise ArgumentError, "Enum values #{values} must not contain a blank name."
+          end
+        when Array
+          if values.empty?
+            raise ArgumentError, "Enum values #{values} must not be empty."
+          end
+
+          unless values.all?(Symbol) || values.all?(String)
+            raise ArgumentError, "Enum values #{values} must only contain symbols or strings."
+          end
+
+          if values.any?(&:blank?)
+            raise ArgumentError, "Enum values #{values} must not contain a blank name."
+          end
+        else
+          raise ArgumentError, "Enum values #{values} must be either a non-empty hash or an array."
         end
       end
 
@@ -290,6 +372,8 @@ module ActiveRecord
           raise_conflict_error(enum_name, method_name, type: "class")
         elsif klass_method && method_defined_within?(method_name, Relation)
           raise_conflict_error(enum_name, method_name, type: "class", source: Relation.name)
+        elsif klass_method && method_name.to_sym == :id
+          raise_conflict_error(enum_name, method_name)
         elsif !klass_method && dangerous_attribute_method?(method_name)
           raise_conflict_error(enum_name, method_name)
         elsif !klass_method && method_defined_within?(method_name, _enum_methods_module, Module)

data/lib/active_record/errors.rb

@@ -7,9 +7,13 @@ module ActiveRecord
   class ActiveRecordError < StandardError
   end
 
-  # Raised when trying to use a feature in Active Record which requires Active Job but the gem is not present.
-  class ActiveJobRequiredError < ActiveRecordError
-  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
@@ -51,10 +55,31 @@ module ActiveRecord
   class AdapterNotFound < ActiveRecordError
   end
 
+  # Superclass for all errors raised from an Active Record adapter.
+  class AdapterError < ActiveRecordError
+    def initialize(message = nil, connection_pool: nil)
+      @connection_pool = connection_pool
+      super(message)
+    end
+
+    attr_reader :connection_pool
+  end
+
   # Raised when connection to the database could not been established (for example when
   # {ActiveRecord::Base.connection=}[rdoc-ref:ConnectionHandling#connection]
   # is given a +nil+ object).
-  class ConnectionNotEstablished < ActiveRecordError
+  class ConnectionNotEstablished < AdapterError
+    def initialize(message = nil, connection_pool: nil)
+      super(message, connection_pool: connection_pool)
+    end
+
+    def set_pool(connection_pool)
+      unless @connection_pool
+        @connection_pool = connection_pool
+      end
+
+      self
+    end
   end
 
   # Raised when a connection could not be obtained within the connection
@@ -90,7 +115,7 @@ module ActiveRecord
   # Raised when a pool was unable to get ahold of all its connections
   # to perform a "group" action such as
   # {ActiveRecord::Base.connection_pool.disconnect!}[rdoc-ref:ConnectionAdapters::ConnectionPool#disconnect!]
-  # or {ActiveRecord::Base.clear_reloadable_connections!}[rdoc-ref:ConnectionAdapters::ConnectionHandler#clear_reloadable_connections!].
+  # or {ActiveRecord::Base.connection_handler.clear_reloadable_connections!}[rdoc-ref:ConnectionAdapters::ConnectionHandler#clear_reloadable_connections!].
   class ExclusiveConnectionTimeoutError < ConnectionTimeoutError
   end
 
@@ -155,14 +180,23 @@ module ActiveRecord
   # Superclass for all database execution errors.
   #
   # Wraps the underlying database error as +cause+.
-  class StatementInvalid < ActiveRecordError
-    def initialize(message = nil, sql: nil, binds: nil)
-      super(message || $!&.message)
+  class StatementInvalid < AdapterError
+    def initialize(message = nil, sql: nil, binds: nil, connection_pool: nil)
+      super(message || $!&.message, connection_pool: connection_pool)
       @sql = sql
       @binds = binds
     end
 
     attr_reader :sql, :binds
+
+    def set_query(sql, binds)
+      unless @sql
+        @sql = sql
+        @binds = binds
+      end
+
+      self
+    end
   end
 
   # Defunct wrapper class kept for compatibility.
@@ -189,8 +223,13 @@ module ActiveRecord
       foreign_key: nil,
       target_table: nil,
       primary_key: nil,
-      primary_key_column: nil
+      primary_key_column: nil,
+      query_parser: nil,
+      connection_pool: nil
     )
+      @original_message = message
+      @query_parser = query_parser
+
       if table
         type = primary_key_column.bigint? ? :bigint : primary_key_column.type
         msg = <<~EOM.squish
@@ -208,7 +247,24 @@ module ActiveRecord
       if message
         msg << "\nOriginal message: #{message}"
       end
-      super(msg, sql: sql, binds: binds)
+
+      super(msg, sql: sql, binds: binds, connection_pool: connection_pool)
+    end
+
+    def set_query(sql, binds)
+      if @query_parser && !@sql
+        self.class.new(
+          message: @original_message,
+          sql: sql,
+          binds: binds,
+          connection_pool: @connection_pool,
+          **@query_parser.call(sql)
+        ).tap do |exception|
+          exception.set_backtrace backtrace
+        end
+      else
+        super
+      end
     end
   end
 
@@ -224,6 +280,19 @@ module ActiveRecord
   class RangeError < StatementInvalid
   end
 
+  # Raised when a statement produces an SQL warning.
+  class SQLWarning < AdapterError
+    attr_reader :code, :level
+    attr_accessor :sql
+
+    def initialize(message = nil, code = nil, level = nil, sql = nil, connection_pool = nil)
+      super(message, connection_pool: connection_pool)
+      @code = code
+      @level = level
+      @sql = sql
+    end
+  end
+
   # Raised when the number of placeholders in an SQL fragment passed to
   # {ActiveRecord::Base.where}[rdoc-ref:QueryMethods#where]
   # does not match the number of values supplied.
@@ -242,16 +311,16 @@ module ActiveRecord
       ActiveRecord::Tasks::DatabaseTasks.create_current
     end
 
-    def initialize(message = nil)
-      super(message || "Database not found")
+    def initialize(message = nil, connection_pool: nil)
+      super(message || "Database not found", connection_pool: connection_pool)
     end
 
     class << self
       def db_error(db_name)
         NoDatabaseError.new(<<~MSG)
-          We could not find your database: #{db_name}. Which can be found in the database configuration file located at config/database.yml.
+          We could not find your database: #{db_name}. Available database configurations can be found in config/database.yml file.
 
-          To resolve this issue:
+          To resolve this error:
 
           - Did you create the database for this app, or delete it? You may need to create your database.
           - Has the database name changed? Check your database.yml config has the correct database name.
@@ -407,13 +476,26 @@ module ActiveRecord
   # * You are joining an existing open transaction
   # * You are creating a nested (savepoint) transaction
   #
-  # The mysql2 and postgresql adapters support setting the transaction isolation level.
+  # The mysql2, trilogy, and postgresql adapters support setting the transaction isolation level.
   class TransactionIsolationError < ActiveRecordError
   end
 
   # TransactionRollbackError will be raised when a transaction is rolled
   # back by the database due to a serialization failure or a deadlock.
   #
+  # These exceptions should not be generally rescued in nested transaction
+  # blocks, because they have side-effects in the actual enclosing transaction
+  # and internal Active Record state. They can be rescued if you are above the
+  # root transaction block, though.
+  #
+  # In that case, beware of transactional tests, however, because they run test
+  # cases in their own umbrella transaction. If you absolutely need to handle
+  # these exceptions in tests please consider disabling transactional tests in
+  # the affected test class (<tt>self.use_transactional_tests = false</tt>).
+  #
+  # Due to the aforementioned side-effects, this exception should not be raised
+  # manually by users.
+  #
   # See the following:
   #
   # * https://www.postgresql.org/docs/current/static/transaction-iso.html
@@ -428,11 +510,17 @@ module ActiveRecord
 
   # SerializationFailure will be raised when a transaction is rolled
   # back by the database due to a serialization failure.
+  #
+  # This is a subclass of TransactionRollbackError, please make sure to check
+  # its documentation to be aware of its caveats.
   class SerializationFailure < TransactionRollbackError
   end
 
   # Deadlocked will be raised when a transaction is rolled
   # back by the database when a deadlock is encountered.
+  #
+  # This is a subclass of TransactionRollbackError, please make sure to check
+  # its documentation to be aware of its caveats.
   class Deadlocked < TransactionRollbackError
   end
 
@@ -461,6 +549,11 @@ module ActiveRecord
   class AdapterTimeout < QueryAborted
   end
 
+  # ConnectionFailed will be raised when the network connection to the
+  # database fails while sending a query or waiting for its result.
+  class ConnectionFailed < QueryAborted
+  end
+
   # UnknownAttributeReference is raised when an unknown and potentially unsafe
   # value is passed to a query method. For example, passing a non column name
   # value to a relation's #order method might cause this exception.

data/lib/active_record/explain.rb

@@ -16,15 +16,15 @@ 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) # :nodoc:
+    def exec_explain(queries, options = []) # :nodoc:
       str = queries.map do |sql, binds|
-        msg = +"EXPLAIN for: #{sql}"
+        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)
+        msg << connection_explain(sql, binds, options)
       end.join("\n")
 
       # Overriding inspect to be more human readable, especially in the console.
@@ -50,5 +50,25 @@ module ActiveRecord
 
         [attr&.name, value]
       end
+
+      def build_explain_clause(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/fixture_set/model_metadata.rb

@@ -12,12 +12,22 @@ module ActiveRecord
       end
 
       def primary_key_type
-        @primary_key_type ||= @model_class && @model_class.type_for_attribute(@model_class.primary_key).type
+        @primary_key_type ||= @model_class && column_type(@model_class.primary_key)
       end
 
-      def has_primary_key_column?
-        @has_primary_key_column ||= primary_key_name &&
-          @model_class.columns.any? { |col| col.name == primary_key_name }
+      def column_type(column_name)
+        @column_type ||= {}
+        return @column_type[column_name] if @column_type.key?(column_name)
+
+        @column_type[column_name] = @model_class && @model_class.type_for_attribute(column_name).type
+      end
+
+      def has_column?(column_name)
+        column_names.include?(column_name)
+      end
+
+      def column_names
+        @column_names ||= @model_class ? @model_class.columns.map(&:name).to_set : Set.new
       end
 
       def timestamp_column_names

data/lib/active_record/fixture_set/render_context.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "base64"
+
 # NOTE: This class has to be defined in compact style in
 # order for rendering context subclassing to work correctly.
 class ActiveRecord::FixtureSet::RenderContext # :nodoc:

data/lib/active_record/fixture_set/table_row.rb

@@ -87,7 +87,7 @@ module ActiveRecord
           return unless model_class
           fill_timestamps
           interpolate_label
-          generate_primary_key
+          model_class.composite_primary_key? ? generate_composite_primary_key : generate_primary_key
           resolve_enums
           resolve_sti_reflections
         end
@@ -117,14 +117,26 @@ module ActiveRecord
         end
 
         def generate_primary_key
-          # generate a primary key if necessary
-          if model_metadata.has_primary_key_column? && !@row.include?(model_metadata.primary_key_name)
-            @row[model_metadata.primary_key_name] = ActiveRecord::FixtureSet.identify(
-              @label, model_metadata.primary_key_type
-            )
+          pk = model_metadata.primary_key_name
+
+          unless column_defined?(pk)
+            @row[pk] = ActiveRecord::FixtureSet.identify(@label, model_metadata.column_type(pk))
+          end
+        end
+
+        def generate_composite_primary_key
+          composite_key = ActiveRecord::FixtureSet.composite_identify(@label, model_metadata.primary_key_name)
+          composite_key.each do |column, value|
+            next if column_defined?(column)
+
+            @row[column] = value
           end
         end
 
+        def column_defined?(col)
+          !model_metadata.has_column?(col) || @row.include?(col)
+        end
+
         def resolve_enums
           reflection_class.defined_enums.each do |name, values|
             if @row.include?(name)
@@ -151,8 +163,17 @@ module ActiveRecord
                   raise PrimaryKeyError.new(@label, association, value)
                 end
 
-                fk_type = reflection_class.type_for_attribute(fk_name).type
-                @row[fk_name] = ActiveRecord::FixtureSet.identify(value, fk_type)
+                if fk_name.is_a?(Array)
+                  composite_key = ActiveRecord::FixtureSet.composite_identify(value, fk_name)
+                  composite_key.each do |column, value|
+                    next if column_defined?(column)
+
+                    @row[column] = value
+                  end
+                else
+                  fk_type = reflection_class.type_for_attribute(fk_name).type
+                  @row[fk_name] = ActiveRecord::FixtureSet.identify(value, fk_type)
+                end
               end
             when :has_many
               if association.options[:through]