activerecord 6.0.3.7 → 6.0.4.3

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

@@ -67,15 +67,34 @@ module ActiveRecord
             end
 
             def extract_bounds(value)
-              from, to = value[1..-2].split(",")
+              from, to = value[1..-2].split(",", 2)
               {
-                from:          (value[1] == "," || from == "-infinity") ? infinity(negative: true) : from,
-                to:            (value[-2] == "," || to == "infinity") ? infinity : to,
-                exclude_start: (value[0] == "("),
-                exclude_end:   (value[-1] == ")")
+                from:          (from == "" || from == "-infinity") ? infinity(negative: true) : unquote(from),
+                to:            (to == "" || to == "infinity") ? infinity : unquote(to),
+                exclude_start: value.start_with?("("),
+                exclude_end:   value.end_with?(")")
               }
             end
 
+            # When formatting the bound values of range types, PostgreSQL quotes
+            # the bound value using double-quotes in certain conditions. Within
+            # a double-quoted string, literal " and \ characters are themselves
+            # escaped. In input, PostgreSQL accepts multiple escape styles for "
+            # (either \" or "") but in output always uses "".
+            # See:
+            # * https://www.postgresql.org/docs/current/rangetypes.html#RANGETYPES-IO
+            # * https://www.postgresql.org/docs/current/rowtypes.html#ROWTYPES-IO-SYNTAX
+            def unquote(value)
+              if value.start_with?('"') && value.end_with?('"')
+                unquoted_value = value[1..-2]
+                unquoted_value.gsub!('""', '"')
+                unquoted_value.gsub!('\\\\', '\\')
+                unquoted_value
+              else
+                value
+              end
+            end
+
             def infinity(negative: false)
               if subtype.respond_to?(:infinity)
                 subtype.infinity(negative: negative)

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

@@ -5,7 +5,7 @@ module ActiveRecord
     module SQLite3
       module DatabaseStatements
         READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
-          :begin, :commit, :explain, :select, :pragma, :release, :savepoint, :rollback, :with
+          :pragma
         ) # :nodoc:
         private_constant :READ_QUERY
 

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

@@ -61,7 +61,7 @@ module ActiveRecord
 
         def remove_foreign_key(from_table, to_table = nil, **options)
           to_table ||= options[:to_table]
-          options = options.except(:name, :to_table)
+          options = options.except(:name, :to_table, :validate)
           foreign_keys = foreign_keys(from_table)
 
           fkey = foreign_keys.detect do |fk|

data/lib/active_record/connection_adapters/sqlite3_adapter.rb

@@ -283,13 +283,14 @@ 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.limit   = options[:limit] if options.include?(:limit)
             self.default = options[:default] if options.include?(:default)
             self.null    = options[:null] if options.include?(:null)
             self.precision = options[:precision] if options.include?(:precision)
             self.scale = options[:scale] if options.include?(:scale)
             self.collation = options[:collation] if options.include?(:collation)
+            self.options.merge!(options)
           end
         end
       end

data/lib/active_record/core.rb

@@ -285,18 +285,17 @@ module ActiveRecord
         false
       end
 
-      private
-        def cached_find_by_statement(key, &block)
-          cache = @find_by_statement_cache[connection.prepared_statements]
-          cache.compute_if_absent(key) { StatementCache.create(connection, &block) }
-        end
+      def cached_find_by_statement(key, &block) # :nodoc:
+        cache = @find_by_statement_cache[connection.prepared_statements]
+        cache.compute_if_absent(key) { StatementCache.create(connection, &block) }
+      end
 
+      private
         def relation
           relation = Relation.create(self)
 
           if finder_needs_type_condition? && !ignore_default_scope?
             relation.where!(type_condition)
-            relation.create_with!(inheritance_column.to_s => sti_name)
           else
             relation
           end

data/lib/active_record/enum.rb

@@ -173,6 +173,7 @@ module ActiveRecord
 
         _enum_methods_module.module_eval do
           pairs = values.respond_to?(:each_pair) ? values.each_pair : values.each_with_index
+          value_method_names = []
           pairs.each do |label, value|
             if enum_prefix == true
               prefix = "#{name}_"
@@ -186,6 +187,7 @@ module ActiveRecord
             end
 
             value_method_name = "#{prefix}#{label}#{suffix}"
+            value_method_names << value_method_name
             enum_values[label] = value
             label = label.to_s
 
@@ -200,8 +202,6 @@ module ActiveRecord
             # scope :active, -> { where(status: 0) }
             # scope :not_active, -> { where.not(status: 0) }
             if enum_scopes != false
