activerecord 8.1.0.beta1 → 8.1.0.rc1

data/lib/active_record/connection_adapters/mysql2_adapter.rb

@@ -92,8 +92,6 @@ module ActiveRecord
         true
       end
 
-      # HELPER METHODS ===========================================
-
       def error_number(exception)
         exception.error_number if exception.respond_to?(:error_number)
       end

data/lib/active_record/connection_adapters/postgresql/column.rb

@@ -30,6 +30,10 @@ module ActiveRecord
           @generated.present?
         end
 
+        def virtual_stored?
+          @generated == "s"
+        end
+
         def has_default?
           super && !virtual?
         end

data/lib/active_record/connection_adapters/postgresql/database_statements.rb

@@ -127,7 +127,14 @@ module ActiveRecord
           def cancel_any_running_query
             return if @raw_connection.nil? || IDLE_TRANSACTION_STATUSES.include?(@raw_connection.transaction_status)
 
-            @raw_connection.cancel
+            # Skip @raw_connection.cancel (PG::Connection#cancel) when using libpq >= 18 with pg < 1.6.0,
+            # because the pg gem cannot obtain the backend_key in that case.
+            # This method is only called from exec_rollback_db_transaction and exec_restart_db_transaction.
+            # Even without cancel, rollback will still run. However, since any running
+            # query must finish first, the rollback may take longer.
+            if !(PG.library_version >= 18_00_00 && Gem::Version.new(PG::VERSION) < Gem::Version.new("1.6.0"))
+              @raw_connection.cancel
+            end
             @raw_connection.block
           rescue PG::Error
           end

data/lib/active_record/connection_adapters/postgresql/schema_creation.rb

@@ -6,6 +6,7 @@ module ActiveRecord
       class SchemaCreation < SchemaCreation # :nodoc:
         private
           delegate :quoted_include_columns_for_index, to: :@conn
+          delegate :database_version, to: :@conn
 
           def visit_AlterTable(o)
             sql = super
@@ -126,16 +127,17 @@ module ActiveRecord
             end
 
             if as = options[:as]
-              sql << " GENERATED ALWAYS AS (#{as})"
+              stored = options[:stored]
 
-              if options[:stored]
-                sql << " STORED"
-              else
+              if stored != true && database_version < 18_00_00
                 raise ArgumentError, <<~MSG
-                  PostgreSQL currently does not support VIRTUAL (not persisted) generated columns.
+                  PostgreSQL versions before 18 do not support VIRTUAL (not persisted) generated columns.
                   Specify 'stored: true' option for '#{options[:column].name}'
                 MSG
               end
+
+              sql << " GENERATED ALWAYS AS (#{as})"
+              sql << (stored ? " STORED" : " VIRTUAL")
             end
             super
           end

data/lib/active_record/connection_adapters/postgresql/schema_dumper.rb

@@ -103,7 +103,7 @@ module ActiveRecord
 
             if @connection.supports_virtual_columns? && column.virtual?
               spec[:as] = extract_expression_for_virtual_column(column)
-              spec[:stored] = true
+              spec[:stored] = "true" if column.virtual_stored?
               spec = { type: schema_type(column).inspect }.merge!(spec)
             end
 

data/lib/active_record/connection_adapters/postgresql/schema_statements.rb

@@ -435,16 +435,13 @@ module ActiveRecord
         def primary_keys(table_name) # :nodoc:
           query_values(<<~SQL, "SCHEMA")
             SELECT a.attname
-              FROM (
-                     SELECT indrelid, indkey, generate_subscripts(indkey, 1) idx
-                       FROM pg_index
-                      WHERE indrelid = #{quote(quote_table_name(table_name))}::regclass
-                        AND indisprimary
-                   ) i
-              JOIN pg_attribute a
-                ON a.attrelid = i.indrelid
-               AND a.attnum = i.indkey[i.idx]
-             ORDER BY i.idx
+            FROM pg_index i
+            JOIN pg_attribute a
+              ON a.attrelid = i.indrelid
+              AND a.attnum = ANY(i.indkey)
+            WHERE i.indrelid = #{quote(quote_table_name(table_name))}::regclass
+              AND i.indisprimary
+            ORDER BY array_position(i.indkey, a.attnum)
           SQL
         end
 

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -288,6 +288,16 @@ module ActiveRecord
         database_version >= 10_00_00 # >= 10.0
       end
 
