activerecord 8.0.0.beta1 → 8.0.0.rc2

data/lib/active_record/railtie.rb

@@ -69,7 +69,7 @@ module ActiveRecord
         Rails.logger.broadcast_to(console)
       end
       ActiveRecord.verbose_query_logs = false
-      ActiveRecord::Base.attributes_for_inspect = :all if Rails.env.production?
+      ActiveRecord::Base.attributes_for_inspect = :all
     end
 
     runner do
@@ -184,30 +184,6 @@ To keep using the current cache store, you can turn off cache versioning entirel
       end
     end
 
-    initializer "active_record.warn_on_records_fetched_greater_than" do
-      if config.active_record.warn_on_records_fetched_greater_than
-        ActiveRecord.deprecator.warn <<~MSG.squish
-          `config.active_record.warn_on_records_fetched_greater_than` is deprecated and will be
-          removed in Rails 8.0.
-          Please subscribe to `sql.active_record` notifications and access the row count field to
-          detect large result set sizes.
-        MSG
-        ActiveSupport.on_load(:active_record) do
-          require "active_record/relation/record_fetch_warning"
-        end
-      end
-    end
-
-    initializer "active_record.sqlite3_deprecated_warning" do
-      if config.active_record.key?(:sqlite3_production_warning)
-        config.active_record.delete(:sqlite3_production_warning)
-        ActiveRecord.deprecator.warn <<~MSG.squish
-          The `config.active_record.sqlite3_production_warning` configuration no longer has any effect
-          and can be safely removed.
-        MSG
-      end
-    end
-
     initializer "active_record.sqlite3_adapter_strict_strings_by_default" do
       config.after_initialize do
         if config.active_record.sqlite3_adapter_strict_strings_by_default
@@ -312,6 +288,7 @@ To keep using the current cache store, you can turn off cache versioning entirel
     initializer "active_record.set_executor_hooks" do
       ActiveRecord::QueryCache.install_executor_hooks
       ActiveRecord::AsynchronousQueriesTracker.install_executor_hooks
+      ActiveRecord::ConnectionAdapters::ConnectionPool.install_executor_hooks
     end
 
     initializer "active_record.add_watchable_files" do |app|

data/lib/active_record/railties/databases.rake

@@ -87,22 +87,7 @@ db_namespace = namespace :db do
 
   desc "Migrate the database (options: VERSION=x, VERBOSE=false, SCOPE=blog)."
   task migrate: :load_config do
-    db_configs = ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env)
-
-    if db_configs.size == 1 && db_configs.first.primary?
-      ActiveRecord::Tasks::DatabaseTasks.migrate
-    else
-      mapped_versions = ActiveRecord::Tasks::DatabaseTasks.db_configs_with_versions
-
-      mapped_versions.sort.each do |version, db_configs|
-        db_configs.each do |db_config|
-          ActiveRecord::Tasks::DatabaseTasks.with_temporary_connection(db_config) do
-            ActiveRecord::Tasks::DatabaseTasks.migrate(version)
-          end
-        end
-      end
-    end
-
+    ActiveRecord::Tasks::DatabaseTasks.migrate_all
     db_namespace["_dump"].invoke
   end
 
@@ -176,7 +161,7 @@ db_namespace = namespace :db do
     end
 
     # desc 'Resets your database using your migrations for the current environment'
-    task reset: ["db:drop", "db:create", "db:migrate"]
+    task reset: ["db:drop", "db:create", "db:schema:dump", "db:migrate"]
 
     desc 'Run the "up" for a given migration VERSION.'
     task up: :load_config do

data/lib/active_record/reflection.rb

@@ -198,7 +198,7 @@ module ActiveRecord
       end
 
       def join_scope(table, foreign_table, foreign_klass)
-        predicate_builder = predicate_builder(table)
+        predicate_builder = klass.predicate_builder.with(TableMetadata.new(klass, table))
         scope_chain_items = join_scopes(table, predicate_builder)
         klass_scope       = klass_join_scope(table, predicate_builder)
 
@@ -224,7 +224,7 @@ module ActiveRecord
         klass_scope
       end
 
