activerecord 7.0.8.7 → 7.1.0.beta1

data/lib/active_record/type/internal/timezone.rb

@@ -4,12 +4,17 @@ module ActiveRecord
   module Type
     module Internal
       module Timezone
+        def initialize(timezone: nil, **kwargs)
+          super(**kwargs)
+          @timezone = timezone
+        end
+
         def is_utc?
-          ActiveRecord.default_timezone == :utc
+          default_timezone == :utc
         end
 
         def default_timezone
-          ActiveRecord.default_timezone
+          @timezone || ActiveRecord.default_timezone
         end
       end
     end

data/lib/active_record/type/time.rb

@@ -17,6 +17,10 @@ module ActiveRecord
         end
       end
 
+      def serialize_cast_value(value) # :nodoc:
+        Value.new(super) if value
+      end
+
       private
         def cast_value(value)
           case value = super

data/lib/active_record/validations/absence.rb

@@ -14,7 +14,7 @@ module ActiveRecord
     module ClassMethods
       # Validates that the specified attributes are not present (as defined by
       # Object#present?). If the attribute is an association, the associated object
-      # is considered absent if it was marked for destruction.
+      # is also considered not present if it is marked for destruction.
       #
       # See ActiveModel::Validations::HelperMethods.validates_absence_of for more information.
       def validates_absence_of(*attr_names)

data/lib/active_record/validations/numericality.rb

@@ -21,10 +21,11 @@ module ActiveRecord
 
     module ClassMethods
       # Validates whether the value of the specified attribute is numeric by
-      # trying to convert it to a float with Kernel.Float (if <tt>only_integer</tt>
-      # is +false+) or applying it to the regular expression <tt>/\A[\+\-]?\d+\z/</tt>
-      # (if <tt>only_integer</tt> is set to +true+). Kernel.Float precision
-      # defaults to the column's precision value or 15.
+      # trying to convert it to a float with +Kernel.Float+ (if
+      # <tt>only_integer</tt> is +false+) or applying it to the regular
+      # expression <tt>/\A[\+\-]?\d+\z/</tt> (if <tt>only_integer</tt> is set to
+      # +true+). +Kernel.Float+ precision defaults to the column's precision
+      # value or 15.
       #
       # See ActiveModel::Validations::HelperMethods.validates_numericality_of for more information.
       def validates_numericality_of(*attr_names)

data/lib/active_record/validations/presence.rb

@@ -13,9 +13,8 @@ module ActiveRecord
 
     module ClassMethods
       # Validates that the specified attributes are not blank (as defined by
-      # Object#blank?), and, if the attribute is an association, that the
-      # associated object is not marked for destruction. Happens by default
-      # on save.
+      # Object#blank?). If the attribute is an association, the associated object
+      # is also considered blank if it is marked for destruction.
       #
       #   class Person < ActiveRecord::Base
       #     has_one :face
@@ -25,41 +24,19 @@ module ActiveRecord
       # The face attribute must be in the object and it cannot be blank or marked
       # for destruction.
       #
-      # If you want to validate the presence of a boolean field (where the real values
-      # are true and false), you will want to use
-      # <tt>validates_inclusion_of :field_name, in: [true, false]</tt>.
-      #
-      # This is due to the way Object#blank? handles boolean values:
-      # <tt>false.blank? # => true</tt>.
-      #
       # This validator defers to the Active Model validation for presence, adding the
       # check to see that an associated object is not marked for destruction. This
       # prevents the parent object from validating successfully and saving, which then
       # deletes the associated object, thus putting the parent object into an invalid
       # state.
       #
+      # See ActiveModel::Validations::HelperMethods.validates_presence_of for
+      # more information.
+      #
       # NOTE: This validation will not fail while using it with an association
       # if the latter was assigned but not valid. If you want to ensure that
       # it is both present and valid, you also need to use
       # {validates_associated}[rdoc-ref:Validations::ClassMethods#validates_associated].
