activerecord 6.1.7.4 → 7.0.6

data/lib/active_record/insert_all.rb

@@ -5,13 +5,19 @@ require "active_support/core_ext/enumerable"
 module ActiveRecord
   class InsertAll # :nodoc:
     attr_reader :model, :connection, :inserts, :keys
-    attr_reader :on_duplicate, :returning, :unique_by
+    attr_reader :on_duplicate, :update_only, :returning, :unique_by, :update_sql
 
-    def initialize(model, inserts, on_duplicate:, returning: nil, unique_by: nil)
+    def initialize(model, inserts, on_duplicate:, update_only: nil, returning: nil, unique_by: nil, record_timestamps: nil)
       raise ArgumentError, "Empty list of attributes passed" if inserts.blank?
 
       @model, @connection, @inserts, @keys = model, model.connection, inserts, inserts.first.keys.map(&:to_s)
-      @on_duplicate, @returning, @unique_by = on_duplicate, returning, unique_by
+      @on_duplicate, @update_only, @returning, @unique_by = on_duplicate, update_only, returning, unique_by
+      @record_timestamps = record_timestamps.nil? ? model.record_timestamps : record_timestamps
+
+      disallow_raw_sql!(on_duplicate)
+      disallow_raw_sql!(returning)
+
+      configure_on_duplicate_update_logic
 
       if model.scope_attributes?
         @scope_attributes = model.scope_attributes
@@ -36,7 +42,7 @@ module ActiveRecord
     end
 
     def updatable_columns
-      keys - readonly_columns - unique_by_columns
+      @updatable_columns ||= keys - readonly_columns - unique_by_columns
     end
 
     def primary_keys
@@ -56,18 +62,50 @@ module ActiveRecord
       inserts.map do |attributes|
         attributes = attributes.stringify_keys
         attributes.merge!(scope_attributes) if scope_attributes
+        attributes.reverse_merge!(timestamps_for_create) if record_timestamps?
 
         verify_attributes(attributes)
 
-        keys.map do |key|
+        keys_including_timestamps.map do |key|
           yield key, attributes[key]
         end
       end
     end
 
+    def record_timestamps?
+      @record_timestamps
+    end
+
+    # TODO: Consider remaining this method, as it only conditionally extends keys, not always
+    def keys_including_timestamps
+      @keys_including_timestamps ||= if record_timestamps?
+        keys + model.all_timestamp_attributes_in_model
+      else
+        keys
+      end
+    end
+
     private
       attr_reader :scope_attributes
 
+      def configure_on_duplicate_update_logic
+        if custom_update_sql_provided? && update_only.present?
+          raise ArgumentError, "You can't set :update_only and provide custom update SQL via :on_duplicate at the same time"
+        end
+
+        if update_only.present?
+          @updatable_columns = Array(update_only)
+          @on_duplicate = :update
+        elsif custom_update_sql_provided?
+          @update_sql = on_duplicate
+          @on_duplicate = :update
+        end
+      end
+
+      def custom_update_sql_provided?
+        @custom_update_sql_provided ||= Arel.arel_node?(on_duplicate)
+      end
+
       def find_unique_index_for(unique_by)
         if !connection.supports_insert_conflict_target?
           return if unique_by.nil?
@@ -126,15 +164,28 @@ module ActiveRecord
 
 
       def verify_attributes(attributes)
-        if keys != attributes.keys.to_set
+        if keys_including_timestamps != attributes.keys.to_set
           raise ArgumentError, "All objects being inserted must have the same keys"
         end
       end
 
+      def disallow_raw_sql!(value)
+        return if !value.is_a?(String) || Arel.arel_node?(value)
+
+        raise ArgumentError, "Dangerous query method (method whose arguments are used as raw " \
+                             "SQL) called: #{value}. " \
+                             "Known-safe values can be passed " \
+                             "by wrapping them in Arel.sql()."
+      end
+
+      def timestamps_for_create
+        model.all_timestamp_attributes_in_model.index_with(connection.high_precision_current_timestamp)
+      end
+
       class Builder # :nodoc:
         attr_reader :model
 
