activerecord 8.0.0.beta1 → 8.0.0.rc1

data/lib/active_record/relation/query_methods.rb

@@ -506,7 +506,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)
@@ -1656,6 +1656,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 +1926,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 +1959,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,34 +2217,29 @@ 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

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

@@ -446,26 +446,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 +520,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 }
       #

data/lib/active_record.rb

@@ -268,14 +268,6 @@ module ActiveRecord
   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
-
   ##
   # :singleton-method: async_query_executor
   # Sets the async_query_executor for an application. By default the thread pool executor
@@ -359,29 +351,6 @@ module ActiveRecord
   singleton_class.attr_accessor :run_after_transaction_callbacks_in_order_defined
   self.run_after_transaction_callbacks_in_order_defined = false
 
-  def self.commit_transaction_on_non_local_return
-    ActiveRecord.deprecator.warn <<-WARNING.squish
-      `Rails.application.config.active_record.commit_transaction_on_non_local_return`
-      is deprecated and will be removed in Rails 8.0.
-    WARNING
-  end
-
-  def self.commit_transaction_on_non_local_return=(value)
-    ActiveRecord.deprecator.warn <<-WARNING.squish
-      `Rails.application.config.active_record.commit_transaction_on_non_local_return`
-      is deprecated and will be removed in Rails 8.0.
-    WARNING
-  end
-
-  ##
-  # :singleton-method: warn_on_records_fetched_greater_than
-  # Specify a threshold for the size of query result sets. If the number of
-  # records in the set exceeds the threshold, a warning is logged. This can
-  # be used to identify queries which load thousands of records and
-  # potentially cause memory bloat.
-  singleton_class.attr_accessor :warn_on_records_fetched_greater_than
-  self.warn_on_records_fetched_greater_than = false
-
   singleton_class.attr_accessor :application_record_class
   self.application_record_class = nil
 
@@ -459,20 +428,6 @@ module ActiveRecord
   singleton_class.attr_accessor :verify_foreign_keys_for_fixtures
   self.verify_foreign_keys_for_fixtures = false
 
-  def self.allow_deprecated_singular_associations_name
-    ActiveRecord.deprecator.warn <<-WARNING.squish
-      `Rails.application.config.active_record.allow_deprecated_singular_associations_name`
-      is deprecated and will be removed in Rails 8.0.
-    WARNING
-  end
-
-  def self.allow_deprecated_singular_associations_name=(value)
-    ActiveRecord.deprecator.warn <<-WARNING.squish
-      `Rails.application.config.active_record.allow_deprecated_singular_associations_name`
-      is deprecated and will be removed in Rails 8.0.
-    WARNING
-  end
-
   singleton_class.attr_accessor :query_transformers
   self.query_transformers = []
 

data/lib/arel/table.rb

@@ -12,13 +12,9 @@ module Arel # :nodoc: all
     attr_reader :table_alias
 
     def initialize(name, as: nil, klass: nil, type_caster: klass&.type_caster)
-      @name =
-        case name
-        when Symbol then name.to_s
-        else
-          name
-        end
+      name = name.name if name.is_a?(Symbol)
 
+      @name = name
       @klass = klass
       @type_caster = type_caster
 
@@ -84,7 +80,7 @@ module Arel # :nodoc: all
     end
 
     def [](name, table = self)
-      name = name.to_s if name.is_a?(Symbol)
+      name = name.name if name.is_a?(Symbol)
       name = @klass.attribute_aliases[name] || name if @klass
       Attribute.new(table, name)
     end

data/lib/arel/visitors/sqlite.rb

@@ -33,6 +33,31 @@ module Arel # :nodoc: all
           collector << " IS NOT "
           visit o.right, collector
         end
