activerecord 8.0.3 → 8.1.0

data/lib/active_record/database_configurations/hash_config.rb

@@ -38,6 +38,7 @@ module ActiveRecord
       def initialize(env_name, name, configuration_hash)
         super(env_name, name)
         @configuration_hash = configuration_hash.symbolize_keys.freeze
+        validate_configuration!
       end
 
       # Determines whether a database configuration is for a replica / readonly
@@ -69,16 +70,35 @@ module ActiveRecord
         @configuration_hash = configuration_hash.merge(database: database).freeze
       end
 
-      def pool
-        (configuration_hash[:pool] || 5).to_i
+      def max_connections
+        max_connections = configuration_hash.fetch(:max_connections) {
+          configuration_hash.fetch(:pool, 5)
+        }&.to_i
+        max_connections if max_connections && max_connections >= 0
       end
 
+      def min_connections
+        (configuration_hash[:min_connections] || 0).to_i
+      end
+
+      alias :pool :max_connections
+      deprecate pool: :max_connections, deprecator: ActiveRecord.deprecator
+
       def min_threads
         (configuration_hash[:min_threads] || 0).to_i
       end
 
       def max_threads
-        (configuration_hash[:max_threads] || pool).to_i
+        (configuration_hash[:max_threads] || (max_connections || 5).clamp(0, 5)).to_i
+      end
+
+      def max_age
+        v = configuration_hash[:max_age]&.to_i
+        if v && v > 0
+          v
+        else
+          Float::INFINITY
+        end
       end
 
       def query_cache
@@ -93,10 +113,8 @@ module ActiveRecord
         (configuration_hash[:checkout_timeout] || 5).to_f
       end
 
-      # `reaping_frequency` is configurable mostly for historical reasons, but it
-      # could also be useful if someone wants a very low `idle_timeout`.
-      def reaping_frequency
-        configuration_hash.fetch(:reaping_frequency, 60)&.to_f
+      def reaping_frequency # :nodoc:
+        configuration_hash.fetch(:reaping_frequency, default_reaping_frequency)&.to_f
       end
 
       def idle_timeout
@@ -104,6 +122,11 @@ module ActiveRecord
         timeout if timeout > 0
       end
 
+      def keepalive
+        keepalive = (configuration_hash[:keepalive] || 600).to_f
+        keepalive if keepalive > 0
+      end
+
       def adapter
         configuration_hash[:adapter]&.to_s
       end
@@ -159,8 +182,8 @@ module ActiveRecord
       end
 
       def schema_format # :nodoc:
-        format = configuration_hash[:schema_format]&.to_sym || ActiveRecord.schema_format
-        raise "Invalid schema format" unless [ :ruby, :sql ].include? format
+        format = configuration_hash.fetch(:schema_format, ActiveRecord.schema_format).to_sym
+        raise "Invalid schema format" unless [:ruby, :sql].include?(format)
         format
       end
 
@@ -181,6 +204,27 @@ module ActiveRecord
             "structure.sql"
           end
         end
+
+        def default_reaping_frequency
+          # Reap every 20 seconds by default, but run more often as necessary to
+          # meet other configured timeouts.
+          [20, idle_timeout, max_age, keepalive].compact.min
+        end
+
+        def validate_configuration!
+          if configuration_hash[:pool] && configuration_hash[:max_connections]
+            pool_val = configuration_hash[:pool].to_i
+            max_conn_val = configuration_hash[:max_connections].to_i
+
+            if pool_val != max_conn_val
+              raise "Ambiguous configuration: 'pool' (#{pool_val}) and 'max_connections' (#{max_conn_val}) are set to different values. Prefer just 'max_connections'."
+            end
+          end
+
+          if configuration_hash[:pool] && configuration_hash[:min_connections]
+            raise "Ambiguous configuration: when setting 'min_connections', use 'max_connections' instead of 'pool'."
+          end
+        end
     end
   end
 end

data/lib/active_record/database_configurations/url_config.rb

@@ -47,9 +47,8 @@ module ActiveRecord
           @configuration_hash[:schema_dump] = false
         end
 
-        if @configuration_hash[:query_cache] == "false"
-          @configuration_hash[:query_cache] = false
-        end
+        query_cache = parse_query_cache
+        @configuration_hash[:query_cache] = query_cache unless query_cache.nil?
 
         to_boolean!(@configuration_hash, :replica)
         to_boolean!(@configuration_hash, :database_tasks)
@@ -58,6 +57,17 @@ module ActiveRecord
       end
 
       private
+        def parse_query_cache
+          case value = @configuration_hash[:query_cache]
+          when /\A\d+\z/
+            value.to_i
+          when "false"
+            false
+          else
+            value
+          end
+        end
+
         def to_boolean!(configuration_hash, key)
           if configuration_hash[key].is_a?(String)
             configuration_hash[key] = configuration_hash[key] != "false"

data/lib/active_record/database_configurations.rb