-        delegate :skip_duplicates?, :update_duplicates?, :keys, to: :insert_all
+        delegate :skip_duplicates?, :update_duplicates?, :keys, :keys_including_timestamps, :record_timestamps?, to: :insert_all
 
         def initialize(insert_all)
           @insert_all, @model, @connection = insert_all, insert_all.model, insert_all.connection
@@ -145,9 +196,10 @@ module ActiveRecord
         end
 
         def values_list
-          types = extract_types_from_columns_on(model.table_name, keys: keys)
+          types = extract_types_from_columns_on(model.table_name, keys: keys_including_timestamps)
 
           values_list = insert_all.map_key_with_value do |key, value|
+            next value if Arel::Nodes::SqlLiteral === value
             connection.with_yaml_fallback(types[key].serialize(value))
           end
 
@@ -155,7 +207,13 @@ module ActiveRecord
         end
 
         def returning
-          format_columns(insert_all.returning) if insert_all.returning
+          return unless insert_all.returning
+
+          if insert_all.returning.is_a?(String)
+            insert_all.returning
+          else
+            format_columns(insert_all.returning)
+          end
         end
 
         def conflict_target
@@ -173,22 +231,30 @@ module ActiveRecord
         end
 
         def touch_model_timestamps_unless(&block)
-          model.send(:timestamp_attributes_for_update_in_model).map do |column_name|
+          return "" unless update_duplicates? && record_timestamps?
+
+          model.timestamp_attributes_for_update_in_model.filter_map do |column_name|
             if touch_timestamp_attribute?(column_name)
-              "#{column_name}=(CASE WHEN (#{updatable_columns.map(&block).join(" AND ")}) THEN #{model.quoted_table_name}.#{column_name} ELSE CURRENT_TIMESTAMP END),"
+              "#{column_name}=(CASE WHEN (#{updatable_columns.map(&block).join(" AND ")}) THEN #{model.quoted_table_name}.#{column_name} ELSE #{connection.high_precision_current_timestamp} END),"
             end
-          end.compact.join
+          end.join
         end
 
+        def raw_update_sql
+          insert_all.update_sql
+        end
+
+        alias raw_update_sql? raw_update_sql
+
         private
           attr_reader :connection, :insert_all
 
           def touch_timestamp_attribute?(column_name)
-            update_duplicates? && !insert_all.updatable_columns.include?(column_name)
+            insert_all.updatable_columns.exclude?(column_name)
           end
 
           def columns_list
-            format_columns(insert_all.keys)
+            format_columns(insert_all.keys_including_timestamps)
           end
 
           def extract_types_from_columns_on(table_name, keys:)

data/lib/active_record/integration.rb

@@ -79,7 +79,7 @@ module ActiveRecord
           timestamp = max_updated_column_timestamp
 
           if timestamp
-            timestamp = timestamp.utc.to_s(cache_timestamp_format)
+            timestamp = timestamp.utc.to_fs(cache_timestamp_format)
             "#{model_name.cache_key}/#{id}-#{timestamp}"
           else
             "#{model_name.cache_key}/#{id}"
@@ -101,8 +101,9 @@ module ActiveRecord
         timestamp = updated_at_before_type_cast
         if can_use_fast_cache_version?(timestamp)
           raw_timestamp_to_cache_version(timestamp)
+
         elsif timestamp = updated_at
-          timestamp.utc.to_s(cache_timestamp_format)
+          timestamp.utc.to_fs(cache_timestamp_format)
         end
       elsif self.class.has_attribute?("updated_at")
         raise ActiveModel::MissingAttributeError, "missing attribute: updated_at"
@@ -177,7 +178,7 @@ module ActiveRecord
       def can_use_fast_cache_version?(timestamp)
         timestamp.is_a?(String) &&
           cache_timestamp_format == :usec &&
-          default_timezone == :utc &&
+          ActiveRecord.default_timezone == :utc &&
           !updated_at_came_from_user?
       end
 

data/lib/active_record/internal_metadata.rb

@@ -17,10 +17,6 @@ module ActiveRecord
         ActiveRecord::Base.connection.use_metadata_table?
       end
 
-      def _internal?
-        true
-      end
-
       def primary_key
         "key"
       end
@@ -38,7 +34,7 @@ module ActiveRecord
       def [](key)
         return unless enabled?
 
