activerecord 6.1.3.2 → 6.1.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4388f56d55688f1f53d21619c1d97a976a0bf198e46813febbaf7a867fb47702
-  data.tar.gz: 63314ed55ab0aa06c816b9208764f00a897ec40485c23dc23659ecadf5490d91
+  metadata.gz: bfce4c7e3e72a9532c8532e7285191bd87922110c4ae68f5b614f9f760c255a8
+  data.tar.gz: ac62553b4d11f238a2f92232b8c5146a239c9afb55a1cee10e013c9b1877b209
 SHA512:
-  metadata.gz: d6da5c43903489b203067e4c187ffa405a91d6f35bd0d23087e225b2bc49f9b1ad4e5c4df73f72de8577ed0c044e049b5381a22a0b1c83215b1d3fc3b5b6d4dd
-  data.tar.gz: 3e3fffe809e00d052c6147b1e373744ac8875abf94c5225289901184447989a998cd953bbc4a0e644feac0eb4fdf33e14071bf48ac8d6b7741bd1aa962a592ea
+  metadata.gz: 94bdbb5e730d7975ba11ea7794ee9e7d36a3a8bbd697d95645e1492f521f16db58f75d12ddfa07c5d35a5f8c98c8971bf95a41fb9e0f5b094b34c2f2671f2fa2
+  data.tar.gz: 9b94ac51e360a48bcc47b1c9c19a29946729bc6460b9c9f11b760f8edac7f467eb0aed05dcaa30f0baba946ffd4f6dc78f16971c8fb93051b10dd23cd22a17d8

data/CHANGELOG.md

@@ -1,3 +1,106 @@
+## Rails 6.1.4.1 (August 19, 2021) ##
+
+*   No changes.
+
+
+## Rails 6.1.4 (June 24, 2021) ##
+
+*   Do not try to rollback transactions that failed due to a `ActiveRecord::TransactionRollbackError`.
+
+    *Jamie McCarthy*
+
+*   Raise an error if `pool_config` is `nil` in `set_pool_config`.
+
+    *Eileen M. Uchitelle*
+
+*   Fix compatibility with `psych >= 4`.
+
+    Starting in Psych 4.0.0 `YAML.load` behaves like `YAML.safe_load`. To preserve compatibility
+    Active Record's schema cache loader and `YAMLColumn` now uses `YAML.unsafe_load` if available.
+
+    *Jean Boussier*
+
+*   Support using replicas when using `rails dbconsole`.
+
+    *Christopher Thornton*
+
+*   Restore connection pools after transactional tests.
+
+    *Eugene Kenny*
+
+*   Change `upsert_all` to fails cleanly for MySQL when `:unique_by` is used.
+
+    *Bastian Bartmann*
+
+*   Fix user-defined `self.default_scope` to respect table alias.
+
+    *Ryuta Kamizono*
+
+*   Clear `@cache_keys` cache after `update_all`, `delete_all`, `destroy_all`.
+
+    *Ryuta Kamizono*
+
+*   Changed Arel predications `contains` and `overlaps` to use
+    `quoted_node` so that PostgreSQL arrays are quoted properly.
+
+    *Bradley Priest*
+
+*   Fix `merge` when the `where` clauses have string contents.
+
+    *Ryuta Kamizono*
+
+*   Fix rollback of parent destruction with nested `dependent: :destroy`.
+
+    *Jacopo Beschi*
+
+*   Fix binds logging for `"WHERE ... IN ..."` statements.
+
+    *Ricardo Díaz*
+
+*   Handle `false` in relation strict loading checks.
+
+    Previously when a model had strict loading set to true and then had a
+    relation set `strict_loading` to false the false wasn't considered when
+    deciding whether to raise/warn about strict loading.
+
+    ```
+    class Dog < ActiveRecord::Base
+      self.strict_loading_by_default = true
+
+      has_many :treats, strict_loading: false
+    end
+    ```
+
+    In the example, `dog.treats` would still raise even though
+    `strict_loading` was set to false. This is a bug effecting more than
+    Active Storage which is why I made this PR superceeding #41461. We need
+    to fix this for all applications since the behavior is a little
+    surprising. I took the test from ##41461 and the code suggestion from #41453
+    with some additions.
+
+    *Eileen M. Uchitelle*, *Radamés Roriz*
+
+*   Fix numericality validator without precision.
+
+    *Ryuta Kamizono*
+
+*   Fix aggregate attribute on Enum types.
+
+    *Ryuta Kamizono*
+
+*   Fix `CREATE INDEX` statement generation for PostgreSQL.
+
+    *eltongo*
+
+*   Fix where clause on enum attribute when providing array of strings.
+
+    *Ryuta Kamizono*
+
+*   Fix `unprepared_statement` to work it when nesting.
+
+    *Ryuta Kamizono*
+
+
 ## Rails 6.1.3.2 (May 05, 2021) ##
 
 *   No changes.
