activerecord 6.0.3.4 → 6.1.2

data/lib/active_record/nested_attributes.rb

@@ -2,7 +2,6 @@
 
 require "active_support/core_ext/hash/except"
 require "active_support/core_ext/module/redefine_method"
-require "active_support/core_ext/object/try"
 require "active_support/core_ext/hash/indifferent_access"
 
 module ActiveRecord
@@ -289,7 +288,7 @@ module ActiveRecord
       # [:allow_destroy]
       #   If true, destroys any members from the attributes hash with a
       #   <tt>_destroy</tt> key and a value that evaluates to +true+
-      #   (eg. 1, '1', true, or 'true'). This option is off by default.
+      #   (e.g. 1, '1', true, or 'true'). This option is off by default.
       # [:reject_if]
       #   Allows you to specify a Proc or a Symbol pointing to a method
       #   that checks whether a record should be built for a certain attribute
@@ -510,7 +509,7 @@ module ActiveRecord
               if target_record
                 existing_record = target_record
               else
-                association.add_to_target(existing_record, :skip_callbacks)
+                association.add_to_target(existing_record, skip_callbacks: true)
               end
 
               assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])

data/lib/active_record/no_touching.rb

@@ -54,7 +54,7 @@ module ActiveRecord
       NoTouching.applied_to?(self.class)
     end
 
-    def touch_later(*, **) # :nodoc:
+    def touch_later(*) # :nodoc:
       super unless no_touching?
     end
 

data/lib/active_record/persistence.rb

@@ -414,8 +414,8 @@ module ActiveRecord
 
         def _substitute_values(values)
           values.map do |name, value|
-            attr = arel_attribute(name)
-            bind = predicate_builder.build_bind_attribute(name, value)
+            attr = arel_table[name]
+            bind = predicate_builder.build_bind_attribute(attr.name, value)
             [attr, bind]
           end
         end
@@ -424,26 +424,30 @@ module ActiveRecord
     # Returns true if this object hasn't been saved yet -- that is, a record
     # for the object doesn't exist in the database yet; otherwise, returns false.
     def new_record?
-      sync_with_transaction_state if @transaction_state&.finalized?
       @new_record
     end
 
+    # Returns true if this object was just created -- that is, prior to the last
+    # save, the object didn't exist in the database and new_record? would have
+    # returned true.
+    def previously_new_record?
+      @previously_new_record
+    end
+
     # Returns true if this object has been destroyed, otherwise returns false.
     def destroyed?
-      sync_with_transaction_state if @transaction_state&.finalized?
       @destroyed
     end
 
     # Returns true if the record is persisted, i.e. it's not a new record and it was
     # not destroyed, otherwise returns false.
     def persisted?
-      sync_with_transaction_state if @transaction_state&.finalized?
       !(@new_record || @destroyed)
     end
 
     ##
     # :call-seq:
-    #   save(*args)
+    #   save(**options)
     #
     # Saves the model.
     #
@@ -466,15 +470,15 @@ module ActiveRecord
     #
     # Attributes marked as readonly are silently ignored if the record is
     # being updated.
-    def save(*args, **options, &block)
-      create_or_update(*args, **options, &block)
+    def save(**options, &block)
+      create_or_update(**options, &block)
     rescue ActiveRecord::RecordInvalid
       false
     end
 
     ##
     # :call-seq:
-    #   save!(*args)
+    #   save!(**options)
     #
     # Saves the model.
     #
@@ -499,8 +503,8 @@ module ActiveRecord
     # being updated.
     #
     # Unless an error is raised, returns true.
-    def save!(*args, **options, &block)
-      create_or_update(*args, **options, &block) || raise(RecordNotSaved.new("Failed to save the record", self))
+    def save!(**options, &block)
+      create_or_update(**options, &block) || raise(RecordNotSaved.new("Failed to save the record", self))
     end
 
     # Deletes the record in the database and freezes this instance to
@@ -514,7 +518,7 @@ module ActiveRecord
     #
     # To enforce the object's +before_destroy+ and +after_destroy+
     # callbacks or any <tt>:dependent</tt> association
-    # options, use <tt>#destroy</tt>.
+    # options, use #destroy.
     def delete
       _delete_row if persisted?
       @destroyed = true
