activerecord 7.0.0.alpha2 → 7.0.0.rc1

data/lib/active_record/reflection.rb

@@ -10,6 +10,7 @@ module ActiveRecord
     included do
       class_attribute :_reflections, instance_writer: false, default: {}
       class_attribute :aggregate_reflections, instance_writer: false, default: {}
+      class_attribute :automatic_scope_inversing, instance_writer: false, default: false
     end
 
     class << self
@@ -234,6 +235,9 @@ module ActiveRecord
           if has_inverse? && inverse_of.nil?
             raise InverseOfAssociationNotFoundError.new(self)
           end
+          if has_inverse? && inverse_of == self
+            raise InverseOfAssociationRecursiveError.new(self)
+          end
         end
       end
 
@@ -631,9 +635,10 @@ module ActiveRecord
         # with the current reflection's klass name.
         def valid_inverse_reflection?(reflection)
           reflection &&
+            reflection != self &&
             foreign_key == reflection.foreign_key &&
             klass <= reflection.active_record &&
-            can_find_inverse_of_automatically?(reflection)
+            can_find_inverse_of_automatically?(reflection, true)
         end
 
         # Checks to see if the reflection doesn't have any options that prevent
@@ -642,14 +647,25 @@ module ActiveRecord
         # have <tt>has_many</tt>, <tt>has_one</tt>, <tt>belongs_to</tt> associations.
         # Third, we must not have options such as <tt>:foreign_key</tt>
         # which prevent us from correctly guessing the inverse association.
-        #
-        # Anything with a scope can additionally ruin our attempt at finding an
-        # inverse, so we exclude reflections with scopes.
-        def can_find_inverse_of_automatically?(reflection)
+        def can_find_inverse_of_automatically?(reflection, inverse_reflection = false)
           reflection.options[:inverse_of] != false &&
             !reflection.options[:through] &&
             !reflection.options[:foreign_key] &&
+            scope_allows_automatic_inverse_of?(reflection, inverse_reflection)
+        end
+
+        # Scopes on the potential inverse reflection prevent automatic
+        # <tt>inverse_of</tt>, since the scope could exclude the owner record
+        # we would inverse from. Scopes on the reflection itself allow for
+        # automatic <tt>inverse_of</tt> as long as
+        # <tt>config.active_record.automatic_scope_inversing<tt> is set to
+        # +true+ (the default for new applications).
+        def scope_allows_automatic_inverse_of?(reflection, inverse_reflection)
+          if inverse_reflection
             !reflection.scope
+          else
+            !reflection.scope || reflection.klass.automatic_scope_inversing
+          end
         end
 
         def derive_class_name
@@ -736,7 +752,7 @@ module ActiveRecord
       end
 
       private
-        def can_find_inverse_of_automatically?(_)
+        def can_find_inverse_of_automatically?(*)
           !polymorphic? && super
         end
     end

data/lib/active_record/relation/calculations.rb

@@ -31,7 +31,7 @@ module ActiveRecord
     #
     #   Article.group(:status, :category).count
     #   # =>  {["draft", "business"]=>10, ["draft", "technology"]=>4,
-    #          ["published", "business"]=>0, ["published", "technology"]=>2}
+    #   #      ["published", "business"]=>0, ["published", "technology"]=>2}
     #
     # If #count is used with {Relation#select}[rdoc-ref:QueryMethods#select], it will count the selected columns:
     #
@@ -329,15 +329,6 @@ module ActiveRecord
         group_fields = group_values
         group_fields = group_fields.uniq if group_fields.size > 1
 
-        unless group_fields == group_values
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            `#{operation}` with group by duplicated fields does no longer affect to result in Rails 7.0.
-            To migrate to Rails 7.0's behavior, use `uniq!(:group)` to deduplicate group fields
-            (`#{klass.name&.tableize || klass.table_name}.uniq!(:group).#{operation}(#{column_name.inspect})`).
-          MSG
-          group_fields = group_values
-        end
-
         if group_fields.size == 1 && group_fields.first.respond_to?(:to_sym)
           association  = klass._reflect_on_association(group_fields.first)
           associated   = association && association.belongs_to? # only count belongs_to associations

data/lib/active_record/relation/finder_methods.rb