-      def join_scopes(table, predicate_builder, klass = self.klass, record = nil) # :nodoc:
+      def join_scopes(table, predicate_builder = nil, klass = self.klass, record = nil) # :nodoc:
         if scope
           [scope_for(build_scope(table, predicate_builder, klass), record)]
         else
@@ -232,7 +232,7 @@ module ActiveRecord
         end
       end
 
-      def klass_join_scope(table, predicate_builder) # :nodoc:
+      def klass_join_scope(table, predicate_builder = nil) # :nodoc:
         relation = build_scope(table, predicate_builder)
         klass.scope_for_association(relation)
       end
@@ -333,12 +333,8 @@ module ActiveRecord
         collect_join_chain
       end
 
-      def build_scope(table, predicate_builder = predicate_builder(table), klass = self.klass)
-        Relation.create(
-          klass,
-          table: table,
-          predicate_builder: predicate_builder
-        )
+      def build_scope(table, predicate_builder = nil, klass = self.klass)
+        Relation.create(klass, table:, predicate_builder:)
       end
 
       def strict_loading?
@@ -357,10 +353,6 @@ module ActiveRecord
         end
 
       private
-        def predicate_builder(table)
-          PredicateBuilder.new(TableMetadata.new(klass, table))
-        end
-
         def primary_key(klass)
           klass.primary_key || raise(UnknownPrimaryKey.new(klass))
         end
@@ -531,9 +523,9 @@ module ActiveRecord
         @association_foreign_key = nil
         @association_primary_key = nil
         if options[:query_constraints]
-          ActiveRecord.deprecator.warn <<~MSG.squish
-            Setting `query_constraints:` option on `#{active_record}.#{macro} :#{name}` is deprecated.
-            To maintain current behavior, use the `foreign_key` option instead.
+          raise ConfigurationError, <<~MSG.squish
+            Setting `query_constraints:` option on `#{active_record}.#{macro} :#{name}` is not allowed.
+            To get the same behavior, use the `foreign_key` option instead.
           MSG
         end
 
@@ -1070,7 +1062,7 @@ module ActiveRecord
         source_reflection.scopes + super
       end
 
-      def join_scopes(table, predicate_builder, klass = self.klass, record = nil) # :nodoc:
+      def join_scopes(table, predicate_builder = nil, klass = self.klass, record = nil) # :nodoc:
         source_reflection.join_scopes(table, predicate_builder, klass, record) + super
       end
 
@@ -1243,8 +1235,11 @@ module ActiveRecord
         @previous_reflection = previous_reflection
       end
 
-      def join_scopes(table, predicate_builder, klass = self.klass, record = nil) # :nodoc:
-        scopes = @previous_reflection.join_scopes(table, predicate_builder, klass, record) + super
+      def join_scopes(table, predicate_builder = nil, klass = self.klass, record = nil) # :nodoc:
+        scopes = super
+        unless @previous_reflection.through_reflection?
+          scopes += @previous_reflection.join_scopes(table, predicate_builder, klass, record)
+        end
         scopes << build_scope(table, predicate_builder, klass).instance_exec(record, &source_type_scope)
       end
 

data/lib/active_record/relation/calculations.rb

@@ -275,10 +275,14 @@ module ActiveRecord
     #   # SELECT people.id FROM people WHERE people.age = 21 LIMIT 5
     #   # => [2, 3]
     #
-    #   Comment.joins(:person).pluck(:id, person: [:id])
-    #   # SELECT comments.id, people.id FROM comments INNER JOIN people on comments.person_id = people.id
+    #   Comment.joins(:person).pluck(:id, person: :id)
+    #   # SELECT comments.id, person.id FROM comments INNER JOIN people person ON person.id = comments.person_id
     #   # => [[1, 2], [2, 2]]
     #
+    #   Comment.joins(:person).pluck(:id, person: [:id, :name])
+    #   # SELECT comments.id, person.id, person.name FROM comments INNER JOIN people person ON person.id = comments.person_id
+    #   # => [[1, 2, 'David'], [2, 2, 'David']]
+    #
     #   Person.pluck(Arel.sql('DATEDIFF(updated_at, created_at)'))
     #   # SELECT DATEDIFF(updated_at, created_at) FROM people
     #   # => ['0', '27761', '173']