@@ -565,12 +569,15 @@ module ActiveRecord
     # If you want to change the sti column as well, use #becomes! instead.
     def becomes(klass)
       became = klass.allocate
-      became.send(:initialize)
-      became.instance_variable_set("@attributes", @attributes)
-      became.instance_variable_set("@mutations_from_database", @mutations_from_database ||= nil)
-      became.instance_variable_set("@new_record", new_record?)
-      became.instance_variable_set("@destroyed", destroyed?)
-      became.errors.copy!(errors)
+
+      became.send(:initialize) do |becoming|
+        becoming.instance_variable_set(:@attributes, @attributes)
+        becoming.instance_variable_set(:@mutations_from_database, @mutations_from_database ||= nil)
+        becoming.instance_variable_set(:@new_record, new_record?)
+        becoming.instance_variable_set(:@destroyed, destroyed?)
+        becoming.errors.copy!(errors)
+      end
+
       became
     end
 
@@ -622,9 +629,6 @@ module ActiveRecord
       end
     end
 
-    alias update_attributes update
-    deprecate update_attributes: "please, use update instead"
-
     # Updates its receiver just like #update but calls #save! instead
     # of +save+, so an exception is raised if the record is invalid and saving will fail.
     def update!(attributes)
@@ -636,9 +640,6 @@ module ActiveRecord
       end
     end
 
-    alias update_attributes! update!
-    deprecate update_attributes!: "please, use update! instead"
-
     # Equivalent to <code>update_columns(name => value)</code>.
     def update_column(name, value)
       update_columns(name => value)
@@ -666,11 +667,8 @@ module ActiveRecord
 
       attributes = attributes.transform_keys do |key|
         name = key.to_s
-        self.class.attribute_aliases[name] || name
-      end
-
-      attributes.each_key do |key|
-        verify_readonly_attribute(key)
+        name = self.class.attribute_aliases[name] || name
+        verify_readonly_attribute(name) || name
       end
 
       id_in_database = self.id_in_database
@@ -703,9 +701,9 @@ module ActiveRecord
     # Returns +self+.
     def increment!(attribute, by = 1, touch: nil)
       increment(attribute, by)
-      change = public_send(attribute) - (attribute_in_database(attribute.to_s) || 0)
+      change = public_send(attribute) - (public_send(:"#{attribute}_in_database") || 0)
       self.class.update_counters(id, attribute => change, touch: touch)
-      clear_attribute_change(attribute) # eww
+      public_send(:"clear_#{attribute}_change")
       self
     end
 
@@ -809,8 +807,9 @@ module ActiveRecord
           self.class.unscoped { self.class.find(id) }
         end
 
-      @attributes = fresh_object.instance_variable_get("@attributes")
+      @attributes = fresh_object.instance_variable_get(:@attributes)
       @new_record = false
+      @previously_new_record = false
       self
     end
 
@@ -849,17 +848,13 @@ module ActiveRecord
     #   ball.touch(:updated_at)   # => raises ActiveRecordError
     #
     def touch(*names, time: nil)
-      unless persisted?
-        raise ActiveRecordError, <<-MSG.squish
-          cannot touch on a new or destroyed record object. Consider using
-          persisted?, new_record?, or destroyed? before touching
-        MSG
-      end
+      _raise_record_not_touched_error unless persisted?
 
       attribute_names = timestamp_attributes_for_update_in_model
-      attribute_names |= names.map!(&:to_s).map! { |name|
+      attribute_names |= names.map! do |name|
+        name = name.to_s
         self.class.attribute_aliases[name] || name
-      }
+      end unless names.empty?
 
       unless attribute_names.empty?
         affected_rows = _touch_row(attribute_names, time)
@@ -919,6 +914,8 @@ module ActiveRecord
         @_trigger_update_callback = affected_rows == 1
       end
 
+      @previously_new_record = false
+
       yield(self) if block_given?
 
       affected_rows
@@ -936,6 +933,7 @@ module ActiveRecord
       self.id ||= new_id if @primary_key
 
       @new_record = false
+      @previously_new_record = true
 
       yield(self) if block_given?
 
@@ -943,7 +941,7 @@ module ActiveRecord
     end
 
     def verify_readonly_attribute(name)