+      if PG::Connection.method_defined?(:close_prepared) # pg 1.6.0 & libpq 17
+        def supports_close_prepared? # :nodoc:
+          database_version >= 17_00_00
+        end
+      else
+        def supports_close_prepared? # :nodoc:
+          false
+        end
+      end
+
       def index_algorithms
         { concurrently: "CONCURRENTLY" }
       end
@@ -309,8 +319,12 @@ module ActiveRecord
             # accessed while holding the connection's lock. (And we
             # don't need the complication of with_raw_connection because
             # a reconnect would invalidate the entire statement pool.)
-            if conn = @connection.instance_variable_get(:@raw_connection)
-              conn.query "DEALLOCATE #{key}" if conn.status == PG::CONNECTION_OK
+            if (conn = @connection.instance_variable_get(:@raw_connection)) && conn.status == PG::CONNECTION_OK
+              if @connection.supports_close_prepared?
+                conn.close_prepared key
+              else
+                conn.query "DEALLOCATE #{key}"
+              end
             end
           rescue PG::Error
           end
@@ -666,9 +680,6 @@ module ActiveRecord
         if database_version < 9_03_00 # < 9.3
           raise "Your version of PostgreSQL (#{database_version}) is too old. Active Record supports PostgreSQL >= 9.3."
         end
-        if database_version >= 18_00_00 && Gem::Version.new(PG::VERSION) < Gem::Version.new("1.6.0")
-          warn "pg gem version #{PG::VERSION} is known to be incompatible with PostgreSQL 18+. Please upgrade to pg 1.6.0 or later."
-        end
       end
 
       class << self

data/lib/active_record/connection_handling.rb

@@ -100,7 +100,8 @@ module ActiveRecord
           db_config = resolve_config_for_connection(database_key)
 
           self.connection_class = true
-          connections << connection_handler.establish_connection(db_config, owner_name: self, role: role, shard: shard.to_sym)
+          shard = shard.to_sym unless shard.is_a? Integer
+          connections << connection_handler.establish_connection(db_config, owner_name: self, role: role, shard: shard)
         end
       end
 

data/lib/active_record/database_configurations/hash_config.rb

@@ -71,7 +71,10 @@ module ActiveRecord
       end
 
       def max_connections
-        (configuration_hash[:max_connections] || configuration_hash[:pool] || 5).to_i
+        max_connections = configuration_hash.fetch(:max_connections) {
+          configuration_hash.fetch(:pool, 5)
+        }&.to_i
+        max_connections if max_connections && max_connections >= 0
       end
 
       def min_connections
@@ -86,7 +89,7 @@ module ActiveRecord
       end
 
       def max_threads
-        (configuration_hash[:max_threads] || max_connections).to_i
+        (configuration_hash[:max_threads] || (max_connections || 5).clamp(0, 5)).to_i
       end
 
       def max_age

data/lib/active_record/encryption/encryptor.rb

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

data/lib/active_record/errors.rb

@@ -12,7 +12,7 @@ module ActiveRecord
 
   # Raised when the single-table inheritance mechanism fails to locate the subclass
   # (for example due to improper usage of column that
-  # {ActiveRecord::Base.inheritance_column}[rdoc-ref:ModelSchema::ClassMethods#inheritance_column]
+  # {ActiveRecord::Base.inheritance_column}[rdoc-ref:ModelSchema.inheritance_column]
   # points to).
   class SubclassNotFound < ActiveRecordError
   end
@@ -451,7 +451,7 @@ module ActiveRecord
   UnknownAttributeError = ActiveModel::UnknownAttributeError
 
   # Raised when an error occurred while doing a mass assignment to an attribute through the
-  # {ActiveRecord::Base#attributes=}[rdoc-ref:AttributeAssignment#attributes=] method.
+  # {ActiveRecord::Base#attributes=}[rdoc-ref:ActiveModel::AttributeAssignment#attributes=] method.
   # The exception has an +attribute+ property that is the name of the offending attribute.
   class AttributeAssignmentError < ActiveRecordError
     attr_reader :exception, :attribute