@@ -307,8 +311,8 @@ module ActiveRecord
         relation.pluck(*column_names)
       else
         model.disallow_raw_sql!(flattened_args(column_names))
-        columns = arel_columns(column_names)
         relation = spawn
+        columns = relation.arel_columns(column_names)
         relation.select_values = columns
         result = skip_query_cache_if_necessary do
           if where_clause.contradiction?
@@ -447,10 +451,13 @@ module ActiveRecord
       end
 
       def aggregate_column(column_name)
-        return column_name if Arel::Expressions === column_name
-
-        arel_column(column_name.to_s) do |name|
-          column_name == :all ? Arel.sql("*", retryable: true) : Arel.sql(name)
+        case column_name
+        when Arel::Expressions
+          column_name
+        when :all
+          Arel.star
+        else
+          arel_column(column_name)
         end
       end
 
@@ -630,27 +637,12 @@ module ActiveRecord
       end
 
       def select_for_count
-        if select_values.present?
-          return select_values.first if select_values.one?
-
-          adapter_class = model.adapter_class
-          select_values.map do |field|
-            column = if Arel.arel_node?(field)
-              field
-            else
-              arel_column(field.to_s) do |attr_name|
-                Arel.sql(attr_name)
-              end
-            end
-
-            if column.is_a?(Arel::Nodes::SqlLiteral)
-              column
-            else
-              "#{adapter_class.quote_table_name(column.relation.name)}.#{adapter_class.quote_column_name(column.name)}"
-            end
-          end.join(", ")
-        else
+        if select_values.empty?
           :all
+        else
+          with_connection do |conn|
+            arel_columns(select_values).map { |column| conn.visitor.compile(column) }.join(", ")
+          end
         end
       end
 
@@ -673,7 +665,11 @@ module ActiveRecord
         subquery_alias = Arel.sql("subquery_for_count", retryable: true)
         select_value = operation_over_aggregate_column(column_alias, "count", false)
 
-        relation.build_subquery(subquery_alias, select_value)
+        if column_name == :all
+          relation.unscope(:order).build_subquery(subquery_alias, select_value)
+        else
+          relation.build_subquery(subquery_alias, select_value)
+        end
       end
   end
 end

data/lib/active_record/relation/predicate_builder.rb

@@ -72,7 +72,15 @@ module ActiveRecord
       table.associated_table(table_name, &block).arel_table[column_name]
     end
 
+    def with(table)
+      other = dup
+      other.table = table
+      other
+    end
+
     protected
+      attr_writer :table
+
       def expand_from_hash(attributes, &block)
         return ["1=0"] if attributes.empty?
 

data/lib/active_record/relation/query_methods.rb

@@ -498,7 +498,8 @@ module ActiveRecord
 
     # Like #with, but modifies relation in place.
     def with!(*args) # :nodoc:
-      self.with_values += args
+      args = process_with_args(args)
+      self.with_values |= args
       self
     end
 
@@ -506,7 +507,7 @@ module ActiveRecord
     #
     #   Post.with_recursive(post_and_replies: [Post.where(id: 42), Post.joins('JOIN post_and_replies ON posts.in_reply_to_id = post_and_replies.id')])
     #   # => ActiveRecord::Relation
-    #   # WITH post_and_replies AS (
+    #   # WITH RECURSIVE post_and_replies AS (
     #   #   (SELECT * FROM posts WHERE id = 42)
     #   #   UNION ALL
     #   #   (SELECT * FROM posts JOIN posts_and_replies ON posts.in_reply_to_id = posts_and_replies.id)
@@ -521,7 +522,8 @@ module ActiveRecord
 
     # Like #with_recursive but modifies the relation in place.
     def with_recursive!(*args) # :nodoc:
-      self.with_values += args
+      args = process_with_args(args)
+      self.with_values |= args
       @with_is_recursive = true
       self
     end
@@ -1656,6 +1658,22 @@ module ActiveRecord
         self
       end
 