@@ -1053,14 +1156,14 @@
     Deprecated behavior:
 
     ```ruby
-    db_config = ActiveRecord::Base.configs_for(env_name: "development", spec_name: "primary")
+    db_config = ActiveRecord::Base.configurations.configs_for(env_name: "development", spec_name: "primary")
     db_config.spec_name
     ```
 
     New behavior:
 
     ```ruby
-    db_config = ActiveRecord::Base.configs_for(env_name: "development", name: "primary")
+    db_config = ActiveRecord::Base.configurations.configs_for(env_name: "development", name: "primary")
     db_config.name
     ```
 

data/lib/active_record/associations/association.rb

@@ -211,7 +211,7 @@ module ActiveRecord
 
       private
         def find_target
-          if (owner.strict_loading? || reflection.strict_loading?) && owner.validation_context.nil?
+          if strict_loading? && owner.validation_context.nil?
             Base.strict_loading_violation!(owner: owner.class, reflection: reflection)
           end
 
@@ -227,6 +227,12 @@ module ActiveRecord
           sc.execute(binds, klass.connection) { |record| set_inverse_instance(record) }
         end
 
+        def strict_loading?
+          return reflection.strict_loading? if reflection.options.key?(:strict_loading)
+
+          owner.strict_loading?
+        end
+
         # The scope for this association.
         #
         # Note that the association_scope is merged into the target_scope only when the

data/lib/active_record/associations/belongs_to_association.rb

@@ -9,8 +9,7 @@ module ActiveRecord
 
         case options[:dependent]
         when :destroy
-          target.destroy
-          raise ActiveRecord::Rollback unless target.destroyed?
+          raise ActiveRecord::Rollback unless target.destroy
         when :destroy_async
           id = owner.public_send(reflection.foreign_key.to_sym)
           primary_key_column = reflection.active_record_primary_key.to_sym

data/lib/active_record/coders/yaml_column.rb

@@ -23,7 +23,7 @@ module ActiveRecord
       def load(yaml)
         return object_class.new if object_class != Object && yaml.nil?
         return yaml unless yaml.is_a?(String) && yaml.start_with?("---")
-        obj = YAML.load(yaml)
+        obj = yaml_load(yaml)
 
         assert_valid_value(obj, action: "load")
         obj ||= object_class.new if object_class != Object
@@ -44,6 +44,16 @@ module ActiveRecord
         rescue ArgumentError
           raise ArgumentError, "Cannot serialize #{object_class}. Classes passed to `serialize` must have a 0 argument constructor."
         end
+
+        if YAML.respond_to?(:unsafe_load)
+          def yaml_load(payload)
+            YAML.unsafe_load(payload)
+          end
+        else
+          def yaml_load(payload)
+            YAML.load(payload)
+          end
+        end
     end
   end
 end

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

@@ -94,8 +94,8 @@ module ActiveRecord
           sql = ["CREATE"]
           sql << "UNIQUE" if index.unique
           sql << "INDEX"
-          sql << "IF NOT EXISTS" if o.if_not_exists
           sql << o.algorithm if o.algorithm
+          sql << "IF NOT EXISTS" if o.if_not_exists
           sql << index.type if index.type
           sql << "#{quote_column_name(index.name)} ON #{quote_table_name(index.table)}"
           sql << "USING #{index.using}" if supports_index_using? && index.using

data/lib/active_record/connection_adapters/abstract/transaction.rb

@@ -33,6 +33,10 @@ module ActiveRecord
         @state == :fully_rolledback
       end
 
+      def invalidated?
+        @state == :invalidated
+      end
+
       def fully_completed?
         completed?
       end
@@ -51,6 +55,11 @@ module ActiveRecord
         @state = :fully_rolledback
       end
 
+      def invalidate!
+        @children&.each { |c| c.invalidate! }
+        @state = :invalidated
+      end
+
       def commit!
         @state = :committed
       end