-        where(key: key).pluck(:value).first
+        where(key: key).pick(:value)
       end
 
       # Creates an internal metadata table with columns +key+ and +value+

data/lib/active_record/legacy_yaml_adapter.rb

@@ -2,50 +2,13 @@
 
 module ActiveRecord
   module LegacyYamlAdapter # :nodoc:
-    def self.convert(klass, coder)
+    def self.convert(coder)
       return coder unless coder.is_a?(Psych::Coder)
 
       case coder["active_record_yaml_version"]
       when 1, 2 then coder
       else
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          YAML loading from legacy format older than Rails 5.0 is deprecated
-          and will be removed in Rails 7.0.
-        MSG
-        if coder["attributes"].is_a?(ActiveModel::AttributeSet)
-          Rails420.convert(klass, coder)
-        else
-          Rails41.convert(klass, coder)
-        end
-      end
-    end
-
-    module Rails420 # :nodoc:
-      def self.convert(klass, coder)
-        attribute_set = coder["attributes"]
-
-        klass.attribute_names.each do |attr_name|
-          attribute = attribute_set[attr_name]
-          if attribute.type.is_a?(Delegator)
-            type_from_klass = klass.type_for_attribute(attr_name)
-            attribute_set[attr_name] = attribute.with_type(type_from_klass)
-          end
-        end
-
-        coder
-      end
-    end
-
-    module Rails41 # :nodoc:
-      def self.convert(klass, coder)
-        attributes = klass.attributes_builder
-          .build_from_database(coder["attributes"])
-        new_record = coder["attributes"][klass.primary_key].blank?
-
-        {
-          "attributes" => attributes,
-          "new_record" => new_record,
-        }
+        raise("Active Record doesn't know how to load YAML with this format.")
       end
     end
   end

data/lib/active_record/locking/optimistic.rb

@@ -2,14 +2,14 @@
 
 module ActiveRecord
   module Locking
-    # == What is Optimistic Locking
+    # == What is \Optimistic \Locking
     #
     # Optimistic locking allows multiple users to access the same record for edits, and assumes a minimum of
     # conflicts with the data. It does this by checking whether another process has made changes to a record since
-    # it was opened, an <tt>ActiveRecord::StaleObjectError</tt> exception is thrown if that has occurred
+    # it was opened, an ActiveRecord::StaleObjectError exception is thrown if that has occurred
     # and the update is ignored.
     #
-    # Check out <tt>ActiveRecord::Locking::Pessimistic</tt> for an alternative.
+    # Check out +ActiveRecord::Locking::Pessimistic+ for an alternative.
     #
     # == Usage
     #
@@ -56,11 +56,11 @@ module ActiveRecord
         class_attribute :lock_optimistically, instance_writer: false, default: true
       end
 
-      def locking_enabled? #:nodoc:
+      def locking_enabled? # :nodoc:
         self.class.locking_enabled?
       end
 
-      def increment!(*, **) #:nodoc:
+      def increment!(*, **) # :nodoc:
         super.tap do
           if locking_enabled?
             self[self.class.locking_column] += 1
@@ -69,6 +69,11 @@ module ActiveRecord
         end
       end
 
+      def initialize_dup(other) # :nodoc:
+        super
+        _clear_locking_column if locking_enabled?
+      end
+
       private
         def _create_record(attribute_names = self.attribute_names)
           if locking_enabled?
@@ -90,7 +95,8 @@ module ActiveRecord
           begin
             locking_column = self.class.locking_column
             lock_attribute_was = @attributes[locking_column]
-            lock_value_for_database = _lock_value_for_database(locking_column)
+
+            update_constraints = _query_constraints_hash
 
             attribute_names = attribute_names.dup if attribute_names.frozen?
             attribute_names << locking_column
@@ -99,8 +105,7 @@ module ActiveRecord
 
             affected_rows = self.class._update_record(
               attributes_with_values(attribute_names),
-              @primary_key => id_in_database,
-              locking_column => lock_value_for_database
+              update_constraints
             )
 
             if affected_rows != 1
@@ -117,16 +122,9 @@ module ActiveRecord
         end
 
         def destroy_row