-      #
-      # Configuration options:
-      # * <tt>:message</tt> - A custom error message (default is: "can't be blank").
-      # * <tt>:on</tt> - Specifies the contexts where this validation is active.
-      #   Runs in all validation contexts by default +nil+. You can pass a symbol
-      #   or an array of symbols. (e.g. <tt>on: :create</tt> or
-      #   <tt>on: :custom_validation_context</tt> or
-      #   <tt>on: [:create, :custom_validation_context]</tt>)
-      # * <tt>:if</tt> - Specifies a method, proc, or string to call to determine if
-      #   the validation should occur (e.g. <tt>if: :allow_validation</tt>, or
-      #   <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>). The method, proc
-      #   or string should return or evaluate to a +true+ or +false+ value.
-      # * <tt>:unless</tt> - Specifies a method, proc, or string to call to determine
-      #   if the validation should not occur (e.g. <tt>unless: :skip_validation</tt>,
-      #   or <tt>unless: Proc.new { |user| user.signup_step <= 2 }</tt>). The method,
-      #   proc or string should return or evaluate to a +true+ or +false+ value.
-      # * <tt>:strict</tt> - Specifies whether validation should be strict.
-      #   See ActiveModel::Validations#validates! for more information.
       def validates_presence_of(*attr_names)
         validates_with PresenceValidator, _merge_attributes(attr_names)
       end

data/lib/active_record/validations/uniqueness.rb

@@ -20,10 +20,12 @@ module ActiveRecord
         finder_class = find_finder_class_for(record)
         value = map_enum_attribute(finder_class, attribute, value)
 
+        return if record.persisted? && !validation_needed?(finder_class, record, attribute)
+
         relation = build_relation(finder_class, attribute, value)
         if record.persisted?
           if finder_class.primary_key
-            relation = relation.where.not(finder_class.primary_key => record.id_in_database)
+            relation = relation.where.not(finder_class.primary_key => [record.id_in_database])
           else
             raise UnknownPrimaryKey.new(finder_class, "Cannot validate uniqueness for persisted record without primary key.")
           end
@@ -64,6 +66,48 @@ module ActiveRecord
         class_hierarchy.detect { |klass| !klass.abstract_class? }
       end
 
+      def validation_needed?(klass, record, attribute)
+        return true if options[:conditions] || options.key?(:case_sensitive)
+
+        scope = Array(options[:scope])
+        attributes = scope + [attribute]
+        attributes = resolve_attributes(record, attributes)
+
+        return true if attributes.any? { |attr| record.attribute_changed?(attr) ||
+                                                record.read_attribute(attr).nil? }
+
+        !covered_by_unique_index?(klass, record, attribute, scope)
+      end
+
+      def covered_by_unique_index?(klass, record, attribute, scope)
+        @covered ||= self.attributes.map(&:to_s).select do |attr|
+          attributes = scope + [attr]
+          attributes = resolve_attributes(record, attributes)
+
+          klass.connection.schema_cache.indexes(klass.table_name).any? do |index|
+            index.unique &&
+              index.where.nil? &&
+              (index.columns - attributes).empty?
+          end
+        end
+
+        @covered.include?(attribute.to_s)
+      end
+
+      def resolve_attributes(record, attributes)
+        attributes.flat_map do |attribute|
+          reflection = record.class._reflect_on_association(attribute)
+
+          if reflection.nil?
+            attribute.to_s
+          elsif reflection.polymorphic?
+            [reflection.foreign_key, reflection.foreign_type]
+          else
+            reflection.foreign_key
+          end
+        end
+      end
+
       def build_relation(klass, attribute, value)
         relation = klass.unscoped
         comparison = relation.bind_attribute(attribute, value) do |attr, bind|
@@ -221,7 +265,7 @@ module ActiveRecord
       # When the database catches such a duplicate insertion,
       # {ActiveRecord::Base#save}[rdoc-ref:Persistence#save] will raise an ActiveRecord::StatementInvalid
       # exception. You can either choose to let this error propagate (which