@@ -36,9 +36,11 @@ module ActiveRecord
     # to respond to `sharded?`. To implement this define the following in an
     # initializer:
     #
-    #   ActiveRecord::DatabaseConfigurations.register_db_config_handler do |env_name, name, url, config|
-    #     next unless config.key?(:vitess)
-    #     VitessConfig.new(env_name, name, config)
+    #   ActiveSupport.on_load(:active_record_database_configurations) do
+    #     ActiveRecord::DatabaseConfigurations.register_db_config_handler do |env_name, name, url, config|
+    #       next unless config.key?(:vitess)
+    #       VitessConfig.new(env_name, name, config)
+    #     end
     #   end
     #
     # Note: applications must handle the condition in which custom config should be
@@ -306,4 +308,6 @@ module ActiveRecord
         url
       end
   end
+
+  ActiveSupport.run_load_hooks(:active_record_database_configurations, DatabaseConfigurations)
 end

data/lib/active_record/delegated_type.rb

@@ -229,7 +229,7 @@ module ActiveRecord
     #   @entry.message_uuid # => returns entryable_uuid, when entryable_type == "Message", otherwise nil
     #   @entry.comment_uuid # => returns entryable_uuid, when entryable_type == "Comment", otherwise nil
     def delegated_type(role, types:, **options)
-      belongs_to role, options.delete(:scope), **options.merge(polymorphic: true)
+      belongs_to role, options.delete(:scope), **options, polymorphic: true
       define_delegated_type_methods role, types: types, options: options
     end
 

data/lib/active_record/dynamic_matchers.rb

@@ -7,16 +7,18 @@ module ActiveRecord
         if self == Base
           super
         else
-          match = Method.match(self, name)
-          match && match.valid? || super
+          super || begin
+            match = Method.match(name)
+            match && match.valid?(self, name)
+          end
         end
       end
 
       def method_missing(name, ...)
-        match = Method.match(self, name)
+        match = Method.match(name)
 
-        if match && match.valid?
-          match.define
+        if match && match.valid?(self, name)
+          match.define(self, name)
           send(name, ...)
         else
           super
@@ -24,97 +26,80 @@ module ActiveRecord
       end
 
       class Method
-        @matchers = []
-
         class << self
-          attr_reader :matchers
-
-          def match(model, name)
-            klass = matchers.find { |k| k.pattern.match?(name) }
-            klass.new(model, name) if klass
+          def match(name)
+            FindBy.match?(name) || FindByBang.match?(name)
           end
 
-          def pattern
-            @pattern ||= /\A#{prefix}_([_a-zA-Z]\w*)#{suffix}\Z/
+          def valid?(model, name)
+            attribute_names(model, name.to_s).all? { |name| model.columns_hash[name] || model.reflect_on_aggregation(name.to_sym) }
           end
 
-          def prefix
-            raise NotImplementedError
+          def define(model, name)
+            model.class_eval <<-CODE, __FILE__, __LINE__ + 1
+            def self.#{name}(#{signature(model, name)})
+              #{body(model, name)}
+            end
+            CODE
           end
 
-          def suffix
-            ""
-          end
-        end
+          private
+            def make_pattern(prefix, suffix)
+              /\A#{prefix}_([_a-zA-Z]\w*)#{suffix}\Z/
+            end
 
-        attr_reader :model, :name, :attribute_names
+            def attribute_names(model, name)
+              attribute_names = name.match(pattern)[1].split("_and_")
+              attribute_names.map! { |name| model.attribute_aliases[name] || name }
+            end
 
-        def initialize(model, method_name)
-          @model           = model
-          @name            = method_name.to_s
-          @attribute_names = @name.match(self.class.pattern)[1].split("_and_")
-          @attribute_names.map! { |name| @model.attribute_aliases[name] || name }
-        end
+            def body(model, method_name)
+              "#{finder}(#{attributes_hash(model, method_name)})"
+            end
 
-        def valid?
-          attribute_names.all? { |name| model.columns_hash[name] || model.reflect_on_aggregation(name.to_sym) }
-        end
+            # The parameters in the signature may have reserved Ruby words, in order
+            # to prevent errors, we start each param name with `_`.
+            def signature(model, method_name)
+              attribute_names(model, method_name.to_s).map { |name| "_#{name}" }.join(", ")
+            end
 
-        def define
-          model.class_eval <<-CODE, __FILE__, __LINE__ + 1
-            def self.#{name}(#{signature})
-              #{body}
+            # Given that the parameters starts with `_`, the finder needs to use the
+            # same parameter name.
+            def attributes_hash(model, method_name)
+              "{" + attribute_names(model, method_name).map { |name| ":#{name} => _#{name}" }.join(",") + "}"
             end
-          CODE
         end
+      end
 
-        private
-          def body
-            "#{finder}(#{attributes_hash})"
-          end
+      class FindBy < Method
+        @pattern = make_pattern("find_by", "")
 