@@ -299,7 +308,7 @@ module ActiveRecord
       def rollback_transaction(transaction = nil)
         @connection.lock.synchronize do
           transaction ||= @stack.pop
-          transaction.rollback
+          transaction.rollback unless transaction.state.invalidated?
           transaction.rollback_records
         end
       end
@@ -312,15 +321,17 @@ module ActiveRecord
           ret
         rescue Exception => error
           if transaction
+            transaction.state.invalidate! if error.is_a? ActiveRecord::TransactionRollbackError
             rollback_transaction
             after_failure_actions(transaction, error)
           end
+
           raise
         ensure
           if transaction
             if error
-              # @connection still holds an open transaction, so we must not
-              # put it back in the pool for reuse
+              # @connection still holds an open or invalid transaction, so we must not
+              # put it back in the pool for reuse.
               @connection.throw_away! unless transaction.state.rolledback?
             else
               if Thread.current.status == "aborting"

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "set"
-require "active_record/connection_adapters/schema_cache"
 require "active_record/connection_adapters/sql_type_metadata"
 require "active_record/connection_adapters/abstract/schema_dumper"
 require "active_record/connection_adapters/abstract/schema_creation"
@@ -154,9 +153,10 @@ module ActiveRecord
                               end
       end
 
-      def prepared_statements
+      def prepared_statements?
         @prepared_statements && !prepared_statements_disabled_cache.include?(object_id)
       end
+      alias :prepared_statements :prepared_statements?
 
       def prepared_statements_disabled_cache # :nodoc:
         Thread.current[:ar_prepared_statements_disabled_cache] ||= Set.new
@@ -250,7 +250,7 @@ module ActiveRecord
       end
 
       def unprepared_statement
-        cache = prepared_statements_disabled_cache.add(object_id) if @prepared_statements
+        cache = prepared_statements_disabled_cache.add?(object_id) if @prepared_statements
         yield
       ensure
         cache&.delete(object_id)

data/lib/active_record/connection_adapters/legacy_pool_manager.rb

@@ -23,8 +23,12 @@ module ActiveRecord
         @name_to_pool_config[shard]
       end
 
-      def set_pool_config(_, shard, pool_config)
-        @name_to_pool_config[shard] = pool_config
+      def set_pool_config(role, shard, pool_config)
+        if pool_config
+          @name_to_pool_config[shard] = pool_config
+        else
+          raise ArgumentError, "The `pool_config` for the :#{role} role and :#{shard} shard was `nil`. Please check your configuration. If you want your writing role to be something other than `:writing` set `config.active_record.writing_role` in your application configuration. The same setting should be applied for the `reading_role` if applicable."
+        end
       end
     end
   end

data/lib/active_record/connection_adapters/pool_manager.rb

@@ -36,7 +36,11 @@ module ActiveRecord
       end
 
       def set_pool_config(role, shard, pool_config)
-        @name_to_role_mapping[role][shard] = pool_config
+        if pool_config
+          @name_to_role_mapping[role][shard] = pool_config
+        else
+          raise ArgumentError, "The `pool_config` for the :#{role} role and :#{shard} shard was `nil`. Please check your configuration. If you want your writing role to be something other than `:writing` set `config.active_record.writing_role` in your application configuration. The same setting should be applied for the `reading_role` if applicable."
+        end
       end
     end
   end

data/lib/active_record/connection_adapters/schema_cache.rb

@@ -9,7 +9,15 @@ module ActiveRecord
         return unless File.file?(filename)
 
         read(filename) do |file|
-          filename.include?(".dump") ? Marshal.load(file) : YAML.load(file)
+          if filename.include?(".dump")
+            Marshal.load(file)
+          else
+            if YAML.respond_to?(:unsafe_load)
+              YAML.unsafe_load(file)
+            else
+              YAML.load(file)
+            end
+          end
         end
       end
 

data/lib/active_record/connection_adapters/sql_type_metadata.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "active_record/connection_adapters/deduplicable"
-
 module ActiveRecord
   # :stopdoc:
   module ConnectionAdapters

data/lib/active_record/connection_adapters.rb

@@ -12,6 +12,8 @@ module ActiveRecord
     autoload :PoolConfig
     autoload :PoolManager
     autoload :LegacyPoolManager
+    autoload :SchemaCache
+    autoload :Deduplicable
 
     autoload_at "active_record/connection_adapters/abstract/schema_definitions" do
       autoload :IndexDefinition