+
+        # Queries used in UNION should not be wrapped by parentheses,
+        # because it is an invalid syntax in SQLite.
+        def infix_value_with_paren(o, collector, value, suppress_parens = false)
+          collector << "( " unless suppress_parens
+
+          left = o.left.is_a?(Nodes::Grouping) ? o.left.expr : o.left
+          collector = if left.class == o.class
+            infix_value_with_paren(left, collector, value, true)
+          else
+            grouping_parentheses left, collector, false
+          end
+
+          collector << value
+
+          right = o.right.is_a?(Nodes::Grouping) ? o.right.expr : o.right
+          collector = if right.class == o.class
+            infix_value_with_paren(right, collector, value, true)
+          else
+            grouping_parentheses right, collector, false
+          end
+
+          collector << " )" unless suppress_parens
+          collector
+        end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord
 version: !ruby/object:Gem::Version
-  version: 8.0.0.beta1
+  version: 8.0.0.rc1
 platform: ruby
 authors:
 - David Heinemeier Hansson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-09-26 00:00:00.000000000 Z
+date: 2024-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 8.0.0.beta1
+        version: 8.0.0.rc1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 8.0.0.beta1
+        version: 8.0.0.rc1
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 8.0.0.beta1
+        version: 8.0.0.rc1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 8.0.0.beta1
+        version: 8.0.0.rc1
 - !ruby/object:Gem::Dependency
   name: timeout
   requirement: !ruby/object:Gem::Requirement
@@ -318,7 +318,6 @@ files:
 - lib/active_record/relation/predicate_builder/relation_handler.rb
 - lib/active_record/relation/query_attribute.rb
 - lib/active_record/relation/query_methods.rb
-- lib/active_record/relation/record_fetch_warning.rb
 - lib/active_record/relation/spawn_methods.rb
 - lib/active_record/relation/where_clause.rb
 - lib/active_record/result.rb
@@ -476,10 +475,10 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/rails/rails/issues
-  changelog_uri: https://github.com/rails/rails/blob/v8.0.0.beta1/activerecord/CHANGELOG.md
-  documentation_uri: https://api.rubyonrails.org/v8.0.0.beta1/
+  changelog_uri: https://github.com/rails/rails/blob/v8.0.0.rc1/activerecord/CHANGELOG.md
+  documentation_uri: https://api.rubyonrails.org/v8.0.0.rc1/
   mailing_list_uri: https://discuss.rubyonrails.org/c/rubyonrails-talk
-  source_code_uri: https://github.com/rails/rails/tree/v8.0.0.beta1/activerecord
+  source_code_uri: https://github.com/rails/rails/tree/v8.0.0.rc1/activerecord
   rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options:

data/lib/active_record/relation/record_fetch_warning.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-  class Relation
-    module RecordFetchWarning
-      # Deprecated: subscribe to sql.active_record notifications and
-      # access the row count field to detect large result set sizes.
-      #
-      # When this module is prepended to ActiveRecord::Relation and
-      # +config.active_record.warn_on_records_fetched_greater_than+ is
-      # set to an integer, if the number of records a query returns is
-      # greater than the value of +warn_on_records_fetched_greater_than+,
-      # a warning is logged. This allows for the detection of queries that
-      # return a large number of records, which could cause memory bloat.
-      #
-      # In most cases, fetching large number of records can be performed
-      # efficiently using the ActiveRecord::Batches methods.
-      # See ActiveRecord::Batches for more information.
-      def exec_queries
-        QueryRegistry.reset
-
-        super.tap do |records|
-          if model.logger && ActiveRecord.warn_on_records_fetched_greater_than
-            if records.length > ActiveRecord.warn_on_records_fetched_greater_than
-              model.logger.warn "Query fetched #{records.size} #{@klass} records: #{QueryRegistry.queries.join(";")}"
-            end
-          end
-        end
-      end
-
-      # :stopdoc:
-      ActiveSupport::Notifications.subscribe("sql.active_record") do |*, payload|
-        QueryRegistry.queries << payload[:sql]
-      end
-      # :startdoc:
-
-      module QueryRegistry # :nodoc:
-        extend self
-
-        def queries
-          ActiveSupport::IsolatedExecutionState[:active_record_query_registry] ||= []
-        end
-
-        def reset
-          queries.clear
-        end
-      end
-    end
-  end
-end
-
-ActiveRecord::Relation.prepend ActiveRecord::Relation::RecordFetchWarning