-      raise ActiveRecordError, "#{name} is marked as readonly" if self.class.readonly_attributes.include?(name)
+      raise ActiveRecordError, "#{name} is marked as readonly" if self.class.readonly_attribute?(name)
     end
 
     def _raise_record_not_destroyed
@@ -953,14 +951,21 @@ module ActiveRecord
       @_association_destroy_exception = nil
     end
 
+    def _raise_readonly_record_error
+      raise ReadOnlyRecord, "#{self.class} is marked as readonly"
+    end
+
+    def _raise_record_not_touched_error
+      raise ActiveRecordError, <<~MSG.squish
+        Cannot touch on a new or destroyed record object. Consider using
+        persisted?, new_record?, or destroyed? before touching.
+      MSG
+    end
+
     # The name of the method used to touch a +belongs_to+ association when the
     # +:touch+ option is used.
     def belongs_to_touch_method
       :touch
     end
-
-    def _raise_readonly_record_error
-      raise ReadOnlyRecord, "#{self.class} is marked as readonly"
-    end
   end
 end

data/lib/active_record/query_cache.rb

@@ -28,18 +28,28 @@ module ActiveRecord
     def self.run
       pools = []
 
-      ActiveRecord::Base.connection_handlers.each do |key, handler|
-        pools << handler.connection_pool_list.reject { |p| p.query_cache_enabled }.each { |p| p.enable_query_cache! }
+      if ActiveRecord::Base.legacy_connection_handling
+        ActiveRecord::Base.connection_handlers.each do |key, handler|
+          pools.concat(handler.connection_pool_list.reject { |p| p.query_cache_enabled }.each { |p| p.enable_query_cache! })
+        end
+      else
+        pools.concat(ActiveRecord::Base.connection_handler.all_connection_pools.reject { |p| p.query_cache_enabled }.each { |p| p.enable_query_cache! })
       end
 
-      pools.flatten
+      pools
     end
 
     def self.complete(pools)
       pools.each { |pool| pool.disable_query_cache! }
 
-      ActiveRecord::Base.connection_handlers.each do |_, handler|
-        handler.connection_pool_list.each do |pool|
+      if ActiveRecord::Base.legacy_connection_handling
+        ActiveRecord::Base.connection_handlers.each do |_, handler|
+          handler.connection_pool_list.each do |pool|
+            pool.release_connection if pool.active_connection? && !pool.connection.transaction_open?
+          end
+        end
+      else
+        ActiveRecord::Base.connection_handler.all_connection_pools.each do |pool|
           pool.release_connection if pool.active_connection? && !pool.connection.transaction_open?
         end
       end

data/lib/active_record/querying.rb

@@ -13,10 +13,11 @@ module ActiveRecord
       :destroy_all, :delete_all, :update_all, :touch_all, :destroy_by, :delete_by,
       :find_each, :find_in_batches, :in_batches,
       :select, :reselect, :order, :reorder, :group, :limit, :offset, :joins, :left_joins, :left_outer_joins,
-      :where, :rewhere, :preload, :extract_associated, :eager_load, :includes, :from, :lock, :readonly, :extending, :or,
-      :having, :create_with, :distinct, :references, :none, :unscope, :optimizer_hints, :merge, :except, :only,
-      :count, :average, :minimum, :maximum, :sum, :calculate, :annotate,
-      :pluck, :pick, :ids
+      :where, :rewhere, :preload, :extract_associated, :eager_load, :includes, :from, :lock, :readonly,
+      :and, :or, :annotate, :optimizer_hints, :extending,
+      :having, :create_with, :distinct, :references, :none, :unscope, :merge, :except, :only,
+      :count, :average, :minimum, :maximum, :sum, :calculate,
+      :pluck, :pick, :ids, :strict_loading
     ].freeze # :nodoc:
     delegate(*QUERYING_METHODS, to: :all)
 
@@ -44,8 +45,12 @@ module ActiveRecord
     #   Post.find_by_sql ["SELECT body FROM comments WHERE author = :user_id OR approved_by = :user_id", { :user_id => user_id }]
     def find_by_sql(sql, binds = [], preparable: nil, &block)
       result_set = connection.select_all(sanitize_sql(sql), "#{name} Load", binds, preparable: preparable)