data/lib/active_record/core.rb

@@ -408,7 +408,21 @@ module ActiveRecord
       end
 
       # Specifies columns which shouldn't be exposed while calling +#inspect+.
-      attr_writer :filter_attributes
+      def filter_attributes=(filter_attributes)
+        @inspection_filter = nil
+        @filter_attributes = filter_attributes
+      end
+
+      def inspection_filter # :nodoc:
+        if defined?(@filter_attributes)
+          @inspection_filter ||= begin
+            mask = InspectionMask.new(ActiveSupport::ParameterFilter::FILTERED)
+            ActiveSupport::ParameterFilter.new(@filter_attributes, mask: mask)
+          end
+        else
+          superclass.inspection_filter
+        end
+      end
 
       # Returns a string like 'Post(id:integer, title:string, body:text)'
       def inspect # :nodoc:
@@ -776,10 +790,7 @@ module ActiveRecord
       private_constant :InspectionMask
 
       def inspection_filter
-        @inspection_filter ||= begin
-          mask = InspectionMask.new(ActiveSupport::ParameterFilter::FILTERED)
-          ActiveSupport::ParameterFilter.new(self.class.filter_attributes, mask: mask)
-        end
+        self.class.inspection_filter
       end
   end
 end

data/lib/active_record/enum.rb

@@ -139,22 +139,20 @@ module ActiveRecord
         mapping.key(subtype.deserialize(value))
       end
 
-      def serializable?(value)
-        (value.blank? || mapping.has_key?(value) || mapping.has_value?(value)) && super
-      end
-
       def serialize(value)
         mapping.fetch(value, value)
       end
 
       def assert_valid_value(value)
-        unless serializable?(value)
+        unless value.blank? || mapping.has_key?(value) || mapping.has_value?(value)
           raise ArgumentError, "'#{value}' is not a valid #{name}"
         end
       end
 
+      attr_reader :subtype
+
       private
-        attr_reader :name, :mapping, :subtype
+        attr_reader :name, :mapping
     end
 
     def enum(definitions)

data/lib/active_record/gem_version.rb

@@ -9,8 +9,8 @@ module ActiveRecord
   module VERSION
     MAJOR = 6
     MINOR = 1
-    TINY  = 3
-    PRE   = "2"
+    TINY  = 4
+    PRE   = "1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_record/insert_all.rb

@@ -69,7 +69,11 @@ module ActiveRecord
       attr_reader :scope_attributes
 
       def find_unique_index_for(unique_by)
-        return unique_by if !connection.supports_insert_conflict_target?
+        if !connection.supports_insert_conflict_target?
+          return if unique_by.nil?
+
+          raise ArgumentError, "#{connection.class} does not support :unique_by"
+        end
 
         name_or_columns = unique_by || model.primary_key
         match = Array(name_or_columns).map(&:to_s)

data/lib/active_record/railties/databases.rake

@@ -413,8 +413,9 @@ db_namespace = namespace :db do
       fixture_files = if ENV["FIXTURES"]
         ENV["FIXTURES"].split(",")
       else
-        # The use of String#[] here is to support namespaced fixtures.
-        Dir["#{fixtures_dir}/**/*.yml"].map { |f| f[(fixtures_dir.size + 1)..-5] }
+        files = Dir[File.join(fixtures_dir, "**/*.{yml}")]
+        files.reject! { |f| f.start_with?(File.join(fixtures_dir, "files")) }
+        files.map! { |f| f[fixtures_dir.to_s.size..-5].delete_prefix("/") }
       end
 
       ActiveRecord::FixtureSet.create_fixtures(fixtures_dir, fixture_files)

data/lib/active_record/relation/calculations.rb

@@ -310,6 +310,7 @@ module ActiveRecord
         type_cast_calculated_value(result.cast_values.first, operation) do |value|
           type = column.try(:type_caster) ||
             lookup_cast_type_from_join_dependencies(column_name.to_s) || Type.default_value
+          type = type.subtype if Enum::EnumType === type
           type.deserialize(value)
         end
       end
@@ -387,8 +388,11 @@ module ActiveRecord
           key = key_records[key] if associated
 
           result[key] = type_cast_calculated_value(row[column_alias], operation) do |value|