-          # The parameters in the signature may have reserved Ruby words, in order
-          # to prevent errors, we start each param name with `_`.
-          def signature
-            attribute_names.map { |name| "_#{name}" }.join(", ")
-          end
+        class << self
+          attr_reader :pattern
 
-          # Given that the parameters starts with `_`, the finder needs to use the
-          # same parameter name.
-          def attributes_hash
-            "{" + attribute_names.map { |name| ":#{name} => _#{name}" }.join(",") + "}"
+          def match?(name)
+            pattern.match?(name) && self
           end
 
           def finder
-            raise NotImplementedError
+            "find_by"
           end
-      end
-
-      class FindBy < Method
-        Method.matchers << self
-
-        def self.prefix
-          "find_by"
-        end
-
-        def finder
-          "find_by"
         end
       end
 
       class FindByBang < Method
-        Method.matchers << self
+        @pattern = make_pattern("find_by", "!")
 
-        def self.prefix
-          "find_by"
-        end
+        class << self
+          attr_reader :pattern
 
-        def self.suffix
-          "!"
-        end
+          def match?(name)
+            pattern.match?(name) && self
+          end
 
-        def finder
-          "find_by!"
+          def finder
+            "find_by!"
+          end
         end
       end
   end

data/lib/active_record/encryption/encryptable_record.rb

@@ -30,10 +30,10 @@ module ActiveRecord
         #   will use the oldest encryption scheme to encrypt new data by default. You can change this by setting
         #   <tt>deterministic: { fixed: false }</tt>. That will make it use the newest encryption scheme for encrypting new
         #   data.
-        # * <tt>:support_unencrypted_data</tt> - If `config.active_record.encryption.support_unencrypted_data` is +true+,
-        #   you can set this to +false+ to opt out of unencrypted data support for this attribute. This is useful for
-        #   scenarios where you encrypt one column, and want to disable support for unencrypted data without having to tweak
-        #   the global setting.
+        # * <tt>:support_unencrypted_data</tt> - When true, unencrypted data can be read normally. When false, it will raise errors.
+        #   Falls back to +config.active_record.encryption.support_unencrypted_data+ if no value is provided.
+        #   This is useful for scenarios where you encrypt one column, and want to disable support for unencrypted data
+        #   without having to tweak the global setting.
         # * <tt>:downcase</tt> - When true, it converts the encrypted content to downcase automatically. This allows to
         #   effectively ignore case when querying data. Notice that the case is lost. Use +:ignore_case+ if you are interested
         #   in preserving it.

data/lib/active_record/encryption/encrypted_attribute_type.rb

@@ -59,7 +59,7 @@ module ActiveRecord
       end
 
       def support_unencrypted_data?
-        ActiveRecord::Encryption.config.support_unencrypted_data && scheme.support_unencrypted_data? && !previous_type?
+        scheme.support_unencrypted_data? && !previous_type?
       end
 
       private

data/lib/active_record/encryption/encryptor.rb

@@ -94,6 +94,18 @@ module ActiveRecord
       private
         DECRYPT_ERRORS = [OpenSSL::Cipher::CipherError, Errors::EncryptedContentIntegrity, Errors::Decryption]
         ENCODING_ERRORS = [EncodingError, Errors::Encoding]
+
+        # This threshold cannot be changed.
+        #
+        # Users can search for attributes encrypted with `deterministic: true`.
+        # That is possible because we are able to generate the message for the
+        # given clear text deterministically, and with that perform a regular
+        # string lookup in SQL.
+        #
+        # Problem is, messages may have a "c" header that is present or not
+        # depending on whether compression was applied on encryption. If this
+        # threshold was modified, the message generated for lookup could vary
+        # for the same clear text, and searches on exisiting data could fail.
         THRESHOLD_TO_JUSTIFY_COMPRESSION = 140.bytes
 
         def default_key_provider

data/lib/active_record/encryption/scheme.rb

@@ -59,7 +59,7 @@ module ActiveRecord
       end
 
       def merge(other_scheme)
-        self.class.new(**to_h.merge(other_scheme.to_h))
+        self.class.new(**to_h, **other_scheme.to_h)
       end
 
       def to_h

data/lib/active_record/enum.rb

@@ -221,7 +221,7 @@ module ActiveRecord
 
     private
       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 = { }
@@ -342,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, true, false, nil
+              # noop
+            else
+              raise ArgumentError, "Enum values #{values} must be only booleans, integers, symbols or strings, got: #{value.class}"
+            end
+          end
+
         when Array
           if values.empty?
             raise ArgumentError, "Enum values #{values} must not be empty."
@@ -357,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)
@@ -368,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
@@ -293,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
@@ -339,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
@@ -490,6 +497,7 @@ module ActiveRecord
   #   end
   #
   #   relation = Task.all
+  #   relation.load
   #   relation.loaded? # => true
   #
   #   # Methods which try to mutate a loaded relation fail.
@@ -552,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
@@ -609,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