-              klass.send(:detect_negative_condition!, value_method_name)
-
               klass.send(:detect_enum_conflict!, name, value_method_name, true)
               klass.scope value_method_name, -> { where(attr => value) }
 
@@ -209,6 +209,7 @@ module ActiveRecord
               klass.scope "not_#{value_method_name}", -> { where.not(attr => value) }
             end
           end
+          klass.send(:detect_negative_enum_conditions!, value_method_names) if enum_scopes != false
         end
         enum_values.freeze
       end
@@ -264,10 +265,16 @@ module ActiveRecord
         }
       end
 
-      def detect_negative_condition!(method_name)
-        if method_name.start_with?("not_") && logger
-          logger.warn "An enum element in #{self.name} uses the prefix 'not_'." \
-            " This will cause a conflict with auto generated negative scopes."
+      def detect_negative_enum_conditions!(method_names)
+        return unless logger
+
+        method_names.select { |m| m.start_with?("not_") }.each do |potential_not|
+          inverted_form = potential_not.sub("not_", "")
+          if method_names.include?(inverted_form)
+            logger.warn "Enum element '#{potential_not}' in #{self.name} uses the prefix 'not_'." \
+              " This has caused a conflict with auto generated negative scopes." \
+              " Avoid using enum elements starting with 'not' where the positive form is also an element."
+          end
         end
       end
   end

data/lib/active_record/fixture_set/render_context.rb

@@ -10,7 +10,7 @@ class ActiveRecord::FixtureSet::RenderContext # :nodoc:
       end
 
       def binary(path)
-        %(!!binary "#{Base64.strict_encode64(File.read(path))}")
+        %(!!binary "#{Base64.strict_encode64(File.read(path, mode: 'rb'))}")
       end
     end
   end

data/lib/active_record/gem_version.rb

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

data/lib/active_record/insert_all.rb

@@ -168,7 +168,7 @@ module ActiveRecord
           end
 
           def format_columns(columns)
-            quote_columns(columns).join(",")
+            columns.respond_to?(:map) ? quote_columns(columns).join(",") : columns
           end
 
           def quote_columns(columns)

data/lib/active_record/locking/optimistic.rb

@@ -60,6 +60,15 @@ module ActiveRecord
         self.class.locking_enabled?
       end
 
+      def increment!(*, **) #:nodoc:
+        super.tap do
+          if locking_enabled?
+            self[self.class.locking_column] += 1
+            clear_attribute_change(self.class.locking_column)
+          end
+        end
+      end
+
       private
         def _create_record(attribute_names = self.attribute_names)
           if locking_enabled?

data/lib/active_record/model_schema.rb

@@ -287,6 +287,35 @@ module ActiveRecord
 
       # Sets the columns names the model should ignore. Ignored columns won't have attribute
       # accessors defined, and won't be referenced in SQL queries.
+      #
+      # A common usage pattern for this method is to ensure all references to an attribute
+      # have been removed and deployed, before a migration to drop the column from the database
+      # has been deployed and run. Using this two step approach to dropping columns ensures there
+      # is no code that raises errors due to having a cached schema in memory at the time the
+      # schema migration is run.
+      #
+      # For example, given a model where you want to drop the "category" attribute, first mark it
+      # as ignored:
+      #
+      #   class Project < ActiveRecord::Base
+      #     # schema:
+      #     #   id         :bigint
+      #     #   name       :string, limit: 255
+      #     #   category   :string, limit: 255
+      #
+      #     self.ignored_columns = [:category]
+      #   end
+      #
+      # The schema still contains `category`, but now the model omits it, so any meta-driven code or
+      # schema caching will not attempt to use the column:
+      #
+      #   Project.columns_hash["category"] => nil
+      #
+      # You will get an error if accessing that attribute directly, so ensure all usages of the
+      # column are removed (automated tests can help you find any usages).
+      #
+      #   user = Project.create!(name: "First Project")
+      #   user.category # => raises NoMethodError
       def ignored_columns=(columns)
         @ignored_columns = columns.map(&:to_s)
       end

data/lib/active_record/reflection.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/string/filters"
-require "concurrent/map"
 
 module ActiveRecord
   # = Active Record Reflection
@@ -201,9 +200,9 @@ module ActiveRecord
         klass_scope
       end
 
-      def join_scopes(table, predicate_builder) # :nodoc:
+      def join_scopes(table, predicate_builder, klass = self.klass) # :nodoc:
         if scope