-            type ||= column.try(:type_caster) ||
-              lookup_cast_type_from_join_dependencies(column_name.to_s) || Type.default_value
+            unless type
+              type = column.try(:type_caster) ||
+                lookup_cast_type_from_join_dependencies(column_name.to_s) || Type.default_value
+              type = type.subtype if Enum::EnumType === type
+            end
             type.deserialize(value)
           end
         end

data/lib/active_record/relation/query_methods.rb

@@ -1133,7 +1133,7 @@ module ActiveRecord
         raise ImmutableRelation if defined?(@arel) && @arel
       end
 
-      def build_arel(aliases)
+      def build_arel(aliases = nil)
         arel = Arel::SelectManager.new(table)
 
         build_joins(arel.join_sources, aliases)

data/lib/active_record/relation/where_clause.rb

@@ -103,28 +103,31 @@ module ActiveRecord
       end
 
       def extract_attributes
-        predicates.each_with_object([]) do |node, attrs|
-          attr = extract_attribute(node) || begin
-            node.left if node.equality? && node.left.is_a?(Arel::Predications)
-          end
-          attrs << attr if attr
-        end
+        attrs = []
+        each_attributes { |attr, _| attrs << attr }
+        attrs
       end
 
       protected
         attr_reader :predicates
 
         def referenced_columns
-          predicates.each_with_object({}) do |node, hash|
+          hash = {}
+          each_attributes { |attr, node| hash[attr] = node }
+          hash
+        end
+
+      private
+        def each_attributes
+          predicates.each do |node|
             attr = extract_attribute(node) || begin
               node.left if equality_node?(node) && node.left.is_a?(Arel::Predications)
             end
 
-            hash[attr] = node if attr
+            yield attr, node if attr
           end
         end
 
-      private
         def extract_attribute(node)
           attr_node = nil
           Arel.fetch_attribute(node) do |attr|

data/lib/active_record/relation.rb

@@ -440,13 +440,11 @@ module ActiveRecord
     def update_all(updates)
       raise ArgumentError, "Empty list of attributes to change" if updates.blank?
 
-      if eager_loading?
-        relation = apply_join_dependency
-        return relation.update_all(updates)
-      end
+      arel = eager_loading? ? apply_join_dependency.arel : build_arel
+      arel.source.left = table
 
       stmt = Arel::UpdateManager.new
-      stmt.table(arel.join_sources.empty? ? table : arel.source)
+      stmt.table(arel.source)
       stmt.key = table[primary_key]
       stmt.take(arel.limit)
       stmt.offset(arel.offset)
@@ -465,7 +463,7 @@ module ActiveRecord
         stmt.set Arel.sql(klass.sanitize_sql_for_assignment(updates, table.name))
       end
 
-      @klass.connection.update stmt, "#{@klass} Update All"
+      klass.connection.update(stmt, "#{klass} Update All").tap { reset }
     end
 
     def update(id = :all, attributes) # :nodoc:
@@ -582,23 +580,18 @@ module ActiveRecord
         raise ActiveRecordError.new("delete_all doesn't support #{invalid_methods.join(', ')}")
       end
 
-      if eager_loading?
-        relation = apply_join_dependency
-        return relation.delete_all
-      end
+      arel = eager_loading? ? apply_join_dependency.arel : build_arel
+      arel.source.left = table
 
       stmt = Arel::DeleteManager.new
-      stmt.from(arel.join_sources.empty? ? table : arel.source)
+      stmt.from(arel.source)
       stmt.key = table[primary_key]
       stmt.take(arel.limit)
       stmt.offset(arel.offset)
       stmt.order(*arel.orders)
       stmt.wheres = arel.constraints
 
-      affected = @klass.connection.delete(stmt, "#{@klass} Destroy")
-
-      reset
-      affected
+      klass.connection.delete(stmt, "#{klass} Destroy").tap { reset }
     end
 
     # Finds and destroys all records matching the specified conditions.
@@ -652,6 +645,7 @@ module ActiveRecord
       @delegate_to_klass = false
       @to_sql = @arel = @loaded = @should_eager_load = nil
       @offsets = @take = nil
+      @cache_keys = nil
       @records = [].freeze
       self
     end

data/lib/active_record/scoping/default.rb

@@ -109,9 +109,7 @@ module ActiveRecord
             if default_scope_override
               # The user has defined their own default scope method, so call that
               evaluate_default_scope do
-                if scope = default_scope
-                  relation.merge!(scope)
-                end
+                relation.scoping { default_scope }
               end
             elsif default_scopes.any?
               evaluate_default_scope do