-          return super unless locking_enabled?
+          affected_rows = super
 
-          locking_column = self.class.locking_column
-
-          affected_rows = self.class._delete_record(
-            @primary_key => id_in_database,
-            locking_column => _lock_value_for_database(locking_column)
-          )
-
-          if affected_rows != 1
+          if locking_enabled? && affected_rows != 1
             raise ActiveRecord::StaleObjectError.new(self, "destroy")
           end
 
@@ -141,6 +139,18 @@ module ActiveRecord
           end
         end
 
+        def _clear_locking_column
+          self[self.class.locking_column] = nil
+          clear_attribute_change(self.class.locking_column)
+        end
+
+        def _query_constraints_hash
+          return super unless locking_enabled?
+
+          locking_column = self.class.locking_column
+          super.merge(locking_column => _lock_value_for_database(locking_column))
+        end
+
         module ClassMethods
           DEFAULT_LOCKING_COLUMN = "lock_version"
 
@@ -158,10 +168,7 @@ module ActiveRecord
           end
 
           # The version column used for optimistic locking. Defaults to +lock_version+.
-          def locking_column
-            @locking_column = DEFAULT_LOCKING_COLUMN unless defined?(@locking_column)
-            @locking_column
-          end
+          attr_reader :locking_column
 
           # Reset the column used for optimistic locking back to the +lock_version+ default.
           def reset_locking_column
@@ -181,6 +188,14 @@ module ActiveRecord
             end
             super
           end
+
+          private
+            def inherited(base)
+              super
+              base.class_eval do
+                @locking_column = DEFAULT_LOCKING_COLUMN
+              end
+            end
         end
     end
 

data/lib/active_record/locking/pessimistic.rb

@@ -5,7 +5,7 @@ module ActiveRecord
     # Locking::Pessimistic provides support for row-level locking using
     # SELECT ... FOR UPDATE and other lock types.
     #
-    # Chain <tt>ActiveRecord::Base#find</tt> to <tt>ActiveRecord::QueryMethods#lock</tt> to obtain an exclusive
+    # Chain <tt>ActiveRecord::Base#find</tt> to ActiveRecord::QueryMethods#lock to obtain an exclusive
     # lock on the selected rows:
     #   # select * from accounts where id=1 for update
     #   Account.lock.find(1)
@@ -81,9 +81,15 @@ module ActiveRecord
 
       # Wraps the passed block in a transaction, locking the object
       # before yielding. You can pass the SQL locking clause
-      # as argument (see <tt>lock!</tt>).
-      def with_lock(lock = true)
-        transaction do
+      # as an optional argument (see #lock!).
+      #
+      # You can also pass options like <tt>requires_new:</tt>, <tt>isolation:</tt>,
+      # and <tt>joinable:</tt> to the wrapping transaction (see
+      # ActiveRecord::ConnectionAdapters::DatabaseStatements#transaction).
+      def with_lock(*args)
+        transaction_opts = args.extract_options!
+        lock = args.present? ? args.first : true
+        transaction(**transaction_opts) do
           lock!(lock)
           yield
         end

data/lib/active_record/log_subscriber.rb

@@ -22,10 +22,8 @@ module ActiveRecord
     def strict_loading_violation(event)
       debug do
         owner = event.payload[:owner]
-        association = event.payload[:reflection].klass
-        name = event.payload[:reflection].name
-
-        color("Strict loading violation: #{owner} is marked for strict loading. The #{association} association named :#{name} cannot be lazily loaded.", RED)
+        reflection = event.payload[:reflection]
+        color(reflection.strict_loading_violation_message(owner), RED)
       end
     end
 
@@ -37,7 +35,11 @@ module ActiveRecord
 
       return if IGNORE_PAYLOAD_NAMES.include?(payload[:name])
 
-      name  = "#{payload[:name]} (#{event.duration.round(1)}ms)"
+      name = if payload[:async]
+        "ASYNC #{payload[:name]} (#{payload[:lock_wait].round(1)}ms) (db time #{event.duration.round(1)}ms)"
+      else
+        "#{payload[:name]} (#{event.duration.round(1)}ms)"
+      end
       name  = "CACHE #{name}" if payload[:cached]
       sql   = payload[:sql]
       binds = nil