-      # will result in the default Rails exception page being shown), or you
+      # will result in the default \Rails exception page being shown), or you
       # can catch it and restart the transaction (e.g. by telling the user
       # that the title already exists, and asking them to re-enter the title).
       # This technique is also known as
@@ -236,6 +280,7 @@ module ActiveRecord
       # The following bundled adapters throw the ActiveRecord::RecordNotUnique exception:
       #
       # * ActiveRecord::ConnectionAdapters::Mysql2Adapter.
+      # * ActiveRecord::ConnectionAdapters::TrilogyAdapter.
       # * ActiveRecord::ConnectionAdapters::SQLite3Adapter.
       # * ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.
       def validates_uniqueness_of(*attr_names)

data/lib/active_record/validations.rb

@@ -30,10 +30,12 @@ module ActiveRecord
 
   # = Active Record \Validations
   #
-  # Active Record includes the majority of its validations from ActiveModel::Validations
-  # all of which accept the <tt>:on</tt> argument to define the context where the
-  # validations are active. Active Record will always supply either the context of
-  # <tt>:create</tt> or <tt>:update</tt> dependent on whether the model is a
+  # Active Record includes the majority of its validations from ActiveModel::Validations.
+  #
+  # In Active Record, all validations are performed on save by default.
+  # Validations accept the <tt>:on</tt> argument to define the context where
+  # the validations are active. Active Record will pass either the context of
+  # <tt>:create</tt> or <tt>:update</tt> depending on whether the model is a
   # {new_record?}[rdoc-ref:Persistence#new_record?].
   module Validations
     extend ActiveSupport::Concern
@@ -60,6 +62,8 @@ module ActiveRecord
     #
     # If the argument is +false+ (default is +nil+), the context is set to <tt>:create</tt> if
     # {new_record?}[rdoc-ref:Persistence#new_record?] is +true+, and to <tt>:update</tt> if it is not.
+    # If the argument is an array of contexts, <tt>post.valid?([:create, :update])</tt>, the validations are
+    # run within multiple contexts.
     #
     # \Validations with no <tt>:on</tt> option will run no matter the context. \Validations with
     # some <tt>:on</tt> option will only run in the specified context.

data/lib/active_record/version.rb

@@ -3,7 +3,7 @@
 require_relative "gem_version"
 
 module ActiveRecord
-  # Returns the currently loaded version of Active Record as a <tt>Gem::Version</tt>.
+  # Returns the currently loaded version of Active Record as a +Gem::Version+.
   def self.version
     gem_version
   end

data/lib/active_record.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #--
-# Copyright (c) 2004-2022 David Heinemeier Hansson
+# Copyright (c) David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -30,9 +30,11 @@ require "arel"
 require "yaml"
 
 require "active_record/version"
+require "active_record/deprecator"
 require "active_model/attribute_set"
 require "active_record/errors"
 
+# :include: activerecord/README.rdoc
 module ActiveRecord
   extend ActiveSupport::Autoload
 
@@ -47,18 +49,22 @@ module ActiveRecord
   autoload :Encryption
   autoload :Enum
   autoload :Explain
+  autoload :FixtureSet, "active_record/fixtures"
   autoload :Inheritance
   autoload :Integration
   autoload :InternalMetadata
+  autoload :LogSubscriber
+  autoload :Marshalling
   autoload :Migration
   autoload :Migrator, "active_record/migration"
   autoload :ModelSchema
   autoload :NestedAttributes
   autoload :NoTouching
+  autoload :Normalization
   autoload :Persistence
   autoload :QueryCache
-  autoload :Querying
   autoload :QueryLogs
+  autoload :Querying
   autoload :ReadonlyAttributes
   autoload :RecordInvalid, "active_record/validations"
   autoload :Reflection
@@ -68,6 +74,7 @@ module ActiveRecord
   autoload :SchemaDumper
   autoload :SchemaMigration
   autoload :Scoping
+  autoload :SecurePassword
   autoload :SecureToken
   autoload :Serialization
   autoload :SignedId
@@ -76,6 +83,7 @@ module ActiveRecord
   autoload :TestDatabases
   autoload :TestFixtures, "active_record/fixtures"
   autoload :Timestamp