data/lib/active_record/statement_cache.rb

@@ -80,8 +80,8 @@ module ActiveRecord
         self
       end
 
-      def add_binds(binds)
-        @binds.concat binds
+      def add_binds(binds, proc_for_binds = nil)
+        @binds.concat proc_for_binds ? binds.map(&proc_for_binds) : binds
         binds.size.times do |i|
           @parts << ", " unless i == 0
           @parts << Substitute.new

data/lib/active_record/test_fixtures.rb

@@ -111,6 +111,8 @@ module ActiveRecord
       @fixture_connections = []
       @@already_loaded_fixtures ||= {}
       @connection_subscriber = nil
+      @legacy_saved_pool_configs = Hash.new { |hash, key| hash[key] = {} }
+      @saved_pool_configs = Hash.new { |hash, key| hash[key] = {} }
 
       # Load fixtures once and begin transaction.
       if run_in_transaction?
@@ -169,6 +171,7 @@ module ActiveRecord
           connection.pool.lock_thread = false
         end
         @fixture_connections.clear
+        teardown_shared_connection_pool
       else
         ActiveRecord::FixtureSet.reset_cache
       end
@@ -200,8 +203,13 @@ module ActiveRecord
                 return unless writing_pool_manager
 
                 pool_manager = handler.send(:owner_to_pool_manager)[name]
+                @legacy_saved_pool_configs[handler][name] ||= {}
                 pool_manager.shard_names.each do |shard_name|
                   writing_pool_config = writing_pool_manager.get_pool_config(nil, shard_name)
+                  pool_config = pool_manager.get_pool_config(nil, shard_name)
+                  next if pool_config == writing_pool_config
+
+                  @legacy_saved_pool_configs[handler][name][shard_name] = pool_config
                   pool_manager.set_pool_config(nil, shard_name, writing_pool_config)
                 end
               end
@@ -214,8 +222,12 @@ module ActiveRecord
             pool_manager = handler.send(:owner_to_pool_manager)[name]
             pool_manager.shard_names.each do |shard_name|
               writing_pool_config = pool_manager.get_pool_config(ActiveRecord::Base.writing_role, shard_name)
+              @saved_pool_configs[name][shard_name] ||= {}
               pool_manager.role_names.each do |role|
-                next unless pool_manager.get_pool_config(role, shard_name)
+                next unless pool_config = pool_manager.get_pool_config(role, shard_name)
+                next if pool_config == writing_pool_config
+
+                @saved_pool_configs[name][shard_name][role] = pool_config
                 pool_manager.set_pool_config(role, shard_name, writing_pool_config)
               end
             end
@@ -223,6 +235,35 @@ module ActiveRecord
         end
       end
 
+      def teardown_shared_connection_pool
+        if ActiveRecord::Base.legacy_connection_handling
+          @legacy_saved_pool_configs.each_pair do |handler, names|
+            names.each_pair do |name, shards|
+              shards.each_pair do |shard_name, pool_config|
+                pool_manager = handler.send(:owner_to_pool_manager)[name]
+                pool_manager.set_pool_config(nil, shard_name, pool_config)
+              end
+            end
+          end
+        else
+          handler = ActiveRecord::Base.connection_handler
+
+          @saved_pool_configs.each_pair do |name, shards|
+            pool_manager = handler.send(:owner_to_pool_manager)[name]
+            shards.each_pair do |shard_name, roles|
+              roles.each_pair do |role, pool_config|
+                next unless pool_manager.get_pool_config(role, shard_name)
+
+                pool_manager.set_pool_config(role, shard_name, pool_config)
+              end
+            end
+          end
+        end
+
+        @legacy_saved_pool_configs.clear
+        @saved_pool_configs.clear
+      end
+
       def load_fixtures(config)
         ActiveRecord::FixtureSet.create_fixtures(fixture_path, fixture_table_names, fixture_class_names, config).index_by(&:name)
       end

data/lib/active_record/validations/numericality.rb

@@ -4,7 +4,7 @@ module ActiveRecord
   module Validations
     class NumericalityValidator < ActiveModel::Validations::NumericalityValidator # :nodoc:
       def validate_each(record, attribute, value, precision: nil, scale: nil)
-        precision = [column_precision_for(record, attribute) || BigDecimal.double_fig, BigDecimal.double_fig].min
+        precision = [column_precision_for(record, attribute) || Float::DIG, Float::DIG].min
         scale     = column_scale_for(record, attribute)
         super(record, attribute, value, precision: precision, scale: scale)
       end