@@ -47,7 +49,17 @@ module ActiveRecord
 
         binds = []
         payload[:binds].each_with_index do |attr, i|
-          binds << render_bind(attr, casted_params[i])
+          attribute_name = if attr.respond_to?(:name)
+            attr.name
+          elsif attr.respond_to?(:[]) && attr[i].respond_to?(:name)
+            attr[i].name
+          else
+            nil
+          end
+
+          filtered_params = filter(attribute_name, casted_params[i])
+
+          binds << render_bind(attr, filtered_params)
         end
         binds = binds.inspect
         binds.prepend("  ")
@@ -115,7 +127,7 @@ module ActiveRecord
       def debug(progname = nil, &block)
         return unless super
 
-        if ActiveRecord::Base.verbose_query_logs
+        if ActiveRecord.verbose_query_logs
           log_query_source
         end
       end
@@ -131,6 +143,10 @@ module ActiveRecord
       def extract_query_source_location(locations)
         backtrace_cleaner.clean(locations.lazy).first
       end
+
+      def filter(name, value)
+        ActiveRecord::Base.inspection_filter.filter_param(name, value)
+      end
   end
 end
 

data/lib/active_record/middleware/database_selector/resolver.rb

@@ -50,23 +50,19 @@ module ActiveRecord
 
         private
           def read_from_primary(&blk)
-            ActiveRecord::Base.connected_to(role: ActiveRecord::Base.writing_role, prevent_writes: true) do
-              instrumenter.instrument("database_selector.active_record.read_from_primary") do
-                yield
-              end
+            ActiveRecord::Base.connected_to(role: ActiveRecord.writing_role, prevent_writes: true) do
+              instrumenter.instrument("database_selector.active_record.read_from_primary", &blk)
             end
           end
 
           def read_from_replica(&blk)
-            ActiveRecord::Base.connected_to(role: ActiveRecord::Base.reading_role, prevent_writes: true) do
-              instrumenter.instrument("database_selector.active_record.read_from_replica") do
-                yield
-              end
+            ActiveRecord::Base.connected_to(role: ActiveRecord.reading_role, prevent_writes: true) do
+              instrumenter.instrument("database_selector.active_record.read_from_replica", &blk)
             end
           end
 
-          def write_to_primary(&blk)
-            ActiveRecord::Base.connected_to(role: ActiveRecord::Base.writing_role, prevent_writes: false) do
+          def write_to_primary
+            ActiveRecord::Base.connected_to(role: ActiveRecord.writing_role, prevent_writes: false) do
               instrumenter.instrument("database_selector.active_record.wrote_to_primary") do
                 yield
               ensure

data/lib/active_record/middleware/database_selector.rb

@@ -19,14 +19,22 @@ module ActiveRecord
     # that informs the application when to read from a primary or read from a
     # replica.
     #
-    # To use the DatabaseSelector in your application with default settings add
-    # the following options to your environment config:
+    # To use the DatabaseSelector in your application with default settings,
+    # run the provided generator.
     #
-    #   config.active_record.database_selector = { delay: 2.seconds }
-    #   config.active_record.database_resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver
-    #   config.active_record.database_resolver_context = ActiveRecord::Middleware::DatabaseSelector::Resolver::Session
+    #   bin/rails g active_record:multi_db
+    #
+    # This will create a file named +config/initializers/multi_db.rb+ with the
+    # following contents:
     #
-    # New applications will include these lines commented out in the production.rb.
+    #   Rails.application.configure do
+    #     config.active_record.database_selector = { delay: 2.seconds }
+    #     config.active_record.database_resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver
+    #     config.active_record.database_resolver_context = ActiveRecord::Middleware::DatabaseSelector::Resolver::Session
+    #   end
+    #
+    # Alternatively you can set the options in your environment config or
+    # any other config file loaded on boot.
     #
     # The default behavior can be changed by setting the config options to a
     # custom class:
@@ -34,6 +42,10 @@ module ActiveRecord
     #   config.active_record.database_selector = { delay: 2.seconds }
     #   config.active_record.database_resolver = MyResolver
     #   config.active_record.database_resolver_context = MyResolver::MySession