@@ -140,8 +140,6 @@ module ActiveRecord
     #   Person.first(3) # returns the first three objects fetched by SELECT * FROM people ORDER BY people.id LIMIT 3
     #
     def first(limit = nil)
-      check_reorder_deprecation unless loaded?
-
       if limit
         find_nth_with_limit(0, limit)
       else
@@ -390,17 +388,6 @@ module ActiveRecord
     end
 
     private
-      def check_reorder_deprecation
-        if !order_values.empty? && order_values.all?(&:blank?)
-          blank_value = order_values.first
-          ActiveSupport::Deprecation.warn(<<~MSG.squish)
-            `.reorder(#{blank_value.inspect})` with `.first` / `.first!` no longer
-            takes non-deterministic result in Rails 7.0.
-            To continue taking non-deterministic result, use `.take` / `.take!` instead.
-          MSG
-        end
-      end
-
       def construct_relation_for_exists(conditions)
         conditions = sanitize_forbidden_attributes(conditions)
 

data/lib/active_record/relation/query_methods.rb

@@ -432,6 +432,7 @@ module ActiveRecord
       references = column_references([column])
       self.references_values |= references unless references.empty?
 
+      values = values.map { |value| type_caster.type_cast_for_database(column, value) }
       column = order_column(column.to_s) if column.is_a?(Symbol)
 
       spawn.order!(connection.field_ordered_value(column, values))
@@ -448,14 +449,14 @@ module ActiveRecord
     # generates a query with 'ORDER BY id ASC, name ASC'.
     def reorder(*args)
       check_if_method_has_arguments!(__callee__, args) do
-        sanitize_order_arguments(args) unless args.all?(&:blank?)
+        sanitize_order_arguments(args)
       end
       spawn.reorder!(*args)
     end
 
     # Same as #reorder but operates on relation in-place instead of copying.
     def reorder!(*args) # :nodoc:
-      preprocess_order_args(args) unless args.all?(&:blank?)
+      preprocess_order_args(args)
       args.uniq!
       self.reordering_value = true
       self.order_values = args
@@ -1339,14 +1340,6 @@ module ActiveRecord
         unless annotate_values.empty?
           annotates = annotate_values
           annotates = annotates.uniq if annotates.size > 1
-          unless annotates == annotate_values
-            ActiveSupport::Deprecation.warn(<<-MSG.squish)
-              Duplicated query annotations are no longer shown in queries in Rails 7.0.
-              To migrate to Rails 7.0's behavior, use `uniq!(:annotate)` to deduplicate query annotations
-              (`#{klass.name&.tableize || klass.table_name}.uniq!(:annotate)`).
-            MSG
-            annotates = annotate_values
-          end
           arel.comment(*annotates)
         end
 
@@ -1606,8 +1599,6 @@ module ActiveRecord
         order_args.map! do |arg|
           klass.sanitize_sql_for_order(arg)
         end
-        order_args.flatten!
-        order_args.compact_blank!
       end
 
       def column_references(order_args)
@@ -1676,9 +1667,9 @@ module ActiveRecord
       def check_if_method_has_arguments!(method_name, args, message = nil)
         if args.blank?
           raise ArgumentError, message || "The method .#{method_name}() must contain arguments."
-        elsif block_given?
-          yield args
         else
+          yield args if block_given?
+
           args.flatten!
           args.compact_blank!
         end

data/lib/active_record/relation/record_fetch_warning.rb

@@ -31,17 +31,15 @@ module ActiveRecord
       end
       # :startdoc:
 
-      class QueryRegistry # :nodoc:
-        extend ActiveSupport::PerThreadRegistry
+      module QueryRegistry # :nodoc:
+        extend self
 
-        attr_reader :queries
-
-        def initialize
-          @queries = []
+        def queries
+          ActiveSupport::IsolatedExecutionState[:active_record_query_registry] ||= []
         end
 
         def reset
-          @queries.clear
+          queries.clear
         end
       end
     end

data/lib/active_record/relation/where_clause.rb

@@ -163,21 +163,8 @@ module ActiveRecord
             attr = extract_attribute(node) || begin
               node.left if equality_node?(node) && node.left.is_a?(Arel::Predications)
             end