+    protected
+      def arel_columns(columns)
+        columns.flat_map do |field|
+          case field
+          when Symbol, String
+            arel_column(field)
+          when Proc
+            field.call
+          when Hash
+            arel_columns_from_hash(field)
+          else
+            field
+          end
+        end
+      end
+
     private
       def async
         spawn.async!
@@ -1910,12 +1928,26 @@ module ActiveRecord
         end
       end
 
-      def build_with_expression_from_value(value)
+      def build_with_expression_from_value(value, nested = false)
         case value
         when Arel::Nodes::SqlLiteral then Arel::Nodes::Grouping.new(value)
-        when ActiveRecord::Relation then value.arel
+        when ActiveRecord::Relation
+          if nested
+            value.arel.ast
+          else
+            value.arel
+          end
         when Arel::SelectManager then value
-        when Array then value.map { |q| build_with_expression_from_value(q) }.reduce { |result, value| result.union(:all, value) }
+        when Array
+          return build_with_expression_from_value(value.first, false) if value.size == 1
+
+          parts = value.map do |query|
+            build_with_expression_from_value(query, true)
+          end
+
+          parts.reduce do |result, value|
+            Arel::Nodes::UnionAll.new(result, value)
+          end
         else
           raise ArgumentError, "Unsupported argument type: `#{value}` #{value.class}"
         end
@@ -1929,38 +1961,43 @@ module ActiveRecord
         ).join_sources.first
       end
 
-      def arel_columns(columns)
-        columns.flat_map do |field|
-          case field
-          when Symbol
-            arel_column(field.to_s) do |attr_name|
-              model.adapter_class.quote_table_name(attr_name)
+      def arel_columns_from_hash(fields)
+        fields.flat_map do |table_name, columns|
+          table_name = table_name.name if table_name.is_a?(Symbol)
+          case columns
+          when Symbol, String
+            arel_column_with_table(table_name, columns.to_s)
+          when Array
+            columns.map do |column|
+              arel_column_with_table(table_name, column.to_s)
             end
-          when String
-            arel_column(field, &:itself)
-          when Proc
-            field.call
-          when Hash
-            arel_columns_from_hash(field)
           else
-            field
+            raise TypeError, "Expected Symbol, String or Array, got: #{columns.class}"
           end
         end
       end
 
+      def arel_column_with_table(table_name, column_name)
+        self.references_values |= [Arel.sql(table_name, retryable: true)]
+        predicate_builder.resolve_arel_attribute(table_name, column_name) do
+          lookup_table_klass_from_join_dependencies(table_name)
+        end
+      end
+
       def arel_column(field)
+        field = field.name if is_symbol = field.is_a?(Symbol)
+
         field = model.attribute_aliases[field] || field
         from = from_clause.name || from_clause.value
 
         if model.columns_hash.key?(field) && (!from || table_name_matches?(from))
           table[field]
-        elsif field.match?(/\A\w+\.\w+\z/)
-          table, column = field.split(".")
-          predicate_builder.resolve_arel_attribute(table, column) do
-            lookup_table_klass_from_join_dependencies(table)
-          end
-        else
+        elsif /\A(?<table>(?:\w+\.)?\w+)\.(?<column>\w+)\z/ =~ field
+          arel_column_with_table(table, column)
+        elsif block_given?
           yield field
+        else
+          Arel.sql(is_symbol ? model.adapter_class.quote_table_name(field) : field)
         end
       end
 
@@ -2182,38 +2219,39 @@ module ActiveRecord
       def process_select_args(fields)
         fields.flat_map do |field|
           if field.is_a?(Hash)
-            arel_columns_from_hash(field)
+            arel_column_aliases_from_hash(field)
           else
             field
           end
         end
       end
 
-      def arel_columns_from_hash(fields)
+      def arel_column_aliases_from_hash(fields)
         fields.flat_map do |key, columns_aliases|
+          table_name = key.is_a?(Symbol) ? key.name : key
           case columns_aliases
           when Hash
             columns_aliases.map do |column, column_alias|
