activerecord 6.1.0 → 6.1.6.1

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

@@ -167,6 +167,9 @@ module ActiveRecord
             elsif type_metadata.extra == "DEFAULT_GENERATED"
               default = +"(#{default})" unless default.start_with?("(")
               default, default_function = nil, default
+            elsif type_metadata.type == :text && default
+              # strip and unescape quotes
+              default = default[1...-1].gsub("\\'", "'")
             end
 
             MySQL::Column.new(
@@ -203,7 +206,7 @@ module ActiveRecord
           def data_source_sql(name = nil, type: nil)
             scope = quoted_scope(name, type: type)
 
-            sql = +"SELECT table_name FROM (SELECT * FROM information_schema.tables "
+            sql = +"SELECT table_name FROM (SELECT table_name, table_type FROM information_schema.tables "
             sql << " WHERE table_schema = #{scope[:schema]}) _subquery"
             if scope[:type] || scope[:name]
               conditions = []

data/lib/active_record/connection_adapters/pool_config.rb

@@ -5,7 +5,7 @@ module ActiveRecord
     class PoolConfig # :nodoc:
       include Mutex_m
 
-      attr_reader :db_config, :connection_specification_name
+      attr_reader :db_config, :connection_klass
       attr_accessor :schema_cache
 
       INSTANCES = ObjectSpace::WeakMap.new
@@ -17,14 +17,24 @@ module ActiveRecord
         end
       end
 
-      def initialize(connection_specification_name, db_config)
+      def initialize(connection_klass, db_config)
         super()
-        @connection_specification_name = connection_specification_name
+        @connection_klass = connection_klass
         @db_config = db_config
         @pool = nil
         INSTANCES[self] = self
       end
 
+      def connection_specification_name
+        if connection_klass.is_a?(String)
+          connection_klass
+        elsif connection_klass.primary_class?
+          "ActiveRecord::Base"
+        else
+          connection_klass.name
+        end
+      end
+
       def disconnect!
         ActiveSupport::ForkTracker.check!
 

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/postgresql/database_statements.rb

@@ -28,6 +28,8 @@ module ActiveRecord
 
         def write_query?(sql) # :nodoc:
           !READ_QUERY.match?(sql)
+        rescue ArgumentError # Invalid encoding
+          !READ_QUERY.match?(sql.b)
         end
 
         # Executes an SQL statement, returning a PG::Result object on success
@@ -57,7 +59,7 @@ module ActiveRecord
               ftype = result.ftype i
               fmod  = result.fmod i
               case type = get_oid_type(ftype, fmod, fname)
-              when Type::Integer, Type::Float, Type::Decimal, Type::String, Type::DateTime, Type::Boolean
+              when Type::Integer, Type::Float, OID::Decimal, Type::String, Type::DateTime, Type::Boolean
                 # skip if a column has already been type casted by pg decoders
               else types[fname] = type
               end

data/lib/active_record/connection_adapters/postgresql/oid/money.rb

@@ -26,9 +26,9 @@ module ActiveRecord
 
             value = value.sub(/^\((.+)\)$/, '-\1') # (4)
             case value
-            when /^-?\D*[\d,]+\.\d{2}$/  # (1)
+            when /^-?\D*+[\d,]+\.\d{2}$/  # (1)
               value.gsub!(/[^-\d.]/, "")
-            when /^-?\D*[\d.]+,\d{2}$/  # (2)
+            when /^-?\D*+[\d.]+,\d{2}$/  # (2)
               value.gsub!(/[^-\d,]/, "").sub!(/,/, ".")
             end
 

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -227,11 +227,7 @@ module ActiveRecord
         end
 
         def next_key
-          "a#{@counter + 1}"
-        end
-
-        def []=(sql, key)
-          super.tap { @counter += 1 }
+          "a#{@counter += 1}"
         end
 
         private
@@ -649,9 +645,7 @@ module ActiveRecord
             raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
           end
 
-          if without_prepared_statement?(binds)
-            result = exec_no_cache(sql, name, [])
-          elsif !prepare
+          if !prepare || without_prepared_statement?(binds)
             result = exec_no_cache(sql, name, binds)
           else
             result = exec_cache(sql, name, binds)

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
 
@@ -190,16 +198,40 @@ module ActiveRecord
           @indexes      = deep_deduplicate(@indexes)
         end
 
-        def deep_deduplicate(value)
-          case value
-          when Hash
-            value.transform_keys { |k| deep_deduplicate(k) }.transform_values { |v| deep_deduplicate(v) }
-          when Array
-            value.map { |i| deep_deduplicate(i) }
-          when String, Deduplicable
-            -value
-          else
-            value
+        if RUBY_VERSION < "2.7"
+          def deep_deduplicate(value)
+            case value
+            when Hash
+              value.transform_keys { |k| deep_deduplicate(k) }.transform_values { |v| deep_deduplicate(v) }
+            when Array
+              value.map { |i| deep_deduplicate(i) }
+            when String
+              if value.tainted?
+                # Ruby 2.6 and 2.7 have slightly different implementations of the String#-@ method.
+                # In Ruby 2.6, the receiver of the String#-@ method is modified under certain
+                # circumstances, and this was later identified as a bug
+                # (https://bugs.ruby-lang.org/issues/15926) and only fixed in Ruby 2.7.
+                value = value.dup
+              end
+              -value
+            when Deduplicable
+              -value
+            else
+              value
+            end
+          end
+        else
+          def deep_deduplicate(value)
+            case value
+            when Hash
+              value.transform_keys { |k| deep_deduplicate(k) }.transform_values { |v| deep_deduplicate(v) }
+            when Array
+              value.map { |i| deep_deduplicate(i) }
+            when String, Deduplicable
+              -value
+            else
+              value
+            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/sqlite3/database_statements.rb

@@ -11,6 +11,8 @@ module ActiveRecord
 
         def write_query?(sql) # :nodoc:
           !READ_QUERY.match?(sql)
+        rescue ArgumentError # Invalid encoding
+          !READ_QUERY.match?(sql.b)
         end
 
         def explain(arel, binds = [])

data/lib/active_record/connection_adapters/sqlite3_adapter.rb

@@ -271,7 +271,7 @@ module ActiveRecord
       def change_column(table_name, column_name, type, **options) #:nodoc:
         alter_table(table_name) do |definition|
           definition[column_name].instance_eval do
-            self.type = type
+            self.type = aliased_types(type.to_s, type)
             self.options.merge!(options)
           end
         end

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/connection_handling.rb

@@ -91,6 +91,7 @@ module ActiveRecord
         db_config, owner_name = resolve_config_for_connection(database_key)
         handler = lookup_connection_handler(role.to_sym)
 
+        self.connection_class = true
         connections << handler.establish_connection(db_config, owner_name: owner_name, role: role)
       end
 
@@ -99,6 +100,7 @@ module ActiveRecord
           db_config, owner_name = resolve_config_for_connection(database_key)
           handler = lookup_connection_handler(role.to_sym)
 
+          self.connection_class = true
           connections << handler.establish_connection(db_config, owner_name: owner_name, role: role, shard: shard.to_sym)
         end
       end
@@ -112,7 +114,7 @@ module ActiveRecord
     #
     # If only a role is passed, Active Record will look up the connection
     # based on the requested role. If a non-established role is requested
-    # an `ActiveRecord::ConnectionNotEstablished` error will be raised:
+    # an +ActiveRecord::ConnectionNotEstablished+ error will be raised:
     #
     #   ActiveRecord::Base.connected_to(role: :writing) do
     #     Dog.create! # creates dog using dog writing connection
@@ -123,7 +125,7 @@ module ActiveRecord
     #   end
     #
     # When swapping to a shard, the role must be passed as well. If a non-existent
-    # shard is passed, an `ActiveRecord::ConnectionNotEstablished` error will be
+    # shard is passed, an +ActiveRecord::ConnectionNotEstablished+ error will be
     # raised.
     #
     # When a shard and role is passed, Active Record will first lookup the role,
@@ -133,7 +135,7 @@ module ActiveRecord
     #     Dog.first # finds first Dog record stored on the shard one replica
     #   end
     #
-    # The database kwarg is deprecated and will be removed in 6.2.0 without replacement.
+    # The database kwarg is deprecated and will be removed in Rails 7.0.0 without replacement.
     def connected_to(database: nil, role: nil, shard: nil, prevent_writes: false, &blk)
       if legacy_connection_handling
         if self != Base
@@ -143,12 +145,16 @@ module ActiveRecord
         if self != Base && !abstract_class
           raise NotImplementedError, "calling `connected_to` is only allowed on ActiveRecord::Base or abstract classes."
         end
+
+        if name != connection_specification_name && !primary_class?
+          raise NotImplementedError, "calling `connected_to` is only allowed on the abstract class that established the connection."
+        end
       end
 
       if database && (role || shard)
         raise ArgumentError, "`connected_to` cannot accept a `database` argument with any other arguments."
       elsif database
-        ActiveSupport::Deprecation.warn("The database key in `connected_to` is deprecated. It will be removed in Rails 6.2.0 without replacement.")
+        ActiveSupport::Deprecation.warn("The database key in `connected_to` is deprecated. It will be removed in Rails 7.0.0 without replacement.")
 
         if database.is_a?(Hash)
           role, database = database.first
@@ -172,20 +178,22 @@ module ActiveRecord
       end
     end
 
-    # Connects a role and/or shard to the provided connection names. Optionally `prevent_writes`
-    # can be passed to block writes on a connection. `reading` will automatically set
-    # `prevent_writes` to true.
+    # Connects a role and/or shard to the provided connection names. Optionally +prevent_writes+
+    # can be passed to block writes on a connection. +reading+ will automatically set
+    # +prevent_writes+ to true.
     #
-    # `connected_to_many` is an alternative to deeply nested `connected_to` blocks.
+    # +connected_to_many+ is an alternative to deeply nested +connected_to+ blocks.
     #
     # Usage:
     #
-    #   ActiveRecord::Base.connected_to(AnimalsRecord, MealsRecord], role: :reading) do
+    #   ActiveRecord::Base.connected_to_many(AnimalsRecord, MealsRecord, role: :reading) do
     #     Dog.first # Read from animals replica
     #     Dinner.first # Read from meals replica
     #     Person.first # Read from primary writer
     #   end
-    def connected_to_many(classes, role:, shard: nil, prevent_writes: false)
+    def connected_to_many(*classes, role:, shard: nil, prevent_writes: false)
+      classes = classes.flatten
+
       if legacy_connection_handling
         raise NotImplementedError, "connected_to_many is not available with legacy connection handling"
       end
@@ -208,7 +216,7 @@ module ActiveRecord
     # being used. For example, when booting a console in readonly mode.
     #
     # It is not recommended to use this method in a request since it
-    # does not yield to a block like `connected_to`.
+    # does not yield to a block like +connected_to+.
     def connecting_to(role: default_role, shard: default_shard, prevent_writes: false)
       if legacy_connection_handling
         raise NotImplementedError, "`connecting_to` is not available with `legacy_connection_handling`."
@@ -222,13 +230,13 @@ module ActiveRecord
     # Prevent writing to the database regardless of role.
     #
     # In some cases you may want to prevent writes to the database
-    # even if you are on a database that can write. `while_preventing_writes`
+    # even if you are on a database that can write. +while_preventing_writes+
     # will prevent writes to the database for the duration of the block.
     #
     # This method does not provide the same protection as a readonly
     # user and is meant to be a safeguard against accidental writes.
     #
-    # See `READ_QUERY` for the queries that are blocked by this
+    # See +READ_QUERY+ for the queries that are blocked by this
     # method.
     def while_preventing_writes(enabled = true, &block)
       if legacy_connection_handling
@@ -357,7 +365,7 @@ module ActiveRecord
         self.connection_specification_name = owner_name
 
         db_config = Base.configurations.resolve(config_or_env)
-        [db_config, owner_name]
+        [db_config, self]
       end
 
       def with_handler(handler_key, &blk)

data/lib/active_record/core.rb

@@ -155,6 +155,14 @@ module ActiveRecord
 
       mattr_accessor :legacy_connection_handling, instance_writer: false, default: true
 
+      # Application configurable boolean that instructs the YAML Coder to use
+      # an unsafe load if set to true.
+      mattr_accessor :use_yaml_unsafe_load, instance_writer: false, default: false
+
+      # Application configurable array that provides additional permitted classes
+      # to Psych safe_load in the YAML Coder
+      mattr_accessor :yaml_column_permitted_classes, instance_writer: false, default: []
+
       self.filter_attributes = []
 
       def self.connection_handler
@@ -196,7 +204,7 @@ module ActiveRecord
         else
           connected_to_stack.reverse_each do |hash|
             return hash[:role] if hash[:role] && hash[:klasses].include?(Base)
-            return hash[:role] if hash[:role] && hash[:klasses].include?(abstract_base_class)
+            return hash[:role] if hash[:role] && hash[:klasses].include?(connection_classes)
           end
 
           default_role
@@ -215,7 +223,7 @@ module ActiveRecord
       def self.current_shard
         connected_to_stack.reverse_each do |hash|
           return hash[:shard] if hash[:shard] && hash[:klasses].include?(Base)
-          return hash[:shard] if hash[:shard] && hash[:klasses].include?(abstract_base_class)
+          return hash[:shard] if hash[:shard] && hash[:klasses].include?(connection_classes)
         end
 
         default_shard
@@ -237,7 +245,7 @@ module ActiveRecord
         else
           connected_to_stack.reverse_each do |hash|
             return hash[:prevent_writes] if !hash[:prevent_writes].nil? && hash[:klasses].include?(Base)
-            return hash[:prevent_writes] if !hash[:prevent_writes].nil? && hash[:klasses].include?(abstract_base_class)
+            return hash[:prevent_writes] if !hash[:prevent_writes].nil? && hash[:klasses].include?(connection_classes)
           end
 
           false
@@ -254,11 +262,23 @@ module ActiveRecord
         end
       end
 
-      def self.abstract_base_class # :nodoc:
+      def self.connection_class=(b) # :nodoc:
+        @connection_class = b
+      end
+
+      def self.connection_class # :nodoc
+        @connection_class ||= false
+      end
+
+      def self.connection_class? # :nodoc:
+        self.connection_class
+      end
+
+      def self.connection_classes # :nodoc:
         klass = self
 
         until klass == Base
-          break if klass.abstract_class?
+          break if klass.connection_class?
           klass = klass.superclass
         end
 
@@ -266,25 +286,25 @@ module ActiveRecord
       end
 
       def self.allow_unsafe_raw_sql # :nodoc:
-        ActiveSupport::Deprecation.warn("ActiveRecord::Base.allow_unsafe_raw_sql is deprecated and will be removed in Rails 6.2")
+        ActiveSupport::Deprecation.warn("ActiveRecord::Base.allow_unsafe_raw_sql is deprecated and will be removed in Rails 7.0")
       end
 
       def self.allow_unsafe_raw_sql=(value) # :nodoc:
-        ActiveSupport::Deprecation.warn("ActiveRecord::Base.allow_unsafe_raw_sql= is deprecated and will be removed in Rails 6.2")
+        ActiveSupport::Deprecation.warn("ActiveRecord::Base.allow_unsafe_raw_sql= is deprecated and will be removed in Rails 7.0")
       end
 
       self.default_connection_handler = ConnectionAdapters::ConnectionHandler.new
       self.default_role = writing_role
       self.default_shard = :default
 
-      def self.strict_loading_violation!(owner:, association:) # :nodoc:
+      def self.strict_loading_violation!(owner:, reflection:) # :nodoc:
         case action_on_strict_loading_violation
         when :raise
-          message = "`#{association}` called on `#{owner}` is marked for strict_loading and cannot be lazily loaded."
+          message = "`#{owner}` is marked for strict_loading. The `#{reflection.klass}` association named `:#{reflection.name}` cannot be lazily loaded."
           raise ActiveRecord::StrictLoadingViolationError.new(message)
         when :log
           name = "strict_loading_violation.active_record"
-          ActiveSupport::Notifications.instrument(name, owner: owner, association: association)
+          ActiveSupport::Notifications.instrument(name, owner: owner, reflection: reflection)
         end
       end
     end
@@ -332,31 +352,37 @@ module ActiveRecord
         hash = args.first
         return super unless Hash === hash
 
-        values = hash.values.map! { |value| value.respond_to?(:id) ? value.id : value }
-        return super if values.any? { |v| StatementCache.unsupported_value?(v) }
-
-        keys = hash.keys.map! do |key|
-          attribute_aliases[name = key.to_s] || begin
-            reflection = _reflect_on_association(name)
-            if reflection&.belongs_to? && !reflection.polymorphic?
-              reflection.join_foreign_key
-            elsif reflect_on_aggregation(name)
-              return super
-            else
-              name
-            end
+        hash = hash.each_with_object({}) do |(key, value), h|
+          key = key.to_s
+          key = attribute_aliases[key] || key
+
+          return super if reflect_on_aggregation(key)
+
+          reflection = _reflect_on_association(key)
+
+          if !reflection
+            value = value.id if value.respond_to?(:id)
+          elsif reflection.belongs_to? && !reflection.polymorphic?
+            key = reflection.join_foreign_key
+            pkey = reflection.join_primary_key
+            value = value.public_send(pkey) if value.respond_to?(pkey)
+          end
+
+          if !columns_hash.key?(key) || StatementCache.unsupported_value?(value)
+            return super
           end
-        end
 
-        return super unless keys.all? { |k| columns_hash.key?(k) }
+          h[key] = value
+        end
 
+        keys = hash.keys
         statement = cached_find_by_statement(keys) { |params|
           wheres = keys.index_with { params.bind }
           where(wheres).limit(1)
         }
 
         begin
-          statement.execute(values, connection).first
+          statement.execute(hash.values, connection).first
         rescue TypeError
           raise ActiveRecord::StatementInvalid
         end
@@ -390,7 +416,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:
@@ -758,10 +798,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/database_configurations/connection_url_resolver.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "uri"
 require "active_support/core_ext/enumerable"
 
 module ActiveRecord

data/lib/active_record/database_configurations/hash_config.rb

@@ -32,7 +32,7 @@ module ActiveRecord
       end
 
       def config
-        ActiveSupport::Deprecation.warn("DatabaseConfig#config will be removed in 6.2.0 in favor of DatabaseConfigurations#configuration_hash which returns a hash with symbol keys")
+        ActiveSupport::Deprecation.warn("DatabaseConfig#config will be removed in 7.0.0 in favor of DatabaseConfig#configuration_hash which returns a hash with symbol keys")
         configuration_hash.stringify_keys
       end
 

data/lib/active_record/database_configurations/url_config.rb

@@ -42,7 +42,7 @@ module ActiveRecord
         # Return a Hash that can be merged into the main config that represents
         # the passed in url
         def build_url_hash
-          if url.nil? || url.start_with?("jdbc:")
+          if url.nil? || %w(jdbc: http: https:).any? { |protocol| url.start_with?(protocol) }
             { url: url }
           else
             ConnectionUrlResolver.new(url).to_hash

data/lib/active_record/database_configurations.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "uri"
 require "active_record/database_configurations/database_config"
 require "active_record/database_configurations/hash_config"
 require "active_record/database_configurations/url_config"
@@ -40,7 +41,7 @@ module ActiveRecord
     def configs_for(env_name: nil, spec_name: nil, name: nil, include_replicas: false)
       if spec_name
         name = spec_name
-        ActiveSupport::Deprecation.warn("The kwarg `spec_name` is deprecated in favor of `name`. `spec_name` will be removed in Rails 6.2")
+        ActiveSupport::Deprecation.warn("The kwarg `spec_name` is deprecated in favor of `name`. `spec_name` will be removed in Rails 7.0")
       end
 
       env_name ||= default_env if name