-            next false unless attr
-
-            ref = referenced_columns[attr]
-            next false unless ref
-
-            if equality_node?(node) && equality_node?(ref) || node == ref
-              true
-            else
-              ActiveSupport::Deprecation.warn(<<-MSG.squish)
-                Merging (#{node.to_sql}) and (#{ref.to_sql}) no longer maintain
-                both conditions, and will be replaced by the latter in Rails 7.0.
-                To migrate to Rails 7.0's behavior, use `relation.merge(other, rewhere: true)`.
-              MSG
-              false
-            end
+
+            attr && referenced_columns[attr]
           end
         end
 

data/lib/active_record/relation.rb

@@ -11,7 +11,7 @@ module ActiveRecord
                             :reverse_order, :distinct, :create_with, :skip_query_cache]
 
     CLAUSE_METHODS = [:where, :having, :from]
-    INVALID_METHODS_FOR_DELETE_ALL = [:distinct, :group, :having]
+    INVALID_METHODS_FOR_DELETE_ALL = [:distinct]
 
     VALUE_METHODS = MULTI_VALUE_METHODS + SINGLE_VALUE_METHODS + CLAUSE_METHODS
 
@@ -41,11 +41,6 @@ module ActiveRecord
       reset
     end
 
-    def arel_attribute(name) # :nodoc:
-      table[name]
-    end
-    deprecate :arel_attribute
-
     def bind_attribute(name, value) # :nodoc:
       if reflection = klass._reflect_on_association(name)
         name = reflection.foreign_key
@@ -295,14 +290,14 @@ module ActiveRecord
     # Returns true if there is exactly one record.
     def one?
       return super if block_given?
-      return records.one? if limit_value || loaded?
+      return records.one? if loaded?
       limited_count == 1
     end
 
     # Returns true if there is more than one record.
     def many?
       return super if block_given?
-      return records.many? if limit_value || loaded?
+      return records.many? if loaded?
       limited_count > 1
     end
 
@@ -394,7 +389,7 @@ module ActiveRecord
       end
 
       if timestamp
-        "#{size}-#{timestamp.utc.to_s(cache_timestamp_format)}"
+        "#{size}-#{timestamp.utc.to_formatted_s(cache_timestamp_format)}"
       else
         "#{size}"
       end
@@ -485,8 +480,9 @@ module ActiveRecord
       arel = eager_loading? ? apply_join_dependency.arel : build_arel
       arel.source.left = table
 
-      stmt = arel.compile_update(values, table[primary_key])
-
+      group_values_arel_columns = arel_columns(group_values.uniq)
+      having_clause_ast = having_clause.ast unless having_clause.empty?
+      stmt = arel.compile_update(values, table[primary_key], having_clause_ast, group_values_arel_columns)
       klass.connection.update(stmt, "#{klass} Update All").tap { reset }
     end
 
@@ -615,7 +611,9 @@ module ActiveRecord
       arel = eager_loading? ? apply_join_dependency.arel : build_arel
       arel.source.left = table
 
-      stmt = arel.compile_delete(table[primary_key])
+      group_values_arel_columns = arel_columns(group_values.uniq)
+      having_clause_ast = having_clause.ast unless having_clause.empty?
+      stmt = arel.compile_delete(table[primary_key], having_clause_ast, group_values_arel_columns)
 
       klass.connection.delete(stmt, "#{klass} Delete All").tap { reset }
     end
@@ -976,7 +974,7 @@ module ActiveRecord
       end
 
       def limited_count
-        @limited_count ||= limit(2).count
+        @limited_count ||= limit_value ? count : limit(2).count
       end
   end
 end

data/lib/active_record/result.rb

@@ -72,11 +72,6 @@ module ActiveRecord
       end
     end
 
-    alias :map! :map
-    alias :collect! :map
-    deprecate "map!": :map
-    deprecate "collect!": :map
-
     # Returns true if there are no records, otherwise false.
     def empty?
       rows.empty?

data/lib/active_record/runtime_registry.rb

@@ -1,22 +1,20 @@
 # frozen_string_literal: true
 
-require "active_support/per_thread_registry"
-
 module ActiveRecord
   # This is a thread locals registry for Active Record. For example:
   #