+    #
+    # Note: If you are using <tt>rails new my_app --minimal</tt> you will need
+    # to call <tt>require "active_support/core_ext/integer/time"</tt> to load
+    # the core extension in order to use +2.seconds+
     class DatabaseSelector
       def initialize(app, resolver_klass = nil, context_klass = nil, options = {})
         @app = app

data/lib/active_record/middleware/shard_selector.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Middleware
+    # The ShardSelector Middleware provides a framework for automatically
+    # swapping shards. Rails provides a basic framework to determine which
+    # shard to switch to and allows for applications to write custom strategies
+    # for swapping if needed.
+    #
+    # The ShardSelector takes a set of options (currently only +lock+ is supported)
+    # that can be used by the middleware to alter behavior. +lock+ is
+    # true by default and will prohibit the request from switching shards once
+    # inside the block. If +lock+ is false, then shard swapping will be allowed.
+    # For tenant based sharding, +lock+ should always be true to prevent application
+    # code from mistakenly switching between tenants.
+    #
+    # Options can be set in the config:
+    #
+    #   config.active_record.shard_selector = { lock: true }
+    #
+    # Applications must also provide the code for the resolver as it depends on application
+    # specific models. An example resolver would look like this:
+    #
+    #   config.active_record.shard_resolver = ->(request) {
+    #     subdomain = request.subdomain
+    #     tenant = Tenant.find_by_subdomain!(subdomain)
+    #     tenant.shard
+    #   }
+    class ShardSelector
+      def initialize(app, resolver, options = {})
+        @app = app
+        @resolver = resolver
+        @options = options
+      end
+
+      attr_reader :resolver, :options
+
+      def call(env)
+        request = ActionDispatch::Request.new(env)
+
+        shard = selected_shard(request)
+
+        set_shard(shard) do
+          @app.call(env)
+        end
+      end
+
+      private
+        def selected_shard(request)
+          resolver.call(request)
+        end
+
+        def set_shard(shard, &block)
+          ActiveRecord::Base.connected_to(shard: shard.to_sym) do
+            ActiveRecord::Base.prohibit_shard_swapping(options.fetch(:lock, true), &block)
+          end
+        end
+    end
+  end
+end

data/lib/active_record/migration/command_recorder.rb

@@ -12,11 +12,10 @@ module ActiveRecord
     # * add_index
     # * add_reference
     # * add_timestamps
-    # * change_column
-    # * change_column_default (must supply a :from and :to option)
+    # * change_column_default (must supply a +:from+ and +:to+ option)
     # * change_column_null
-    # * change_column_comment (must supply a :from and :to option)
-    # * change_table_comment (must supply a :from and :to option)
+    # * change_column_comment (must supply a +:from+ and +:to+ option)
+    # * change_table_comment (must supply a +:from+ and +:to+ option)
     # * create_join_table
     # * create_table
     # * disable_extension
@@ -24,7 +23,7 @@ module ActiveRecord
     # * drop_table (must supply a block)
     # * enable_extension
     # * remove_column (must supply a type)
-    # * remove_columns (must specify at least one column name or more)
+    # * remove_columns (must supply a +:type+ option)
     # * remove_foreign_key (must supply a second table)
     # * remove_check_constraint
     # * remove_index
@@ -112,7 +111,7 @@ module ActiveRecord
             record(:"#{method}", args, &block)  #   record(:create_table, args, &block)
           end                                   # end
         EOV
-        ruby2_keywords(method) if respond_to?(:ruby2_keywords, true)
+        ruby2_keywords(method)
       end
       alias :add_belongs_to :add_reference
       alias :remove_belongs_to :remove_reference
@@ -154,9 +153,9 @@ module ActiveRecord
 
         include StraightReversions
 
-        def invert_transaction(args)
+        def invert_transaction(args, &block)
           sub_recorder = CommandRecorder.new(delegate)
-          sub_recorder.revert { yield }
+          sub_recorder.revert(&block)
 
           invertions_proc = proc {
             sub_recorder.replay(self)
@@ -286,7 +285,7 @@ module ActiveRecord
             super
           end
         end
-        ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+        ruby2_keywords(:method_missing)
     end
   end
 end