-      column_types = result_set.column_types.dup
-      attribute_types.each_key { |k| column_types.delete k }
+      column_types = result_set.column_types
+
+      unless column_types.empty?
+        column_types = column_types.reject { |k, _| attribute_types.key?(k) }
+      end
+
       message_bus = ActiveSupport::Notifications.instrumenter
 
       payload = {

data/lib/active_record/railtie.rb

@@ -2,6 +2,7 @@
 
 require "active_record"
 require "rails"
+require "active_support/core_ext/object/try"
 require "active_model/railtie"
 
 # For now, action_controller must always be present with
@@ -26,18 +27,17 @@ module ActiveRecord
     )
 
     config.active_record.use_schema_cache_dump = true
+    config.active_record.check_schema_cache_dump_version = true
     config.active_record.maintain_test_schema = true
+    config.active_record.has_many_inversing = false
 
-    config.active_record.sqlite3 = ActiveSupport::OrderedOptions.new
-    config.active_record.sqlite3.represent_boolean_as_integer = nil
+    config.active_record.queues = ActiveSupport::InheritableOptions.new
 
     config.eager_load_namespaces << ActiveRecord
 
     rake_tasks do
       namespace :db do
         task :load_config do
-          ActiveRecord::Tasks::DatabaseTasks.database_configuration = Rails.application.config.database_configuration
-
           if defined?(ENGINE_ROOT) && engine = Rails::Engine.find(ENGINE_ROOT)
             if engine.paths["db/migrate"].existent
               ActiveRecord::Tasks::DatabaseTasks.migrations_paths += engine.paths["db/migrate"].to_a
@@ -57,6 +57,7 @@ module ActiveRecord
       require "active_record/base"
       unless ActiveSupport::Logger.logger_outputs_to?(Rails.logger, STDERR, STDOUT)
         console = ActiveSupport::Logger.new(STDERR)
+        console.level = Rails.logger.level
         Rails.logger.extend ActiveSupport::Logger.broadcast console
       end
       ActiveRecord::Base.verbose_query_logs = false
@@ -81,10 +82,11 @@ module ActiveRecord
       ActiveSupport.on_load(:active_record) { LogSubscriber.backtrace_cleaner = ::Rails.backtrace_cleaner }
     end
 
-    initializer "active_record.migration_error" do
+    initializer "active_record.migration_error" do |app|
       if config.active_record.delete(:migration_error) == :page_load
         config.app_middleware.insert_after ::ActionDispatch::Callbacks,
-          ActiveRecord::Migration::CheckPending
+          ActiveRecord::Migration::CheckPending,
+          file_watcher: app.config.file_watcher
       end
     end
 
@@ -122,23 +124,37 @@ To keep using the current cache store, you can turn off cache versioning entirel
     end
 
     initializer "active_record.check_schema_cache_dump" do
+      check_schema_cache_dump_version = config.active_record.delete(:check_schema_cache_dump_version)
+
       if config.active_record.delete(:use_schema_cache_dump)
         config.after_initialize do |app|
           ActiveSupport.on_load(:active_record) do
-            filename = File.join(app.config.paths["db"].first, "schema_cache.yml")
-
-            if File.file?(filename)
-              current_version = ActiveRecord::Migrator.current_version
-
+            db_config = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env).first
+
+            filename = ActiveRecord::Tasks::DatabaseTasks.cache_dump_filename(
+              db_config.name,
+              schema_cache_path: db_config&.schema_cache_path
+            )
+
+            cache = ActiveRecord::ConnectionAdapters::SchemaCache.load_from(filename)
+            next if cache.nil?
+
+            if check_schema_cache_dump_version
+              current_version = begin
+                ActiveRecord::Migrator.current_version
+              rescue ActiveRecordError => error
+                warn "Failed to validate the schema cache because of #{error.class}: #{error.message}"
+                nil
+              end
               next if current_version.nil?
 
-              cache = YAML.load(File.read(filename))
-              if cache.version == current_version
-                connection_pool.schema_cache = cache.dup
-              else
-                warn "Ignoring db/schema_cache.yml because it has expired. The current schema version is #{current_version}, but the one in the cache is #{cache.version}."
+              if cache.version != current_version
+                warn "Ignoring #{filename} because it has expired. The current schema version is #{current_version}, but the one in the cache is #{cache.version}."
+                next
               end
             end