+  autoload :TokenFor
   autoload :TouchLater
   autoload :Transactions
   autoload :Translation
@@ -93,7 +101,7 @@ module ActiveRecord
     autoload :DisableJoinsAssociationRelation
     autoload :FutureResult
     autoload :LegacyYamlAdapter
-    autoload :NullRelation
+    autoload :Promise
     autoload :Relation
     autoload :Result
     autoload :StatementCache
@@ -101,17 +109,18 @@ module ActiveRecord
     autoload :Type
 
     autoload_under "relation" do
-      autoload :QueryMethods
-      autoload :FinderMethods
+      autoload :Batches
       autoload :Calculations
+      autoload :Delegation
+      autoload :FinderMethods
       autoload :PredicateBuilder
+      autoload :QueryMethods
       autoload :SpawnMethods
-      autoload :Batches
-      autoload :Delegation
     end
   end
 
   module Coders
+    autoload :ColumnSerializer, "active_record/coders/column_serializer"
     autoload :JSON, "active_record/coders/json"
     autoload :YAMLColumn, "active_record/coders/yaml_column"
   end
@@ -165,6 +174,9 @@ module ActiveRecord
     autoload :SQLiteDatabaseTasks, "active_record/tasks/sqlite_database_tasks"
   end
 
+  singleton_class.attr_accessor :disable_prepared_statements
+  self.disable_prepared_statements = false
+
   # Lazily load the schema cache. This option will load the schema cache
   # when a connection is established rather than on boot. If set,
   # +config.active_record.use_schema_cache_dump+ will be set to false.
@@ -177,9 +189,6 @@ module ActiveRecord
   singleton_class.attr_accessor :schema_cache_ignored_tables
   self.schema_cache_ignored_tables = []
 
-  singleton_class.attr_accessor :legacy_connection_handling
-  self.legacy_connection_handling = true
-
   singleton_class.attr_reader :default_timezone
 
   # Determines whether to use Time.utc (using :utc) or Time.local (using :local) when pulling
@@ -194,12 +203,53 @@ module ActiveRecord
 
   self.default_timezone = :utc
 
+  # The action to take when database query produces warning.
+  # Must be one of :ignore, :log, :raise, :report, or a custom proc.
+  # The default is :ignore.
+  singleton_class.attr_reader :db_warnings_action
+
+  def self.db_warnings_action=(action)
+    @db_warnings_action =
+      case action
+      when :ignore
+        nil
+      when :log
+        ->(warning) do
+          warning_message = "[#{warning.class}] #{warning.message}"
+          warning_message += " (#{warning.code})" if warning.code
+          ActiveRecord::Base.logger.warn(warning_message)
+        end
+      when :raise
+        ->(warning) { raise warning }
+      when :report
+        ->(warning) { Rails.error.report(warning, handled: true) }
+      when Proc
+        action
+      else
+        raise ArgumentError, "db_warnings_action must be one of :ignore, :log, :raise, :report, or a custom proc."
+      end
+  end
+
+  self.db_warnings_action = :ignore
+
+  # Specify allowlist of database warnings.
+  singleton_class.attr_accessor :db_warnings_ignore
+  self.db_warnings_ignore = []
+
   singleton_class.attr_accessor :writing_role
   self.writing_role = :writing
 
   singleton_class.attr_accessor :reading_role
   self.reading_role = :reading
 
+  def self.legacy_connection_handling=(_)
+    raise ArgumentError, <<~MSG.squish
+      The `legacy_connection_handling` setter was deprecated in 7.0 and removed in 7.1,
+      but is still defined in your configuration. Please remove this call as it no longer
+      has any effect."
+    MSG
+  end
+
   # Sets the async_query_executor for an application. By default the thread pool executor
   # set to +nil+ which will not run queries in the background. Applications must configure
   # a thread pool executor to use this feature. Options are:
@@ -258,6 +308,21 @@ module ActiveRecord
   singleton_class.attr_accessor :maintain_test_schema
   self.maintain_test_schema = nil
 