-          [scope_for(build_scope(table, predicate_builder))]
+          [scope_for(build_scope(table, predicate_builder, klass))]
         else
           []
         end
@@ -292,7 +291,7 @@ module ActiveRecord
         JoinKeys.new(join_primary_key(association_klass), join_foreign_key)
       end
 
-      def build_scope(table, predicate_builder = predicate_builder(table))
+      def build_scope(table, predicate_builder = predicate_builder(table), klass = self.klass)
         Relation.create(
           klass,
           table: table,
@@ -432,19 +431,18 @@ module ActiveRecord
         @type         = options[:as] && (options[:foreign_type] || "#{options[:as]}_type")
         @foreign_type = options[:polymorphic] && (options[:foreign_type] || "#{name}_type")
         @constructable = calculate_constructable(macro, options)
-        @association_scope_cache = Concurrent::Map.new
 
         if options[:class_name] && options[:class_name].class == Class
           raise ArgumentError, "A class was passed to `:class_name` but we are expecting a string."
         end
       end
 
-      def association_scope_cache(conn, owner, &block)
-        key = conn.prepared_statements
+      def association_scope_cache(klass, owner, &block)
+        key = self
         if polymorphic?
           key = [key, owner._read_attribute(@foreign_type)]
         end
-        @association_scope_cache.compute_if_absent(key) { StatementCache.create(conn, &block) }
+        klass.cached_find_by_statement(key, &block)
       end
 
       def constructable? # :nodoc:
@@ -510,7 +508,7 @@ module ActiveRecord
       # This is for clearing cache on the reflection. Useful for tests that need to compare
       # SQL queries on associations.
       def clear_association_scope_cache # :nodoc:
-        @association_scope_cache.clear
+        klass.initialize_find_by_cache
       end
 
       def nested?
@@ -839,8 +837,8 @@ module ActiveRecord
         source_reflection.scopes + super
       end
 
-      def join_scopes(table, predicate_builder) # :nodoc:
-        source_reflection.join_scopes(table, predicate_builder) + super
+      def join_scopes(table, predicate_builder, klass = self.klass) # :nodoc:
+        source_reflection.join_scopes(table, predicate_builder, klass) + super
       end
 
       def has_scope?
@@ -1003,9 +1001,9 @@ module ActiveRecord
         @previous_reflection = previous_reflection
       end
 
-      def join_scopes(table, predicate_builder) # :nodoc:
+      def join_scopes(table, predicate_builder, klass = self.klass) # :nodoc:
         scopes = @previous_reflection.join_scopes(table, predicate_builder) + super
-        scopes << build_scope(table, predicate_builder).instance_exec(nil, &source_type_scope)
+        scopes << build_scope(table, predicate_builder, klass).instance_exec(nil, &source_type_scope)
       end
 
       def constraints

data/lib/active_record/relation/calculations.rb

@@ -134,7 +134,7 @@ module ActiveRecord
             relation.select_values = [ klass.primary_key || table[Arel.star] ]
           end
           # PostgreSQL: ORDER BY expressions must appear in SELECT list when using DISTINCT
-          relation.order_values = []
+          relation.order_values = [] if group_values.empty?
         end
 
         relation.calculate(operation, column_name)

data/lib/active_record/relation/delegation.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "mutex_m"
+require "active_support/core_ext/module/delegation"
 
 module ActiveRecord
   module Delegation # :nodoc:
@@ -59,7 +60,7 @@ module ActiveRecord
         synchronize do
           return if method_defined?(method)
 
-          if /\A[a-zA-Z_]\w*[!?]?\z/.match?(method)
+          if /\A[a-zA-Z_]\w*[!?]?\z/.match?(method) && !DELEGATION_RESERVED_METHOD_NAMES.include?(method.to_s)
             definition = RUBY_VERSION >= "2.7" ? "..." : "*args, &block"
             module_eval <<-RUBY, __FILE__, __LINE__ + 1
               def #{method}(#{definition})

data/lib/active_record/relation/finder_methods.rb

@@ -371,7 +371,7 @@ module ActiveRecord
 
       def apply_join_dependency(eager_loading: group_values.empty?)
         join_dependency = construct_join_dependency(
-          eager_load_values + includes_values, Arel::Nodes::OuterJoin
+          eager_load_values | includes_values, Arel::Nodes::OuterJoin
         )
         relation = except(:includes, :eager_load, :preload).joins!(join_dependency)
 

data/lib/active_record/relation/merger.rb

@@ -135,11 +135,16 @@ module ActiveRecord
           if other.klass == relation.klass
             relation.left_outer_joins!(*other.left_outer_joins_values)
           else
-            associations = other.left_outer_joins_values
+            associations, others = other.left_outer_joins_values.partition do |join|
+              case join
+              when Hash, Symbol, Array; true
+              end
+            end
+
             join_dependency = other.construct_join_dependency(
               associations, Arel::Nodes::OuterJoin
             )
-            relation.joins!(join_dependency)
+            relation.left_outer_joins!(join_dependency, *others)
           end
         end
 

data/lib/active_record/relation/query_methods.rb

@@ -331,7 +331,7 @@ module ActiveRecord
     def group!(*args) # :nodoc:
       args.flatten!
 
-      self.group_values |= args
+      self.group_values += args
       self
     end
 
@@ -1094,12 +1094,14 @@ module ActiveRecord
         end
       end
 
-      def select_association_list(associations)
+      def select_association_list(associations, stashed_joins = nil)
         result = []
         associations.each do |association|
           case association
           when Hash, Symbol, Array
             result << association
+          when ActiveRecord::Associations::JoinDependency
+            stashed_joins&.<< association
           else
             yield if block_given?
           end
@@ -1107,28 +1109,32 @@ module ActiveRecord
         result
       end
 
-      def valid_association_list(associations)
-        select_association_list(associations) do
+      def valid_association_list(associations, stashed_joins)
+        select_association_list(associations, stashed_joins) do
           raise ArgumentError, "only Hash, Symbol and Array are allowed"
         end
       end
 
       def build_left_outer_joins(manager, outer_joins, aliases)
         buckets = Hash.new { |h, k| h[k] = [] }
-        buckets[:association_join] = valid_association_list(outer_joins)
+        buckets[:association_join] = valid_association_list(outer_joins, buckets[:stashed_join])
         build_join_query(manager, buckets, Arel::Nodes::OuterJoin, aliases)
       end
 
+      class ::Arel::Nodes::LeadingJoin < Arel::Nodes::InnerJoin # :nodoc:
+      end
+
       def build_joins(manager, joins, aliases)
         buckets = Hash.new { |h, k| h[k] = [] }
 
         unless left_outer_joins_values.empty?
-          left_joins = valid_association_list(left_outer_joins_values.flatten)
-          buckets[:stashed_join] << construct_join_dependency(left_joins, Arel::Nodes::OuterJoin)
+          stashed_left_joins = []
+          left_joins = valid_association_list(left_outer_joins_values.flatten, stashed_left_joins)
+          stashed_left_joins.unshift construct_join_dependency(left_joins, Arel::Nodes::OuterJoin)
         end
 
         if joins.last.is_a?(ActiveRecord::Associations::JoinDependency)
-          buckets[:stashed_join] << joins.pop if joins.last.base_klass == klass
+          stashed_eager_load = joins.pop if joins.last.base_klass == klass
         end
 
         joins.map! do |join|
@@ -1141,7 +1147,7 @@ module ActiveRecord
 
         while joins.first.is_a?(Arel::Nodes::Join)
           join_node = joins.shift
-          if join_node.is_a?(Arel::Nodes::StringJoin) && !buckets[:stashed_join].empty?
+          if !join_node.is_a?(Arel::Nodes::LeadingJoin) && (stashed_eager_load || stashed_left_joins)
             buckets[:join_node] << join_node
           else
             buckets[:leading_join] << join_node
@@ -1161,6 +1167,9 @@ module ActiveRecord
           end
         end
 
+        buckets[:stashed_join].concat stashed_left_joins if stashed_left_joins
+        buckets[:stashed_join] << stashed_eager_load if stashed_eager_load
+
         build_join_query(manager, buckets, Arel::Nodes::InnerJoin, aliases)
       end
 
@@ -1356,12 +1365,15 @@ module ActiveRecord
         end
       end
 
-      STRUCTURAL_OR_METHODS = Relation::VALUE_METHODS - [:extending, :where, :having, :unscope, :references]
+      STRUCTURAL_OR_METHODS = Relation::VALUE_METHODS - [:extending, :where, :having, :unscope, :references, :annotate, :optimizer_hints]
       def structurally_incompatible_values_for_or(other)
         values = other.values
         STRUCTURAL_OR_METHODS.reject do |method|
           default = DEFAULT_VALUES[method]
-          @values.fetch(method, default) == values.fetch(method, default)
+          v1, v2 = @values.fetch(method, default), values.fetch(method, default)
+          v1 = v1.uniq if v1.is_a?(Array)
+          v2 = v2.uniq if v2.is_a?(Array)
+          v1 == v2
         end
       end
 

data/lib/active_record/relation.rb

@@ -497,8 +497,8 @@ module ActiveRecord
       update_all updates
     end
 
-    # Touches all records in the current relation without instantiating records first with the +updated_at+/+updated_on+ attributes
-    # set to the current time or the time specified.
+    # Touches all records in the current relation, setting the +updated_at+/+updated_on+ attributes to the current time or the time specified.
+    # It does not instantiate the involved models, and it does not trigger Active Record callbacks or validations.
     # This method can be passed attribute names and an optional time argument.
     # If attribute names are passed, they are updated along with +updated_at+/+updated_on+ attributes.
     # If no time argument is passed, the current time is used as default.
@@ -671,7 +671,10 @@ module ActiveRecord
     end
 
     def scope_for_create
-      where_values_hash.merge!(create_with_value.stringify_keys)
+      hash = where_values_hash
+      hash.delete(klass.inheritance_column) if klass.finder_needs_type_condition?
+      create_with_value.each { |k, v| hash[k.to_s] = v } unless create_with_value.empty?
+      hash
     end
 
     # Returns true if relation needs eager loading.

data/lib/active_record/scoping/named.rb

@@ -200,11 +200,16 @@ module ActiveRecord
               scope
             end
           end
+          singleton_class.send(:ruby2_keywords, name) if respond_to?(:ruby2_keywords, true)
 
           generate_relation_method(name)
         end
 
         private
+          def singleton_method_added(name)
+            generate_relation_method(name) if Kernel.respond_to?(name) && !ActiveRecord::Relation.method_defined?(name)
+          end
+
           def valid_scope_name?(name)
             if respond_to?(name, true) && logger
               logger.warn "Creating scope :#{name}. " \

data/lib/active_record/test_fixtures.rb

@@ -112,6 +112,8 @@ module ActiveRecord
 
       # Load fixtures once and begin transaction.
       if run_in_transaction?
+        @saved_pool_configs = Hash.new { |hash, key| hash[key] = {} }
+
         if @@already_loaded_fixtures[self.class]
           @loaded_fixtures = @@already_loaded_fixtures[self.class]
         else
@@ -166,6 +168,7 @@ module ActiveRecord
           connection.pool.lock_thread = false
         end
         @fixture_connections.clear
+        teardown_shared_connection_pool
       else
         ActiveRecord::FixtureSet.reset_cache
       end
@@ -187,7 +190,7 @@ module ActiveRecord
       # need to share a connection pool so that the reading connection
       # can see data in the open transaction on the writing connection.
       def setup_shared_connection_pool
-        writing_handler = ActiveRecord::Base.connection_handler
+        writing_handler = ActiveRecord::Base.connection_handlers[ActiveRecord::Base.writing_role]
 
         ActiveRecord::Base.connection_handlers.values.each do |handler|
           if handler != writing_handler
@@ -195,12 +198,27 @@ module ActiveRecord
               name = pool.spec.name
               writing_connection = writing_handler.retrieve_connection_pool(name)
               return unless writing_connection
+
+              reading_connection = handler.send(:owner_to_pool)[name]
+              next if reading_connection == writing_connection
+
+              @saved_pool_configs[handler][name] = reading_connection
               handler.send(:owner_to_pool)[name] = writing_connection
             end
           end
         end
       end
 
+      def teardown_shared_connection_pool
+        @saved_pool_configs.each_pair do |handler, pools|
+          pools.each_pair do |name, pool|
+            handler.send(:owner_to_pool)[name] = pool
+          end
+        end
+
+        @saved_pool_configs.clear
+      end
+
       def load_fixtures(config)
         fixtures = ActiveRecord::FixtureSet.create_fixtures(fixture_path, fixture_table_names, fixture_class_names, config)
         Hash[fixtures.map { |f| [f.name, f] }]

data/lib/active_record/type/time.rb

@@ -16,6 +16,16 @@ module ActiveRecord
           value
         end
       end
+
+      private
+        def cast_value(value)
+          case value = super
+          when Value
+            value.__getobj__
+          else
+            value
+          end
+        end
     end
   end
 end

data/lib/active_record/validations/associated.rb

@@ -5,7 +5,7 @@ module ActiveRecord
     class AssociatedValidator < ActiveModel::EachValidator #:nodoc:
       def validate_each(record, attribute, value)
         if Array(value).reject { |r| valid_object?(r) }.any?
-          record.errors.add(attribute, :invalid, **options.merge(value: value))
+          record.errors.add(attribute, :invalid, options.merge(value: value))
         end
       end