@@ -464,7 +464,7 @@ module ActiveRecord
   end
 
   # Raised when there are multiple errors while doing a mass assignment through the
-  # {ActiveRecord::Base#attributes=}[rdoc-ref:AttributeAssignment#attributes=]
+  # {ActiveRecord::Base#attributes=}[rdoc-ref:ActiveModel::AttributeAssignment#attributes=]
   # method. The exception has an +errors+ property that contains an array of AttributeAssignmentError
   # objects, each corresponding to the error while assigning to an attribute.
   class MultiparameterAssignmentErrors < ActiveRecordError

data/lib/active_record/explain.rb

@@ -7,7 +7,7 @@ module ActiveRecord
     # Executes the block with the collect flag enabled. Queries are collected
     # asynchronously by the subscriber and returned.
     def collecting_queries_for_explain # :nodoc:
-      ExplainRegistry.collect = true
+      ExplainRegistry.start
       yield
       ExplainRegistry.queries
     ensure

data/lib/active_record/explain_registry.rb

@@ -8,8 +8,53 @@ module ActiveRecord
   #
   # returns the collected queries local to the current thread.
   class ExplainRegistry # :nodoc:
+    class Subscriber
+      MUTEX = Mutex.new
+      @subscribed = false
+
+      class << self
+        def ensure_subscribed
+          return if @subscribed
+          MUTEX.synchronize do
+            return if @subscribed
+
+            ActiveSupport::Notifications.subscribe("sql.active_record", new)
+            @subscribed = true
+          end
+        end
+      end
+
+      def start(name, id, payload)
+        # unused
+      end
+
+      def finish(name, id, payload)
+        if ExplainRegistry.collect? && !ignore_payload?(payload)
+          ExplainRegistry.queries << payload.values_at(:sql, :binds)
+        end
+      end
+
+      def silenced?(_name)
+        !ExplainRegistry.collect?
+      end
+
+      # SCHEMA queries cannot be EXPLAINed, also we do not want to run EXPLAIN on
+      # our own EXPLAINs no matter how loopingly beautiful that would be.
+      #
+      # On the other hand, we want to monitor the performance of our real database
+      # queries, not the performance of the access to the query cache.
+      IGNORED_PAYLOADS = %w(SCHEMA EXPLAIN)
+      EXPLAINED_SQLS = /\A\s*(\/\*.*\*\/)?\s*(with|select|update|delete|insert)\b/i
+      def ignore_payload?(payload)
+        payload[:exception] ||
+          payload[:cached] ||
+          IGNORED_PAYLOADS.include?(payload[:name]) ||
+          !payload[:sql].match?(EXPLAINED_SQLS)
+      end
+    end
+
     class << self
-      delegate :reset, :collect, :collect=, :collect?, :queries, to: :instance
+      delegate :start, :reset, :collect, :collect=, :collect?, :queries, to: :instance
 
       private
         def instance
@@ -24,6 +69,11 @@ module ActiveRecord
       reset
     end
 
+    def start
+      Subscriber.ensure_subscribed
+      @collect = true
+    end
+
     def collect?
       @collect
     end

data/lib/active_record/gem_version.rb

@@ -10,7 +10,7 @@ module ActiveRecord
     MAJOR = 8
     MINOR = 1
     TINY  = 0
-    PRE   = "beta1"
+    PRE   = "rc1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_record/log_subscriber.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveRecord
-  class LogSubscriber < ActiveSupport::LogSubscriber
+  class LogSubscriber < ActiveSupport::LogSubscriber # :nodoc:
     IGNORE_PAYLOAD_NAMES = ["SCHEMA", "EXPLAIN"]
 
     class_attribute :backtrace_cleaner, default: ActiveSupport::BacktraceCleaner.new

data/lib/active_record/migration/compatibility.rb

@@ -33,7 +33,7 @@ module ActiveRecord
 
       class V8_0 < V8_1
         module RemoveForeignKeyColumnMatch
-          def remove_foreign_key(from_table, to_table = nil, **options)
+          def remove_foreign_key(*args, **options)
             options[:_skip_column_match] = true
             super
           end