data/lib/arel/collectors/bind.rb

@@ -16,8 +16,8 @@ module Arel # :nodoc: all
         self
       end
 
-      def add_binds(binds)
-        @binds.concat binds
+      def add_binds(binds, proc_for_binds = nil)
+        @binds.concat proc_for_binds ? binds.map(&proc_for_binds) : binds
         self
       end
 

data/lib/arel/collectors/composite.rb

@@ -22,9 +22,9 @@ module Arel # :nodoc: all
         self
       end
 
-      def add_binds(binds, &block)
-        left.add_binds(binds, &block)
-        right.add_binds(binds, &block)
+      def add_binds(binds, proc_for_binds = nil, &block)
+        left.add_binds(binds, proc_for_binds, &block)
+        right.add_binds(binds, proc_for_binds, &block)
         self
       end
 

data/lib/arel/collectors/sql_string.rb

@@ -18,7 +18,7 @@ module Arel # :nodoc: all
         self
       end
 
-      def add_binds(binds, &block)
+      def add_binds(binds, proc_for_binds = nil, &block)
         self << (@bind_index...@bind_index += binds.size).map(&block).join(", ")
         self
       end

data/lib/arel/collectors/substitute_binds.rb

@@ -20,7 +20,7 @@ module Arel # :nodoc: all
         self << quoter.quote(bind)
       end
 
-      def add_binds(binds)
+      def add_binds(binds, proc_for_binds = nil)
         self << binds.map { |bind| quoter.quote(bind) }.join(", ")
       end
 

data/lib/arel/nodes/homogeneous_in.rb

@@ -55,6 +55,10 @@ module Arel # :nodoc: all
         casted_values
       end
 
+      def proc_for_binds
+        -> value { ActiveModel::Attribute.with_cast_value(attribute.name, value, attribute.type_caster) }
+      end
+
       def fetch_attribute(&block)
         if attribute
           yield attribute

data/lib/arel/predications.rb

@@ -207,11 +207,11 @@ module Arel # :nodoc: all
     end
 
     def contains(other)
-      Arel::Nodes::Contains.new(self, other)
+      Arel::Nodes::Contains.new self, quoted_node(other)
     end
 
     def overlaps(other)
-      Arel::Nodes::Overlaps.new(self, other)
+      Arel::Nodes::Overlaps.new self, quoted_node(other)
     end
 
     def quoted_array(others)

data/lib/arel/visitors/to_sql.rb

@@ -337,7 +337,7 @@ module Arel # :nodoc: all
           if values.empty?
             collector << @connection.quote(nil)
           else
-            collector.add_binds(values, &bind_block)
+            collector.add_binds(values, o.proc_for_binds, &bind_block)
           end
 
           collector << ")"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord
 version: !ruby/object:Gem::Version
-  version: 6.1.3.2
+  version: 6.1.4.1
 platform: ruby
 authors:
 - David Heinemeier Hansson
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-05 00:00:00.000000000 Z
+date: 2021-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 6.1.3.2
+        version: 6.1.4.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 6.1.3.2
+        version: 6.1.4.1
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 6.1.3.2
+        version: 6.1.4.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 6.1.3.2
+        version: 6.1.4.1
 description: Databases on Rails. Build a persistent domain model by mapping database
   tables to Ruby classes. Strong conventions for associations, validations, aggregations,
   migrations, and testing come baked-in.
@@ -390,10 +390,10 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/rails/rails/issues
-  changelog_uri: https://github.com/rails/rails/blob/v6.1.3.2/activerecord/CHANGELOG.md
-  documentation_uri: https://api.rubyonrails.org/v6.1.3.2/
+  changelog_uri: https://github.com/rails/rails/blob/v6.1.4.1/activerecord/CHANGELOG.md
+  documentation_uri: https://api.rubyonrails.org/v6.1.4.1/
   mailing_list_uri: https://discuss.rubyonrails.org/c/rubyonrails-talk
-  source_code_uri: https://github.com/rails/rails/tree/v6.1.3.2/activerecord
+  source_code_uri: https://github.com/rails/rails/tree/v6.1.4.1/activerecord
 post_install_message:
 rdoc_options:
 - "--main"
@@ -411,7 +411,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.2.15
 signing_key:
 specification_version: 4
 summary: Object-relational mapper framework (part of Rails).