-  #   ActiveRecord::RuntimeRegistry.connection_handler
-  #
-  # returns the connection handler local to the current thread.
+  #   ActiveRecord::RuntimeRegistry.sql_runtime
   #
-  # See the documentation of ActiveSupport::PerThreadRegistry
-  # for further details.
-  class RuntimeRegistry # :nodoc:
-    extend ActiveSupport::PerThreadRegistry
+  # returns the connection handler local to the current unit of execution (either thread of fiber).
+  module RuntimeRegistry # :nodoc:
+    extend self
 
-    attr_accessor :sql_runtime
+    def sql_runtime
+      ActiveSupport::IsolatedExecutionState[:active_record_sql_runtime]
+    end
 
-    def self.sql_runtime; instance.sql_runtime; end
-    def self.sql_runtime=(x); instance.sql_runtime = x; end
+    def sql_runtime=(runtime)
+      ActiveSupport::IsolatedExecutionState[:active_record_sql_runtime] = runtime
+    end
   end
 end

data/lib/active_record/schema_dumper.rb

@@ -47,6 +47,7 @@ module ActiveRecord
     def dump(stream)
       header(stream)
       extensions(stream)
+      types(stream)
       tables(stream)
       trailer(stream)
       stream
@@ -99,6 +100,10 @@ HEADER
       def extensions(stream)
       end
 
+      # (enum) types are only supported by PostgreSQL
+      def types(stream)
+      end
+
       def tables(stream)
         sorted_tables = @connection.tables.sort
 
@@ -154,6 +159,7 @@ HEADER
           columns.each do |column|
             raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" unless @connection.valid_type?(column.type)
             next if column.name == pk
+
             type, colspec = column_spec(column)
             if type.is_a?(Symbol)
               tbl.print "    t.#{type} #{column.name.inspect}"
@@ -259,6 +265,7 @@ HEADER
 
             parts << "on_update: #{foreign_key.on_update.inspect}" if foreign_key.on_update
             parts << "on_delete: #{foreign_key.on_delete.inspect}" if foreign_key.on_delete
+            parts << "deferrable: #{foreign_key.deferrable.inspect}" if foreign_key.deferrable
 
             "  #{parts.join(', ')}"
           end

data/lib/active_record/scoping.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "active_support/per_thread_registry"
+require "active_support/core_ext/module/delegation"
 
 module ActiveRecord
   module Scoping
@@ -57,8 +57,8 @@ module ActiveRecord
     end
 
     # This class stores the +:current_scope+ and +:ignore_default_scope+ values
-    # for different classes. The registry is stored as a thread local, which is
-    # accessed through +ScopeRegistry.current+.
+    # for different classes. The registry is stored as either a thread or fiber
+    # local depending on the application configuration.
     #
     # This class allows you to store and get the scope values on different
     # classes and different types of scopes. For example, if you are attempting
@@ -66,22 +66,22 @@ module ActiveRecord
     # following code:
     #
     #   registry = ActiveRecord::Scoping::ScopeRegistry
-    #   registry.set_value_for(:current_scope, Board, some_new_scope)
+    #   registry.set_current_scope(Board, some_new_scope)
     #
     # Now when you run:
     #
-    #   registry.value_for(:current_scope, Board)
+    #   registry.current_scope(Board)
     #
-    # You will obtain whatever was defined in +some_new_scope+. The #value_for
-    # and #set_value_for methods are delegated to the current ScopeRegistry
-    # object, so the above example code can also be called as:
-    #
-    #   ActiveRecord::Scoping::ScopeRegistry.set_value_for(:current_scope,
-    #       Board, some_new_scope)
+    # You will obtain whatever was defined in +some_new_scope+.
     class ScopeRegistry # :nodoc:
-      extend ActiveSupport::PerThreadRegistry
+      class << self
+        delegate :current_scope, :set_current_scope, :ignore_default_scope, :set_ignore_default_scope,
+          :global_current_scope, :set_global_current_scope, to: :instance
 
-      VALID_SCOPE_TYPES = [:current_scope, :ignore_default_scope, :global_current_scope]
+        def instance
+          ActiveSupport::IsolatedExecutionState[:active_record_scope_registry] ||= new
+        end
+      end
 
       def initialize
         @current_scope        = {}