data/lib/active_record/model_schema.rb

@@ -48,7 +48,7 @@ module ActiveRecord
     # way of creating a namespace for tables in a shared database. By default, the prefix is the
     # empty string.
     #
-    # If you are organising your models within modules you can add a prefix to the models within
+    # If you are organizing your models within modules you can add a prefix to the models within
     # a namespace by defining a singleton method in the parent module called table_name_prefix which
     # returns your chosen prefix.
 
@@ -65,7 +65,7 @@ module ActiveRecord
     # Works like +table_name_prefix=+, but appends instead of prepends (set to "_basecamp" gives "projects_basecamp",
     # "people_basecamp"). By default, the suffix is the empty string.
     #
-    # If you are organising your models within modules, you can add a suffix to the models within
+    # If you are organizing your models within modules, you can add a suffix to the models within
     # a namespace by defining a singleton method in the parent module called table_name_suffix which
     # returns your chosen suffix.
 
@@ -181,6 +181,7 @@ module ActiveRecord
       self.protected_environments = ["production"]
 
       self.ignored_columns = [].freeze
+      self.only_columns = [].freeze
 
       delegate :type_for_attribute, :column_for_attribute, to: :class
 
@@ -334,6 +335,12 @@ module ActiveRecord
         @ignored_columns || superclass.ignored_columns
       end
 
+      # The list of columns names the model should allow. Only columns are used to define
+      # attribute accessors, and are referenced in SQL queries.
+      def only_columns
+        @only_columns || superclass.only_columns
+      end
+
       # Sets the columns names the model should ignore. Ignored columns won't have attribute
       # accessors defined, and won't be referenced in SQL queries.
       #
@@ -366,10 +373,17 @@ module ActiveRecord
       #   user = Project.create!(name: "First Project")
       #   user.category # => raises NoMethodError
       def ignored_columns=(columns)
+        check_model_columns(@only_columns.present?)
         reload_schema_from_cache
         @ignored_columns = columns.map(&:to_s).freeze
       end
 
+      def only_columns=(columns)
+        check_model_columns(@ignored_columns.present?)
+        reload_schema_from_cache
+        @only_columns = columns.map(&:to_s).freeze
+      end
+
       def sequence_name
         if base_class?
           @sequence_name ||= reset_sequence_name
@@ -579,6 +593,7 @@ module ActiveRecord
           child_class.reload_schema_from_cache(false)
           child_class.class_eval do
             @ignored_columns = nil
+            @only_columns = nil
           end
         end
 
@@ -592,7 +607,11 @@ module ActiveRecord
           end
 
           columns_hash = schema_cache.columns_hash(table_name)
-          columns_hash = columns_hash.except(*ignored_columns) unless ignored_columns.empty?
+          if only_columns.present?
+            columns_hash = columns_hash.slice(*only_columns)
+          elsif ignored_columns.present?
+            columns_hash = columns_hash.except(*ignored_columns)
+          end
           @columns_hash = columns_hash.freeze
 
           _default_attributes # Precompute to cache DB-dependent attribute types
@@ -631,6 +650,10 @@ module ActiveRecord
 
           type
         end
+
+        def check_model_columns(columns_present)
+          raise ArgumentError, "You can not use both only_columns and ignored_columns in the same model." if columns_present
+        end
     end
   end
 end

data/lib/active_record/railties/controller_runtime.rb

@@ -41,11 +41,14 @@ module ActiveRecord
 
         def cleanup_view_runtime
           if logger && logger.info?
-            db_rt_before_render = ActiveRecord::RuntimeRegistry.reset_runtimes
+            runtime_stats = ActiveRecord::RuntimeRegistry.stats
+            db_rt_before_render = runtime_stats.reset_runtimes
             self.db_runtime = (db_runtime || 0) + db_rt_before_render
+
             runtime = super
-            queries_rt = ActiveRecord::RuntimeRegistry.sql_runtime - ActiveRecord::RuntimeRegistry.async_sql_runtime
-            db_rt_after_render = ActiveRecord::RuntimeRegistry.reset_runtimes
+
+            queries_rt = runtime_stats.sql_runtime - runtime_stats.async_sql_runtime
+            db_rt_after_render = runtime_stats.reset_runtimes
             self.db_runtime += db_rt_after_render
             runtime - queries_rt
           else