-              if values[:joins]&.include?(key)
-                references = PredicateBuilder.references({ key.to_s => fields[key] })
-                self.references_values |= references unless references.empty?
-              end
-              arel_column("#{key}.#{column}") do
-                predicate_builder.resolve_arel_attribute(key.to_s, column)
-              end.as(column_alias.to_s)
+              arel_column_with_table(table_name, column.to_s)
+                .as(model.adapter_class.quote_column_name(column_alias.to_s))
             end
           when Array
             columns_aliases.map do |column|
-              arel_column("#{key}.#{column}", &:itself)
+              arel_column_with_table(table_name, column.to_s)
             end
           when String, Symbol
-            arel_column(key.to_s) do
-              predicate_builder.resolve_arel_attribute(model.table_name, key.to_s)
-            end.as(columns_aliases.to_s)
+            arel_column(key)
+              .as(model.adapter_class.quote_column_name(columns_aliases.to_s))
           end
         end
       end
 
+      def process_with_args(args)
+        args.flat_map do |arg|
+          arg.map { |k, v| { k => v } }
+        end
+      end
+
       STRUCTURAL_VALUE_METHODS = (
         Relation::VALUE_METHODS -
         [:extending, :where, :having, :unscope, :references, :annotate, :optimizer_hints]

data/lib/active_record/relation.rb

@@ -74,7 +74,14 @@ module ActiveRecord
     alias :loaded? :loaded
     alias :locked? :lock_value
 
-    def initialize(model, table: model.arel_table, predicate_builder: model.predicate_builder, values: {})
+    def initialize(model, table: nil, predicate_builder: nil, values: {})
+      if table
+        predicate_builder ||= model.predicate_builder.with(TableMetadata.new(model, table))
+      else
+        table = model.arel_table
+        predicate_builder ||= model.predicate_builder
+      end
+
       @model  = model
       @table  = table
       @values = values

data/lib/active_record/result.rb

@@ -127,9 +127,9 @@ module ActiveRecord
     # Returns an +Enumerator+ if no block is given.
     def each(&block)
       if block_given?
-        indexed_rows.each(&block)
+        hash_rows.each(&block)
       else
-        indexed_rows.to_enum { @rows.size }
+        hash_rows.to_enum { @rows.size }
       end
     end
 
@@ -191,6 +191,7 @@ module ActiveRecord
     def initialize_copy(other)
       @rows = rows.dup
       @column_types = column_types.dup
+      @hash_rows    = nil
     end
 
     def freeze # :nodoc:
@@ -212,6 +213,13 @@ module ActiveRecord
       end
     end
 
+    def indexed_rows # :nodoc:
+      @indexed_rows ||= begin
+        columns = column_indexes
+        @rows.map { |row| IndexedRow.new(columns, row) }.freeze
+      end
+    end
+
     private
       def column_type(name, index, type_overrides)
         type_overrides.fetch(name) do
@@ -221,13 +229,6 @@ module ActiveRecord
         end
       end
 
-      def indexed_rows
-        @indexed_rows ||= begin
-          columns = column_indexes
-          @rows.map { |row| IndexedRow.new(columns, row) }.freeze
-        end
-      end
-
       def hash_rows
         # We use transform_values to rows.
         # This is faster because we avoid any reallocs and avoid hashing entirely.

data/lib/active_record/table_metadata.rb

@@ -69,9 +69,7 @@ module ActiveRecord
 
     def predicate_builder
       if klass
-        predicate_builder = klass.predicate_builder.dup
-        predicate_builder.instance_variable_set(:@table, self)
-        predicate_builder
+        klass.predicate_builder.with(self)
       else
         PredicateBuilder.new(self)
       end

data/lib/active_record/tasks/database_tasks.rb

@@ -180,7 +180,7 @@ module ActiveRecord
         each_current_configuration(env) do |db_config|
           database_initialized = initialize_database(db_config)
 
-          seed = true if database_initialized
+          seed = true if database_initialized && db_config.seeds?
         end
 
         each_current_environment(env) do |environment|
@@ -240,13 +240,32 @@ module ActiveRecord
         end
       end
 
-      def migrate(version = nil)
+      def migrate_all
+        db_configs = ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env)
+        db_configs.each { |db_config| initialize_database(db_config) }
+
+        if db_configs.size == 1 && db_configs.first.primary?
+          ActiveRecord::Tasks::DatabaseTasks.migrate(skip_initialize: true)
+        else
+          mapped_versions = ActiveRecord::Tasks::DatabaseTasks.db_configs_with_versions
+
+          mapped_versions.sort.each do |version, db_configs|
+            db_configs.each do |db_config|
+              ActiveRecord::Tasks::DatabaseTasks.with_temporary_connection(db_config) do
+                ActiveRecord::Tasks::DatabaseTasks.migrate(version, skip_initialize: true)
+              end
+            end
+          end
+        end
+      end
+
+      def migrate(version = nil, skip_initialize: false)
         scope = ENV["SCOPE"]
         verbose_was, Migration.verbose = Migration.verbose, verbose?
 
         check_target_version
 