+
+            connection_pool.set_schema_cache(cache)
           end
         end
       end
@@ -148,16 +164,29 @@ To keep using the current cache store, you can turn off cache versioning entirel
       config.after_initialize do
         ActiveSupport.on_load(:active_record) do
           if app.config.eager_load
-            descendants.each do |model|
-              # SchemaMigration and InternalMetadata both override `table_exists?`
-              # to bypass the schema cache, so skip them to avoid the extra queries.
-              next if model._internal?
-
-              # If there's no connection yet, or the schema cache doesn't have the columns
-              # hash for the model cached, `define_attribute_methods` would trigger a query.
-              next unless model.connected? && model.connection.schema_cache.columns_hash?(model.table_name)
-
-              model.define_attribute_methods
+            begin
+              descendants.each do |model|
+                # SchemaMigration and InternalMetadata both override `table_exists?`
+                # to bypass the schema cache, so skip them to avoid the extra queries.
+                next if model._internal?
+
+                # If the schema cache was loaded from a dump, we can use it without connecting
+                schema_cache = model.connection_pool.schema_cache
+
+                # If there's no connection yet, we avoid connecting.
+                schema_cache ||= model.connected? && model.connection.schema_cache
+
+                # If the schema cache doesn't have the columns
+                # hash for the model cached, `define_attribute_methods` would trigger a query.
+                if schema_cache && schema_cache.columns_hash?(model.table_name)
+                  model.define_attribute_methods
+                end
+              end
+            rescue ActiveRecordError => error
+              # Regardless of whether there was already a connection or not, we rescue any database
+              # error because it is critical that the application can boot even if the database
+              # is unhealthy.
+              warn "Failed to define attribute methods because of #{error.class}: #{error.message}"
             end
           end
         end
@@ -176,16 +205,6 @@ To keep using the current cache store, you can turn off cache versioning entirel
       ActiveSupport.on_load(:active_record) do
         configs = app.config.active_record
 
-        represent_boolean_as_integer = configs.sqlite3.delete(:represent_boolean_as_integer)
-
-        unless represent_boolean_as_integer.nil?
-          ActiveSupport.on_load(:active_record_sqlite3adapter) do
-            ActiveRecord::ConnectionAdapters::SQLite3Adapter.represent_boolean_as_integer = represent_boolean_as_integer
-          end
-        end
-
-        configs.delete(:sqlite3)
-
         configs.each do |k, v|
           send "#{k}=", v
         end
@@ -196,7 +215,9 @@ To keep using the current cache store, you can turn off cache versioning entirel
     # and then establishes the connection.
     initializer "active_record.initialize_database" do
       ActiveSupport.on_load(:active_record) do
-        self.connection_handlers = { writing_role => ActiveRecord::Base.default_connection_handler }
+        if ActiveRecord::Base.legacy_connection_handling
+          self.connection_handlers = { writing_role => ActiveRecord::Base.default_connection_handler }
+        end
         self.configurations = Rails.application.config.database_configuration
         establish_connection
       end
@@ -210,13 +231,6 @@ To keep using the current cache store, you can turn off cache versioning entirel
       end
     end
 
-    initializer "active_record.collection_cache_association_loading" do
-      require "active_record/railties/collection_cache_association_loading"
-      ActiveSupport.on_load(:action_view) do
-        ActionView::PartialRenderer.prepend(ActiveRecord::Railties::CollectionCacheAssociationLoading)
-      end
-    end
-
     initializer "active_record.set_reloader_hooks" do
       ActiveSupport.on_load(:active_record) do
         ActiveSupport::Reloader.before_class_unload do
@@ -259,5 +273,11 @@ To keep using the current cache store, you can turn off cache versioning entirel
         self.filter_attributes += Rails.application.config.filter_parameters
       end
     end
+
+    initializer "active_record.set_signed_id_verifier_secret" do
+      ActiveSupport.on_load(:active_record) do
+        self.signed_id_verifier_secret ||= -> { Rails.application.key_generator.generate_key("active_record/signed_id") }
+      end
+    end
   end
 end