+  singleton_class.attr_accessor :raise_on_assign_to_attr_readonly
+  self.raise_on_assign_to_attr_readonly = false
+
+  singleton_class.attr_accessor :belongs_to_required_validates_foreign_key
+  self.belongs_to_required_validates_foreign_key = true
+
+  singleton_class.attr_accessor :before_committed_on_all_records
+  self.before_committed_on_all_records = false
+
+  singleton_class.attr_accessor :run_after_transaction_callbacks_in_order_defined
+  self.run_after_transaction_callbacks_in_order_defined = false
+
+  singleton_class.attr_accessor :commit_transaction_on_non_local_return
+  self.commit_transaction_on_non_local_return = false
+
   ##
   # :singleton-method:
   # Specify a threshold for the size of query result sets. If the number of
@@ -302,6 +367,12 @@ module ActiveRecord
   singleton_class.attr_accessor :timestamped_migrations
   self.timestamped_migrations = true
 
+  ##
+  # :singleton-method:
+  # Specify strategy to use for executing migrations.
+  singleton_class.attr_accessor :migration_strategy
+  self.migration_strategy = Migration::DefaultStrategy
+
   ##
   # :singleton-method:
   # Specify whether schema dump should happen at the end of the
@@ -321,12 +392,19 @@ module ActiveRecord
   singleton_class.attr_accessor :dump_schemas
   self.dump_schemas = :schema_search_path
 
-  ##
-  # :singleton-method:
-  # Show a warning when Rails couldn't parse your database.yml
-  # for multiple databases.
-  singleton_class.attr_accessor :suppress_multiple_database_warning
-  self.suppress_multiple_database_warning = false
+  def self.suppress_multiple_database_warning
+    ActiveRecord.deprecator.warn(<<-MSG.squish)
+      config.active_record.suppress_multiple_database_warning is deprecated and will be removed in Rails 7.2.
+      It no longer has any effect and should be removed from the configuration file.
+    MSG
+  end
+
+  def self.suppress_multiple_database_warning=(value)
+    ActiveRecord.deprecator.warn(<<-MSG.squish)
+      config.active_record.suppress_multiple_database_warning= is deprecated and will be removed in Rails 7.2.
+      It no longer has any effect and should be removed from the configuration file.
+    MSG
+  end
 
   ##
   # :singleton-method:
@@ -337,6 +415,13 @@ module ActiveRecord
   singleton_class.attr_accessor :verify_foreign_keys_for_fixtures
   self.verify_foreign_keys_for_fixtures = false
 
+  ##
+  # :singleton-method:
+  # If true, Rails will continue allowing plural association names in where clauses on singular associations
+  # This behavior will be removed in Rails 7.2.
+  singleton_class.attr_accessor :allow_deprecated_singular_associations_name
+  self.allow_deprecated_singular_associations_name = true
+
   singleton_class.attr_accessor :query_transformers
   self.query_transformers = []
 
@@ -362,6 +447,21 @@ module ActiveRecord
   singleton_class.attr_accessor :yaml_column_permitted_classes
   self.yaml_column_permitted_classes = [Symbol]
 
+  ##
+  # :singleton-method:
+  # Controls when to generate a value for <tt>has_secure_token</tt>
+  # declarations. Defaults to <tt>:create</tt>.
+  singleton_class.attr_accessor :generate_secure_token_on
+  self.generate_secure_token_on = :create
+
+  def self.marshalling_format_version
+    Marshalling.format_version
+  end
+
+  def self.marshalling_format_version=(value)
+    Marshalling.format_version = value
+  end
+
   def self.eager_load!
     super
     ActiveRecord::Locking.eager_load!
@@ -371,6 +471,11 @@ module ActiveRecord
     ActiveRecord::ConnectionAdapters.eager_load!
     ActiveRecord::Encryption.eager_load!
   end
+
+  # Explicitly closes all database connections in all pools.
+  def self.disconnect_all!
+    ConnectionAdapters::PoolConfig.disconnect_all!
+  end
 end
 
 ActiveSupport.on_load(:active_record) do