-        initialize_database(migration_connection_pool.db_config)
+        initialize_database(migration_connection_pool.db_config) unless skip_initialize
 
         migration_connection_pool.migration_context.migrate(target_version) do |migration|
           if version.blank?
@@ -446,26 +465,10 @@ module ActiveRecord
         end
       end
 
-      def cache_dump_filename(db_config_or_name, schema_cache_path: nil)
-        if db_config_or_name.is_a?(DatabaseConfigurations::DatabaseConfig)
-          schema_cache_path ||
-            db_config_or_name.schema_cache_path ||
-            schema_cache_env ||
-            db_config_or_name.default_schema_cache_path(ActiveRecord::Tasks::DatabaseTasks.db_dir)
-        else
-          ActiveRecord.deprecator.warn(<<~MSG.squish)
-            Passing a database name to `cache_dump_filename` is deprecated and will be removed in Rails 8.0. Pass a
-            `ActiveRecord::DatabaseConfigurations::DatabaseConfig` object instead.
-          MSG
-
-          filename = if ActiveRecord::Base.configurations.primary?(db_config_or_name)
-            "schema_cache.yml"
-          else
-            "#{db_config_or_name}_schema_cache.yml"
-          end
-
-          schema_cache_path || schema_cache_env || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, filename)
-        end
+      def cache_dump_filename(db_config, schema_cache_path: nil)
+        schema_cache_path ||
+          db_config.schema_cache_path ||
+          db_config.default_schema_cache_path(ActiveRecord::Tasks::DatabaseTasks.db_dir)
       end
 
       def load_schema_current(format = ActiveRecord.schema_format, file = nil, environment = env)
@@ -536,17 +539,6 @@ module ActiveRecord
       end
 
       private
-        def schema_cache_env
-          if ENV["SCHEMA_CACHE"]
-            ActiveRecord.deprecator.warn(<<~MSG.squish)
-              Setting `ENV["SCHEMA_CACHE"]` is deprecated and will be removed in Rails 8.0.
-              Configure the `:schema_cache_path` in the database configuration instead.
-            MSG
-
-            nil
-          end
-        end
-
         def with_temporary_pool(db_config, clobber: false)
           original_db_config = migration_class.connection_db_config
           pool = migration_class.connection_handler.establish_connection(db_config, clobber: clobber)

data/lib/active_record/testing/query_assertions.rb

@@ -52,7 +52,7 @@ module ActiveRecord
       #   assert_queries_match(/LIMIT \?/) { Post.first }
       #
       # If the +:include_schema+ option is provided, any queries (including schema related)
-      #   that match the matcher are considered.
+      # that match the matcher are considered.
       #
       #   assert_queries_match(/FROM pg_attribute/i, include_schema: true) { Post.columns }
       #
@@ -80,7 +80,7 @@ module ActiveRecord
       #   assert_no_queries_match(/SELECT/i) { post.comments }
       #
       # If the +:include_schema+ option is provided, any queries (including schema related)
-      #   that match the matcher are counted.
+      # that match the matcher are counted.
       #
       #   assert_no_queries_match(/FROM pg_attribute/i, include_schema: true) { Post.columns }
       #