@@ -56,9 +59,11 @@ module ActiveRecord
         def append_info_to_payload(payload)
           super
 
-          payload[:db_runtime] = (db_runtime || 0) + ActiveRecord::RuntimeRegistry.reset_runtimes
-          payload[:queries_count] = ActiveRecord::RuntimeRegistry.reset_queries_count
-          payload[:cached_queries_count] = ActiveRecord::RuntimeRegistry.reset_cached_queries_count
+          runtime_stats = ActiveRecord::RuntimeRegistry.stats
+          payload[:db_runtime] = (db_runtime || 0) + runtime_stats.sql_runtime
+          payload[:queries_count] = runtime_stats.queries_count
+          payload[:cached_queries_count] = runtime_stats.cached_queries_count
+          runtime_stats.reset
         end
     end
   end

data/lib/active_record/railties/databases.rake

@@ -466,7 +466,7 @@ db_namespace = namespace :db do
 
     desc "Load a database schema file (either db/schema.rb or db/structure.sql, depending on `ENV['SCHEMA_FORMAT']` or `config.active_record.schema_format`) into the database"
     task load: [:load_config, :check_protected_environments] do
-      ActiveRecord::Tasks::DatabaseTasks.load_schema_current(nil, ENV["SCHEMA"])
+      ActiveRecord::Tasks::DatabaseTasks.load_schema_current(ENV["SCHEMA_FORMAT"], ENV["SCHEMA"])
     end
 
     namespace :dump do

data/lib/active_record/railties/job_runtime.rb

@@ -8,9 +8,9 @@ module ActiveRecord
       def instrument(operation, payload = {}, &block) # :nodoc:
         if operation == :perform && block
           super(operation, payload) do
-            db_runtime_before_perform = ActiveRecord::RuntimeRegistry.sql_runtime
+            db_runtime_before_perform = ActiveRecord::RuntimeRegistry.stats.sql_runtime
             result = block.call
-            payload[:db_runtime] = ActiveRecord::RuntimeRegistry.sql_runtime - db_runtime_before_perform
+            payload[:db_runtime] = ActiveRecord::RuntimeRegistry.stats.sql_runtime - db_runtime_before_perform
             result
           end
         else

data/lib/active_record/relation/batches.rb

@@ -437,7 +437,7 @@ module ActiveRecord
             values = records.pluck(*cursor)
             values_size = values.size
             values_last = values.last
-            yielded_relation = where(cursor => values).order(batch_orders.to_h)
+            yielded_relation = rewhere(cursor => values)
             yielded_relation.load_records(records)
           elsif (empty_scope && use_ranges != false) || use_ranges
             # Efficiently peak at the last value for the next batch using offset and limit.
@@ -455,14 +455,14 @@ module ActiveRecord
             # Finally, build the yielded relation if at least one value found.
             if values_last
               yielded_relation = apply_finish_limit(batch_relation, cursor, values_last, batch_orders)
-              yielded_relation = yielded_relation.except(:limit).reorder(batch_orders.to_h)
+              yielded_relation = yielded_relation.except(:limit, :order)
               yielded_relation.skip_query_cache!(false)
             end
           else
             values = batch_relation.pluck(*cursor)
             values_size = values.size
             values_last = values.last
-            yielded_relation = where(cursor => values).order(batch_orders.to_h)
+            yielded_relation = rewhere(cursor => values)
           end
 
           break if values_size == 0

data/lib/active_record/relation/merger.rb

@@ -85,9 +85,9 @@ module ActiveRecord
           return if other.select_values.empty?
 
           if other.model == relation.model
-            relation.select_values += other.select_values if relation.select_values != other.select_values
+            relation.select_values |= other.select_values
           else
-            relation.select_values += other.instance_eval do
+            relation.select_values |= other.instance_eval do
               arel_columns(select_values)
             end
           end

data/lib/active_record/relation/predicate_builder/association_query_value.rb

@@ -3,24 +3,24 @@
 module ActiveRecord
   class PredicateBuilder
     class AssociationQueryValue # :nodoc:
-      def initialize(associated_table, value)
-        @associated_table = associated_table
+      def initialize(reflection, value)
+        @reflection = reflection
         @value = value
       end
 
       def queries
-        if associated_table.join_foreign_key.is_a?(Array)
+        if reflection.join_foreign_key.is_a?(Array)
           id_list = ids
           id_list = id_list.pluck(primary_key) if id_list.is_a?(Relation)
 
-          id_list.map { |ids_set| associated_table.join_foreign_key.zip(ids_set).to_h }
+          id_list.map { |ids_set| reflection.join_foreign_key.zip(ids_set).to_h }
         else
-          [ associated_table.join_foreign_key => ids ]
+          [ reflection.join_foreign_key => ids ]
         end
       end
 
       private
-        attr_reader :associated_table, :value
+        attr_reader :reflection, :value
 
         def ids
           case value
@@ -37,15 +37,15 @@ module ActiveRecord
         end
 
         def primary_key
-          associated_table.join_primary_key
+          reflection.join_primary_key
         end
 
         def primary_type
-          associated_table.join_primary_type
+          reflection.join_primary_type
         end
 
         def polymorphic_name
-          associated_table.polymorphic_name_association
+          reflection.polymorphic_name
         end
 
         def select_clause?

data/lib/active_record/relation/predicate_builder/polymorphic_array_value.rb

@@ -3,24 +3,24 @@
 module ActiveRecord
   class PredicateBuilder
     class PolymorphicArrayValue # :nodoc:
-      def initialize(associated_table, values)
-        @associated_table = associated_table
+      def initialize(reflection, values)
+        @reflection = reflection
         @values = values
       end
 
       def queries
-        return [ associated_table.join_foreign_key => values ] if values.empty?
+        return [ reflection.join_foreign_key => values ] if values.empty?
 
         type_to_ids_mapping.map do |type, ids|
           query = {}
-          query[associated_table.join_foreign_type] = type if type
-          query[associated_table.join_foreign_key] = ids
+          query[reflection.join_foreign_type] = type if type
+          query[reflection.join_foreign_key] = ids
           query
         end
       end
 
       private
-        attr_reader :associated_table, :values
+        attr_reader :reflection, :values
 
         def type_to_ids_mapping
           default_hash = Hash.new { |hsh, key| hsh[key] = [] }
@@ -30,7 +30,7 @@ module ActiveRecord
         end
 
         def primary_key(value)
-          associated_table.join_primary_key(klass(value))
+          reflection.join_primary_key(klass(value))
         end
 
         def klass(value)

data/lib/active_record/relation/predicate_builder.rb

@@ -99,24 +99,26 @@ module ActiveRecord
           elsif value.is_a?(Hash) && !table.has_column?(key)
             table.associated_table(key, &block)
               .predicate_builder.expand_from_hash(value.stringify_keys)
-          elsif table.associated_with?(key)
+          elsif (associated_reflection = table.associated_with(key))
             # Find the foreign key when using queries such as:
             # Post.where(author: author)
             #
             # For polymorphic relationships, find the foreign key and type:
             # PriceEstimate.where(estimate_of: treasure)
-            associated_table = table.associated_table(key)
-            if associated_table.polymorphic_association?
+
+            if associated_reflection.polymorphic?
               value = [value] unless value.is_a?(Array)
               klass = PolymorphicArrayValue
-            elsif associated_table.through_association?
+            elsif associated_reflection.through_reflection?
+              associated_table = table.associated_table(key)
+
               next associated_table.predicate_builder.expand_from_hash(
                 associated_table.primary_key => value
               )
             end
 
             klass ||= AssociationQueryValue
-            queries = klass.new(associated_table, value).queries.map! do |query|
+            queries = klass.new(associated_reflection, value).queries.map! do |query|
               # If the query produced is identical to attributes don't go any deeper.
               # Prevents stack level too deep errors when association and foreign_key are identical.
               query == attributes ? self[key, value] : expand_from_hash(query)

data/lib/active_record/relation/query_methods.rb

@@ -426,7 +426,7 @@ module ActiveRecord
     end
 
     def _select!(*fields) # :nodoc:
-      self.select_values += fields
+      self.select_values |= fields
       self
     end