@@ -89,16 +89,28 @@ module ActiveRecord
         @global_current_scope = {}
       end
 
-      VALID_SCOPE_TYPES.each do |type|
-        class_eval <<-eorb, __FILE__, __LINE__
-        def #{type}(model, skip_inherited_scope = false)
-          value_for(@#{type}, model, skip_inherited_scope)
-        end
+      def current_scope(model, skip_inherited_scope = false)
+        value_for(@current_scope, model, skip_inherited_scope)
+      end
 
-        def set_#{type}(model, value)
-          set_value_for(@#{type}, model, value)
-        end
-        eorb
+      def set_current_scope(model, value)
+        set_value_for(@current_scope, model, value)
+      end
+
+      def ignore_default_scope(model, skip_inherited_scope = false)
+        value_for(@ignore_default_scope, model, skip_inherited_scope)
+      end
+
+      def set_ignore_default_scope(model, value)
+        set_value_for(@ignore_default_scope, model, value)
+      end
+
+      def global_current_scope(model, skip_inherited_scope = false)
+        value_for(@global_current_scope, model, skip_inherited_scope)
+      end
+
+      def set_global_current_scope(model, value)
+        set_value_for(@global_current_scope, model, value)
       end
 
       private

data/lib/active_record/suppressor.rb

@@ -30,32 +30,28 @@ module ActiveRecord
   module Suppressor
     extend ActiveSupport::Concern
 
+    class << self
+      def registry # :nodoc:
+        ActiveSupport::IsolatedExecutionState[:active_record_suppresor_registry] ||= {}
+      end
+    end
+
     module ClassMethods
       def suppress(&block)
-        previous_state = SuppressorRegistry.suppressed[name]
-        SuppressorRegistry.suppressed[name] = true
+        previous_state = Suppressor.registry[name]
+        Suppressor.registry[name] = true
         yield
       ensure
-        SuppressorRegistry.suppressed[name] = previous_state
+        Suppressor.registry[name] = previous_state
       end
     end
 
     def save(**) # :nodoc:
-      SuppressorRegistry.suppressed[self.class.name] ? true : super
+      Suppressor.registry[self.class.name] ? true : super
     end
 
     def save!(**) # :nodoc:
-      SuppressorRegistry.suppressed[self.class.name] ? true : super
-    end
-  end
-
-  class SuppressorRegistry # :nodoc:
-    extend ActiveSupport::PerThreadRegistry
-
-    attr_reader :suppressed
-
-    def initialize
-      @suppressed = {}
+      Suppressor.registry[self.class.name] ? true : super
     end
   end
 end

data/lib/active_record/tasks/database_tasks.rb

@@ -55,8 +55,7 @@ module ActiveRecord
 
       extend self
 
-      attr_writer :current_config, :db_dir, :migrations_paths, :fixtures_path, :root, :env, :seed_loader
-      deprecate :current_config=
+      attr_writer :db_dir, :migrations_paths, :fixtures_path, :root, :env, :seed_loader
       attr_accessor :database_configuration
 
       LOCAL_HOSTS = ["127.0.0.1", "localhost"]
@@ -110,11 +109,6 @@ module ActiveRecord
         @env ||= Rails.env
       end
 
-      def spec
-        @spec ||= "primary"
-      end
-      deprecate spec: "please use name instead"
-
       def name
         @name ||= "primary"
       end
@@ -123,18 +117,6 @@ module ActiveRecord
         @seed_loader ||= Rails.application
       end
 
-      def current_config(options = {})
-        if options.has_key?(:config)
-          @current_config = options[:config]
-        else
-          env_name = options[:env] || env
-          name = options[:spec] || "primary"
-
-          @current_config ||= configs_for(env_name: env_name, name: name)&.configuration_hash
-        end
-      end
-      deprecate :current_config
-
       def create(configuration, *arguments)
         db_config = resolve_configuration(configuration)
         database_adapter_for(db_config, *arguments).create
@@ -216,10 +198,9 @@ module ActiveRecord
             dump_schema(db_config, ActiveRecord.schema_format)
           end
         rescue ActiveRecord::NoDatabaseError
-          config_name = db_config.name
-          create_current(db_config.env_name, config_name)
+          create_current(db_config.env_name, db_config.name)
 
-          if File.exist?(dump_filename(config_name))
+          if File.exist?(schema_dump_path(db_config))
             load_schema(
               db_config,
               ActiveRecord.schema_format,
@@ -378,7 +359,7 @@ module ActiveRecord
       end
 
       def load_schema(db_config, format = ActiveRecord.schema_format, file = nil) # :nodoc:
-        file ||= dump_filename(db_config.name, format)
+        file ||= schema_dump_path(db_config, format)
 
         verbose_was, Migration.verbose = Migration.verbose, verbose? && ENV["VERBOSE"]
         check_schema_file(file)
@@ -399,16 +380,10 @@ module ActiveRecord
         Migration.verbose = verbose_was
       end
 
-      def schema_up_to_date?(configuration, format = ActiveRecord.schema_format, file = nil, environment = nil, name = nil)
+      def schema_up_to_date?(configuration, format = ActiveRecord.schema_format, file = nil)
         db_config = resolve_configuration(configuration)
 
-        if environment || name
-          ActiveSupport::Deprecation.warn("`environment` and `name` will be removed as parameters in 7.0.0, you may now pass an ActiveRecord::DatabaseConfigurations::DatabaseConfig as `configuration` instead.")
-        end
-
-        name ||= db_config.name
-
-        file ||= dump_filename(name, format)
+        file ||= schema_dump_path(db_config)
 
         return true unless File.exist?(file)
 
@@ -421,7 +396,7 @@ module ActiveRecord
       end
 
       def reconstruct_from_schema(db_config, format = ActiveRecord.schema_format, file = nil) # :nodoc:
-        file ||= dump_filename(db_config.name, format)
+        file ||= schema_dump_path(db_config, format)
 
         check_schema_file(file)
 
@@ -440,7 +415,7 @@ module ActiveRecord
 
       def dump_schema(db_config, format = ActiveRecord.schema_format) # :nodoc:
         require "active_record/schema_dumper"
-        filename = dump_filename(db_config.name, format)
+        filename = schema_dump_path(db_config, format)
         connection = ActiveRecord::Base.connection
 
         FileUtils.mkdir_p(db_dir)
@@ -460,11 +435,6 @@ module ActiveRecord
         end
       end
 
-      def schema_file(format = ActiveRecord.schema_format)
-        File.join(db_dir, schema_file_type(format))
-      end
-      deprecate :schema_file
-
       def schema_file_type(format = ActiveRecord.schema_format)
         case format
         when :ruby
@@ -473,15 +443,19 @@ module ActiveRecord
           "structure.sql"
         end
       end
+      deprecate :schema_file_type
 
-      def dump_filename(db_config_name, format = ActiveRecord.schema_format)
-        filename = if ActiveRecord::Base.configurations.primary?(db_config_name)
-          schema_file_type(format)
+      def schema_dump_path(db_config, format = ActiveRecord.schema_format)
+        return ENV["SCHEMA"] if ENV["SCHEMA"]
+
+        filename = db_config.schema_dump(format)
+        return unless filename
+
+        if File.dirname(filename) == ActiveRecord::Tasks::DatabaseTasks.db_dir
+          filename
         else
-          "#{db_config_name}_#{schema_file_type(format)}"
+          File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, filename)
         end
-
-        ENV["SCHEMA"] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, filename)
       end
 
       def cache_dump_filename(db_config_name, schema_cache_path: nil)

data/lib/active_record/tasks/postgresql_database_tasks.rb

@@ -57,8 +57,12 @@ module ActiveRecord
             ActiveRecord.dump_schemas
           end
 
-        args = ["--schema-only", "--no-privileges", "--no-owner", "--file", filename]
+        args = ["--schema-only", "--no-privileges", "--no-owner"]
+        args << "--no-comment" if connection.database_version >= 110_000
+        args.concat(["--file", filename])
+
         args.concat(Array(extra_flags)) if extra_flags
+
         unless search_path.blank?
           args += search_path.split(",").map do |part|
             "--schema=#{part.strip}"