data/lib/arel/errors.rb

@@ -6,4 +6,14 @@ module Arel # :nodoc: all
 
   class EmptyJoinError < ArelError
   end
+
+  class BindError < ArelError
+    def initialize(message, sql = nil)
+      if sql
+        super("#{message} in: #{sql.inspect}")
+      else
+        super(message)
+      end
+    end
+  end
 end

data/lib/arel/factory_methods.rb

@@ -45,5 +45,9 @@ module Arel # :nodoc: all
     def coalesce(*exprs)
       Nodes::NamedFunction.new "COALESCE", exprs
     end
+
+    def cast(name, type)
+      Nodes::NamedFunction.new "CAST", [name.as(type)]
+    end
   end
 end

data/lib/arel/nodes/binary.rb

@@ -39,6 +39,12 @@ module Arel # :nodoc: all
       end
     end
 
+    class As < Binary
+      def to_cte
+        Arel::Nodes::Cte.new(left.name, right)
+      end
+    end
+
     class Between < Binary; include FetchAttribute; end
 
     class GreaterThan < Binary
@@ -112,7 +118,6 @@ module Arel # :nodoc: all
     end
 
     %w{
-      As
       Assignment
       Join
       Union

data/lib/arel/nodes/bound_sql_literal.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class BoundSqlLiteral < NodeExpression
+      attr_reader :sql_with_placeholders, :positional_binds, :named_binds
+
+      def initialize(sql_with_placeholders, positional_binds, named_binds)
+        if !positional_binds.empty? && !named_binds.empty?
+          raise BindError.new("cannot mix positional and named binds", sql_with_placeholders)
+        elsif !positional_binds.empty?
+          if positional_binds.size != (expected = sql_with_placeholders.count("?"))
+            raise BindError.new("wrong number of bind variables (#{positional_binds.size} for #{expected})", sql_with_placeholders)
+          end
+        elsif !named_binds.empty?
+          tokens_in_string = sql_with_placeholders.scan(/:(?<!::)([a-zA-Z]\w*)/).flatten.map(&:to_sym).uniq
+          tokens_in_hash = named_binds.keys.map(&:to_sym).uniq
+
+          if !(missing = (tokens_in_string - tokens_in_hash)).empty?
+            if missing.size == 1
+              raise BindError.new("missing value for #{missing.first.inspect}", sql_with_placeholders)
+            else
+              raise BindError.new("missing values for #{missing.inspect}", sql_with_placeholders)
+            end
+          end
+        end
+
+        @sql_with_placeholders = sql_with_placeholders
+        if !positional_binds.empty?
+          @positional_binds = positional_binds
+          @named_binds = nil
+        else
+          @positional_binds = nil
+          @named_binds = named_binds
+        end
+      end
+
+      def hash
+        [self.class, sql_with_placeholders, positional_binds, named_binds].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          sql_with_placeholders == other.sql_with_placeholders &&
+          positional_binds == other.positional_binds &&
+          named_binds == other.named_binds
+      end
+      alias :== :eql?
+
+      def +(other)
+        raise ArgumentError, "Expected Arel node" unless Arel.arel_node?(other)
+
+        Fragments.new([self, other])
+      end
+
+      def inspect
+        "#<#{self.class.name} #{sql_with_placeholders.inspect} #{(named_binds || positional_binds).inspect}>"
+      end
+    end
+  end
+end

data/lib/arel/nodes/cte.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Cte < Arel::Nodes::Binary
+      alias :name :left
+      alias :relation :right
+      attr_reader :materialized
+
+      def initialize(name, relation, materialized: nil)
+        super(name, relation)
+        @materialized = materialized
+      end
+
+      def hash
+        [name, relation, materialized].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.name == other.name &&
+          self.relation == other.relation &&
+          self.materialized == other.materialized
+      end
+      alias :== :eql?
+
+      def to_cte
+        self
+      end
+
+      def to_table
+        Arel::Table.new(name)
+      end
+    end
+  end
+end